gdb/procfs.c

   1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
   2    Copyright 1991, 1992-97, 1998 Free Software Foundation, Inc.
   3    Written by Fred Fish at Cygnus Support.  Changes for sysv4.2mp procfs
   4    compatibility by Geoffrey Noer at Cygnus Solutions.
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22
  23 /*                      N  O  T  E  S
  24
  25 For information on the details of using /proc consult section proc(4)
  26 in the UNIX System V Release 4 System Administrator's Reference Manual.
  27
  28 The general register and floating point register sets are manipulated
  29 separately.  This file makes the assumption that if FP0_REGNUM is
  30 defined, then support for the floating point register set is desired,
  31 regardless of whether or not the actual target has floating point hardware.
  32
  33  */
  34
  35
  36 #include "defs.h"
  37
  38 #include <sys/types.h>
  39 #include <time.h>
  40 #include <sys/fault.h>
  41 #include <sys/syscall.h>
  42 #include <sys/procfs.h>
  43 #include <fcntl.h>
  44 #include <errno.h>
  45 #include "gdb_string.h"
  46 #include <stropts.h>
  47 #include <poll.h>
  48 #include <unistd.h>
  49 #include "gdb_stat.h"
  50
  51 #include "inferior.h"
  52 #include "target.h"
  53 #include "command.h"
  54 #include "gdbcore.h"
  55 #include "gdbthread.h"
  56
  57 #if !defined(SYS_lwp_create) && defined(SYS_lwpcreate)
  58 # define SYS_lwp_create SYS_lwpcreate
  59 #endif
  60
  61 #if !defined(SYS_lwp_exit) && defined(SYS_lwpexit)
  62 # define SYS_lwp_exit SYS_lwpexit
  63 #endif
  64
  65 #if !defined(SYS_lwp_wait) && defined(SYS_lwpwait)
  66 # define SYS_lwp_wait SYS_lwpwait
  67 #endif
  68
  69 #if !defined(SYS_lwp_self) && defined(SYS_lwpself)
  70 # define SYS_lwp_self SYS_lwpself
  71 #endif
  72
  73 #if !defined(SYS_lwp_info) && defined(SYS_lwpinfo)
  74 # define SYS_lwp_info SYS_lwpinfo
  75 #endif
  76
  77 #if !defined(SYS_lwp_private) && defined(SYS_lwpprivate)
  78 # define SYS_lwp_private SYS_lwpprivate
  79 #endif
  80
  81 #if !defined(SYS_lwp_kill) && defined(SYS_lwpkill)
  82 # define SYS_lwp_kill SYS_lwpkill
  83 #endif
  84
  85 #if !defined(SYS_lwp_suspend) && defined(SYS_lwpsuspend)
  86 # define SYS_lwp_suspend SYS_lwpsuspend
  87 #endif
  88
  89 #if !defined(SYS_lwp_continue) && defined(SYS_lwpcontinue)
  90 # define SYS_lwp_continue SYS_lwpcontinue
  91 #endif
  92
  93 /* the name of the proc status struct depends on the implementation */
  94 #ifdef HAVE_PSTATUS_T
  95   typedef pstatus_t gdb_prstatus_t;
  96 #else
  97   typedef prstatus_t gdb_prstatus_t;
  98 #endif
  99
 100 #define MAX_SYSCALLS    256     /* Maximum number of syscalls for table */
 101
 102 /* proc name formats may vary depending on the proc implementation */
 103 #ifdef HAVE_MULTIPLE_PROC_FDS
 104 #  ifndef CTL_PROC_NAME_FMT
 105 #  define CTL_PROC_NAME_FMT "/proc/%d/ctl"
 106 #  define AS_PROC_NAME_FMT "/proc/%d/as"
 107 #  define MAP_PROC_NAME_FMT "/proc/%d/map"
 108 #  define STATUS_PROC_NAME_FMT "/proc/%d/status"
 109 #  endif
 110 #else /* HAVE_MULTIPLE_PROC_FDS */
 111 #  ifndef CTL_PROC_NAME_FMT
 112 #  define CTL_PROC_NAME_FMT "/proc/%05d"
 113 #  define AS_PROC_NAME_FMT "/proc/%05d"
 114 #  define MAP_PROC_NAME_FMT "/proc/%05d"
 115 #  define STATUS_PROC_NAME_FMT "/proc/%05d"
 116 #  endif
 117 #endif /* HAVE_MULTIPLE_PROC_FDS */
 118
 119
 120 /* These #ifdefs are for sol2.x in particular.  sol2.x has
 121    both a "gregset_t" and a "prgregset_t", which have
 122    similar uses but different layouts.  sol2.x gdb tries to
 123    use prgregset_t (and prfpregset_t) everywhere. */
 124
 125 #ifdef GDB_GREGSET_TYPE
 126   typedef GDB_GREGSET_TYPE gdb_gregset_t;
 127 #else
 128   typedef gregset_t gdb_gregset_t;
 129 #endif
 130
 131 #ifdef GDB_FPREGSET_TYPE
 132   typedef GDB_FPREGSET_TYPE gdb_fpregset_t;
 133 #else
 134   typedef fpregset_t gdb_fpregset_t;
 135 #endif
 136
 137
 138 #define MAX_PROC_NAME_SIZE sizeof("/proc/1234567890/status")
 139
 140 struct target_ops procfs_ops;
 141
 142 int procfs_suppress_run = 0;    /* Non-zero if procfs should pretend not to
 143                                    be a runnable target.  Used by targets
 144                                    that can sit atop procfs, such as solaris
 145                                    thread support.  */
 146
 147 #if 1   /* FIXME: Gross and ugly hack to resolve coredep.c global */
 148 CORE_ADDR kernel_u_addr;
 149 #endif
 150
 151 #ifdef BROKEN_SIGINFO_H         /* Workaround broken SGS <sys/siginfo.h> */
 152 #undef si_pid
 153 #define si_pid _data._proc.pid
 154 #undef si_uid
 155 #define si_uid _data._proc._pdata._kill.uid
 156 #endif /* BROKEN_SIGINFO_H */
 157
 158 /* Define structures for passing commands to /proc/pid/ctl file.  Note that
 159    while we create these for the PROCFS_USE_READ_WRITE world, we use them
 160    and ignore the extra cmd int in other proc schemes.
 161 */
 162 /* generic ctl msg */
 163 struct proc_ctl {
 164         int     cmd;
 165         long    data;
 166 };
 167
 168 /* set general registers */
 169 struct greg_ctl {
 170         int             cmd;
 171         gdb_gregset_t   gregset;
 172 };
 173
 174 /* set fp registers */
 175 struct fpreg_ctl {
 176         int             cmd;
 177         gdb_fpregset_t  fpregset;
 178 };
 179
 180 /* set signals to be traced */
 181 struct sig_ctl {
 182         int             cmd;
 183         sigset_t        sigset;
 184 };
 185
 186 /* set faults to be traced */
 187 struct flt_ctl {
 188         int             cmd;
 189         fltset_t        fltset;
 190 };
 191
 192 /* set system calls to be traced */
 193 struct sys_ctl {
 194         int             cmd;
 195         sysset_t        sysset;
 196 };
 197
 198 /* set current signal to be traced */
 199 struct sigi_ctl {
 200         int             cmd;
 201         siginfo_t       siginfo;
 202 };
 203
 204 /*  All access to the inferior, either one started by gdb or one that has
 205     been attached to, is controlled by an instance of a procinfo structure,
 206     defined below.  Since gdb currently only handles one inferior at a time,
 207     the procinfo structure for the inferior is statically allocated and
 208     only one exists at any given time.  There is a separate procinfo
 209     structure for use by the "info proc" command, so that we can print
 210     useful information about any random process without interfering with
 211     the inferior's procinfo information. */
 212
 213 struct procinfo {
 214   struct procinfo *next;
 215   int pid;                      /* Process ID of inferior */
 216   int ctl_fd;                   /* File descriptor for /proc ctl file */
 217   int status_fd;                /* File descriptor for /proc status file */
 218   int as_fd;                    /* File descriptor for /proc as file */
 219   int map_fd;                   /* File descriptor for /proc map file */
 220   char *pathname;               /* Pathname to /proc entry */
 221   int had_event;                /* poll/select says something happened */
 222   int was_stopped;              /* Nonzero if was stopped prior to attach */
 223   int nopass_next_sigstop;      /* Don't pass a sigstop on next resume */
 224 #ifndef HAVE_NO_PRRUN_T
 225   prrun_t prrun;                /* Control state when it is run */
 226 #endif
 227   gdb_prstatus_t prstatus;      /* Current process status info */
 228   struct greg_ctl gregset;      /* General register set */
 229   struct fpreg_ctl fpregset;    /* Floating point register set */
 230   struct flt_ctl fltset;        /* Current traced hardware fault set */
 231   struct sig_ctl trace;         /* Current traced signal set */
 232   struct sys_ctl exitset;       /* Current traced system call exit set */
 233   struct sys_ctl entryset;      /* Current traced system call entry set */
 234   struct sig_ctl saved_sighold; /* Saved held signal set */
 235   struct flt_ctl saved_fltset;  /* Saved traced hardware fault set */
 236   struct sig_ctl saved_trace;   /* Saved traced signal set */
 237   struct sys_ctl saved_exitset; /* Saved traced system call exit set */
 238   struct sys_ctl saved_entryset;/* Saved traced system call entry set */
 239   int num_syscall_handlers;     /* Number of syscall trap handlers
 240                                    currently installed */
 241                                 /* Pointer to list of syscall trap handlers */
 242   struct procfs_syscall_handler *syscall_handlers;
 243   int saved_rtnval;             /* return value and status for wait(), */
 244   int saved_statval;            /*  as supplied by a syscall handler. */
 245   int new_child;                /* Non-zero if it's a new thread */
 246 };
 247
 248 /* List of inferior process information */
 249 static struct procinfo *procinfo_list = NULL;
 250 static struct pollfd *poll_list; /* pollfds used for waiting on /proc */
 251
 252 static int num_poll_list = 0;   /* Number of entries in poll_list */
 253
 254 /*  Much of the information used in the /proc interface, particularly for
 255     printing status information, is kept as tables of structures of the
 256     following form.  These tables can be used to map numeric values to
 257     their symbolic names and to a string that describes their specific use. */
 258
 259 struct trans {
 260   int value;                    /* The numeric value */
 261   char *name;                   /* The equivalent symbolic value */
 262   char *desc;                   /* Short description of value */
 263 };
 264
 265 /*  Translate bits in the pr_flags member of the prstatus structure, into the
 266     names and desc information. */
 267
 268 static struct trans pr_flag_table[] =
 269 {
 270 #if defined (PR_STOPPED)
 271   { PR_STOPPED, "PR_STOPPED", "Process is stopped" },
 272 #endif
 273 #if defined (PR_ISTOP)
 274   { PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest" },
 275 #endif
 276 #if defined (PR_DSTOP)
 277   { PR_DSTOP, "PR_DSTOP", "A stop directive is in effect" },
 278 #endif
 279 #if defined (PR_ASLEEP)
 280   { PR_ASLEEP, "PR_ASLEEP", "Sleeping in an interruptible system call" },
 281 #endif
 282 #if defined (PR_FORK)
 283   { PR_FORK, "PR_FORK", "Inherit-on-fork is in effect" },
 284 #endif
 285 #if defined (PR_RLC)
 286   { PR_RLC, "PR_RLC", "Run-on-last-close is in effect" },
 287 #endif
 288 #if defined (PR_PTRACE)
 289   { PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace" },
 290 #endif
 291 #if defined (PR_PCINVAL)
 292   { PR_PCINVAL, "PR_PCINVAL", "PC refers to an invalid virtual address" },
 293 #endif
 294 #if defined (PR_ISSYS)
 295   { PR_ISSYS, "PR_ISSYS", "Is a system process" },
 296 #endif
 297 #if defined (PR_STEP)
 298   { PR_STEP, "PR_STEP", "Process has single step pending" },
 299 #endif
 300 #if defined (PR_KLC)
 301   { PR_KLC, "PR_KLC", "Kill-on-last-close is in effect" },
 302 #endif
 303 #if defined (PR_ASYNC)
 304   { PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect" },
 305 #endif
 306 #if defined (PR_PCOMPAT)
 307   { PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect" },
 308 #endif
 309 #if defined (PR_MSACCT)
 310   { PR_MSACCT, "PR_MSACCT", "Microstate accounting enabled" },
 311 #endif
 312 #if defined (PR_BPTADJ)
 313   { PR_BPTADJ, "PR_BPTADJ", "Breakpoint PC adjustment in effect" },
 314 #endif
 315 #if defined (PR_ASLWP)
 316   { PR_ASLWP, "PR_ASLWP", "Asynchronus signal LWP" },
 317 #endif
 318   { 0, NULL, NULL }
 319 };
 320
 321 /*  Translate values in the pr_why field of the prstatus struct. */
 322
 323 static struct trans pr_why_table[] =
 324 {
 325 #if defined (PR_REQUESTED)
 326   { PR_REQUESTED, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP" },
 327 #endif
 328 #if defined (PR_SIGNALLED)
 329   { PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal" },
 330 #endif
 331 #if defined (PR_SYSENTRY)
 332   { PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call" },
 333 #endif
 334 #if defined (PR_SYSEXIT)
 335   { PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call" },
 336 #endif
 337 #if defined (PR_JOBCONTROL)
 338   { PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action" },
 339 #endif
 340 #if defined (PR_FAULTED)
 341   { PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault" },
 342 #endif
 343 #if defined (PR_SUSPENDED)
 344   { PR_SUSPENDED, "PR_SUSPENDED", "Process suspended" },
 345 #endif
 346 #if defined (PR_CHECKPOINT)
 347   { PR_CHECKPOINT, "PR_CHECKPOINT", "(???)" },
 348 #endif
 349   { 0, NULL, NULL }
 350 };
 351
 352 /*  Hardware fault translation table. */
 353
 354 static struct trans faults_table[] =
 355 {
 356 #if defined (FLTILL)
 357   { FLTILL, "FLTILL", "Illegal instruction" },
 358 #endif
 359 #if defined (FLTPRIV)
 360   { FLTPRIV, "FLTPRIV", "Privileged instruction" },
 361 #endif
 362 #if defined (FLTBPT)
 363   { FLTBPT, "FLTBPT", "Breakpoint trap" },
 364 #endif
 365 #if defined (FLTTRACE)
 366   { FLTTRACE, "FLTTRACE", "Trace trap" },
 367 #endif
 368 #if defined (FLTACCESS)
 369   { FLTACCESS, "FLTACCESS", "Memory access fault" },
 370 #endif
 371 #if defined (FLTBOUNDS)
 372   { FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation" },
 373 #endif
 374 #if defined (FLTIOVF)
 375   { FLTIOVF, "FLTIOVF", "Integer overflow" },
 376 #endif
 377 #if defined (FLTIZDIV)
 378   { FLTIZDIV, "FLTIZDIV", "Integer zero divide" },
 379 #endif
 380 #if defined (FLTFPE)
 381   { FLTFPE, "FLTFPE", "Floating-point exception" },
 382 #endif
 383 #if defined (FLTSTACK)
 384   { FLTSTACK, "FLTSTACK", "Unrecoverable stack fault" },
 385 #endif
 386 #if defined (FLTPAGE)
 387   { FLTPAGE, "FLTPAGE", "Recoverable page fault" },
 388 #endif
 389   { 0, NULL, NULL }
 390 };
 391
 392 /* Translation table for signal generation information.  See UNIX System
 393    V Release 4 Programmer's Reference Manual, siginfo(5).  */
 394
 395 static struct sigcode {
 396   int signo;
 397   int code;
 398   char *codename;
 399   char *desc;
 400 } siginfo_table[] = {
 401 #if defined (SIGILL) && defined (ILL_ILLOPC)
 402   { SIGILL, ILL_ILLOPC, "ILL_ILLOPC", "Illegal opcode" },
 403 #endif
 404 #if defined (SIGILL) && defined (ILL_ILLOPN)
 405   { SIGILL, ILL_ILLOPN, "ILL_ILLOPN", "Illegal operand", },
 406 #endif
 407 #if defined (SIGILL) && defined (ILL_ILLADR)
 408   { SIGILL, ILL_ILLADR, "ILL_ILLADR", "Illegal addressing mode" },
 409 #endif
 410 #if defined (SIGILL) && defined (ILL_ILLTRP)
 411   { SIGILL, ILL_ILLTRP, "ILL_ILLTRP", "Illegal trap" },
 412 #endif
 413 #if defined (SIGILL) && defined (ILL_PRVOPC)
 414   { SIGILL, ILL_PRVOPC, "ILL_PRVOPC", "Privileged opcode" },
 415 #endif
 416 #if defined (SIGILL) && defined (ILL_PRVREG)
 417   { SIGILL, ILL_PRVREG, "ILL_PRVREG", "Privileged register" },
 418 #endif
 419 #if defined (SIGILL) && defined (ILL_COPROC)
 420   { SIGILL, ILL_COPROC, "ILL_COPROC", "Coprocessor error" },
 421 #endif
 422 #if defined (SIGILL) && defined (ILL_BADSTK)
 423   { SIGILL, ILL_BADSTK, "ILL_BADSTK", "Internal stack error" },
 424 #endif
 425 #if defined (SIGFPE) && defined (FPE_INTDIV)
 426   { SIGFPE, FPE_INTDIV, "FPE_INTDIV", "Integer divide by zero" },
 427 #endif
 428 #if defined (SIGFPE) && defined (FPE_INTOVF)
 429   { SIGFPE, FPE_INTOVF, "FPE_INTOVF", "Integer overflow" },
 430 #endif
 431 #if defined (SIGFPE) && defined (FPE_FLTDIV)
 432   { SIGFPE, FPE_FLTDIV, "FPE_FLTDIV", "Floating point divide by zero" },
 433 #endif
 434 #if defined (SIGFPE) && defined (FPE_FLTOVF)
 435   { SIGFPE, FPE_FLTOVF, "FPE_FLTOVF", "Floating point overflow" },
 436 #endif
 437 #if defined (SIGFPE) && defined (FPE_FLTUND)
 438   { SIGFPE, FPE_FLTUND, "FPE_FLTUND", "Floating point underflow" },
 439 #endif
 440 #if defined (SIGFPE) && defined (FPE_FLTRES)
 441   { SIGFPE, FPE_FLTRES, "FPE_FLTRES", "Floating point inexact result" },
 442 #endif
 443 #if defined (SIGFPE) && defined (FPE_FLTINV)
 444   { SIGFPE, FPE_FLTINV, "FPE_FLTINV", "Invalid floating point operation" },
 445 #endif
 446 #if defined (SIGFPE) && defined (FPE_FLTSUB)
 447   { SIGFPE, FPE_FLTSUB, "FPE_FLTSUB", "Subscript out of range" },
 448 #endif
 449 #if defined (SIGSEGV) && defined (SEGV_MAPERR)
 450   { SIGSEGV, SEGV_MAPERR, "SEGV_MAPERR", "Address not mapped to object" },
 451 #endif
 452 #if defined (SIGSEGV) && defined (SEGV_ACCERR)
 453   { SIGSEGV, SEGV_ACCERR, "SEGV_ACCERR", "Invalid permissions for object" },
 454 #endif
 455 #if defined (SIGBUS) && defined (BUS_ADRALN)
 456   { SIGBUS, BUS_ADRALN, "BUS_ADRALN", "Invalid address alignment" },
 457 #endif
 458 #if defined (SIGBUS) && defined (BUS_ADRERR)
 459   { SIGBUS, BUS_ADRERR, "BUS_ADRERR", "Non-existent physical address" },
 460 #endif
 461 #if defined (SIGBUS) && defined (BUS_OBJERR)
 462   { SIGBUS, BUS_OBJERR, "BUS_OBJERR", "Object specific hardware error" },
 463 #endif
 464 #if defined (SIGTRAP) && defined (TRAP_BRKPT)
 465   { SIGTRAP, TRAP_BRKPT, "TRAP_BRKPT", "Process breakpoint" },
 466 #endif
 467 #if defined (SIGTRAP) && defined (TRAP_TRACE)
 468   { SIGTRAP, TRAP_TRACE, "TRAP_TRACE", "Process trace trap" },
 469 #endif
 470 #if defined (SIGCLD) && defined (CLD_EXITED)
 471   { SIGCLD, CLD_EXITED, "CLD_EXITED", "Child has exited" },
 472 #endif
 473 #if defined (SIGCLD) && defined (CLD_KILLED)
 474   { SIGCLD, CLD_KILLED, "CLD_KILLED", "Child was killed" },
 475 #endif
 476 #if defined (SIGCLD) && defined (CLD_DUMPED)
 477   { SIGCLD, CLD_DUMPED, "CLD_DUMPED", "Child has terminated abnormally" },
 478 #endif
 479 #if defined (SIGCLD) && defined (CLD_TRAPPED)
 480   { SIGCLD, CLD_TRAPPED, "CLD_TRAPPED", "Traced child has trapped" },
 481 #endif
 482 #if defined (SIGCLD) && defined (CLD_STOPPED)
 483   { SIGCLD, CLD_STOPPED, "CLD_STOPPED", "Child has stopped" },
 484 #endif
 485 #if defined (SIGCLD) && defined (CLD_CONTINUED)
 486   { SIGCLD, CLD_CONTINUED, "CLD_CONTINUED", "Stopped child had continued" },
 487 #endif
 488 #if defined (SIGPOLL) && defined (POLL_IN)
 489   { SIGPOLL, POLL_IN, "POLL_IN", "Input input available" },
 490 #endif
 491 #if defined (SIGPOLL) && defined (POLL_OUT)
 492   { SIGPOLL, POLL_OUT, "POLL_OUT", "Output buffers available" },
 493 #endif
 494 #if defined (SIGPOLL) && defined (POLL_MSG)
 495   { SIGPOLL, POLL_MSG, "POLL_MSG", "Input message available" },
 496 #endif
 497 #if defined (SIGPOLL) && defined (POLL_ERR)
 498   { SIGPOLL, POLL_ERR, "POLL_ERR", "I/O error" },
 499 #endif
 500 #if defined (SIGPOLL) && defined (POLL_PRI)
 501   { SIGPOLL, POLL_PRI, "POLL_PRI", "High priority input available" },
 502 #endif
 503 #if defined (SIGPOLL) && defined (POLL_HUP)
 504   { SIGPOLL, POLL_HUP, "POLL_HUP", "Device disconnected" },
 505 #endif
 506   { 0, 0, NULL, NULL }
 507 };
 508
 509 static char *syscall_table[MAX_SYSCALLS];
 510
 511 /* Prototypes for local functions */
 512
 513 static void procfs_stop PARAMS ((void));
 514
 515 static int procfs_thread_alive PARAMS ((int));
 516
 517 static int procfs_can_run PARAMS ((void));
 518
 519 static void procfs_mourn_inferior PARAMS ((void));
 520
 521 static void procfs_fetch_registers PARAMS ((int));
 522
 523 static int procfs_wait PARAMS ((int, struct target_waitstatus *));
 524
 525 static void procfs_open PARAMS ((char *, int));
 526
 527 static void procfs_files_info PARAMS ((struct target_ops *));
 528
 529 static void procfs_prepare_to_store PARAMS ((void));
 530
 531 static void procfs_detach PARAMS ((char *, int));
 532
 533 static void procfs_attach PARAMS ((char *, int));
 534
 535 static void proc_set_exec_trap PARAMS ((void));
 536
 537 static void  procfs_init_inferior PARAMS ((int));
 538
 539 static struct procinfo *create_procinfo PARAMS ((int));
 540
 541 static void procfs_store_registers PARAMS ((int));
 542
 543 static int procfs_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
 544
 545 static void procfs_kill_inferior PARAMS ((void));
 546
 547 static char *sigcodedesc PARAMS ((siginfo_t *));
 548
 549 static char *sigcodename PARAMS ((siginfo_t *));
 550
 551 static struct procinfo *wait_fd PARAMS ((void));
 552
 553 static void remove_fd PARAMS ((struct procinfo *));
 554
 555 static void add_fd PARAMS ((struct procinfo *));
 556
 557 static void set_proc_siginfo PARAMS ((struct procinfo *, int));
 558
 559 static void init_syscall_table PARAMS ((void));
 560
 561 static char *syscallname PARAMS ((int));
 562
 563 static char *signalname PARAMS ((int));
 564
 565 static char *errnoname PARAMS ((int));
 566
 567 static int proc_address_to_fd PARAMS ((struct procinfo *, CORE_ADDR, int));
 568
 569 static int open_proc_file PARAMS ((int, struct procinfo *, int, int));
 570
 571 static void close_proc_file PARAMS ((struct procinfo *));
 572
 573 static void unconditionally_kill_inferior PARAMS ((struct procinfo *));
 574
 575 static NORETURN void proc_init_failed PARAMS ((struct procinfo *, char *, int)) ATTR_NORETURN;
 576
 577 static void info_proc PARAMS ((char *, int));
 578
 579 static void info_proc_flags PARAMS ((struct procinfo *, int));
 580
 581 static void info_proc_stop PARAMS ((struct procinfo *, int));
 582
 583 static void info_proc_siginfo PARAMS ((struct procinfo *, int));
 584
 585 static void info_proc_syscalls PARAMS ((struct procinfo *, int));
 586
 587 static void info_proc_mappings PARAMS ((struct procinfo *, int));
 588
 589 static void info_proc_signals PARAMS ((struct procinfo *, int));
 590
 591 static void info_proc_faults PARAMS ((struct procinfo *, int));
 592
 593 static char *mappingflags PARAMS ((long));
 594
 595 static char *lookupname PARAMS ((struct trans *, unsigned int, char *));
 596
 597 static char *lookupdesc PARAMS ((struct trans *, unsigned int));
 598
 599 static int do_attach PARAMS ((int pid));
 600
 601 static void do_detach PARAMS ((int siggnal));
 602
 603 static void procfs_create_inferior PARAMS ((char *, char *, char **));
 604
 605 static void procfs_notice_signals PARAMS ((int pid));
 606
 607 static void notice_signals PARAMS ((struct procinfo *, struct sig_ctl *));
 608
 609 static struct procinfo *find_procinfo PARAMS ((pid_t pid, int okfail));
 610
 611 static int procfs_write_pcwstop PARAMS ((struct procinfo *));
 612 static int procfs_read_status PARAMS ((struct procinfo *));
 613 static void procfs_write_pckill PARAMS ((struct procinfo *));
 614
 615 typedef int syscall_func_t PARAMS ((struct procinfo *pi, int syscall_num,
 616                                     int why, int *rtnval, int *statval));
 617
 618 static void procfs_set_syscall_trap PARAMS ((struct procinfo *pi,
 619                                              int syscall_num, int flags,
 620                                              syscall_func_t *func));
 621
 622 static void procfs_clear_syscall_trap PARAMS ((struct procinfo *pi,
 623                                                int syscall_num, int errok));
 624
 625 #define PROCFS_SYSCALL_ENTRY 0x1 /* Trap on entry to sys call */
 626 #define PROCFS_SYSCALL_EXIT 0x2 /* Trap on exit from sys call */
 627
 628 static syscall_func_t procfs_exit_handler;
 629
 630 static syscall_func_t procfs_exec_handler;
 631
 632 #ifdef SYS_sproc
 633 static syscall_func_t procfs_sproc_handler;
 634 static syscall_func_t procfs_fork_handler;
 635 #endif
 636
 637 #ifdef SYS_lwp_create
 638 static syscall_func_t procfs_lwp_creation_handler;
 639 #endif
 640
 641 static void modify_inherit_on_fork_flag PARAMS ((int fd, int flag));
 642 static void modify_run_on_last_close_flag PARAMS ((int fd, int flag));
 643
 644 /* */
 645
 646 struct procfs_syscall_handler
 647 {
 648   int syscall_num;              /* The number of the system call being handled */
 649                                 /* The function to be called */
 650   syscall_func_t *func;
 651 };
 652
 653 static void procfs_resume PARAMS ((int pid, int step,
 654                                    enum target_signal signo));
 655
 656 static void init_procfs_ops PARAMS ((void));
 657
 658 /* External function prototypes that can't be easily included in any
 659    header file because the args are typedefs in system include files. */
 660
 661 extern void supply_gregset PARAMS ((gdb_gregset_t *));
 662
 663 extern void fill_gregset PARAMS ((gdb_gregset_t *, int));
 664
 665 #ifdef FP0_REGNUM
 666 extern void supply_fpregset PARAMS ((gdb_fpregset_t *));
 667
 668 extern void fill_fpregset PARAMS ((gdb_fpregset_t *, int));
 669 #endif
 670
 671 /*
 672
 673 LOCAL FUNCTION
 674
 675         find_procinfo -- convert a process id to a struct procinfo
 676
 677 SYNOPSIS
 678
 679         static struct procinfo * find_procinfo (pid_t pid, int okfail);
 680
 681 DESCRIPTION
 682
 683         Given a process id, look it up in the procinfo chain.  Returns
 684         a struct procinfo *.  If can't find pid, then call error(),
 685         unless okfail is set, in which case, return NULL;
 686  */
 687
 688 static struct procinfo *
 689 find_procinfo (pid, okfail)
 690      pid_t pid;
 691      int okfail;
 692 {
 693   struct procinfo *procinfo;
 694
 695   for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
 696     if (procinfo->pid == pid)
 697       return procinfo;
 698
 699   if (okfail)
 700     return NULL;
 701
 702   error ("procfs (find_procinfo):  Couldn't locate pid %d", pid);
 703 }
 704
 705 /*
 706
 707 LOCAL MACRO
 708
 709         current_procinfo -- convert inferior_pid to a struct procinfo
 710
 711 SYNOPSIS
 712
 713         static struct procinfo * current_procinfo;
 714
 715 DESCRIPTION
 716
 717         Looks up inferior_pid in the procinfo chain.  Always returns a
 718         struct procinfo *.  If process can't be found, we error() out.
 719  */
 720
 721 #define current_procinfo find_procinfo (inferior_pid, 0)
 722
 723 /*
 724
 725 LOCAL FUNCTION
 726
 727         add_fd -- Add the fd to the poll/select list
 728
 729 SYNOPSIS
 730
 731         static void add_fd (struct procinfo *);
 732
 733 DESCRIPTION
 734
 735         Add the fd of the supplied procinfo to the list of fds used for
 736         poll/select operations.
 737  */
 738
 739 static void
 740 add_fd (pi)
 741      struct procinfo *pi;
 742 {
 743   if (num_poll_list <= 0)
 744     poll_list = (struct pollfd *) xmalloc (sizeof (struct pollfd));
 745   else
 746     poll_list = (struct pollfd *) xrealloc (poll_list,
 747                                             (num_poll_list + 1)
 748                                             * sizeof (struct pollfd));
 749   poll_list[num_poll_list].fd = pi->ctl_fd;
 750 #ifdef UNIXWARE
 751   poll_list[num_poll_list].events = POLLWRNORM;
 752 #else
 753   poll_list[num_poll_list].events = POLLPRI;
 754 #endif
 755
 756   num_poll_list++;
 757 }
 758
 759 /*
 760
 761 LOCAL FUNCTION
 762
 763         remove_fd -- Remove the fd from the poll/select list
 764
 765 SYNOPSIS
 766
 767         static void remove_fd (struct procinfo *);
 768
 769 DESCRIPTION
 770
 771         Remove the fd of the supplied procinfo from the list of fds used
 772         for poll/select operations.
 773  */
 774
 775 static void
 776 remove_fd (pi)
 777      struct procinfo *pi;
 778 {
 779   int i;
 780
 781   for (i = 0; i < num_poll_list; i++)
 782     {
 783       if (poll_list[i].fd == pi->ctl_fd)
 784         {
 785           if (i != num_poll_list - 1)
 786             memcpy (poll_list + i, poll_list + i + 1,
 787                     (num_poll_list - i - 1) * sizeof (struct pollfd));
 788
 789           num_poll_list--;
 790
 791           if (num_poll_list == 0)
 792             free (poll_list);
 793           else
 794             poll_list = (struct pollfd *) xrealloc (poll_list,
 795                                                     num_poll_list
 796                                                     * sizeof (struct pollfd));
 797           return;
 798         }
 799     }
 800 }
 801
 802 /*
 803
 804 LOCAL FUNCTION
 805
 806         procfs_read_status - get procfs fd status
 807
 808 SYNOPSIS
 809
 810         static int procfs_read_status (pi) struct procinfo *pi;
 811
 812 DESCRIPTION
 813
 814         Given a pointer to a procinfo struct, get the status of
 815         the status_fd in the appropriate way.  Returns 0 on failure,
 816         1 on success.
 817  */
 818
 819 static int
 820 procfs_read_status (pi)
 821   struct procinfo *pi;
 822 {
 823 #ifdef PROCFS_USE_READ_WRITE
 824    if ((lseek (pi->status_fd, 0, SEEK_SET) < 0) ||
 825            (read (pi->status_fd, (char *) &pi->prstatus,
 826              sizeof (gdb_prstatus_t)) != sizeof (gdb_prstatus_t)))
 827 #else
 828   if (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) < 0)
 829 #endif
 830     return 0;
 831   else
 832     return 1;
 833 }
 834
 835 /*
 836
 837 LOCAL FUNCTION
 838
 839         procfs_write_pcwstop - send a PCWSTOP to procfs fd
 840
 841 SYNOPSIS
 842
 843         static int procfs_write_pcwstop (pi) struct procinfo *pi;
 844
 845 DESCRIPTION
 846
 847         Given a pointer to a procinfo struct, send a PCWSTOP to
 848         the ctl_fd in the appropriate way.  Returns 0 on failure,
 849         1 on success.
 850  */
 851
 852 static int
 853 procfs_write_pcwstop (pi)
 854   struct procinfo *pi;
 855 {
 856 #ifdef PROCFS_USE_READ_WRITE
 857   long cmd = PCWSTOP;
 858   if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
 859 #else
 860   if (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) < 0)
 861 #endif
 862     return 0;
 863   else
 864     return 1;
 865 }
 866
 867 /*
 868
 869 LOCAL FUNCTION
 870
 871         procfs_write_pckill - send a kill to procfs fd
 872
 873 SYNOPSIS
 874
 875         static void procfs_write_pckill (pi) struct procinfo *pi;
 876
 877 DESCRIPTION
 878
 879         Given a pointer to a procinfo struct, send a kill to
 880         the ctl_fd in the appropriate way.  Returns 0 on failure,
 881         1 on success.
 882  */
 883
 884 static void
 885 procfs_write_pckill (pi)
 886   struct procinfo *pi;
 887 {
 888 #ifdef PROCFS_USE_READ_WRITE
 889   struct proc_ctl pctl;
 890   pctl.cmd = PCKILL;
 891   pctl.data = SIGKILL;
 892   write (pi->ctl_fd, &pctl, sizeof (struct proc_ctl));
 893 #else
 894   int signo = SIGKILL;
 895   ioctl (pi->ctl_fd, PIOCKILL, &signo);
 896 #endif
 897 }
 898
 899 static struct procinfo *
 900 wait_fd ()
 901 {
 902   struct procinfo *pi, *next_pi;
 903 #ifndef LOSING_POLL
 904   int num_fds;
 905   int i;
 906 #endif
 907
 908   set_sigint_trap ();   /* Causes SIGINT to be passed on to the
 909                            attached process. */
 910   set_sigio_trap ();
 911
 912  wait_again:
 913 #ifndef LOSING_POLL
 914   while (1)
 915     {
 916       num_fds = poll (poll_list, num_poll_list, -1);
 917       if (num_fds > 0)
 918         break;
 919       if (num_fds < 0 && errno == EINTR)
 920         continue;
 921       print_sys_errmsg ("poll failed", errno);
 922       error ("Poll failed, returned %d", num_fds);
 923     }
 924 #else /* LOSING_POLL */
 925   pi = current_procinfo;
 926
 927   while (!procfs_write_pcwstop (pi))
 928     {
 929       if (errno == ENOENT)
 930         {
 931           /* Process exited.  */
 932           pi->prstatus.pr_flags = 0;
 933           break;
 934         }
 935       else if (errno != EINTR)
 936         {
 937           print_sys_errmsg (pi->pathname, errno);
 938           error ("procfs_write_pcwstop failed");
 939         }
 940     }
 941   pi->had_event = 1;
 942 #endif /* LOSING_POLL */
 943
 944   clear_sigint_trap ();
 945   clear_sigio_trap ();
 946
 947 #ifndef LOSING_POLL
 948
 949   for (i = 0; i < num_poll_list && num_fds > 0; i++)
 950     {
 951       if (0 == (poll_list[i].revents &
 952                 (POLLWRNORM | POLLPRI | POLLERR | POLLHUP | POLLNVAL)))
 953         continue;
 954       for (pi = procinfo_list; pi; pi = next_pi)
 955         {
 956           next_pi = pi->next;
 957           if (poll_list[i].fd == pi->ctl_fd)
 958             {
 959               num_fds--;
 960               if ((poll_list[i].revents & POLLHUP) != 0 ||
 961                   !procfs_read_status(pi))
 962                 { /* The LWP has apparently terminated.  */
 963                   if (num_poll_list <= 1)
 964                     {
 965                       pi->prstatus.pr_flags = 0;
 966                       pi->had_event = 1;
 967                       break;
 968                     }
 969                   if (info_verbose)
 970                     printf_filtered ("LWP %d exited.\n",
 971                                      (pi->pid >> 16) & 0xffff);
 972                   close_proc_file (pi);
 973                   i--;                  /* don't skip deleted entry */
 974                   if (num_fds != 0)
 975                     break;              /* already another event to process */
 976                   else
 977                     goto wait_again;    /* wait for another event */
 978                 }
 979               pi->had_event = 1;
 980               break;
 981             }
 982         }
 983       if (!pi)
 984         error ("wait_fd: Couldn't find procinfo for fd %d\n",
 985                poll_list[i].fd);
 986     }
 987 #endif /* LOSING_POLL */
 988
 989   return pi;
 990 }
 991
 992 /*
 993
 994 LOCAL FUNCTION
 995
 996         lookupdesc -- translate a value to a summary desc string
 997
 998 SYNOPSIS
 999
1000         static char *lookupdesc (struct trans *transp, unsigned int val);
1001
1002 DESCRIPTION
1003
1004         Given a pointer to a translation table and a value to be translated,
1005         lookup the desc string and return it.
1006  */
1007
1008 static char *
1009 lookupdesc (transp, val)
1010      struct trans *transp;
1011      unsigned int val;
1012 {
1013   char *desc;
1014
1015   for (desc = NULL; transp -> name != NULL; transp++)
1016     {
1017       if (transp -> value == val)
1018         {
1019           desc = transp -> desc;
1020           break;
1021         }
1022     }
1023
1024   /* Didn't find a translation for the specified value, set a default one. */
1025
1026   if (desc == NULL)
1027     {
1028       desc = "Unknown";
1029     }
1030   return (desc);
1031 }
1032
1033 /*
1034
1035 LOCAL FUNCTION
1036
1037         lookupname -- translate a value to symbolic name
1038
1039 SYNOPSIS
1040
1041         static char *lookupname (struct trans *transp, unsigned int val,
1042                                  char *prefix);
1043
1044 DESCRIPTION
1045
1046         Given a pointer to a translation table, a value to be translated,
1047         and a default prefix to return if the value can't be translated,
1048         match the value with one of the translation table entries and
1049         return a pointer to the symbolic name.
1050
1051         If no match is found it just returns the value as a printable string,
1052         with the given prefix.  The previous such value, if any, is freed
1053         at this time.
1054  */
1055
1056 static char *
1057 lookupname (transp, val, prefix)
1058      struct trans *transp;
1059      unsigned int val;
1060      char *prefix;
1061 {
1062   static char *locbuf;
1063   char *name;
1064
1065   for (name = NULL; transp -> name != NULL; transp++)
1066     {
1067       if (transp -> value == val)
1068         {
1069           name = transp -> name;
1070           break;
1071         }
1072     }
1073
1074   /* Didn't find a translation for the specified value, build a default
1075      one using the specified prefix and return it.  The lifetime of
1076      the value is only until the next one is needed. */
1077
1078   if (name == NULL)
1079     {
1080       if (locbuf != NULL)
1081         {
1082           free (locbuf);
1083         }
1084       locbuf = xmalloc (strlen (prefix) + 16);
1085       sprintf (locbuf, "%s %u", prefix, val);
1086       name = locbuf;
1087     }
1088   return (name);
1089 }
1090
1091 static char *
1092 sigcodename (sip)
1093      siginfo_t *sip;
1094 {
1095   struct sigcode *scp;
1096   char *name = NULL;
1097   static char locbuf[32];
1098
1099   for (scp = siginfo_table; scp -> codename != NULL; scp++)
1100     {
1101       if ((scp -> signo == sip -> si_signo) &&
1102           (scp -> code == sip -> si_code))
1103         {
1104           name = scp -> codename;
1105           break;
1106         }
1107     }
1108   if (name == NULL)
1109     {
1110       sprintf (locbuf, "sigcode %u", sip -> si_signo);
1111       name = locbuf;
1112     }
1113   return (name);
1114 }
1115
1116 static char *
1117 sigcodedesc (sip)
1118      siginfo_t *sip;
1119 {
1120   struct sigcode *scp;
1121   char *desc = NULL;
1122
1123   for (scp = siginfo_table; scp -> codename != NULL; scp++)
1124     {
1125       if ((scp -> signo == sip -> si_signo) &&
1126           (scp -> code == sip -> si_code))
1127         {
1128           desc = scp -> desc;
1129           break;
1130         }
1131     }
1132   if (desc == NULL)
1133     {
1134       desc = "Unrecognized signal or trap use";
1135     }
1136   return (desc);
1137 }
1138
1139 /*
1140
1141 LOCAL FUNCTION
1142
1143         syscallname - translate a system call number into a system call name
1144
1145 SYNOPSIS
1146
1147         char *syscallname (int syscallnum)
1148
1149 DESCRIPTION
1150
1151         Given a system call number, translate it into the printable name
1152         of a system call, or into "syscall <num>" if it is an unknown
1153         number.
1154  */
1155
1156 static char *
1157 syscallname (syscallnum)
1158      int syscallnum;
1159 {
1160   static char locbuf[32];
1161
1162   if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS
1163       && syscall_table[syscallnum] != NULL)
1164     return syscall_table[syscallnum];
1165   else
1166     {
1167       sprintf (locbuf, "syscall %u", syscallnum);
1168       return locbuf;
1169     }
1170 }
1171
1172 /*
1173
1174 LOCAL FUNCTION
1175
1176         init_syscall_table - initialize syscall translation table
1177
1178 SYNOPSIS
1179
1180         void init_syscall_table (void)
1181
1182 DESCRIPTION
1183
1184         Dynamically initialize the translation table to convert system
1185         call numbers into printable system call names.  Done once per
1186         gdb run, on initialization.
1187
1188 NOTES
1189
1190         This is awfully ugly, but preprocessor tricks to make it prettier
1191         tend to be nonportable.
1192  */
1193
1194 static void
1195 init_syscall_table ()
1196 {
1197 #if defined (SYS_exit)
1198   syscall_table[SYS_exit] = "exit";
1199 #endif
1200 #if defined (SYS_fork)
1201   syscall_table[SYS_fork] = "fork";
1202 #endif
1203 #if defined (SYS_read)
1204   syscall_table[SYS_read] = "read";
1205 #endif
1206 #if defined (SYS_write)
1207   syscall_table[SYS_write] = "write";
1208 #endif
1209 #if defined (SYS_open)
1210   syscall_table[SYS_open] = "open";
1211 #endif
1212 #if defined (SYS_close)
1213   syscall_table[SYS_close] = "close";
1214 #endif
1215 #if defined (SYS_wait)
1216   syscall_table[SYS_wait] = "wait";
1217 #endif
1218 #if defined (SYS_creat)
1219   syscall_table[SYS_creat] = "creat";
1220 #endif
1221 #if defined (SYS_link)
1222   syscall_table[SYS_link] = "link";
1223 #endif
1224 #if defined (SYS_unlink)
1225   syscall_table[SYS_unlink] = "unlink";
1226 #endif
1227 #if defined (SYS_exec)
1228   syscall_table[SYS_exec] = "exec";
1229 #endif
1230 #if defined (SYS_execv)
1231   syscall_table[SYS_execv] = "execv";
1232 #endif
1233 #if defined (SYS_execve)
1234   syscall_table[SYS_execve] = "execve";
1235 #endif
1236 #if defined (SYS_chdir)
1237   syscall_table[SYS_chdir] = "chdir";
1238 #endif
1239 #if defined (SYS_time)
1240   syscall_table[SYS_time] = "time";
1241 #endif
1242 #if defined (SYS_mknod)
1243   syscall_table[SYS_mknod] = "mknod";
1244 #endif
1245 #if defined (SYS_chmod)
1246   syscall_table[SYS_chmod] = "chmod";
1247 #endif
1248 #if defined (SYS_chown)
1249   syscall_table[SYS_chown] = "chown";
1250 #endif
1251 #if defined (SYS_brk)
1252   syscall_table[SYS_brk] = "brk";
1253 #endif
1254 #if defined (SYS_stat)
1255   syscall_table[SYS_stat] = "stat";
1256 #endif
1257 #if defined (SYS_lseek)
1258   syscall_table[SYS_lseek] = "lseek";
1259 #endif
1260 #if defined (SYS_getpid)
1261   syscall_table[SYS_getpid] = "getpid";
1262 #endif
1263 #if defined (SYS_mount)
1264   syscall_table[SYS_mount] = "mount";
1265 #endif
1266 #if defined (SYS_umount)
1267   syscall_table[SYS_umount] = "umount";
1268 #endif
1269 #if defined (SYS_setuid)
1270   syscall_table[SYS_setuid] = "setuid";
1271 #endif
1272 #if defined (SYS_getuid)
1273   syscall_table[SYS_getuid] = "getuid";
1274 #endif
1275 #if defined (SYS_stime)
1276   syscall_table[SYS_stime] = "stime";
1277 #endif
1278 #if defined (SYS_ptrace)
1279   syscall_table[SYS_ptrace] = "ptrace";
1280 #endif
1281 #if defined (SYS_alarm)
1282   syscall_table[SYS_alarm] = "alarm";
1283 #endif
1284 #if defined (SYS_fstat)
1285   syscall_table[SYS_fstat] = "fstat";
1286 #endif
1287 #if defined (SYS_pause)
1288   syscall_table[SYS_pause] = "pause";
1289 #endif
1290 #if defined (SYS_utime)
1291   syscall_table[SYS_utime] = "utime";
1292 #endif
1293 #if defined (SYS_stty)
1294   syscall_table[SYS_stty] = "stty";
1295 #endif
1296 #if defined (SYS_gtty)
1297   syscall_table[SYS_gtty] = "gtty";
1298 #endif
1299 #if defined (SYS_access)
1300   syscall_table[SYS_access] = "access";
1301 #endif
1302 #if defined (SYS_nice)
1303   syscall_table[SYS_nice] = "nice";
1304 #endif
1305 #if defined (SYS_statfs)
1306   syscall_table[SYS_statfs] = "statfs";
1307 #endif
1308 #if defined (SYS_sync)
1309   syscall_table[SYS_sync] = "sync";
1310 #endif
1311 #if defined (SYS_kill)
1312   syscall_table[SYS_kill] = "kill";
1313 #endif
1314 #if defined (SYS_fstatfs)
1315   syscall_table[SYS_fstatfs] = "fstatfs";
1316 #endif
1317 #if defined (SYS_pgrpsys)
1318   syscall_table[SYS_pgrpsys] = "pgrpsys";
1319 #endif
1320 #if defined (SYS_xenix)
1321   syscall_table[SYS_xenix] = "xenix";
1322 #endif
1323 #if defined (SYS_dup)
1324   syscall_table[SYS_dup] = "dup";
1325 #endif
1326 #if defined (SYS_pipe)
1327   syscall_table[SYS_pipe] = "pipe";
1328 #endif
1329 #if defined (SYS_times)
1330   syscall_table[SYS_times] = "times";
1331 #endif
1332 #if defined (SYS_profil)
1333   syscall_table[SYS_profil] = "profil";
1334 #endif
1335 #if defined (SYS_plock)
1336   syscall_table[SYS_plock] = "plock";
1337 #endif
1338 #if defined (SYS_setgid)
1339   syscall_table[SYS_setgid] = "setgid";
1340 #endif
1341 #if defined (SYS_getgid)
1342   syscall_table[SYS_getgid] = "getgid";
1343 #endif
1344 #if defined (SYS_signal)
1345   syscall_table[SYS_signal] = "signal";
1346 #endif
1347 #if defined (SYS_msgsys)
1348   syscall_table[SYS_msgsys] = "msgsys";
1349 #endif
1350 #if defined (SYS_sys3b)
1351   syscall_table[SYS_sys3b] = "sys3b";
1352 #endif
1353 #if defined (SYS_sysi86)
1354   syscall_table[SYS_sysi86] = "sysi86";
1355 #endif
1356 #if defined (SYS_acct)
1357   syscall_table[SYS_acct] = "acct";
1358 #endif
1359 #if defined (SYS_shmsys)
1360   syscall_table[SYS_shmsys] = "shmsys";
1361 #endif
1362 #if defined (SYS_semsys)
1363   syscall_table[SYS_semsys] = "semsys";
1364 #endif
1365 #if defined (SYS_ioctl)
1366   syscall_table[SYS_ioctl] = "ioctl";
1367 #endif
1368 #if defined (SYS_uadmin)
1369   syscall_table[SYS_uadmin] = "uadmin";
1370 #endif
1371 #if defined (SYS_utssys)
1372   syscall_table[SYS_utssys] = "utssys";
1373 #endif
1374 #if defined (SYS_fsync)
1375   syscall_table[SYS_fsync] = "fsync";
1376 #endif
1377 #if defined (SYS_umask)
1378   syscall_table[SYS_umask] = "umask";
1379 #endif
1380 #if defined (SYS_chroot)
1381   syscall_table[SYS_chroot] = "chroot";
1382 #endif
1383 #if defined (SYS_fcntl)
1384   syscall_table[SYS_fcntl] = "fcntl";
1385 #endif
1386 #if defined (SYS_ulimit)
1387   syscall_table[SYS_ulimit] = "ulimit";
1388 #endif
1389 #if defined (SYS_rfsys)
1390   syscall_table[SYS_rfsys] = "rfsys";
1391 #endif
1392 #if defined (SYS_rmdir)
1393   syscall_table[SYS_rmdir] = "rmdir";
1394 #endif
1395 #if defined (SYS_mkdir)
1396   syscall_table[SYS_mkdir] = "mkdir";
1397 #endif
1398 #if defined (SYS_getdents)
1399   syscall_table[SYS_getdents] = "getdents";
1400 #endif
1401 #if defined (SYS_sysfs)
1402   syscall_table[SYS_sysfs] = "sysfs";
1403 #endif
1404 #if defined (SYS_getmsg)
1405   syscall_table[SYS_getmsg] = "getmsg";
1406 #endif
1407 #if defined (SYS_putmsg)
1408   syscall_table[SYS_putmsg] = "putmsg";
1409 #endif
1410 #if defined (SYS_poll)
1411   syscall_table[SYS_poll] = "poll";
1412 #endif
1413 #if defined (SYS_lstat)
1414   syscall_table[SYS_lstat] = "lstat";
1415 #endif
1416 #if defined (SYS_symlink)
1417   syscall_table[SYS_symlink] = "symlink";
1418 #endif
1419 #if defined (SYS_readlink)
1420   syscall_table[SYS_readlink] = "readlink";
1421 #endif
1422 #if defined (SYS_setgroups)
1423   syscall_table[SYS_setgroups] = "setgroups";
1424 #endif
1425 #if defined (SYS_getgroups)
1426   syscall_table[SYS_getgroups] = "getgroups";
1427 #endif
1428 #if defined (SYS_fchmod)
1429   syscall_table[SYS_fchmod] = "fchmod";
1430 #endif
1431 #if defined (SYS_fchown)
1432   syscall_table[SYS_fchown] = "fchown";
1433 #endif
1434 #if defined (SYS_sigprocmask)
1435   syscall_table[SYS_sigprocmask] = "sigprocmask";
1436 #endif
1437 #if defined (SYS_sigsuspend)
1438   syscall_table[SYS_sigsuspend] = "sigsuspend";
1439 #endif
1440 #if defined (SYS_sigaltstack)
1441   syscall_table[SYS_sigaltstack] = "sigaltstack";
1442 #endif
1443 #if defined (SYS_sigaction)
1444   syscall_table[SYS_sigaction] = "sigaction";
1445 #endif
1446 #if defined (SYS_sigpending)
1447   syscall_table[SYS_sigpending] = "sigpending";
1448 #endif
1449 #if defined (SYS_context)
1450   syscall_table[SYS_context] = "context";
1451 #endif
1452 #if defined (SYS_evsys)
1453   syscall_table[SYS_evsys] = "evsys";
1454 #endif
1455 #if defined (SYS_evtrapret)
1456   syscall_table[SYS_evtrapret] = "evtrapret";
1457 #endif
1458 #if defined (SYS_statvfs)
1459   syscall_table[SYS_statvfs] = "statvfs";
1460 #endif
1461 #if defined (SYS_fstatvfs)
1462   syscall_table[SYS_fstatvfs] = "fstatvfs";
1463 #endif
1464 #if defined (SYS_nfssys)
1465   syscall_table[SYS_nfssys] = "nfssys";
1466 #endif
1467 #if defined (SYS_waitsys)
1468   syscall_table[SYS_waitsys] = "waitsys";
1469 #endif
1470 #if defined (SYS_sigsendsys)
1471   syscall_table[SYS_sigsendsys] = "sigsendsys";
1472 #endif
1473 #if defined (SYS_hrtsys)
1474   syscall_table[SYS_hrtsys] = "hrtsys";
1475 #endif
1476 #if defined (SYS_acancel)
1477   syscall_table[SYS_acancel] = "acancel";
1478 #endif
1479 #if defined (SYS_async)
1480   syscall_table[SYS_async] = "async";
1481 #endif
1482 #if defined (SYS_priocntlsys)
1483   syscall_table[SYS_priocntlsys] = "priocntlsys";
1484 #endif
1485 #if defined (SYS_pathconf)
1486   syscall_table[SYS_pathconf] = "pathconf";
1487 #endif
1488 #if defined (SYS_mincore)
1489   syscall_table[SYS_mincore] = "mincore";
1490 #endif
1491 #if defined (SYS_mmap)
1492   syscall_table[SYS_mmap] = "mmap";
1493 #endif
1494 #if defined (SYS_mprotect)
1495   syscall_table[SYS_mprotect] = "mprotect";
1496 #endif
1497 #if defined (SYS_munmap)
1498   syscall_table[SYS_munmap] = "munmap";
1499 #endif
1500 #if defined (SYS_fpathconf)
1501   syscall_table[SYS_fpathconf] = "fpathconf";
1502 #endif
1503 #if defined (SYS_vfork)
1504   syscall_table[SYS_vfork] = "vfork";
1505 #endif
1506 #if defined (SYS_fchdir)
1507   syscall_table[SYS_fchdir] = "fchdir";
1508 #endif
1509 #if defined (SYS_readv)
1510   syscall_table[SYS_readv] = "readv";
1511 #endif
1512 #if defined (SYS_writev)
1513   syscall_table[SYS_writev] = "writev";
1514 #endif
1515 #if defined (SYS_xstat)
1516   syscall_table[SYS_xstat] = "xstat";
1517 #endif
1518 #if defined (SYS_lxstat)
1519   syscall_table[SYS_lxstat] = "lxstat";
1520 #endif
1521 #if defined (SYS_fxstat)
1522   syscall_table[SYS_fxstat] = "fxstat";
1523 #endif
1524 #if defined (SYS_xmknod)
1525   syscall_table[SYS_xmknod] = "xmknod";
1526 #endif
1527 #if defined (SYS_clocal)
1528   syscall_table[SYS_clocal] = "clocal";
1529 #endif
1530 #if defined (SYS_setrlimit)
1531   syscall_table[SYS_setrlimit] = "setrlimit";
1532 #endif
1533 #if defined (SYS_getrlimit)
1534   syscall_table[SYS_getrlimit] = "getrlimit";
1535 #endif
1536 #if defined (SYS_lchown)
1537   syscall_table[SYS_lchown] = "lchown";
1538 #endif
1539 #if defined (SYS_memcntl)
1540   syscall_table[SYS_memcntl] = "memcntl";
1541 #endif
1542 #if defined (SYS_getpmsg)
1543   syscall_table[SYS_getpmsg] = "getpmsg";
1544 #endif
1545 #if defined (SYS_putpmsg)
1546   syscall_table[SYS_putpmsg] = "putpmsg";
1547 #endif
1548 #if defined (SYS_rename)
1549   syscall_table[SYS_rename] = "rename";
1550 #endif
1551 #if defined (SYS_uname)
1552   syscall_table[SYS_uname] = "uname";
1553 #endif
1554 #if defined (SYS_setegid)
1555   syscall_table[SYS_setegid] = "setegid";
1556 #endif
1557 #if defined (SYS_sysconfig)
1558   syscall_table[SYS_sysconfig] = "sysconfig";
1559 #endif
1560 #if defined (SYS_adjtime)
1561   syscall_table[SYS_adjtime] = "adjtime";
1562 #endif
1563 #if defined (SYS_systeminfo)
1564   syscall_table[SYS_systeminfo] = "systeminfo";
1565 #endif
1566 #if defined (SYS_seteuid)
1567   syscall_table[SYS_seteuid] = "seteuid";
1568 #endif
1569 #if defined (SYS_sproc)
1570   syscall_table[SYS_sproc] = "sproc";
1571 #endif
1572 #if defined (SYS_keyctl)
1573   syscall_table[SYS_keyctl] = "keyctl";
1574 #endif
1575 #if defined (SYS_secsys)
1576   syscall_table[SYS_secsys] = "secsys";
1577 #endif
1578 #if defined (SYS_filepriv)
1579   syscall_table[SYS_filepriv] = "filepriv";
1580 #endif
1581 #if defined (SYS_procpriv)
1582   syscall_table[SYS_procpriv] = "procpriv";
1583 #endif
1584 #if defined (SYS_devstat)
1585   syscall_table[SYS_devstat] = "devstat";
1586 #endif
1587 #if defined (SYS_aclipc)
1588   syscall_table[SYS_aclipc] = "aclipc";
1589 #endif
1590 #if defined (SYS_fdevstat)
1591   syscall_table[SYS_fdevstat] = "fdevstat";
1592 #endif
1593 #if defined (SYS_flvlfile)
1594   syscall_table[SYS_flvlfile] = "flvlfile";
1595 #endif
1596 #if defined (SYS_lvlfile)
1597   syscall_table[SYS_lvlfile] = "lvlfile";
1598 #endif
1599 #if defined (SYS_lvlequal)
1600   syscall_table[SYS_lvlequal] = "lvlequal";
1601 #endif
1602 #if defined (SYS_lvlproc)
1603   syscall_table[SYS_lvlproc] = "lvlproc";
1604 #endif
1605 #if defined (SYS_lvlipc)
1606   syscall_table[SYS_lvlipc] = "lvlipc";
1607 #endif
1608 #if defined (SYS_acl)
1609   syscall_table[SYS_acl] = "acl";
1610 #endif
1611 #if defined (SYS_auditevt)
1612   syscall_table[SYS_auditevt] = "auditevt";
1613 #endif
1614 #if defined (SYS_auditctl)
1615   syscall_table[SYS_auditctl] = "auditctl";
1616 #endif
1617 #if defined (SYS_auditdmp)
1618   syscall_table[SYS_auditdmp] = "auditdmp";
1619 #endif
1620 #if defined (SYS_auditlog)
1621   syscall_table[SYS_auditlog] = "auditlog";
1622 #endif
1623 #if defined (SYS_auditbuf)
1624   syscall_table[SYS_auditbuf] = "auditbuf";
1625 #endif
1626 #if defined (SYS_lvldom)
1627   syscall_table[SYS_lvldom] = "lvldom";
1628 #endif
1629 #if defined (SYS_lvlvfs)
1630   syscall_table[SYS_lvlvfs] = "lvlvfs";
1631 #endif
1632 #if defined (SYS_mkmld)
1633   syscall_table[SYS_mkmld] = "mkmld";
1634 #endif
1635 #if defined (SYS_mldmode)
1636   syscall_table[SYS_mldmode] = "mldmode";
1637 #endif
1638 #if defined (SYS_secadvise)
1639   syscall_table[SYS_secadvise] = "secadvise";
1640 #endif
1641 #if defined (SYS_online)
1642   syscall_table[SYS_online] = "online";
1643 #endif
1644 #if defined (SYS_setitimer)
1645   syscall_table[SYS_setitimer] = "setitimer";
1646 #endif
1647 #if defined (SYS_getitimer)
1648   syscall_table[SYS_getitimer] = "getitimer";
1649 #endif
1650 #if defined (SYS_gettimeofday)
1651   syscall_table[SYS_gettimeofday] = "gettimeofday";
1652 #endif
1653 #if defined (SYS_settimeofday)
1654   syscall_table[SYS_settimeofday] = "settimeofday";
1655 #endif
1656 #if defined (SYS_lwp_create)
1657   syscall_table[SYS_lwp_create] = "_lwp_create";
1658 #endif
1659 #if defined (SYS_lwp_exit)
1660   syscall_table[SYS_lwp_exit] = "_lwp_exit";
1661 #endif
1662 #if defined (SYS_lwp_wait)
1663   syscall_table[SYS_lwp_wait] = "_lwp_wait";
1664 #endif
1665 #if defined (SYS_lwp_self)
1666   syscall_table[SYS_lwp_self] = "_lwp_self";
1667 #endif
1668 #if defined (SYS_lwp_info)
1669   syscall_table[SYS_lwp_info] = "_lwp_info";
1670 #endif
1671 #if defined (SYS_lwp_private)
1672   syscall_table[SYS_lwp_private] = "_lwp_private";
1673 #endif
1674 #if defined (SYS_processor_bind)
1675   syscall_table[SYS_processor_bind] = "processor_bind";
1676 #endif
1677 #if defined (SYS_processor_exbind)
1678   syscall_table[SYS_processor_exbind] = "processor_exbind";
1679 #endif
1680 #if defined (SYS_prepblock)
1681   syscall_table[SYS_prepblock] = "prepblock";
1682 #endif
1683 #if defined (SYS_block)
1684   syscall_table[SYS_block] = "block";
1685 #endif
1686 #if defined (SYS_rdblock)
1687   syscall_table[SYS_rdblock] = "rdblock";
1688 #endif
1689 #if defined (SYS_unblock)
1690   syscall_table[SYS_unblock] = "unblock";
1691 #endif
1692 #if defined (SYS_cancelblock)
1693   syscall_table[SYS_cancelblock] = "cancelblock";
1694 #endif
1695 #if defined (SYS_pread)
1696   syscall_table[SYS_pread] = "pread";
1697 #endif
1698 #if defined (SYS_pwrite)
1699   syscall_table[SYS_pwrite] = "pwrite";
1700 #endif
1701 #if defined (SYS_truncate)
1702   syscall_table[SYS_truncate] = "truncate";
1703 #endif
1704 #if defined (SYS_ftruncate)
1705   syscall_table[SYS_ftruncate] = "ftruncate";
1706 #endif
1707 #if defined (SYS_lwp_kill)
1708   syscall_table[SYS_lwp_kill] = "_lwp_kill";
1709 #endif
1710 #if defined (SYS_sigwait)
1711   syscall_table[SYS_sigwait] = "sigwait";
1712 #endif
1713 #if defined (SYS_fork1)
1714   syscall_table[SYS_fork1] = "fork1";
1715 #endif
1716 #if defined (SYS_forkall)
1717   syscall_table[SYS_forkall] = "forkall";
1718 #endif
1719 #if defined (SYS_modload)
1720   syscall_table[SYS_modload] = "modload";
1721 #endif
1722 #if defined (SYS_moduload)
1723   syscall_table[SYS_moduload] = "moduload";
1724 #endif
1725 #if defined (SYS_modpath)
1726   syscall_table[SYS_modpath] = "modpath";
1727 #endif
1728 #if defined (SYS_modstat)
1729   syscall_table[SYS_modstat] = "modstat";
1730 #endif
1731 #if defined (SYS_modadm)
1732   syscall_table[SYS_modadm] = "modadm";
1733 #endif
1734 #if defined (SYS_getksym)
1735   syscall_table[SYS_getksym] = "getksym";
1736 #endif
1737 #if defined (SYS_lwp_suspend)
1738   syscall_table[SYS_lwp_suspend] = "_lwp_suspend";
1739 #endif
1740 #if defined (SYS_lwp_continue)
1741   syscall_table[SYS_lwp_continue] = "_lwp_continue";
1742 #endif
1743 #if defined (SYS_priocntllst)
1744   syscall_table[SYS_priocntllst] = "priocntllst";
1745 #endif
1746 #if defined (SYS_sleep)
1747   syscall_table[SYS_sleep] = "sleep";
1748 #endif
1749 #if defined (SYS_lwp_sema_wait)
1750   syscall_table[SYS_lwp_sema_wait] = "_lwp_sema_wait";
1751 #endif
1752 #if defined (SYS_lwp_sema_post)
1753   syscall_table[SYS_lwp_sema_post] = "_lwp_sema_post";
1754 #endif
1755 #if defined (SYS_lwp_sema_trywait)
1756   syscall_table[SYS_lwp_sema_trywait] = "lwp_sema_trywait";
1757 #endif
1758 #if defined(SYS_fstatvfs64)
1759   syscall_table[SYS_fstatvfs64] = "fstatvfs64";
1760 #endif
1761 #if defined(SYS_statvfs64)
1762   syscall_table[SYS_statvfs64] = "statvfs64";
1763 #endif
1764 #if defined(SYS_ftruncate64)
1765   syscall_table[SYS_ftruncate64] = "ftruncate64";
1766 #endif
1767 #if defined(SYS_truncate64)
1768   syscall_table[SYS_truncate64] = "truncate64";
1769 #endif
1770 #if defined(SYS_getrlimit64)
1771   syscall_table[SYS_getrlimit64] = "getrlimit64";
1772 #endif
1773 #if defined(SYS_setrlimit64)
1774   syscall_table[SYS_setrlimit64] = "setrlimit64";
1775 #endif
1776 #if defined(SYS_lseek64)
1777   syscall_table[SYS_lseek64] = "lseek64";
1778 #endif
1779 #if defined(SYS_mmap64)
1780   syscall_table[SYS_mmap64] = "mmap64";
1781 #endif
1782 #if defined(SYS_pread64)
1783   syscall_table[SYS_pread64] = "pread64";
1784 #endif
1785 #if defined(SYS_creat64)
1786   syscall_table[SYS_creat64] = "creat64";
1787 #endif
1788 #if defined(SYS_dshmsys)
1789   syscall_table[SYS_dshmsys] = "dshmsys";
1790 #endif
1791 #if defined(SYS_invlpg)
1792   syscall_table[SYS_invlpg] = "invlpg";
1793 #endif
1794 #if defined(SYS_cg_ids)
1795   syscall_table[SYS_cg_ids] = "cg_ids";
1796 #endif
1797 #if defined(SYS_cg_processors)
1798   syscall_table[SYS_cg_processors] = "cg_processors";
1799 #endif
1800 #if defined(SYS_cg_info)
1801   syscall_table[SYS_cg_info] = "cg_info";
1802 #endif
1803 #if defined(SYS_cg_bind)
1804   syscall_table[SYS_cg_bind] = "cg_bind";
1805 #endif
1806 #if defined(SYS_cg_current)
1807   syscall_table[SYS_cg_current] = "cg_current";
1808 #endif
1809 #if defined(SYS_cg_memloc)
1810   syscall_table[SYS_cg_memloc] = "cg_memloc";
1811 #endif
1812 }
1813
1814 /*
1815
1816 LOCAL FUNCTION
1817
1818         procfs_kill_inferior - kill any currently inferior
1819
1820 SYNOPSIS
1821
1822         void procfs_kill_inferior (void)
1823
1824 DESCRIPTION
1825
1826         Kill any current inferior.
1827
1828 NOTES
1829
1830         Kills even attached inferiors.  Presumably the user has already
1831         been prompted that the inferior is an attached one rather than
1832         one started by gdb.  (FIXME?)
1833
1834 */
1835
1836 static void
1837 procfs_kill_inferior ()
1838 {
1839   target_mourn_inferior ();
1840 }
1841
1842 /*
1843
1844 LOCAL FUNCTION
1845
1846         unconditionally_kill_inferior - terminate the inferior
1847
1848 SYNOPSIS
1849
1850         static void unconditionally_kill_inferior (struct procinfo *)
1851
1852 DESCRIPTION
1853
1854         Kill the specified inferior.
1855
1856 NOTE
1857
1858         A possibly useful enhancement would be to first try sending
1859         the inferior a terminate signal, politely asking it to commit
1860         suicide, before we murder it (we could call that
1861         politely_kill_inferior()).
1862
1863 */
1864
1865 static void
1866 unconditionally_kill_inferior (pi)
1867      struct procinfo *pi;
1868 {
1869   int ppid;
1870   struct proc_ctl pctl;
1871
1872   ppid = pi->prstatus.pr_ppid;
1873
1874 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
1875   /* Alpha OSF/1-3.x procfs needs a clear of the current signal
1876      before the PIOCKILL, otherwise it might generate a corrupted core
1877      file for the inferior.  */
1878   ioctl (pi->ctl_fd, PIOCSSIG, NULL);
1879 #endif
1880 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
1881   /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
1882      to kill the inferior, otherwise it might remain stopped with a
1883      pending SIGKILL.
1884      We do not check the result of the PIOCSSIG, the inferior might have
1885      died already.  */
1886   {
1887     struct siginfo newsiginfo;
1888
1889     memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
1890     newsiginfo.si_signo = SIGKILL;
1891     newsiginfo.si_code = 0;
1892     newsiginfo.si_errno = 0;
1893     newsiginfo.si_pid = getpid ();
1894     newsiginfo.si_uid = getuid ();
1895     ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo);
1896   }
1897 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
1898   procfs_write_pckill (pi);
1899 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
1900
1901   close_proc_file (pi);
1902
1903 /* Only wait() for our direct children.  Our grandchildren zombies are killed
1904    by the death of their parents.  */
1905
1906   if (ppid == getpid())
1907     wait ((int *) 0);
1908 }
1909
1910 /*
1911
1912 LOCAL FUNCTION
1913
1914         procfs_xfer_memory -- copy data to or from inferior memory space
1915
1916 SYNOPSIS
1917
1918         int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1919                 int dowrite, struct target_ops target)
1920
1921 DESCRIPTION
1922
1923         Copy LEN bytes to/from inferior's memory starting at MEMADDR
1924         from/to debugger memory starting at MYADDR.  Copy from inferior
1925         if DOWRITE is zero or to inferior if DOWRITE is nonzero.
1926
1927         Returns the length copied, which is either the LEN argument or
1928         zero.  This xfer function does not do partial moves, since procfs_ops
1929         doesn't allow memory operations to cross below us in the target stack
1930         anyway.
1931
1932 NOTES
1933
1934         The /proc interface makes this an almost trivial task.
1935  */
1936
1937 static int
1938 procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
1939      CORE_ADDR memaddr;
1940      char *myaddr;
1941      int len;
1942      int dowrite;
1943      struct target_ops *target; /* ignored */
1944 {
1945   int nbytes = 0;
1946   struct procinfo *pi;
1947
1948   pi = current_procinfo;
1949
1950   if (lseek(pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
1951     {
1952       if (dowrite)
1953         {
1954           nbytes = write (pi->as_fd, myaddr, len);
1955         }
1956       else
1957         {
1958           nbytes = read (pi->as_fd, myaddr, len);
1959         }
1960       if (nbytes < 0)
1961         {
1962           nbytes = 0;
1963         }
1964     }
1965   return (nbytes);
1966 }
1967
1968 /*
1969
1970 LOCAL FUNCTION
1971
1972         procfs_store_registers -- copy register values back to inferior
1973
1974 SYNOPSIS
1975
1976         void procfs_store_registers (int regno)
1977
1978 DESCRIPTION
1979
1980         Store our current register values back into the inferior.  If
1981         REGNO is -1 then store all the register, otherwise store just
1982         the value specified by REGNO.
1983
1984 NOTES
1985
1986         If we are storing only a single register, we first have to get all
1987         the current values from the process, overwrite the desired register
1988         in the gregset with the one we want from gdb's registers, and then
1989         send the whole set back to the process.  For writing all the
1990         registers, all we have to do is generate the gregset and send it to
1991         the process.
1992
1993         Also note that the process has to be stopped on an event of interest
1994         for this to work, which basically means that it has to have been
1995         run under the control of one of the other /proc ioctl calls and not
1996         ptrace.  Since we don't use ptrace anyway, we don't worry about this
1997         fine point, but it is worth noting for future reference.
1998
1999         Gdb is confused about what this function is supposed to return.
2000         Some versions return a value, others return nothing.  Some are
2001         declared to return a value and actually return nothing.  Gdb ignores
2002         anything returned.  (FIXME)
2003
2004  */
2005
2006 static void
2007 procfs_store_registers (regno)
2008      int regno;
2009 {
2010   struct procinfo *pi;
2011 #ifdef PROCFS_USE_READ_WRITE
2012   struct greg_ctl greg;
2013   struct fpreg_ctl fpreg;
2014 #endif
2015
2016   pi = current_procinfo;
2017
2018 #ifdef PROCFS_USE_READ_WRITE
2019   if (regno != -1)
2020     {
2021       procfs_read_status (pi);
2022       memcpy ((char *) &greg.gregset,
2023          (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs,
2024          sizeof (gdb_gregset_t));
2025     }
2026   fill_gregset (&greg.gregset, regno);
2027   greg.cmd = PCSREG;
2028   write (pi->ctl_fd, &greg, sizeof (greg));
2029 #else /* PROCFS_USE_READ_WRITE */
2030   if (regno != -1)
2031     {
2032       ioctl (pi->ctl_fd, PIOCGREG, &pi->gregset.gregset);
2033     }
2034   fill_gregset (&pi->gregset.gregset, regno);
2035   ioctl (pi->ctl_fd, PIOCSREG, &pi->gregset.gregset);
2036 #endif /* PROCFS_USE_READ_WRITE */
2037
2038 #if defined (FP0_REGNUM)
2039
2040   /* Now repeat everything using the floating point register set, if the
2041      target has floating point hardware. Since we ignore the returned value,
2042      we'll never know whether it worked or not anyway. */
2043
2044 #ifdef PROCFS_USE_READ_WRITE
2045   if (regno != -1)
2046     {
2047       procfs_read_status (pi);
2048       memcpy ((char *) &fpreg.fpregset,
2049           (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs,
2050           sizeof (gdb_fpregset_t));
2051     }
2052   fill_fpregset (&fpreg.fpregset, regno);
2053   fpreg.cmd = PCSFPREG;
2054   write (pi->ctl_fd, &fpreg, sizeof (fpreg));
2055 #else /* PROCFS_USE_READ_WRITE */
2056   if (regno != -1)
2057     {
2058       ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset.fpregset);
2059     }
2060   fill_fpregset (&pi->fpregset.fpregset, regno);
2061   ioctl (pi->ctl_fd, PIOCSFPREG, &pi->fpregset.fpregset);
2062 #endif /* PROCFS_USE_READ_WRITE */
2063
2064 #endif  /* FP0_REGNUM */
2065
2066 }
2067
2068 /*
2069
2070 LOCAL FUNCTION
2071
2072         init_procinfo - setup a procinfo struct and connect it to a process
2073
2074 SYNOPSIS
2075
2076         struct procinfo * init_procinfo (int pid)
2077
2078 DESCRIPTION
2079
2080         Allocate a procinfo structure, open the /proc file and then set up the
2081         set of signals and faults that are to be traced.  Returns a pointer to
2082         the new procinfo structure.
2083
2084 NOTES
2085
2086         If proc_init_failed ever gets called, control returns to the command
2087         processing loop via the standard error handling code.
2088
2089  */
2090
2091 static struct procinfo *
2092 init_procinfo (pid, kill)
2093      int pid;
2094      int kill;
2095 {
2096   struct procinfo *pi = (struct procinfo *)
2097     xmalloc (sizeof (struct procinfo));
2098   struct sig_ctl  sctl;
2099   struct flt_ctl  fctl;
2100
2101   memset ((char *) pi, 0, sizeof (*pi));
2102   if (!open_proc_file (pid, pi, O_RDWR, 1))
2103     proc_init_failed (pi, "can't open process file", kill);
2104
2105   /* open_proc_file may modify pid.  */
2106
2107   pid = pi -> pid;
2108
2109   /* Add new process to process info list */
2110
2111   pi->next = procinfo_list;
2112   procinfo_list = pi;
2113
2114   add_fd (pi);                  /* Add to list for poll/select */
2115
2116   /*  Remember some things about the inferior that we will, or might, change
2117       so that we can restore them when we detach. */
2118 #ifdef UNIXWARE
2119   memcpy ((char *) &pi->saved_trace.sigset,
2120           (char *) &pi->prstatus.pr_sigtrace, sizeof (sigset_t));
2121   memcpy ((char *) &pi->saved_fltset.fltset,
2122           (char *) &pi->prstatus.pr_flttrace, sizeof (fltset_t));
2123   memcpy ((char *) &pi->saved_entryset.sysset,
2124           (char *) &pi->prstatus.pr_sysentry, sizeof (sysset_t));
2125   memcpy ((char *) &pi->saved_exitset.sysset,
2126           (char *) &pi->prstatus.pr_sysexit, sizeof (sysset_t));
2127
2128   /* Set up trace and fault sets, as gdb expects them. */
2129
2130   prfillset (&sctl.sigset);
2131   notice_signals (pi, &sctl);
2132   prfillset (&fctl.fltset);
2133   prdelset (&fctl.fltset, FLTPAGE);
2134
2135 #else /* ! UNIXWARE */
2136   ioctl (pi->ctl_fd, PIOCGTRACE, &pi->saved_trace.sigset);
2137   ioctl (pi->ctl_fd, PIOCGHOLD, &pi->saved_sighold.sigset);
2138   ioctl (pi->ctl_fd, PIOCGFAULT, &pi->saved_fltset.fltset);
2139   ioctl (pi->ctl_fd, PIOCGENTRY, &pi->saved_entryset.sysset);
2140   ioctl (pi->ctl_fd, PIOCGEXIT, &pi->saved_exitset.sysset);
2141
2142   /* Set up trace and fault sets, as gdb expects them. */
2143
2144   memset ((char *) &pi->prrun, 0, sizeof (pi->prrun));
2145   prfillset (&pi->prrun.pr_trace);
2146   procfs_notice_signals (pid);
2147   prfillset (&pi->prrun.pr_fault);
2148   prdelset (&pi->prrun.pr_fault, FLTPAGE);
2149 #ifdef PROCFS_DONT_TRACE_FAULTS
2150   premptyset (&pi->prrun.pr_fault);
2151 #endif
2152 #endif /* UNIXWARE */
2153
2154   if (!procfs_read_status (pi))
2155     proc_init_failed (pi, "procfs_read_status failed", kill);
2156
2157   return pi;
2158 }
2159
2160 /*
2161
2162 LOCAL FUNCTION
2163
2164         create_procinfo - initialize access to a /proc entry
2165
2166 SYNOPSIS
2167
2168         struct procinfo * create_procinfo (int pid)
2169
2170 DESCRIPTION
2171
2172         Allocate a procinfo structure, open the /proc file and then set up the
2173         set of signals and faults that are to be traced.  Returns a pointer to
2174         the new procinfo structure.
2175
2176 NOTES
2177
2178         If proc_init_failed ever gets called, control returns to the command
2179         processing loop via the standard error handling code.
2180
2181  */
2182
2183 static struct procinfo *
2184 create_procinfo (pid)
2185      int pid;
2186 {
2187   struct procinfo *pi;
2188   struct sig_ctl  sctl;
2189   struct flt_ctl  fctl;
2190
2191   pi = find_procinfo (pid, 1);
2192   if (pi != NULL)
2193     return pi;                  /* All done!  It already exists */
2194
2195   pi = init_procinfo (pid, 1);
2196
2197 #ifndef UNIXWARE
2198 /* A bug in Solaris (2.5 at least) causes PIOCWSTOP to hang on LWPs that are
2199    already stopped, even if they all have PR_ASYNC set.  */
2200   if (!(pi->prstatus.pr_flags & PR_STOPPED))
2201 #endif
2202     if (!procfs_write_pcwstop (pi))
2203       proc_init_failed (pi, "procfs_write_pcwstop failed", 1);
2204
2205 #ifdef PROCFS_USE_READ_WRITE
2206   fctl.cmd = PCSFAULT;
2207   if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
2208     proc_init_failed (pi, "PCSFAULT failed", 1);
2209 #else
2210   if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0)
2211     proc_init_failed (pi, "PIOCSFAULT failed", 1);
2212 #endif
2213
2214   return pi;
2215 }
2216
2217 /*
2218
2219 LOCAL FUNCTION
2220
2221         procfs_exit_handler - handle entry into the _exit syscall
2222
2223 SYNOPSIS
2224
2225         int procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
2226
2227 DESCRIPTION
2228
2229         This routine is called when an inferior process enters the _exit()
2230         system call.  It continues the process, and then collects the exit
2231         status and pid which are returned in *statvalp and *rtnvalp.  After
2232         that it returns non-zero to indicate that procfs_wait should wake up.
2233
2234 NOTES
2235         There is probably a better way to do this.
2236
2237  */
2238
2239 static int
2240 procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
2241      struct procinfo *pi;
2242      int syscall_num;
2243      int why;
2244      int *rtnvalp;
2245      int *statvalp;
2246 {
2247   struct procinfo *temp_pi, *next_pi;
2248   struct proc_ctl pctl;
2249
2250 #ifdef UNIXWARE
2251   pctl.cmd = PCRUN;
2252   pctl.data = PRCFAULT;
2253 #else
2254   pi->prrun.pr_flags = PRCFAULT;
2255 #endif
2256
2257 #ifdef PROCFS_USE_READ_WRITE
2258   if (write (pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
2259 #else
2260   if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
2261 #endif
2262     perror_with_name (pi->pathname);
2263
2264   if (attach_flag)
2265     {
2266       /* Claim it exited (don't call wait). */
2267       if (info_verbose)
2268         printf_filtered ("(attached process has exited)\n");
2269       *statvalp = 0;
2270       *rtnvalp  = inferior_pid;
2271     }
2272   else
2273     {
2274       *rtnvalp = wait (statvalp);
2275       if (*rtnvalp >= 0)
2276         *rtnvalp = pi->pid;
2277     }
2278
2279   /* Close ALL open proc file handles,
2280      except the one that called SYS_exit. */
2281   for (temp_pi = procinfo_list; temp_pi; temp_pi = next_pi)
2282     {
2283       next_pi = temp_pi->next;
2284       if (temp_pi == pi)
2285         continue;               /* Handled below */
2286       close_proc_file (temp_pi);
2287     }
2288   return 1;
2289 }
2290
2291 /*
2292
2293 LOCAL FUNCTION
2294
2295         procfs_exec_handler - handle exit from the exec family of syscalls
2296
2297 SYNOPSIS
2298
2299         int procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
2300
2301 DESCRIPTION
2302
2303         This routine is called when an inferior process is about to finish any
2304         of the exec() family of system calls.  It pretends that we got a
2305         SIGTRAP (for compatibility with ptrace behavior), and returns non-zero
2306         to tell procfs_wait to wake up.
2307
2308 NOTES
2309         This need for compatibility with ptrace is questionable.  In the
2310         future, it shouldn't be necessary.
2311
2312  */
2313
2314 static int
2315 procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
2316      struct procinfo *pi;
2317      int syscall_num;
2318      int why;
2319      int *rtnvalp;
2320      int *statvalp;
2321 {
2322   *statvalp = (SIGTRAP << 8) | 0177;
2323
2324   return 1;
2325 }
2326
2327 #if defined(SYS_sproc) && !defined(UNIXWARE)
2328 /* IRIX lwp creation system call */
2329
2330 /*
2331
2332 LOCAL FUNCTION
2333
2334         procfs_sproc_handler - handle exit from the sproc syscall
2335
2336 SYNOPSIS
2337
2338         int procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
2339
2340 DESCRIPTION
2341
2342         This routine is called when an inferior process is about to finish an
2343         sproc() system call.  This is the system call that IRIX uses to create
2344         a lightweight process.  When the target process gets this event, we can
2345         look at rval1 to find the new child processes ID, and create a new
2346         procinfo struct from that.
2347
2348         After that, it pretends that we got a SIGTRAP, and returns non-zero
2349         to tell procfs_wait to wake up.  Subsequently, wait_for_inferior gets
2350         woken up, sees the new process and continues it.
2351
2352 NOTES
2353         We actually never see the child exiting from sproc because we will
2354         shortly stop the child with PIOCSTOP, which is then registered as the
2355         event of interest.
2356  */
2357
2358 static int
2359 procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
2360      struct procinfo *pi;
2361      int syscall_num;
2362      int why;
2363      int *rtnvalp;
2364      int *statvalp;
2365 {
2366 /* We've just detected the completion of an sproc system call.  Now we need to
2367    setup a procinfo struct for this thread, and notify the thread system of the
2368    new arrival.  */
2369
2370 /* If sproc failed, then nothing interesting happened.  Continue the process
2371    and go back to sleep. */
2372
2373   if (pi->prstatus.pr_errno != 0)
2374     {
2375       pi->prrun.pr_flags &= PRSTEP;
2376       pi->prrun.pr_flags |= PRCFAULT;
2377
2378       if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
2379         perror_with_name (pi->pathname);
2380
2381       return 0;
2382     }
2383
2384   /* At this point, the new thread is stopped at it's first instruction, and
2385      the parent is stopped at the exit from sproc.  */
2386
2387   /* Notify the caller of the arrival of a new thread. */
2388   create_procinfo (pi->prstatus.pr_rval1);
2389
2390   *rtnvalp = pi->prstatus.pr_rval1;
2391   *statvalp = (SIGTRAP << 8) | 0177;
2392
2393   return 1;
2394 }
2395
2396 /*
2397
2398 LOCAL FUNCTION
2399
2400         procfs_fork_handler - handle exit from the fork syscall
2401
2402 SYNOPSIS
2403
2404         int procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
2405
2406 DESCRIPTION
2407
2408         This routine is called when an inferior process is about to finish a
2409         fork() system call.  We will open up the new process, and then close
2410         it, which releases it from the clutches of the debugger.
2411
2412         After that, we continue the target process as though nothing had
2413         happened.
2414
2415 NOTES
2416         This is necessary for IRIX because we have to set PR_FORK in order
2417         to catch the creation of lwps (via sproc()).  When an actual fork
2418         occurs, it becomes necessary to reset the forks debugger flags and
2419         continue it because we can't hack multiple processes yet.
2420  */
2421
2422 static int
2423 procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
2424      struct procinfo *pi;
2425      int syscall_num;
2426      int why;
2427      int *rtnvalp;
2428      int *statvalp;
2429 {
2430   struct procinfo *pitemp;
2431
2432 /* At this point, we've detected the completion of a fork (or vfork) call in
2433    our child.  The grandchild is also stopped because we set inherit-on-fork
2434    earlier.  (Note that nobody has the grandchilds' /proc file open at this
2435    point.)  We will release the grandchild from the debugger by opening it's
2436    /proc file and then closing it.  Since run-on-last-close is set, the
2437    grandchild continues on its' merry way.  */
2438
2439
2440   pitemp = create_procinfo (pi->prstatus.pr_rval1);
2441   if (pitemp)
2442     close_proc_file (pitemp);
2443
2444   if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
2445     perror_with_name (pi->pathname);
2446
2447   return 0;
2448 }
2449 #endif /* SYS_sproc && !UNIXWARE */
2450
2451 /*
2452
2453 LOCAL FUNCTION
2454
2455         procfs_set_inferior_syscall_traps - setup the syscall traps
2456
2457 SYNOPSIS
2458
2459         void procfs_set_inferior_syscall_traps (struct procinfo *pip)
2460
2461 DESCRIPTION
2462
2463         Called for each "procinfo" (process, thread, or LWP) in the
2464         inferior, to register for notification of and handlers for
2465         syscall traps in the inferior.
2466
2467  */
2468
2469 static void
2470 procfs_set_inferior_syscall_traps (pip)
2471      struct procinfo *pip;
2472 {
2473   procfs_set_syscall_trap (pip, SYS_exit, PROCFS_SYSCALL_ENTRY,
2474                            procfs_exit_handler);
2475
2476 #ifndef PRFS_STOPEXEC
2477 #ifdef SYS_exec
2478   procfs_set_syscall_trap (pip, SYS_exec, PROCFS_SYSCALL_EXIT,
2479                            procfs_exec_handler);
2480 #endif
2481 #ifdef SYS_execv
2482   procfs_set_syscall_trap (pip, SYS_execv, PROCFS_SYSCALL_EXIT,
2483                            procfs_exec_handler);
2484 #endif
2485 #ifdef SYS_execve
2486   procfs_set_syscall_trap (pip, SYS_execve, PROCFS_SYSCALL_EXIT,
2487                            procfs_exec_handler);
2488 #endif
2489 #endif  /* PRFS_STOPEXEC */
2490
2491   /* Setup traps on exit from sproc() */
2492
2493 #ifdef SYS_sproc
2494   procfs_set_syscall_trap (pip, SYS_sproc, PROCFS_SYSCALL_EXIT,
2495                            procfs_sproc_handler);
2496   procfs_set_syscall_trap (pip, SYS_fork, PROCFS_SYSCALL_EXIT,
2497                            procfs_fork_handler);
2498 #ifdef SYS_vfork
2499   procfs_set_syscall_trap (pip, SYS_vfork, PROCFS_SYSCALL_EXIT,
2500                            procfs_fork_handler);
2501 #endif
2502 /* Turn on inherit-on-fork flag so that all children of the target process
2503    start with tracing flags set.  This allows us to trap lwp creation.  Note
2504    that we also have to trap on fork and vfork in order to disable all tracing
2505    in the targets child processes.  */
2506
2507   modify_inherit_on_fork_flag (pip->ctl_fd, 1);
2508 #endif
2509
2510 #ifdef SYS_lwp_create
2511   procfs_set_syscall_trap (pip, SYS_lwp_create, PROCFS_SYSCALL_EXIT,
2512                            procfs_lwp_creation_handler);
2513 #endif
2514 }
2515
2516 /*
2517
2518 LOCAL FUNCTION
2519
2520         procfs_init_inferior - initialize target vector and access to a
2521         /proc entry
2522
2523 SYNOPSIS
2524
2525         void procfs_init_inferior (int pid)
2526
2527 DESCRIPTION
2528
2529         When gdb starts an inferior, this function is called in the parent
2530         process immediately after the fork.  It waits for the child to stop
2531         on the return from the exec system call (the child itself takes care
2532         of ensuring that this is set up), then sets up the set of signals
2533         and faults that are to be traced.  Returns the pid, which may have had
2534         the thread-id added to it.
2535
2536 NOTES
2537
2538         If proc_init_failed ever gets called, control returns to the command
2539         processing loop via the standard error handling code.
2540
2541  */
2542
2543 static void
2544 procfs_init_inferior (pid)
2545      int pid;
2546 {
2547   struct procinfo *pip;
2548
2549   push_target (&procfs_ops);
2550
2551   pip = create_procinfo (pid);
2552
2553   procfs_set_inferior_syscall_traps (pip);
2554
2555   /* create_procinfo may change the pid, so we have to update inferior_pid
2556      here before calling other gdb routines that need the right pid.  */
2557
2558   pid = pip -> pid;
2559   inferior_pid = pid;
2560
2561   add_thread (pip -> pid);      /* Setup initial thread */
2562
2563 #ifdef START_INFERIOR_TRAPS_EXPECTED
2564   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
2565 #else
2566   /* One trap to exec the shell, one to exec the program being debugged.  */
2567   startup_inferior (2);
2568 #endif
2569 }
2570
2571 /*
2572
2573 GLOBAL FUNCTION
2574
2575         procfs_notice_signals
2576
2577 SYNOPSIS
2578
2579         static void procfs_notice_signals (int pid);
2580
2581 DESCRIPTION
2582
2583         When the user changes the state of gdb's signal handling via the
2584         "handle" command, this function gets called to see if any change
2585         in the /proc interface is required.  It is also called internally
2586         by other /proc interface functions to initialize the state of
2587         the traced signal set.
2588
2589         One thing it does is that signals for which the state is "nostop",
2590         "noprint", and "pass", have their trace bits reset in the pr_trace
2591         field, so that they are no longer traced.  This allows them to be
2592         delivered directly to the inferior without the debugger ever being
2593         involved.
2594  */
2595
2596 static void
2597 procfs_notice_signals (pid)
2598      int pid;
2599 {
2600   struct procinfo *pi;
2601   struct sig_ctl  sctl;
2602
2603   pi = find_procinfo (pid, 0);
2604
2605 #ifdef UNIXWARE
2606   premptyset (&sctl.sigset);
2607 #else
2608   sctl.sigset = pi->prrun.pr_trace;
2609 #endif
2610
2611   notice_signals (pi, &sctl);
2612
2613 #ifndef UNIXWARE
2614   pi->prrun.pr_trace = sctl.sigset;
2615 #endif
2616 }
2617
2618 static void
2619 notice_signals (pi, sctl)
2620         struct procinfo *pi;
2621         struct sig_ctl *sctl;
2622 {
2623   int signo;
2624
2625   for (signo = 0; signo < NSIG; signo++)
2626     {
2627       if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
2628           signal_print_state (target_signal_from_host (signo)) == 0 &&
2629           signal_pass_state (target_signal_from_host (signo)) == 1)
2630         {
2631           prdelset (&sctl->sigset, signo);
2632         }
2633       else
2634         {
2635           praddset (&sctl->sigset, signo);
2636         }
2637     }
2638 #ifdef PROCFS_USE_READ_WRITE
2639   sctl->cmd = PCSTRACE;
2640   if (write (pi->ctl_fd, (char *) sctl, sizeof (struct sig_ctl)) < 0)
2641 #else
2642   if (ioctl (pi->ctl_fd, PIOCSTRACE, &sctl->sigset))
2643 #endif
2644     {
2645       print_sys_errmsg ("PIOCSTRACE failed", errno);
2646     }
2647 }
2648
2649 /*
2650
2651 LOCAL FUNCTION
2652
2653         proc_set_exec_trap -- arrange for exec'd child to halt at startup
2654
2655 SYNOPSIS
2656
2657         void proc_set_exec_trap (void)
2658
2659 DESCRIPTION
2660
2661         This function is called in the child process when starting up
2662         an inferior, prior to doing the exec of the actual inferior.
2663         It sets the child process's exitset to make exit from the exec
2664         system call an event of interest to stop on, and then simply
2665         returns.  The child does the exec, the system call returns, and
2666         the child stops at the first instruction, ready for the gdb
2667         parent process to take control of it.
2668
2669 NOTE
2670
2671         We need to use all local variables since the child may be sharing
2672         it's data space with the parent, if vfork was used rather than
2673         fork.
2674
2675         Also note that we want to turn off the inherit-on-fork flag in
2676         the child process so that any grand-children start with all
2677         tracing flags cleared.
2678  */
2679
2680 static void
2681 proc_set_exec_trap ()
2682 {
2683   struct sys_ctl exitset;
2684   struct sys_ctl entryset;
2685   char procname[MAX_PROC_NAME_SIZE];
2686   int fd;
2687
2688   sprintf (procname, CTL_PROC_NAME_FMT, getpid ());
2689 #ifdef UNIXWARE
2690   if ((fd = open (procname, O_WRONLY)) < 0)
2691 #else
2692   if ((fd = open (procname, O_RDWR)) < 0)
2693 #endif
2694     {
2695       perror (procname);
2696       gdb_flush (gdb_stderr);
2697       _exit (127);
2698     }
2699   premptyset (&exitset.sysset);
2700   premptyset (&entryset.sysset);
2701
2702 #ifdef PRFS_STOPEXEC
2703   /* Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
2704      exits from exec system calls because of the user level loader.  */
2705   {
2706     int prfs_flags;
2707
2708     if (ioctl (fd, PIOCGSPCACT, &prfs_flags) < 0)
2709       {
2710         perror (procname);
2711         gdb_flush (gdb_stderr);
2712         _exit (127);
2713       }
2714     prfs_flags |= PRFS_STOPEXEC;
2715     if (ioctl (fd, PIOCSSPCACT, &prfs_flags) < 0)
2716       {
2717         perror (procname);
2718         gdb_flush (gdb_stderr);
2719         _exit (127);
2720       }
2721   }
2722 #else /* PRFS_STOPEXEC */
2723   /* GW: Rationale...
2724      Not all systems with /proc have all the exec* syscalls with the same
2725      names.  On the SGI, for example, there is no SYS_exec, but there
2726      *is* a SYS_execv.  So, we try to account for that. */
2727
2728 #ifdef SYS_exec
2729   praddset (&exitset.sysset, SYS_exec);
2730 #endif
2731 #ifdef SYS_execve
2732   praddset (&exitset.sysset, SYS_execve);
2733 #endif
2734 #ifdef SYS_execv
2735   praddset (&exitset.sysset, SYS_execv);
2736 #endif
2737
2738 #ifdef PROCFS_USE_READ_WRITE
2739   exitset.cmd = PCSEXIT;
2740   if (write (fd, (char *) &exitset, sizeof (struct sys_ctl)) < 0)
2741 #else
2742   if (ioctl (fd, PIOCSEXIT, &exitset.sysset) < 0)
2743 #endif
2744     {
2745       perror (procname);
2746       gdb_flush (gdb_stderr);
2747       _exit (127);
2748     }
2749 #endif /* PRFS_STOPEXEC */
2750
2751   praddset (&entryset.sysset, SYS_exit);
2752
2753 #ifdef PROCFS_USE_READ_WRITE
2754   entryset.cmd = PCSENTRY;
2755   if (write (fd, (char *) &entryset, sizeof (struct sys_ctl)) < 0)
2756 #else
2757   if (ioctl (fd, PIOCSENTRY, &entryset.sysset) < 0)
2758 #endif
2759     {
2760       perror (procname);
2761       gdb_flush (gdb_stderr);
2762       _exit (126);
2763     }
2764
2765   /* Turn off inherit-on-fork flag so that all grand-children of gdb
2766      start with tracing flags cleared. */
2767
2768   modify_inherit_on_fork_flag (fd, 0);
2769
2770   /* Turn on run-on-last-close flag so that this process will not hang
2771      if GDB goes away for some reason.  */
2772
2773   modify_run_on_last_close_flag (fd, 1);
2774
2775 #ifndef UNIXWARE        /* since this is a solaris-ism, we don't want it */
2776                         /* NOTE: revisit when doing thread support for UW */
2777 #ifdef PR_ASYNC
2778   {
2779     long pr_flags;
2780     struct proc_ctl pctl;
2781
2782 /* Solaris needs this to make procfs treat all threads seperately.  Without
2783    this, all threads halt whenever something happens to any thread.  Since
2784    GDB wants to control all this itself, it needs to set PR_ASYNC.  */
2785
2786     pr_flags = PR_ASYNC;
2787 #ifdef PROCFS_USE_READ_WRITE
2788     pctl.cmd = PCSET;
2789     pctl.data = PR_FORK|PR_ASYNC;
2790     write (fd, (char *) &pctl, sizeof (struct proc_ctl));
2791 #else
2792     ioctl (fd, PIOCSET, &pr_flags);
2793 #endif
2794   }
2795 #endif  /* PR_ASYNC */
2796 #endif  /* !UNIXWARE */
2797 }
2798
2799 /*
2800
2801 GLOBAL FUNCTION
2802
2803         proc_iterate_over_mappings -- call function for every mapped space
2804
2805 SYNOPSIS
2806
2807         int proc_iterate_over_mappings (int (*func)())
2808
2809 DESCRIPTION
2810
2811         Given a pointer to a function, call that function for every
2812         mapped address space, passing it an open file descriptor for
2813         the file corresponding to that mapped address space (if any)
2814         and the base address of the mapped space.  Quit when we hit
2815         the end of the mappings or the function returns nonzero.
2816  */
2817
2818 #ifdef UNIXWARE
2819 int
2820 proc_iterate_over_mappings (func)
2821      int (*func) PARAMS ((int, CORE_ADDR));
2822 {
2823   int nmap;
2824   int fd;
2825   int funcstat = 0;
2826   prmap_t *prmaps;
2827   prmap_t *prmap;
2828   struct procinfo *pi;
2829   struct stat sbuf;
2830
2831   pi = current_procinfo;
2832
2833   if (fstat (pi->map_fd, &sbuf) < 0)
2834     return 0;
2835
2836   nmap = sbuf.st_size / sizeof (prmap_t);
2837   prmaps = (prmap_t *) alloca (nmap * sizeof(prmap_t));
2838   if ((lseek (pi->map_fd, 0, SEEK_SET) == 0) &&
2839         (read (pi->map_fd, (char *) prmaps, nmap * sizeof (prmap_t)) ==
2840         (nmap * sizeof (prmap_t))))
2841     {
2842       int i = 0;
2843       for (prmap = prmaps; i < nmap && funcstat == 0; ++prmap, ++i)
2844         {
2845           char name[sizeof ("/proc/1234567890/object") +
2846                 sizeof (prmap->pr_mapname)];
2847           sprintf (name, "/proc/%d/object/%s", pi->pid, prmap->pr_mapname);
2848           if ((fd = open (name, O_RDONLY)) == -1)
2849             {
2850               funcstat = 1;
2851               break;
2852             }
2853           funcstat = (*func) (fd, (CORE_ADDR) prmap->pr_vaddr);
2854           close (fd);
2855         }
2856     }
2857   return (funcstat);
2858 }
2859 #else /* UNIXWARE */
2860 int
2861 proc_iterate_over_mappings (func)
2862      int (*func) PARAMS ((int, CORE_ADDR));
2863 {
2864   int nmap;
2865   int fd;
2866   int funcstat = 0;
2867   struct prmap *prmaps;
2868   struct prmap *prmap;
2869   struct procinfo *pi;
2870
2871   pi = current_procinfo;
2872
2873   if (ioctl (pi->map_fd, PIOCNMAP, &nmap) == 0)
2874     {
2875       prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
2876       if (ioctl (pi->map_fd, PIOCMAP, prmaps) == 0)
2877         {
2878           for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
2879             {
2880               fd = proc_address_to_fd (pi, (CORE_ADDR) prmap -> pr_vaddr, 0);
2881               funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
2882               close (fd);
2883             }
2884         }
2885     }
2886   return (funcstat);
2887 }
2888 #endif /* UNIXWARE */
2889
2890 #if 0   /* Currently unused */
2891 /*
2892
2893 GLOBAL FUNCTION
2894
2895         proc_base_address -- find base address for segment containing address
2896
2897 SYNOPSIS
2898
2899         CORE_ADDR proc_base_address (CORE_ADDR addr)
2900
2901 DESCRIPTION
2902
2903         Given an address of a location in the inferior, find and return
2904         the base address of the mapped segment containing that address.
2905
2906         This is used for example, by the shared library support code,
2907         where we have the pc value for some location in the shared library
2908         where we are stopped, and need to know the base address of the
2909         segment containing that address.
2910 */
2911
2912 CORE_ADDR
2913 proc_base_address (addr)
2914      CORE_ADDR addr;
2915 {
2916   int nmap;
2917   struct prmap *prmaps;
2918   struct prmap *prmap;
2919   CORE_ADDR baseaddr = 0;
2920   struct procinfo *pi;
2921
2922   pi = current_procinfo;
2923
2924   if (ioctl (pi->map_fd, PIOCNMAP, &nmap) == 0)
2925     {
2926       prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
2927       if (ioctl (pi->map_fd, PIOCMAP, prmaps) == 0)
2928         {
2929           for (prmap = prmaps; prmap -> pr_size; ++prmap)
2930             {
2931               if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
2932                   (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
2933                 {
2934                   baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
2935                   break;
2936                 }
2937             }
2938         }
2939     }
2940   return (baseaddr);
2941 }
2942
2943 #endif  /* 0 */
2944
2945 #ifndef UNIXWARE
2946 /*
2947
2948 LOCAL FUNCTION
2949
2950         proc_address_to_fd -- return open fd for file mapped to address
2951
2952 SYNOPSIS
2953
2954         int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
2955
2956 DESCRIPTION
2957
2958         Given an address in the current inferior's address space, use the
2959         /proc interface to find an open file descriptor for the file that
2960         this address was mapped in from.  Return -1 if there is no current
2961         inferior.  Print a warning message if there is an inferior but
2962         the address corresponds to no file (IE a bogus address).
2963
2964 */
2965
2966 static int
2967 proc_address_to_fd (pi, addr, complain)
2968      struct procinfo *pi;
2969      CORE_ADDR addr;
2970      int complain;
2971 {
2972   int fd = -1;
2973
2974   if ((fd = ioctl (pi->ctl_fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
2975     {
2976       if (complain)
2977         {
2978           print_sys_errmsg (pi->pathname, errno);
2979           warning ("can't find mapped file for address 0x%x", addr);
2980         }
2981     }
2982   return (fd);
2983 }
2984 #endif /* !UNIXWARE */
2985
2986 /* Attach to process PID, then initialize for debugging it
2987    and wait for the trace-trap that results from attaching.  */
2988
2989 static void
2990 procfs_attach (args, from_tty)
2991      char *args;
2992      int from_tty;
2993 {
2994   char *exec_file;
2995   int pid;
2996
2997   if (!args)
2998     error_no_arg ("process-id to attach");
2999
3000   pid = atoi (args);
3001
3002   if (pid == getpid())          /* Trying to masturbate? */
3003     error ("I refuse to debug myself!");
3004
3005   if (from_tty)
3006     {
3007       exec_file = (char *) get_exec_file (0);
3008
3009       if (exec_file)
3010         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, target_pid_to_str (pid));
3011       else
3012         printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
3013
3014       gdb_flush (gdb_stdout);
3015     }
3016
3017   inferior_pid = pid = do_attach (pid);
3018   push_target (&procfs_ops);
3019 }
3020
3021
3022 /* Take a program previously attached to and detaches it.
3023    The program resumes execution and will no longer stop
3024    on signals, etc.  We'd better not have left any breakpoints
3025    in the program or it'll die when it hits one.  For this
3026    to work, it may be necessary for the process to have been
3027    previously attached.  It *might* work if the program was
3028    started via the normal ptrace (PTRACE_TRACEME).  */
3029
3030 static void
3031 procfs_detach (args, from_tty)
3032      char *args;
3033      int from_tty;
3034 {
3035   int siggnal = 0;
3036
3037   if (from_tty)
3038     {
3039       char *exec_file = get_exec_file (0);
3040       if (exec_file == 0)
3041         exec_file = "";
3042       printf_unfiltered ("Detaching from program: %s %s\n",
3043               exec_file, target_pid_to_str (inferior_pid));
3044       gdb_flush (gdb_stdout);
3045     }
3046   if (args)
3047     siggnal = atoi (args);
3048
3049   do_detach (siggnal);
3050   inferior_pid = 0;
3051   unpush_target (&procfs_ops);          /* Pop out of handling an inferior */
3052 }
3053
3054 /* Get ready to modify the registers array.  On machines which store
3055    individual registers, this doesn't need to do anything.  On machines
3056    which store all the registers in one fell swoop, this makes sure
3057    that registers contains all the registers from the program being
3058    debugged.  */
3059
3060 static void
3061 procfs_prepare_to_store ()
3062 {
3063 #ifdef CHILD_PREPARE_TO_STORE
3064   CHILD_PREPARE_TO_STORE ();
3065 #endif
3066 }
3067
3068 /* Print status information about what we're accessing.  */
3069
3070 static void
3071 procfs_files_info (ignore)
3072      struct target_ops *ignore;
3073 {
3074   printf_unfiltered ("\tUsing the running image of %s %s via /proc.\n",
3075           attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
3076 }
3077
3078 /* ARGSUSED */
3079 static void
3080 procfs_open (arg, from_tty)
3081      char *arg;
3082      int from_tty;
3083 {
3084   error ("Use the \"run\" command to start a Unix child process.");
3085 }
3086
3087 /*
3088
3089 LOCAL FUNCTION
3090
3091         do_attach -- attach to an already existing process
3092
3093 SYNOPSIS
3094
3095         int do_attach (int pid)
3096
3097 DESCRIPTION
3098
3099         Attach to an already existing process with the specified process
3100         id.  If the process is not already stopped, query whether to
3101         stop it or not.
3102
3103 NOTES
3104
3105         The option of stopping at attach time is specific to the /proc
3106         versions of gdb.  Versions using ptrace force the attachee
3107         to stop.  (I have changed this version to do so, too.  All you
3108         have to do is "continue" to make it go on. -- [email protected])
3109
3110 */
3111
3112 static int
3113 do_attach (pid)
3114      int pid;
3115 {
3116   struct procinfo *pi;
3117   struct sig_ctl sctl;
3118   struct flt_ctl fctl;
3119   int nlwp, *lwps;
3120
3121   pi  = init_procinfo (pid, 0);
3122
3123 #ifdef PIOCLWPIDS
3124   nlwp = pi->prstatus.pr_nlwp;
3125   lwps = alloca ((2 * nlwp + 2) * sizeof (id_t));
3126
3127   if (ioctl (pi->ctl_fd, PIOCLWPIDS, lwps))
3128     {
3129       print_sys_errmsg (pi -> pathname, errno);
3130       error ("PIOCLWPIDS failed");
3131     }
3132 #else /* PIOCLWPIDS */
3133   nlwp = 1;
3134   lwps = alloca ((2 * nlwp + 2) * sizeof *lwps);
3135   lwps[0] = 0;
3136 #endif
3137   for (; nlwp > 0; nlwp--, lwps++)
3138     {
3139       /* First one has already been created above.  */
3140       if ((pi = find_procinfo ((*lwps << 16) | pid, 1)) == 0)
3141         pi = init_procinfo ((*lwps << 16) | pid, 0);
3142
3143 #ifdef UNIXWARE
3144       if (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP))
3145 #else
3146       if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
3147 #endif
3148         {
3149           pi->was_stopped = 1;
3150         }
3151       else
3152         {
3153           pi->was_stopped = 0;
3154           if (1 || query ("Process is currently running, stop it? "))
3155             {
3156               long cmd;
3157               /* Make it run again when we close it.  */
3158               modify_run_on_last_close_flag (pi->ctl_fd, 1);
3159 #ifdef PROCFS_USE_READ_WRITE
3160               cmd = PCSTOP;
3161               if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
3162 #else
3163               if (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) < 0)
3164 #endif
3165                 {
3166                   print_sys_errmsg (pi->pathname, errno);
3167                   close_proc_file (pi);
3168                   error ("PIOCSTOP failed");
3169                 }
3170 #ifdef UNIXWARE
3171               if (!procfs_read_status (pi))
3172                 {
3173                   print_sys_errmsg (pi->pathname, errno);
3174                   close_proc_file (pi);
3175                   error ("procfs_read_status failed");
3176                 }
3177 #endif
3178               pi->nopass_next_sigstop = 1;
3179             }
3180           else
3181             {
3182               printf_unfiltered ("Ok, gdb will wait for %s to stop.\n",
3183                                  target_pid_to_str (pi->pid));
3184             }
3185         }
3186
3187 #ifdef PROCFS_USE_READ_WRITE
3188       fctl.cmd = PCSFAULT;
3189       if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
3190         print_sys_errmsg ("PCSFAULT failed", errno);
3191 #else /* PROCFS_USE_READ_WRITE */
3192       if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault))
3193         {
3194           print_sys_errmsg ("PIOCSFAULT failed", errno);
3195         }
3196       if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->prrun.pr_trace))
3197         {
3198           print_sys_errmsg ("PIOCSTRACE failed", errno);
3199         }
3200       add_thread (pi->pid);
3201       procfs_set_inferior_syscall_traps (pi);
3202 #endif /* PROCFS_USE_READ_WRITE */
3203     }
3204   attach_flag = 1;
3205   return (pi->pid);
3206 }
3207
3208 /*
3209
3210 LOCAL FUNCTION
3211
3212         do_detach -- detach from an attached-to process
3213
3214 SYNOPSIS
3215
3216         void do_detach (int signal)
3217
3218 DESCRIPTION
3219
3220         Detach from the current attachee.
3221
3222         If signal is non-zero, the attachee is started running again and sent
3223         the specified signal.
3224
3225         If signal is zero and the attachee was not already stopped when we
3226         attached to it, then we make it runnable again when we detach.
3227
3228         Otherwise, we query whether or not to make the attachee runnable
3229         again, since we may simply want to leave it in the state it was in
3230         when we attached.
3231
3232         We report any problems, but do not consider them errors, since we
3233         MUST detach even if some things don't seem to go right.  This may not
3234         be the ideal situation.  (FIXME).
3235  */
3236
3237 static void
3238 do_detach (signal)
3239      int signal;
3240 {
3241   struct procinfo *pi;
3242
3243   for (pi = procinfo_list; pi; pi = pi->next)
3244     {
3245       if (signal)
3246         {
3247           set_proc_siginfo (pi, signal);
3248         }
3249 #ifdef PROCFS_USE_READ_WRITE
3250       pi->saved_exitset.cmd = PCSEXIT;
3251       if (write (pi->ctl_fd, (char *) &pi->saved_exitset,
3252                  sizeof (struct sys_ctl)) < 0)
3253 #else
3254         if (ioctl (pi->ctl_fd, PIOCSEXIT, &pi->saved_exitset.sysset) < 0)
3255 #endif
3256           {
3257             print_sys_errmsg (pi->pathname, errno);
3258             printf_unfiltered ("PIOCSEXIT failed.\n");
3259           }
3260 #ifdef PROCFS_USE_READ_WRITE
3261       pi->saved_entryset.cmd = PCSENTRY;
3262       if (write (pi->ctl_fd, (char *) &pi->saved_entryset,
3263                  sizeof (struct sys_ctl)) < 0)
3264 #else
3265         if (ioctl (pi->ctl_fd, PIOCSENTRY, &pi->saved_entryset.sysset) < 0)
3266 #endif
3267           {
3268             print_sys_errmsg (pi->pathname, errno);
3269             printf_unfiltered ("PIOCSENTRY failed.\n");
3270           }
3271 #ifdef PROCFS_USE_READ_WRITE
3272       pi->saved_trace.cmd = PCSTRACE;
3273       if (write (pi->ctl_fd, (char *) &pi->saved_trace,
3274                  sizeof (struct sig_ctl)) < 0)
3275 #else
3276         if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->saved_trace.sigset) < 0)
3277 #endif
3278           {
3279             print_sys_errmsg (pi->pathname, errno);
3280             printf_unfiltered ("PIOCSTRACE failed.\n");
3281           }
3282 #ifndef UNIXWARE
3283       if (ioctl (pi->ctl_fd, PIOCSHOLD, &pi->saved_sighold.sigset) < 0)
3284         {
3285           print_sys_errmsg (pi->pathname, errno);
3286           printf_unfiltered ("PIOSCHOLD failed.\n");
3287         }
3288 #endif
3289 #ifdef PROCFS_USE_READ_WRITE
3290       pi->saved_fltset.cmd = PCSFAULT;
3291       if (write (pi->ctl_fd, (char *) &pi->saved_fltset,
3292                  sizeof (struct flt_ctl)) < 0)
3293 #else
3294       if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->saved_fltset.fltset) < 0)
3295 #endif
3296         {
3297           print_sys_errmsg (pi->pathname, errno);
3298           printf_unfiltered ("PIOCSFAULT failed.\n");
3299         }
3300       if (!procfs_read_status (pi))
3301         {
3302           print_sys_errmsg (pi->pathname, errno);
3303           printf_unfiltered ("procfs_read_status failed.\n");
3304         }
3305       else
3306         {
3307 #ifdef UNIXWARE
3308           if (signal || (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)))
3309 #else
3310           if (signal || (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
3311 #endif
3312             {
3313               long cmd;
3314               struct proc_ctl pctl;
3315
3316               if (signal || !pi->was_stopped ||
3317                   query ("Was stopped when attached, make it runnable again? "))
3318                 {
3319                   /* Clear any pending signal if we want to detach without
3320                      a signal.  */
3321                   if (signal == 0)
3322                     set_proc_siginfo (pi, signal);
3323
3324                   /* Clear any fault that might have stopped it.  */
3325 #ifdef PROCFS_USE_READ_WRITE
3326                   cmd = PCCFAULT;
3327                   if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
3328 #else
3329                   if (ioctl (pi->ctl_fd, PIOCCFAULT, 0))
3330 #endif
3331                     {
3332                       print_sys_errmsg (pi->pathname, errno);
3333                       printf_unfiltered ("PIOCCFAULT failed.\n");
3334                     }
3335
3336                   /* Make it run again when we close it.  */
3337
3338                   modify_run_on_last_close_flag (pi->ctl_fd, 1);
3339                 }
3340             }
3341         }
3342       close_proc_file (pi);
3343     }
3344   attach_flag = 0;
3345 }
3346
3347 /*  emulate wait() as much as possible.
3348     Wait for child to do something.  Return pid of child, or -1 in case
3349     of error; store status in *OURSTATUS.
3350
3351     Not sure why we can't
3352     just use wait(), but it seems to have problems when applied to a
3353     process being controlled with the /proc interface.
3354
3355     We have a race problem here with no obvious solution.  We need to let
3356     the inferior run until it stops on an event of interest, which means
3357     that we need to use the PIOCWSTOP ioctl.  However, we cannot use this
3358     ioctl if the process is already stopped on something that is not an
3359     event of interest, or the call will hang indefinitely.  Thus we first
3360     use PIOCSTATUS to see if the process is not stopped.  If not, then we
3361     use PIOCWSTOP.  But during the window between the two, if the process
3362     stops for any reason that is not an event of interest (such as a job
3363     control signal) then gdb will hang.  One possible workaround is to set
3364     an alarm to wake up every minute of so and check to see if the process
3365     is still running, and if so, then reissue the PIOCWSTOP.  But this is
3366     a real kludge, so has not been implemented.  FIXME: investigate
3367     alternatives.
3368
3369     FIXME:  Investigate why wait() seems to have problems with programs
3370     being control by /proc routines.  */
3371 static int
3372 procfs_wait (pid, ourstatus)
3373      int pid;
3374      struct target_waitstatus *ourstatus;
3375 {
3376   short what;
3377   short why;
3378   int statval = 0;
3379   int checkerr = 0;
3380   int rtnval = -1;
3381   struct procinfo *pi;
3382   struct proc_ctl pctl;
3383
3384 scan_again:
3385
3386   /* handle all syscall events first, otherwise we might not
3387      notice a thread was created until too late. */
3388
3389   for (pi = procinfo_list; pi; pi = pi->next)
3390     {
3391       if (!pi->had_event)
3392         continue;
3393
3394 #ifdef UNIXWARE
3395       if (! (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)) )
3396         continue;
3397
3398       why = pi->prstatus.pr_lwp.pr_why;
3399       what = pi->prstatus.pr_lwp.pr_what;
3400 #else
3401       if (! (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)) )
3402         continue;
3403
3404       why = pi->prstatus.pr_why;
3405       what = pi->prstatus.pr_what;
3406 #endif
3407       if (why == PR_SYSENTRY || why == PR_SYSEXIT)
3408         {
3409           int i;
3410           int found_handler = 0;
3411
3412           for (i = 0; i < pi->num_syscall_handlers; i++)
3413             if (pi->syscall_handlers[i].syscall_num == what)
3414               {
3415                 found_handler = 1;
3416                 pi->saved_rtnval = pi->pid;
3417                 pi->saved_statval = 0;
3418                 if (!pi->syscall_handlers[i].func
3419                     (pi, what, why, &pi->saved_rtnval, &pi->saved_statval))
3420                   pi->had_event = 0;
3421                 break;
3422               }
3423
3424           if (!found_handler)
3425             {
3426               if (why == PR_SYSENTRY)
3427                 error ("PR_SYSENTRY, unhandled system call %d", what);
3428               else
3429                 error ("PR_SYSEXIT, unhandled system call %d", what);
3430             }
3431         }
3432     }
3433
3434   /* find a relevant process with an event */
3435
3436   for (pi = procinfo_list; pi; pi = pi->next)
3437     if (pi->had_event && (pid == -1 || pi->pid == pid))
3438       break;
3439
3440   if (!pi)
3441     {
3442       wait_fd ();
3443       goto scan_again;
3444     }
3445
3446 #ifdef UNIXWARE
3447   if (!checkerr && !(pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)))
3448 #else
3449   if (!checkerr && !(pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
3450 #endif
3451     {
3452       if (!procfs_write_pcwstop (pi))
3453         {
3454           checkerr++;
3455         }
3456     }
3457   if (checkerr)
3458     {
3459       if (errno == ENOENT)
3460         {
3461           /* XXX Fixme -- what to do if attached?  Can't call wait... */
3462           rtnval = wait (&statval);
3463           if ((rtnval) != (PIDGET (inferior_pid)))
3464             {
3465               print_sys_errmsg (pi->pathname, errno);
3466               error ("procfs_wait: wait failed, returned %d", rtnval);
3467               /* NOTREACHED */
3468             }
3469         }
3470       else
3471         {
3472           print_sys_errmsg (pi->pathname, errno);
3473           error ("PIOCSTATUS or PIOCWSTOP failed.");
3474           /* NOTREACHED */
3475         }
3476     }
3477 #ifdef UNIXWARE
3478   else if (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP))
3479 #else
3480   else if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
3481 #endif
3482     {
3483 #ifdef UNIXWARE
3484       rtnval = pi->prstatus.pr_pid;
3485       why = pi->prstatus.pr_lwp.pr_why;
3486       what = pi->prstatus.pr_lwp.pr_what;
3487 #else
3488       rtnval = pi->pid;
3489       why = pi->prstatus.pr_why;
3490       what = pi->prstatus.pr_what;
3491 #endif
3492
3493       switch (why)
3494         {
3495         case PR_SIGNALLED:
3496           statval = (what << 8) | 0177;
3497           break;
3498         case PR_SYSENTRY:
3499         case PR_SYSEXIT:
3500           rtnval = pi->saved_rtnval;
3501           statval = pi->saved_statval;
3502           break;
3503         case PR_REQUESTED:
3504           statval = (SIGSTOP << 8) | 0177;
3505           break;
3506         case PR_JOBCONTROL:
3507           statval = (what << 8) | 0177;
3508           break;
3509         case PR_FAULTED:
3510           switch (what)
3511             {
3512 #ifdef FLTWATCH
3513             case FLTWATCH:
3514               statval = (SIGTRAP << 8) | 0177;
3515               break;
3516 #endif
3517 #ifdef FLTKWATCH
3518             case FLTKWATCH:
3519               statval = (SIGTRAP << 8) | 0177;
3520               break;
3521 #endif
3522 #ifndef FAULTED_USE_SIGINFO
3523               /* Irix, contrary to the documentation, fills in 0 for si_signo.
3524                  Solaris fills in si_signo.  I'm not sure about others.  */
3525             case FLTPRIV:
3526             case FLTILL:
3527               statval = (SIGILL << 8) | 0177;
3528               break;
3529             case FLTBPT:
3530             case FLTTRACE:
3531               statval = (SIGTRAP << 8) | 0177;
3532               break;
3533             case FLTSTACK:
3534             case FLTACCESS:
3535             case FLTBOUNDS:
3536               statval = (SIGSEGV << 8) | 0177;
3537               break;
3538             case FLTIOVF:
3539             case FLTIZDIV:
3540             case FLTFPE:
3541               statval = (SIGFPE << 8) | 0177;
3542               break;
3543             case FLTPAGE:               /* Recoverable page fault */
3544 #endif /* not FAULTED_USE_SIGINFO */
3545             default:
3546               /* Use the signal which the kernel assigns.  This is better than
3547                  trying to second-guess it from the fault.  In fact, I suspect
3548                  that FLTACCESS can be either SIGSEGV or SIGBUS.  */
3549 #ifdef UNIXWARE
3550               statval = ((pi->prstatus.pr_lwp.pr_info.si_signo) << 8) | 0177;
3551 #else
3552               statval = ((pi->prstatus.pr_info.si_signo) << 8) | 0177;
3553 #endif
3554               break;
3555             }
3556           break;
3557         default:
3558           error ("PIOCWSTOP, unknown why %d, what %d", why, what);
3559         }
3560       /* Stop all the other threads when any of them stops.  */
3561
3562       {
3563         struct procinfo *procinfo, *next_pi;
3564
3565         for (procinfo = procinfo_list; procinfo; procinfo = next_pi)
3566           {
3567             next_pi = procinfo->next;
3568             if (!procinfo->had_event)
3569               {
3570 #ifdef PROCFS_USE_READ_WRITE
3571                 long cmd = PCSTOP;
3572                 if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0)
3573                   {
3574                     print_sys_errmsg (procinfo->pathname, errno);
3575                     error ("PCSTOP failed");
3576                   }
3577 #else
3578                 /* A bug in Solaris (2.5) causes us to hang when trying to
3579                    stop a stopped process.  So, we have to check first in
3580                    order to avoid the hang. */
3581                 if (!procfs_read_status (procinfo))
3582                   {
3583                     /* The LWP has apparently terminated.  */
3584                     if (info_verbose)
3585                       printf_filtered ("LWP %d doesn't respond.\n",
3586                                        (procinfo->pid >> 16) & 0xffff);
3587                     close_proc_file (procinfo);
3588                     continue;
3589                   }
3590
3591                 if (!(procinfo->prstatus.pr_flags & PR_STOPPED))
3592                   if (ioctl (procinfo->ctl_fd, PIOCSTOP, &procinfo->prstatus)
3593                       < 0)
3594                     {
3595                       print_sys_errmsg (procinfo->pathname, errno);
3596                       warning ("PIOCSTOP failed");
3597                     }
3598 #endif
3599               }
3600           }
3601       }
3602     }
3603   else
3604     {
3605       error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
3606 #ifdef UNIXWARE
3607              pi->prstatus.pr_lwp.pr_flags);
3608 #else
3609              pi->prstatus.pr_flags);
3610 #endif
3611     }
3612
3613   store_waitstatus (ourstatus, statval);
3614
3615   if (rtnval == -1)             /* No more children to wait for */
3616     {
3617       warning ("Child process unexpectedly missing");
3618       /* Claim it exited with unknown signal.  */
3619       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
3620       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
3621       return rtnval;
3622     }
3623
3624   pi->had_event = 0;            /* Indicate that we've seen this one */
3625   return (rtnval);
3626 }
3627
3628 /*
3629
3630 LOCAL FUNCTION
3631
3632         set_proc_siginfo - set a process's current signal info
3633
3634 SYNOPSIS
3635
3636         void set_proc_siginfo (struct procinfo *pip, int signo);
3637
3638 DESCRIPTION
3639
3640         Given a pointer to a process info struct in PIP and a signal number
3641         in SIGNO, set the process's current signal and its associated signal
3642         information.  The signal will be delivered to the process immediately
3643         after execution is resumed, even if it is being held.  In addition,
3644         this particular delivery will not cause another PR_SIGNALLED stop
3645         even if the signal is being traced.
3646
3647         If we are not delivering the same signal that the prstatus siginfo
3648         struct contains information about, then synthesize a siginfo struct
3649         to match the signal we are doing to deliver, make it of the type
3650         "generated by a user process", and send this synthesized copy.  When
3651         used to set the inferior's signal state, this will be required if we
3652         are not currently stopped because of a traced signal, or if we decide
3653         to continue with a different signal.
3654
3655         Note that when continuing the inferior from a stop due to receipt
3656         of a traced signal, we either have set PRCSIG to clear the existing
3657         signal, or we have to call this function to do a PIOCSSIG with either
3658         the existing siginfo struct from pr_info, or one we have synthesized
3659         appropriately for the signal we want to deliver.  Otherwise if the
3660         signal is still being traced, the inferior will immediately stop
3661         again.
3662
3663         See siginfo(5) for more details.
3664 */
3665
3666 static void
3667 set_proc_siginfo (pip, signo)
3668      struct procinfo *pip;
3669      int signo;
3670 {
3671   struct siginfo newsiginfo;
3672   struct siginfo *sip;
3673   struct sigi_ctl sictl;
3674
3675 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
3676   /* With Alpha OSF/1 procfs, the kernel gets really confused if it
3677      receives a PIOCSSIG with a signal identical to the current signal,
3678      it messes up the current signal. Work around the kernel bug.  */
3679 #ifdef UNIXWARE
3680   if (signo == pip -> prstatus.pr_lwp.pr_cursig)
3681 #else
3682   if (signo == pip -> prstatus.pr_cursig)
3683 #endif
3684     return;
3685 #endif
3686
3687 #ifdef UNIXWARE
3688   if (signo == pip->prstatus.pr_lwp.pr_info.si_signo)
3689     {
3690       memcpy ((char *) &sictl.siginfo, (char *) &pip->prstatus.pr_lwp.pr_info,
3691                 sizeof (siginfo_t));
3692     }
3693 #else
3694   if (signo == pip -> prstatus.pr_info.si_signo)
3695     {
3696       sip = &pip -> prstatus.pr_info;
3697     }
3698 #endif
3699   else
3700     {
3701 #ifdef UNIXWARE
3702       siginfo_t *sip = &sictl.siginfo;
3703       memset ((char *) sip, 0, sizeof (siginfo_t));
3704 #else
3705       memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
3706       sip = &newsiginfo;
3707 #endif
3708       sip -> si_signo = signo;
3709       sip -> si_code = 0;
3710       sip -> si_errno = 0;
3711       sip -> si_pid = getpid ();
3712       sip -> si_uid = getuid ();
3713     }
3714 #ifdef PROCFS_USE_READ_WRITE
3715   sictl.cmd = PCSSIG;
3716   if (write (pip->ctl_fd, (char *) &sictl, sizeof (struct sigi_ctl)) < 0)
3717 #else
3718   if (ioctl (pip->ctl_fd, PIOCSSIG, sip) < 0)
3719 #endif
3720     {
3721       print_sys_errmsg (pip -> pathname, errno);
3722       warning ("PIOCSSIG failed");
3723     }
3724 }
3725
3726 /* Resume execution of process PID.  If STEP is nozero, then
3727    just single step it.  If SIGNAL is nonzero, restart it with that
3728    signal activated.  */
3729
3730 static void
3731 procfs_resume (pid, step, signo)
3732      int pid;
3733      int step;
3734      enum target_signal signo;
3735 {
3736   int signal_to_pass;
3737   struct procinfo *pi, *procinfo, *next_pi;
3738   struct proc_ctl pctl;
3739
3740   pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3741
3742   errno = 0;
3743 #ifdef UNIXWARE
3744   pctl.cmd = PCRUN;
3745   pctl.data = PRCFAULT;
3746 #else
3747   pi->prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
3748 #endif
3749
3750 #if 0
3751   /* It should not be necessary.  If the user explicitly changes the value,
3752      value_assign calls write_register_bytes, which writes it.  */
3753 /*      It may not be absolutely necessary to specify the PC value for
3754         restarting, but to be safe we use the value that gdb considers
3755         to be current.  One case where this might be necessary is if the
3756         user explicitly changes the PC value that gdb considers to be
3757         current.  FIXME:  Investigate if this is necessary or not.  */
3758
3759 #ifdef PRSVADDR_BROKEN
3760 /* Can't do this under Solaris running on a Sparc, as there seems to be no
3761    place to put nPC.  In fact, if you use this, nPC seems to be set to some
3762    random garbage.  We have to rely on the fact that PC and nPC have been
3763    written previously via PIOCSREG during a register flush. */
3764
3765   pi->prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
3766   pi->prrun.pr_flags != PRSVADDR;
3767 #endif
3768 #endif
3769
3770   if (signo == TARGET_SIGNAL_STOP && pi->nopass_next_sigstop)
3771     /* When attaching to a child process, if we forced it to stop with
3772        a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
3773        Upon resuming the first time after such a stop, we explicitly
3774        inhibit sending it another SIGSTOP, which would be the normal
3775        result of default signal handling.  One potential drawback to
3776        this is that we will also ignore any attempt to by the user
3777        to explicitly continue after the attach with a SIGSTOP.  Ultimately
3778        this problem should be dealt with by making the routines that
3779        deal with the inferior a little smarter, and possibly even allow
3780        an inferior to continue running at the same time as gdb.  (FIXME?)  */
3781     signal_to_pass = 0;
3782   else if (signo == TARGET_SIGNAL_TSTP
3783 #ifdef UNIXWARE
3784            && pi->prstatus.pr_lwp.pr_cursig == SIGTSTP
3785            && pi->prstatus.pr_lwp.pr_action.sa_handler == SIG_DFL
3786 #else
3787            && pi->prstatus.pr_cursig == SIGTSTP
3788            && pi->prstatus.pr_action.sa_handler == SIG_DFL
3789 #endif
3790            )
3791
3792     /* We are about to pass the inferior a SIGTSTP whose action is
3793        SIG_DFL.  The SIG_DFL action for a SIGTSTP is to stop
3794        (notifying the parent via wait()), and then keep going from the
3795        same place when the parent is ready for you to keep going.  So
3796        under the debugger, it should do nothing (as if the program had
3797        been stopped and then later resumed.  Under ptrace, this
3798        happens for us, but under /proc, the system obligingly stops
3799        the process, and wait_for_inferior would have no way of
3800        distinguishing that type of stop (which indicates that we
3801        should just start it again), with a stop due to the pr_trace
3802        field of the prrun_t struct.
3803
3804        Note that if the SIGTSTP is being caught, we *do* need to pass it,
3805        because the handler needs to get executed.  */
3806     signal_to_pass = 0;
3807   else
3808     signal_to_pass = target_signal_to_host (signo);
3809
3810   if (signal_to_pass)
3811     {
3812       set_proc_siginfo (pi, signal_to_pass);
3813     }
3814   else
3815     {
3816 #ifdef UNIXWARE
3817       pctl.data |= PRCSIG;
3818 #else
3819       pi->prrun.pr_flags |= PRCSIG;
3820 #endif
3821     }
3822   pi->nopass_next_sigstop = 0;
3823   if (step)
3824     {
3825 #ifdef UNIXWARE
3826       pctl.data |= PRSTEP;
3827 #else
3828       pi->prrun.pr_flags |= PRSTEP;
3829 #endif
3830     }
3831   pi->had_event = 0;
3832   /* Don't try to start a process unless it's stopped on an
3833      `event of interest'.  Doing so will cause errors.  */
3834
3835   if (!procfs_read_status (pi))
3836     {
3837       /* The LWP has apparently terminated.  */
3838       if (info_verbose)
3839         printf_filtered ("LWP %d doesn't respond.\n",
3840                          (pi->pid >> 16) & 0xffff);
3841       close_proc_file (pi);
3842     }
3843   else
3844     {
3845 #ifdef PROCFS_USE_READ_WRITE
3846       if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
3847 #else
3848       if ((pi->prstatus.pr_flags & PR_ISTOP)
3849           && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
3850 #endif
3851         {
3852           /* The LWP has apparently terminated.  */
3853           if (info_verbose)
3854             printf_filtered ("LWP %d doesn't respond.\n",
3855                              (pi->pid >> 16) & 0xffff);
3856           close_proc_file (pi);
3857         }
3858     }
3859
3860   /* Continue all the other threads that haven't had an event of interest.
3861      Also continue them if they have NOPASS_NEXT_SIGSTOP set; this is only
3862      set by do_attach, and means this is the first resume after an attach.
3863      All threads were CSTOP'd by do_attach, and should be resumed now.  */
3864
3865   if (pid == -1)
3866     for (procinfo = procinfo_list; procinfo; procinfo = next_pi)
3867       {
3868         next_pi = procinfo->next;
3869         if (pi != procinfo)
3870           if (!procinfo->had_event ||
3871               (procinfo->nopass_next_sigstop && signo == TARGET_SIGNAL_STOP))
3872             {
3873               procinfo->had_event = procinfo->nopass_next_sigstop = 0;
3874 #ifdef PROCFS_USE_READ_WRITE
3875               pctl.data = PRCFAULT | PRCSIG;
3876               if (write (procinfo->ctl_fd, (char *) &pctl,
3877                          sizeof (struct proc_ctl)) < 0)
3878                 {
3879                   if (!procfs_read_status (procinfo))
3880                     fprintf_unfiltered(gdb_stderr,
3881                                        "procfs_read_status failed, errno=%d\n",
3882                                        errno);
3883                   print_sys_errmsg (procinfo->pathname, errno);
3884                   error ("PCRUN failed");
3885                 }
3886 #else
3887               procinfo->prrun.pr_flags &= PRSTEP;
3888               procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG;
3889               if (!procfs_read_status (procinfo))
3890                 {
3891                   /* The LWP has apparently terminated.  */
3892                   if (info_verbose)
3893                     printf_filtered ("LWP %d doesn't respond.\n",
3894                                      (procinfo->pid >> 16) & 0xffff);
3895                   close_proc_file (procinfo);
3896                   continue;
3897                 }
3898
3899               /* Don't try to start a process unless it's stopped on an
3900                  `event of interest'.  Doing so will cause errors.  */
3901
3902               if ((procinfo->prstatus.pr_flags & PR_ISTOP)
3903                   && ioctl (procinfo->ctl_fd, PIOCRUN, &procinfo->prrun) < 0)
3904                 {
3905                   if (!procfs_read_status (procinfo))
3906                     fprintf_unfiltered(gdb_stderr,
3907                                        "procfs_read_status failed, errno=%d\n",
3908                                        errno);
3909                   print_sys_errmsg (procinfo->pathname, errno);
3910                   warning ("PIOCRUN failed");
3911                 }
3912 #endif
3913             }
3914         procfs_read_status (procinfo);
3915       }
3916 }
3917
3918 /*
3919
3920 LOCAL FUNCTION
3921
3922         procfs_fetch_registers -- fetch current registers from inferior
3923
3924 SYNOPSIS
3925
3926         void procfs_fetch_registers (int regno)
3927
3928 DESCRIPTION
3929
3930         Read the current values of the inferior's registers, both the
3931         general register set and floating point registers (if supported)
3932         and update gdb's idea of their current values.
3933
3934 */
3935
3936 static void
3937 procfs_fetch_registers (regno)
3938      int regno;
3939 {
3940   struct procinfo *pi;
3941
3942   pi = current_procinfo;
3943
3944 #ifdef UNIXWARE
3945   if (procfs_read_status (pi))
3946     {
3947       supply_gregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs);
3948 #if defined (FP0_REGNUM)
3949       supply_fpregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs);
3950 #endif
3951     }
3952 #else /* UNIXWARE */
3953   if (ioctl (pi->ctl_fd, PIOCGREG, &pi->gregset.gregset) != -1)
3954     {
3955       supply_gregset (&pi->gregset.gregset);
3956     }
3957 #if defined (FP0_REGNUM)
3958   if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset.fpregset) != -1)
3959     {
3960       supply_fpregset (&pi->fpregset.fpregset);
3961     }
3962 #endif
3963 #endif /* UNIXWARE */
3964 }
3965
3966 /*
3967
3968 LOCAL FUNCTION
3969
3970         proc_init_failed - called when /proc access initialization fails
3971 fails
3972
3973 SYNOPSIS
3974
3975         static void proc_init_failed (struct procinfo *pi,
3976                                       char *why, int kill_p)
3977
3978 DESCRIPTION
3979
3980         This function is called whenever initialization of access to a /proc
3981         entry fails.  It prints a suitable error message, does some cleanup,
3982         and then invokes the standard error processing routine which dumps
3983         us back into the command loop.  If KILL_P is true, sends SIGKILL.
3984  */
3985
3986 static void
3987 proc_init_failed (pi, why, kill_p)
3988      struct procinfo *pi;
3989      char *why;
3990      int  kill_p;
3991 {
3992   print_sys_errmsg (pi->pathname, errno);
3993   if (kill_p)
3994     kill (pi->pid, SIGKILL);
3995   close_proc_file (pi);
3996   error (why);
3997   /* NOTREACHED */
3998 }
3999
4000 /*
4001
4002 LOCAL FUNCTION
4003
4004         close_proc_file - close any currently open /proc entry
4005
4006 SYNOPSIS
4007
4008         static void close_proc_file (struct procinfo *pip)
4009
4010 DESCRIPTION
4011
4012         Close any currently open /proc entry and mark the process information
4013         entry as invalid.  In order to ensure that we don't try to reuse any
4014         stale information, the pid, fd, and pathnames are explicitly
4015         invalidated, which may be overkill.
4016
4017  */
4018
4019 static void
4020 close_proc_file (pip)
4021      struct procinfo *pip;
4022 {
4023   struct procinfo *procinfo;
4024
4025   delete_thread (pip->pid);     /* remove thread from GDB's thread list */
4026   remove_fd (pip);              /* Remove fd from poll/select list */
4027
4028   close (pip->ctl_fd);
4029 #ifdef HAVE_MULTIPLE_PROC_FDS
4030   close (pip->as_fd);
4031   close (pip->status_fd);
4032   close (pip->map_fd);
4033 #endif
4034
4035   free (pip -> pathname);
4036
4037   /* Unlink pip from the procinfo chain.  Note pip might not be on the list. */
4038
4039   if (procinfo_list == pip)
4040     procinfo_list = pip->next;
4041   else
4042     {
4043       for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
4044         {
4045           if (procinfo->next == pip)
4046             {
4047               procinfo->next = pip->next;
4048               break;
4049             }
4050         }
4051       free (pip);
4052     }
4053 }
4054
4055 /*
4056
4057 LOCAL FUNCTION
4058
4059         open_proc_file - open a /proc entry for a given process id
4060
4061 SYNOPSIS
4062
4063         static int open_proc_file (int pid, struct procinfo *pip, int mode)
4064
4065 DESCRIPTION
4066
4067         Given a process id and a mode, close the existing open /proc
4068         entry (if any) and open one for the new process id, in the
4069         specified mode.  Once it is open, then mark the local process
4070         information structure as valid, which guarantees that the pid,
4071         fd, and pathname fields match an open /proc entry.  Returns
4072         zero if the open fails, nonzero otherwise.
4073
4074         Note that the pathname is left intact, even when the open fails,
4075         so that callers can use it to construct meaningful error messages
4076         rather than just "file open failed".
4077
4078         Note that for Solaris, the process-id also includes an LWP-id, so we
4079         actually attempt to open that.  If we are handed a pid with a 0 LWP-id,
4080         then we will ask the kernel what it is and add it to the pid.  Hence,
4081         the pid can be changed by us.
4082  */
4083
4084 static int
4085 open_proc_file (pid, pip, mode, control)
4086      int pid;
4087      struct procinfo *pip;
4088      int mode;
4089      int control;
4090 {
4091   int tmp, tmpfd;
4092
4093   pip -> next = NULL;
4094   pip -> had_event = 0;
4095   pip -> pathname = xmalloc (MAX_PROC_NAME_SIZE);
4096   pip -> pid = pid;
4097
4098 #ifndef PIOCOPENLWP
4099   tmp = pid;
4100 #else
4101   tmp = pid & 0xffff;
4102 #endif
4103
4104 #ifdef HAVE_MULTIPLE_PROC_FDS
4105   sprintf (pip->pathname, STATUS_PROC_NAME_FMT, tmp);
4106   if ((pip->status_fd = open (pip->pathname, O_RDONLY)) < 0)
4107     {
4108       return 0;
4109     }
4110
4111   sprintf (pip->pathname, AS_PROC_NAME_FMT, tmp);
4112   if ((pip->as_fd = open (pip->pathname, O_RDWR)) < 0)
4113     {
4114       close (pip->status_fd);
4115       return 0;
4116     }
4117
4118   sprintf (pip->pathname, MAP_PROC_NAME_FMT, tmp);
4119   if ((pip->map_fd = open (pip->pathname, O_RDONLY)) < 0)
4120     {
4121       close (pip->status_fd);
4122       close (pip->as_fd);
4123       return 0;
4124     }
4125
4126   sprintf (pip->pathname, MAP_PROC_NAME_FMT, tmp);
4127   if ((pip->map_fd = open (pip->pathname, O_RDONLY)) < 0)
4128     {
4129       close (pip->status_fd);
4130       close (pip->as_fd);
4131       return 0;
4132     }
4133
4134   if (control)
4135     {
4136       sprintf (pip->pathname, CTL_PROC_NAME_FMT, tmp);
4137       if ((pip->ctl_fd = open (pip->pathname, O_WRONLY)) < 0)
4138         {
4139           close (pip->status_fd);
4140           close (pip->as_fd);
4141           close (pip->map_fd);
4142           return 0;
4143         }
4144     }
4145
4146 #else /* HAVE_MULTIPLE_PROC_FDS */
4147   sprintf (pip -> pathname, CTL_PROC_NAME_FMT, tmp);
4148
4149   if ((tmpfd = open (pip -> pathname, mode)) < 0)
4150     return 0;
4151
4152 #ifndef PIOCOPENLWP
4153     pip -> ctl_fd = tmpfd;
4154     pip -> as_fd = tmpfd;
4155     pip -> map_fd = tmpfd;
4156     pip -> status_fd = tmpfd;
4157 #else
4158   tmp = (pid >> 16) & 0xffff;   /* Extract thread id */
4159
4160   if (tmp == 0)
4161     {                           /* Don't know thread id yet */
4162       if (ioctl (tmpfd, PIOCSTATUS, &pip -> prstatus) < 0)
4163         {
4164           print_sys_errmsg (pip -> pathname, errno);
4165           close (tmpfd);
4166           error ("open_proc_file: PIOCSTATUS failed");
4167         }
4168
4169       tmp = pip -> prstatus.pr_who; /* Get thread id from prstatus_t */
4170       pip -> pid = (tmp << 16) | pid; /* Update pip */
4171     }
4172
4173   if ((pip -> ctl_fd = ioctl (tmpfd, PIOCOPENLWP, &tmp)) < 0)
4174     {
4175       close (tmpfd);
4176       return 0;
4177     }
4178
4179 #ifdef PIOCSET                  /* New method */
4180   {
4181       long pr_flags;
4182       pr_flags = PR_ASYNC;
4183       ioctl (pip -> ctl_fd, PIOCSET, &pr_flags);
4184   }
4185 #endif
4186
4187   /* keep extra fds in sync */
4188   pip->as_fd = pip->ctl_fd;
4189   pip->map_fd = pip->ctl_fd;
4190   pip->status_fd = pip->ctl_fd;
4191
4192   close (tmpfd);                /* All done with main pid */
4193 #endif  /* PIOCOPENLWP */
4194
4195 #endif /* HAVE_MULTIPLE_PROC_FDS */
4196
4197   return 1;
4198 }
4199
4200 static char *
4201 mappingflags (flags)
4202      long flags;
4203 {
4204   static char asciiflags[8];
4205
4206   strcpy (asciiflags, "-------");
4207 #if defined (MA_PHYS)
4208   if (flags & MA_PHYS)   asciiflags[0] = 'd';
4209 #endif
4210   if (flags & MA_STACK)  asciiflags[1] = 's';
4211   if (flags & MA_BREAK)  asciiflags[2] = 'b';
4212   if (flags & MA_SHARED) asciiflags[3] = 's';
4213   if (flags & MA_READ)   asciiflags[4] = 'r';
4214   if (flags & MA_WRITE)  asciiflags[5] = 'w';
4215   if (flags & MA_EXEC)   asciiflags[6] = 'x';
4216   return (asciiflags);
4217 }
4218
4219 static void
4220 info_proc_flags (pip, summary)
4221      struct procinfo *pip;
4222      int summary;
4223 {
4224   struct trans *transp;
4225 #ifdef UNIXWARE
4226   long flags = pip->prstatus.pr_flags | pip->prstatus.pr_lwp.pr_flags;
4227 #else
4228   long flags = pip->prstatus.pr_flags;
4229 #endif
4230
4231   printf_filtered ("%-32s", "Process status flags:");
4232   if (!summary)
4233     {
4234       printf_filtered ("\n\n");
4235     }
4236   for (transp = pr_flag_table; transp -> name != NULL; transp++)
4237     {
4238       if (flags & transp -> value)
4239         {
4240           if (summary)
4241             {
4242               printf_filtered ("%s ", transp -> name);
4243             }
4244           else
4245             {
4246               printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
4247             }
4248         }
4249     }
4250   printf_filtered ("\n");
4251 }
4252
4253 static void
4254 info_proc_stop (pip, summary)
4255      struct procinfo *pip;
4256      int summary;
4257 {
4258   struct trans *transp;
4259   int why;
4260   int what;
4261
4262 #ifdef UNIXWARE
4263   why = pip -> prstatus.pr_lwp.pr_why;
4264   what = pip -> prstatus.pr_lwp.pr_what;
4265 #else
4266   why = pip -> prstatus.pr_why;
4267   what = pip -> prstatus.pr_what;
4268 #endif
4269
4270 #ifdef UNIXWARE
4271   if (pip -> prstatus.pr_lwp.pr_flags & PR_STOPPED)
4272 #else
4273   if (pip -> prstatus.pr_flags & PR_STOPPED)
4274 #endif
4275     {
4276       printf_filtered ("%-32s", "Reason for stopping:");
4277       if (!summary)
4278         {
4279           printf_filtered ("\n\n");
4280         }
4281       for (transp = pr_why_table; transp -> name != NULL; transp++)
4282         {
4283           if (why == transp -> value)
4284             {
4285               if (summary)
4286                 {
4287                   printf_filtered ("%s ", transp -> name);
4288                 }
4289               else
4290                 {
4291                   printf_filtered ("\t%-16s %s.\n",
4292                                    transp -> name, transp -> desc);
4293                 }
4294               break;
4295             }
4296         }
4297
4298       /* Use the pr_why field to determine what the pr_what field means, and
4299          print more information. */
4300
4301       switch (why)
4302         {
4303           case PR_REQUESTED:
4304             /* pr_what is unused for this case */
4305             break;
4306           case PR_JOBCONTROL:
4307           case PR_SIGNALLED:
4308             if (summary)
4309               {
4310                 printf_filtered ("%s ", signalname (what));
4311               }
4312             else
4313               {
4314                 printf_filtered ("\t%-16s %s.\n", signalname (what),
4315                                  safe_strsignal (what));
4316               }
4317             break;
4318           case PR_SYSENTRY:
4319             if (summary)
4320               {
4321                 printf_filtered ("%s ", syscallname (what));
4322               }
4323             else
4324               {
4325                 printf_filtered ("\t%-16s %s.\n", syscallname (what),
4326                                  "Entered this system call");
4327               }
4328             break;
4329           case PR_SYSEXIT:
4330             if (summary)
4331               {
4332                 printf_filtered ("%s ", syscallname (what));
4333               }
4334             else
4335               {
4336                 printf_filtered ("\t%-16s %s.\n", syscallname (what),
4337                                  "Returned from this system call");
4338               }
4339             break;
4340           case PR_FAULTED:
4341             if (summary)
4342               {
4343                 printf_filtered ("%s ",
4344                                  lookupname (faults_table, what, "fault"));
4345               }
4346             else
4347               {
4348                 printf_filtered ("\t%-16s %s.\n",
4349                                  lookupname (faults_table, what, "fault"),
4350                                  lookupdesc (faults_table, what));
4351               }
4352             break;
4353           }
4354       printf_filtered ("\n");
4355     }
4356 }
4357
4358 static void
4359 info_proc_siginfo (pip, summary)
4360      struct procinfo *pip;
4361      int summary;
4362 {
4363   struct siginfo *sip;
4364
4365 #ifdef UNIXWARE
4366   if ((pip -> prstatus.pr_lwp.pr_flags & PR_STOPPED) &&
4367       (pip -> prstatus.pr_lwp.pr_why == PR_SIGNALLED ||
4368        pip -> prstatus.pr_lwp.pr_why == PR_FAULTED))
4369 #else
4370   if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
4371       (pip -> prstatus.pr_why == PR_SIGNALLED ||
4372        pip -> prstatus.pr_why == PR_FAULTED))
4373 #endif
4374     {
4375       printf_filtered ("%-32s", "Additional signal/fault info:");
4376 #ifdef UNIXWARE
4377       sip = &pip -> prstatus.pr_lwp.pr_info;
4378 #else
4379       sip = &pip -> prstatus.pr_info;
4380 #endif
4381       if (summary)
4382         {
4383           printf_filtered ("%s ", signalname (sip -> si_signo));
4384           if (sip -> si_errno > 0)
4385             {
4386               printf_filtered ("%s ", errnoname (sip -> si_errno));
4387             }
4388           if (sip -> si_code <= 0)
4389             {
4390               printf_filtered ("sent by %s, uid %d ",
4391                                target_pid_to_str (sip -> si_pid),
4392                                sip -> si_uid);
4393             }
4394           else
4395             {
4396               printf_filtered ("%s ", sigcodename (sip));
4397               if ((sip -> si_signo == SIGILL) ||
4398                   (sip -> si_signo == SIGFPE) ||
4399                   (sip -> si_signo == SIGSEGV) ||
4400                   (sip -> si_signo == SIGBUS))
4401                 {
4402                   printf_filtered ("addr=%#lx ",
4403                                    (unsigned long) sip -> si_addr);
4404                 }
4405               else if ((sip -> si_signo == SIGCHLD))
4406                 {
4407                   printf_filtered ("child %s, status %u ",
4408                                    target_pid_to_str (sip -> si_pid),
4409                                    sip -> si_status);
4410                 }
4411               else if ((sip -> si_signo == SIGPOLL))
4412                 {
4413                   printf_filtered ("band %u ", sip -> si_band);
4414                 }
4415             }
4416         }
4417       else
4418         {
4419           printf_filtered ("\n\n");
4420           printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
4421                            safe_strsignal (sip -> si_signo));
4422           if (sip -> si_errno > 0)
4423             {
4424               printf_filtered ("\t%-16s %s.\n",
4425                                errnoname (sip -> si_errno),
4426                                safe_strerror (sip -> si_errno));
4427             }
4428           if (sip -> si_code <= 0)
4429             {
4430               printf_filtered ("\t%-16u %s\n", sip -> si_pid, /* XXX need target_pid_to_str() */
4431                                "PID of process sending signal");
4432               printf_filtered ("\t%-16u %s\n", sip -> si_uid,
4433                                "UID of process sending signal");
4434             }
4435           else
4436             {
4437               printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
4438                                sigcodedesc (sip));
4439               if ((sip -> si_signo == SIGILL) ||
4440                   (sip -> si_signo == SIGFPE))
4441                 {
4442                   printf_filtered ("\t%#-16lx %s.\n",
4443                                    (unsigned long) sip -> si_addr,
4444                                    "Address of faulting instruction");
4445                 }
4446               else if ((sip -> si_signo == SIGSEGV) ||
4447                        (sip -> si_signo == SIGBUS))
4448                 {
4449                   printf_filtered ("\t%#-16lx %s.\n",
4450                                    (unsigned long) sip -> si_addr,
4451                                    "Address of faulting memory reference");
4452                 }
4453               else if ((sip -> si_signo == SIGCHLD))
4454                 {
4455                   printf_filtered ("\t%-16u %s.\n", sip -> si_pid, /* XXX need target_pid_to_str() */
4456                                    "Child process ID");
4457                   printf_filtered ("\t%-16u %s.\n", sip -> si_status,
4458                                    "Child process exit value or signal");
4459                 }
4460               else if ((sip -> si_signo == SIGPOLL))
4461                 {
4462                   printf_filtered ("\t%-16u %s.\n", sip -> si_band,
4463                                    "Band event for POLL_{IN,OUT,MSG}");
4464                 }
4465             }
4466         }
4467       printf_filtered ("\n");
4468     }
4469 }
4470
4471 static void
4472 info_proc_syscalls (pip, summary)
4473      struct procinfo *pip;
4474      int summary;
4475 {
4476   int syscallnum;
4477
4478   if (!summary)
4479     {
4480
4481 #if 0   /* FIXME:  Needs to use gdb-wide configured info about system calls. */
4482       if (pip -> prstatus.pr_flags & PR_ASLEEP)
4483         {
4484           int syscallnum = pip -> prstatus.pr_reg[R_D0];
4485           if (summary)
4486             {
4487               printf_filtered ("%-32s", "Sleeping in system call:");
4488               printf_filtered ("%s", syscallname (syscallnum));
4489             }
4490           else
4491             {
4492               printf_filtered ("Sleeping in system call '%s'.\n",
4493                                syscallname (syscallnum));
4494             }
4495         }
4496 #endif
4497
4498 #ifndef UNIXWARE
4499       if (ioctl (pip -> ctl_fd, PIOCGENTRY, &pip -> entryset) < 0)
4500         {
4501           print_sys_errmsg (pip -> pathname, errno);
4502           error ("PIOCGENTRY failed");
4503         }
4504
4505       if (ioctl (pip -> ctl_fd, PIOCGEXIT, &pip -> exitset) < 0)
4506         {
4507           print_sys_errmsg (pip -> pathname, errno);
4508           error ("PIOCGEXIT failed");
4509         }
4510 #endif
4511
4512       printf_filtered ("System call tracing information:\n\n");
4513
4514       printf_filtered ("\t%-12s %-8s %-8s\n",
4515                        "System call",
4516                        "Entry",
4517                        "Exit");
4518       for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
4519         {
4520           QUIT;
4521           if (syscall_table[syscallnum] != NULL)
4522             printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
4523           else
4524             printf_filtered ("\t%-12d ", syscallnum);
4525
4526 #ifdef UNIXWARE
4527           printf_filtered ("%-8s ",
4528                            prismember (&pip->prstatus.pr_sysentry, syscallnum)
4529                            ? "on" : "off");
4530           printf_filtered ("%-8s ",
4531                            prismember (&pip->prstatus.pr_sysexit, syscallnum)
4532                            ? "on" : "off");
4533 #else
4534           printf_filtered ("%-8s ",
4535                            prismember (&pip -> entryset, syscallnum)
4536                            ? "on" : "off");
4537           printf_filtered ("%-8s ",
4538                            prismember (&pip -> exitset, syscallnum)
4539                            ? "on" : "off");
4540 #endif
4541           printf_filtered ("\n");
4542         }
4543       printf_filtered ("\n");
4544     }
4545 }
4546
4547 static char *
4548 signalname (signo)
4549      int signo;
4550 {
4551   const char *name;
4552   static char locbuf[32];
4553
4554   name = strsigno (signo);
4555   if (name == NULL)
4556     {
4557       sprintf (locbuf, "Signal %d", signo);
4558     }
4559   else
4560     {
4561       sprintf (locbuf, "%s (%d)", name, signo);
4562     }
4563   return (locbuf);
4564 }
4565
4566 static char *
4567 errnoname (errnum)
4568      int errnum;
4569 {
4570   const char *name;
4571   static char locbuf[32];
4572
4573   name = strerrno (errnum);
4574   if (name == NULL)
4575     {
4576       sprintf (locbuf, "Errno %d", errnum);
4577     }
4578   else
4579     {
4580       sprintf (locbuf, "%s (%d)", name, errnum);
4581     }
4582   return (locbuf);
4583 }
4584
4585 static void
4586 info_proc_signals (pip, summary)
4587      struct procinfo *pip;
4588      int summary;
4589 {
4590   int signo;
4591
4592   if (!summary)
4593     {
4594 #ifndef PROCFS_USE_READ_WRITE
4595       if (ioctl (pip -> ctl_fd, PIOCGTRACE, &pip -> trace) < 0)
4596         {
4597           print_sys_errmsg (pip -> pathname, errno);
4598           error ("PIOCGTRACE failed");
4599         }
4600 #endif
4601
4602       printf_filtered ("Disposition of signals:\n\n");
4603       printf_filtered ("\t%-15s %-8s %-8s %-8s  %s\n\n",
4604                        "Signal", "Trace", "Hold", "Pending", "Description");
4605       for (signo = 0; signo < NSIG; signo++)
4606         {
4607           QUIT;
4608           printf_filtered ("\t%-15s ", signalname (signo));
4609 #ifdef UNIXWARE
4610           printf_filtered ("%-8s ",
4611                            prismember (&pip -> prstatus.pr_sigtrace, signo)
4612                            ? "on" : "off");
4613           printf_filtered ("%-8s ",
4614                            prismember (&pip -> prstatus.pr_lwp.pr_context.uc_sigmask, signo)
4615                            ? "on" : "off");
4616 #else
4617           printf_filtered ("%-8s ",
4618                            prismember (&pip -> trace, signo)
4619                            ? "on" : "off");
4620           printf_filtered ("%-8s ",
4621                            prismember (&pip -> prstatus.pr_sighold, signo)
4622                            ? "on" : "off");
4623 #endif
4624
4625 #ifdef UNIXWARE
4626           if (prismember (&pip->prstatus.pr_sigpend, signo) ||
4627                 prismember (&pip->prstatus.pr_lwp.pr_lwppend, signo))
4628             printf_filtered("%-8s ", "yes");
4629           else
4630             printf_filtered("%-8s ", "no");
4631 #else /* UNIXWARE */
4632 #ifdef PROCFS_SIGPEND_OFFSET
4633           /* Alpha OSF/1 numbers the pending signals from 1.  */
4634           printf_filtered ("%-8s ",
4635                            (signo ? prismember (&pip -> prstatus.pr_sigpend,
4636                                                 signo - 1)
4637                                   : 0)
4638                            ? "yes" : "no");
4639 #else
4640           printf_filtered ("%-8s ",
4641                            prismember (&pip -> prstatus.pr_sigpend, signo)
4642                            ? "yes" : "no");
4643 #endif
4644 #endif /* UNIXWARE */
4645           printf_filtered (" %s\n", safe_strsignal (signo));
4646         }
4647       printf_filtered ("\n");
4648     }
4649 }
4650
4651 static void
4652 info_proc_faults (pip, summary)
4653      struct procinfo *pip;
4654      int summary;
4655 {
4656   struct trans *transp;
4657
4658   if (!summary)
4659     {
4660 #ifndef UNIXWARE
4661       if (ioctl (pip -> ctl_fd, PIOCGFAULT, &pip->fltset.fltset) < 0)
4662         {
4663           print_sys_errmsg (pip -> pathname, errno);
4664           error ("PIOCGFAULT failed");
4665         }
4666 #endif
4667
4668       printf_filtered ("Current traced hardware fault set:\n\n");
4669       printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
4670
4671       for (transp = faults_table; transp -> name != NULL; transp++)
4672         {
4673           QUIT;
4674           printf_filtered ("\t%-12s ", transp -> name);
4675 #ifdef UNIXWARE
4676           printf_filtered ("%-8s", prismember (&pip->prstatus.pr_flttrace, transp -> value)
4677                            ? "on" : "off");
4678 #else
4679           printf_filtered ("%-8s", prismember (&pip->fltset.fltset, transp -> value)
4680                            ? "on" : "off");
4681 #endif
4682           printf_filtered ("\n");
4683         }
4684       printf_filtered ("\n");
4685     }
4686 }
4687
4688 static void
4689 info_proc_mappings (pip, summary)
4690      struct procinfo *pip;
4691      int summary;
4692 {
4693   int nmap;
4694   struct prmap *prmaps;
4695   struct prmap *prmap;
4696   struct stat sbuf;
4697
4698   if (!summary)
4699     {
4700       printf_filtered ("Mapped address spaces:\n\n");
4701 #ifdef BFD_HOST_64_BIT
4702       printf_filtered ("  %18s %18s %10s %10s %7s\n",
4703 #else
4704       printf_filtered ("\t%10s %10s %10s %10s %7s\n",
4705 #endif
4706                        "Start Addr",
4707                        "  End Addr",
4708                        "      Size",
4709                        "    Offset",
4710                        "Flags");
4711 #ifdef PROCFS_USE_READ_WRITE
4712       if (fstat (pip->map_fd, &sbuf) == 0)
4713         {
4714           nmap = sbuf.st_size / sizeof (prmap_t);
4715           prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
4716           if ((lseek (pip->map_fd, 0, SEEK_SET) == 0) &&
4717                 (read (pip->map_fd, (char *) prmaps,
4718                 nmap * sizeof (*prmaps)) == (nmap * sizeof (*prmaps))))
4719             {
4720               int i = 0;
4721               for (prmap = prmaps; i < nmap; ++prmap, ++i)
4722 #else
4723       if (ioctl (pip -> ctl_fd, PIOCNMAP, &nmap) == 0)
4724         {
4725           prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
4726           if (ioctl (pip -> ctl_fd, PIOCMAP, prmaps) == 0)
4727             {
4728               for (prmap = prmaps; prmap -> pr_size; ++prmap)
4729 #endif /* PROCFS_USE_READ_WRITE */
4730                 {
4731 #ifdef BFD_HOST_64_BIT
4732                   printf_filtered ("  %#18lx %#18lx %#10x %#10x %7s\n",
4733 #else
4734                   printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
4735 #endif
4736                                    (unsigned long)prmap -> pr_vaddr,
4737                                    (unsigned long)prmap -> pr_vaddr
4738                                      + prmap -> pr_size - 1,
4739                                    prmap -> pr_size,
4740                                    prmap -> pr_off,
4741                                    mappingflags (prmap -> pr_mflags));
4742                 }
4743             }
4744         }
4745       printf_filtered ("\n");
4746     }
4747 }
4748
4749 /*
4750
4751 LOCAL FUNCTION
4752
4753         info_proc -- implement the "info proc" command
4754
4755 SYNOPSIS
4756
4757         void info_proc (char *args, int from_tty)
4758
4759 DESCRIPTION
4760
4761         Implement gdb's "info proc" command by using the /proc interface
4762         to print status information about any currently running process.
4763
4764         Examples of the use of "info proc" are:
4765
4766         info proc               (prints summary info for current inferior)
4767         info proc 123           (prints summary info for process with pid 123)
4768         info proc mappings      (prints address mappings)
4769         info proc times         (prints process/children times)
4770         info proc id            (prints pid, ppid, gid, sid, etc)
4771                 FIXME:  i proc id not implemented.
4772         info proc status        (prints general process state info)
4773                 FIXME:  i proc status not implemented.
4774         info proc signals       (prints info about signal handling)
4775         info proc all           (prints all info)
4776
4777  */
4778
4779 static void
4780 info_proc (args, from_tty)
4781      char *args;
4782      int from_tty;
4783 {
4784   int pid;
4785   struct procinfo *pip;
4786   struct cleanup *old_chain;
4787   char **argv;
4788   int argsize;
4789   int summary = 1;
4790   int flags = 0;
4791   int syscalls = 0;
4792   int signals = 0;
4793   int faults = 0;
4794   int mappings = 0;
4795   int times = 0;
4796   int id = 0;
4797   int status = 0;
4798   int all = 0;
4799   int nlwp;
4800   int *lwps;
4801
4802   old_chain = make_cleanup (null_cleanup, 0);
4803
4804   /* Default to using the current inferior if no pid specified.  Note
4805      that inferior_pid may be 0, hence we set okerr.  */
4806
4807   pid = inferior_pid & 0x7fffffff;              /* strip off sol-thread bit */
4808   if (!(pip = find_procinfo (pid, 1)))          /* inferior_pid no good?  */
4809     pip = procinfo_list;                        /* take first available */
4810   pid = pid & 0xffff;                           /* extract "real" pid */
4811
4812   if (args != NULL)
4813     {
4814       if ((argv = buildargv (args)) == NULL)
4815         {
4816           nomem (0);
4817         }
4818       make_cleanup (freeargv, (char *) argv);
4819
4820       while (*argv != NULL)
4821         {
4822           argsize = strlen (*argv);
4823           if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
4824             {
4825               summary = 0;
4826               all = 1;
4827             }
4828           else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
4829             {
4830               summary = 0;
4831               faults = 1;
4832             }
4833           else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
4834             {
4835               summary = 0;
4836               flags = 1;
4837             }
4838           else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
4839             {
4840               summary = 0;
4841               id = 1;
4842             }
4843           else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
4844             {
4845               summary = 0;
4846               mappings = 1;
4847             }
4848           else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
4849             {
4850               summary = 0;
4851               signals = 1;
4852             }
4853           else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
4854             {
4855               summary = 0;
4856               status = 1;
4857             }
4858           else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
4859             {
4860               summary = 0;
4861               syscalls = 1;
4862             }
4863           else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
4864             {
4865               summary = 0;
4866               times = 1;
4867             }
4868           else if ((pid = atoi (*argv)) > 0)
4869             {
4870               pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
4871               memset (pip, 0, sizeof (*pip));
4872
4873               pip->pid = pid;
4874               if (!open_proc_file (pid, pip, O_RDONLY, 0))
4875                 {
4876                   perror_with_name (pip -> pathname);
4877                   /* NOTREACHED */
4878                 }
4879               pid = pip->pid;
4880               make_cleanup (close_proc_file, pip);
4881             }
4882           else if (**argv != '\000')
4883             {
4884               error ("Unrecognized or ambiguous keyword `%s'.", *argv);
4885             }
4886           argv++;
4887         }
4888     }
4889
4890   /* If we don't have a valid open process at this point, then we have no
4891      inferior or didn't specify a specific pid. */
4892
4893   if (!pip)
4894     {
4895       error ("\
4896 No process.  Start debugging a program or specify an explicit process ID.");
4897     }
4898
4899   if (!procfs_read_status (pip))
4900     {
4901       print_sys_errmsg (pip -> pathname, errno);
4902       error ("procfs_read_status failed");
4903     }
4904
4905 #ifndef PROCFS_USE_READ_WRITE
4906 #ifdef PIOCLWPIDS
4907   nlwp = pip->prstatus.pr_nlwp;
4908   lwps = alloca ((2 * nlwp + 2) * sizeof (*lwps));
4909
4910   if (ioctl (pip->ctl_fd, PIOCLWPIDS, lwps))
4911     {
4912       print_sys_errmsg (pip -> pathname, errno);
4913       error ("PIOCLWPIDS failed");
4914     }
4915 #else /* PIOCLWPIDS */
4916   nlwp = 1;
4917   lwps = alloca ((2 * nlwp + 2) * sizeof *lwps);
4918   lwps[0] = 0;
4919 #endif /* PIOCLWPIDS */
4920
4921   for (; nlwp > 0; nlwp--, lwps++)
4922     {
4923       pip = find_procinfo ((*lwps << 16) | pid, 1);
4924
4925       if (!pip)
4926         {
4927           pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
4928           memset (pip, 0, sizeof (*pip));
4929           if (!open_proc_file ((*lwps << 16) | pid, pip, O_RDONLY, 0))
4930             continue;
4931
4932           make_cleanup (close_proc_file, pip);
4933
4934           if (!procfs_read_status (pip))
4935             {
4936               print_sys_errmsg (pip -> pathname, errno);
4937               error ("procfs_read_status failed");
4938             }
4939         }
4940
4941 #endif /* PROCFS_USE_READ_WRITE */
4942
4943       /* Print verbose information of the requested type(s), or just a summary
4944          of the information for all types. */
4945
4946       printf_filtered ("\nInformation for %s.%d:\n\n", pip -> pathname, *lwps);
4947       if (summary || all || flags)
4948         {
4949           info_proc_flags (pip, summary);
4950         }
4951       if (summary || all)
4952         {
4953           info_proc_stop (pip, summary);
4954 #ifdef UNIXWARE
4955           supply_gregset (&pip->prstatus.pr_lwp.pr_context.uc_mcontext.gregs);
4956 #else
4957           supply_gregset (&pip->prstatus.pr_reg);
4958 #endif
4959           printf_filtered ("PC: ");
4960           print_address (read_pc (), gdb_stdout);
4961           printf_filtered ("\n");
4962         }
4963       if (summary || all || signals || faults)
4964         {
4965           info_proc_siginfo (pip, summary);
4966         }
4967       if (summary || all || syscalls)
4968         {
4969           info_proc_syscalls (pip, summary);
4970         }
4971       if (summary || all || mappings)
4972         {
4973           info_proc_mappings (pip, summary);
4974         }
4975       if (summary || all || signals)
4976         {
4977           info_proc_signals (pip, summary);
4978         }
4979       if (summary || all || faults)
4980         {
4981           info_proc_faults (pip, summary);
4982         }
4983       printf_filtered ("\n");
4984
4985       /* All done, deal with closing any temporary process info structure,
4986          freeing temporary memory , etc. */
4987
4988       do_cleanups (old_chain);
4989 #ifndef PROCFS_USE_READ_WRITE
4990     }
4991 #endif
4992 }
4993
4994 /*
4995
4996 LOCAL FUNCTION
4997
4998         modify_inherit_on_fork_flag - Change the inherit-on-fork flag
4999
5000 SYNOPSIS
5001
5002         void modify_inherit_on_fork_flag (fd, flag)
5003
5004 DESCRIPTION
5005
5006         Call this routine to modify the inherit-on-fork flag.  This routine is
5007         just a nice wrapper to hide the #ifdefs needed by various systems to
5008         control this flag.
5009
5010  */
5011
5012 static void
5013 modify_inherit_on_fork_flag (fd, flag)
5014      int fd;
5015      int flag;
5016 {
5017 #if defined (PIOCSET) || defined (PCSET)
5018   long pr_flags;
5019 #endif
5020   int retval = 0;
5021   struct proc_ctl pctl;
5022
5023 #if defined (PIOCSET) || defined (PCSET)        /* New method */
5024   pr_flags = PR_FORK;
5025   if (flag)
5026     {
5027 #ifdef PROCFS_USE_READ_WRITE
5028       pctl.cmd = PCSET;
5029       pctl.data = PR_FORK;
5030       if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5031         retval = -1;
5032 #else
5033       retval = ioctl (fd, PIOCSET, &pr_flags);
5034 #endif
5035     }
5036   else
5037     {
5038 #ifdef PROCFS_USE_READ_WRITE
5039       pctl.cmd = PCRESET;
5040       pctl.data = PR_FORK;
5041       if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5042         retval = -1;
5043 #else
5044       retval = ioctl (fd, PIOCRESET, &pr_flags);
5045 #endif
5046     }
5047
5048 #else
5049 #ifdef PIOCSFORK                /* Original method */
5050   if (flag)
5051     {
5052       retval = ioctl (fd, PIOCSFORK, NULL);
5053     }
5054   else
5055     {
5056       retval = ioctl (fd, PIOCRFORK, NULL);
5057     }
5058 #else
5059   Neither PR_FORK nor PIOCSFORK exist!!!
5060 #endif
5061 #endif
5062
5063   if (!retval)
5064     return;
5065
5066   print_sys_errmsg ("modify_inherit_on_fork_flag", errno);
5067   error ("PIOCSFORK or PR_FORK modification failed");
5068 }
5069
5070 /*
5071
5072 LOCAL FUNCTION
5073
5074         modify_run_on_last_close_flag - Change the run-on-last-close flag
5075
5076 SYNOPSIS
5077
5078         void modify_run_on_last_close_flag (fd, flag)
5079
5080 DESCRIPTION
5081
5082         Call this routine to modify the run-on-last-close flag.  This routine
5083         is just a nice wrapper to hide the #ifdefs needed by various systems to
5084         control this flag.
5085
5086  */
5087
5088 static void
5089 modify_run_on_last_close_flag (fd, flag)
5090      int fd;
5091      int flag;
5092 {
5093 #if defined (PIOCSET) || defined (PCSET)
5094   long pr_flags;
5095 #endif
5096   int retval = 0;
5097   struct proc_ctl pctl;
5098
5099 #if defined (PIOCSET) || defined (PCSET)        /* New method */
5100   pr_flags = PR_RLC;
5101   if (flag)
5102     {
5103 #ifdef PROCFS_USE_READ_WRITE
5104       pctl.cmd = PCSET;
5105       pctl.data = PR_RLC;
5106       if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5107         retval = -1;
5108 #else
5109       retval = ioctl (fd, PIOCSET, &pr_flags);
5110 #endif
5111     }
5112   else
5113     {
5114 #ifdef PROCFS_USE_READ_WRITE
5115       pctl.cmd = PCRESET;
5116       pctl.data = PR_RLC;
5117       if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5118         retval = -1;
5119 #else
5120       retval = ioctl (fd, PIOCRESET, &pr_flags);
5121 #endif
5122     }
5123
5124 #else
5125 #ifdef PIOCSRLC                 /* Original method */
5126   if (flag)
5127     retval = ioctl (fd, PIOCSRLC, NULL);
5128   else
5129     retval = ioctl (fd, PIOCRRLC, NULL);
5130 #else
5131   Neither PR_RLC nor PIOCSRLC exist!!!
5132 #endif
5133 #endif
5134
5135   if (!retval)
5136     return;
5137
5138   print_sys_errmsg ("modify_run_on_last_close_flag", errno);
5139   error ("PIOCSRLC or PR_RLC modification failed");
5140 }
5141
5142 /*
5143
5144 LOCAL FUNCTION
5145
5146         procfs_clear_syscall_trap -- Deletes the trap for the specified system call.
5147
5148 SYNOPSIS
5149
5150         void procfs_clear_syscall_trap (struct procinfo *, int syscall_num, int errok)
5151
5152 DESCRIPTION
5153
5154         This function function disables traps for the specified system call.
5155         errok is non-zero if errors should be ignored.
5156  */
5157
5158 static void
5159 procfs_clear_syscall_trap (pi, syscall_num, errok)
5160      struct procinfo *pi;
5161      int syscall_num;
5162      int errok;
5163 {
5164   sysset_t sysset;
5165   int goterr, i;
5166
5167 #ifndef UNIXWARE
5168   goterr = ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0;
5169
5170   if (goterr && !errok)
5171     {
5172       print_sys_errmsg (pi->pathname, errno);
5173       error ("PIOCGENTRY failed");
5174     }
5175
5176   if (!goterr)
5177     {
5178       prdelset (&sysset, syscall_num);
5179
5180       if ((ioctl (pi->ctl_fd, PIOCSENTRY, &sysset) < 0) && !errok)
5181         {
5182           print_sys_errmsg (pi->pathname, errno);
5183           error ("PIOCSENTRY failed");
5184         }
5185     }
5186
5187   goterr = ioctl (pi->ctl_fd, PIOCGEXIT, &sysset) < 0;
5188
5189   if (goterr && !errok)
5190     {
5191       procfs_clear_syscall_trap (pi, syscall_num, 1);
5192       print_sys_errmsg (pi->pathname, errno);
5193       error ("PIOCGEXIT failed");
5194     }
5195
5196   if (!goterr)
5197     {
5198       praddset (&sysset, syscall_num);
5199
5200       if ((ioctl (pi->ctl_fd, PIOCSEXIT, &sysset) < 0) && !errok)
5201         {
5202           procfs_clear_syscall_trap (pi, syscall_num, 1);
5203           print_sys_errmsg (pi->pathname, errno);
5204           error ("PIOCSEXIT failed");
5205         }
5206     }
5207 #endif
5208
5209   if (!pi->syscall_handlers)
5210     {
5211       if (!errok)
5212         error ("procfs_clear_syscall_trap:  syscall_handlers is empty");
5213       return;
5214     }
5215
5216   /* Remove handler func from the handler list */
5217
5218   for (i = 0; i < pi->num_syscall_handlers; i++)
5219     if (pi->syscall_handlers[i].syscall_num == syscall_num)
5220       {
5221         if (i + 1 != pi->num_syscall_handlers)
5222           {                     /* Not the last entry.
5223                                    Move subsequent entries fwd. */
5224             memcpy (&pi->syscall_handlers[i], &pi->syscall_handlers[i + 1],
5225                     (pi->num_syscall_handlers - i - 1)
5226                     * sizeof (struct procfs_syscall_handler));
5227           }
5228
5229         pi->syscall_handlers = xrealloc (pi->syscall_handlers,
5230                                          (pi->num_syscall_handlers - 1)
5231                                          * sizeof (struct procfs_syscall_handler));
5232         pi->num_syscall_handlers--;
5233         return;
5234       }
5235
5236   if (!errok)
5237     error ("procfs_clear_syscall_trap:  Couldn't find handler for sys call %d",
5238            syscall_num);
5239 }
5240
5241 /*
5242
5243 LOCAL FUNCTION
5244
5245         procfs_set_syscall_trap -- arrange for a function to be called when the
5246                                    child executes the specified system call.
5247
5248 SYNOPSIS
5249
5250         void procfs_set_syscall_trap (struct procinfo *, int syscall_num, int flags,
5251                                       syscall_func_t *function)
5252
5253 DESCRIPTION
5254
5255         This function sets up an entry and/or exit trap for the specified system
5256         call.  When the child executes the specified system call, your function
5257         will be called with the call #, a flag that indicates entry or exit, and
5258         pointers to rtnval and statval (which are used by procfs_wait).  The
5259         function should return non-zero if something interesting happened, zero
5260         otherwise.
5261  */
5262
5263 static void
5264 procfs_set_syscall_trap (pi, syscall_num, flags, func)
5265      struct procinfo *pi;
5266      int syscall_num;
5267      int flags;
5268      syscall_func_t *func;
5269 {
5270   sysset_t sysset;
5271
5272 #ifndef UNIXWARE
5273   if (flags & PROCFS_SYSCALL_ENTRY)
5274     {
5275       if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0)
5276         {
5277           print_sys_errmsg (pi->pathname, errno);
5278           error ("PIOCGENTRY failed");
5279         }
5280
5281       praddset (&sysset, syscall_num);
5282
5283       if (ioctl (pi->ctl_fd, PIOCSENTRY, &sysset) < 0)
5284         {
5285           print_sys_errmsg (pi->pathname, errno);
5286           error ("PIOCSENTRY failed");
5287         }
5288     }
5289
5290   if (flags & PROCFS_SYSCALL_EXIT)
5291     {
5292       if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysset) < 0)
5293         {
5294           procfs_clear_syscall_trap (pi, syscall_num, 1);
5295           print_sys_errmsg (pi->pathname, errno);
5296           error ("PIOCGEXIT failed");
5297         }
5298
5299       praddset (&sysset, syscall_num);
5300
5301       if (ioctl (pi->ctl_fd, PIOCSEXIT, &sysset) < 0)
5302         {
5303           procfs_clear_syscall_trap (pi, syscall_num, 1);
5304           print_sys_errmsg (pi->pathname, errno);
5305           error ("PIOCSEXIT failed");
5306         }
5307     }
5308 #endif
5309
5310   if (!pi->syscall_handlers)
5311     {
5312       pi->syscall_handlers = xmalloc (sizeof (struct procfs_syscall_handler));
5313       pi->syscall_handlers[0].syscall_num = syscall_num;
5314       pi->syscall_handlers[0].func = func;
5315       pi->num_syscall_handlers = 1;
5316     }
5317   else
5318     {
5319       int i;
5320
5321       for (i = 0; i < pi->num_syscall_handlers; i++)
5322         if (pi->syscall_handlers[i].syscall_num == syscall_num)
5323           {
5324             pi->syscall_handlers[i].func = func;
5325             return;
5326           }
5327
5328       pi->syscall_handlers = xrealloc (pi->syscall_handlers, (i + 1)
5329                                        * sizeof (struct procfs_syscall_handler));
5330       pi->syscall_handlers[i].syscall_num = syscall_num;
5331       pi->syscall_handlers[i].func = func;
5332       pi->num_syscall_handlers++;
5333     }
5334 }
5335
5336 #ifdef SYS_lwp_create
5337
5338 /*
5339
5340 LOCAL FUNCTION
5341
5342         procfs_lwp_creation_handler - handle exit from the _lwp_create syscall
5343
5344 SYNOPSIS
5345
5346         int procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
5347
5348 DESCRIPTION
5349
5350         This routine is called both when an inferior process and it's new lwp
5351         are about to finish a _lwp_create() system call.  This is the system
5352         call that Solaris uses to create a lightweight process.  When the
5353         target process gets this event, we can look at sysarg[2] to find the
5354         new childs lwp ID, and create a procinfo struct from that.  After that,
5355         we pretend that we got a SIGTRAP, and return non-zero to tell
5356         procfs_wait to wake up.  Subsequently, wait_for_inferior gets woken up,
5357         sees the new process and continues it.
5358
5359         When we see the child exiting from lwp_create, we just contine it,
5360         since everything was handled when the parent trapped.
5361
5362 NOTES
5363         In effect, we are only paying attention to the parent's completion of
5364         the lwp_create syscall.  If we only paid attention to the child
5365         instead, then we wouldn't detect the creation of a suspended thread.
5366  */
5367
5368 static int
5369 procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
5370      struct procinfo *pi;
5371      int syscall_num;
5372      int why;
5373      int *rtnvalp;
5374      int *statvalp;
5375 {
5376   int lwp_id;
5377   struct procinfo *childpi;
5378   struct proc_ctl pctl;
5379
5380   /* We've just detected the completion of an lwp_create system call.  Now we
5381      need to setup a procinfo struct for this thread, and notify the thread
5382      system of the new arrival.  */
5383
5384   /* If lwp_create failed, then nothing interesting happened.  Continue the
5385      process and go back to sleep. */
5386
5387 #ifdef UNIXWARE
5388   /* Joel ... can you check this logic out please? JKJ */
5389   if (pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs[R_EFL] & 1)
5390     { /* _lwp_create failed */
5391       pctl.cmd = PCRUN;
5392       pctl.data = PRCFAULT;
5393
5394       if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
5395         perror_with_name (pi->pathname);
5396
5397       return 0;
5398     }
5399 #else /* UNIXWARE */
5400   if (PROCFS_GET_CARRY (pi->prstatus.pr_reg))
5401     {                           /* _lwp_create failed */
5402       pi->prrun.pr_flags &= PRSTEP;
5403       pi->prrun.pr_flags |= PRCFAULT;
5404
5405       if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5406         perror_with_name (pi->pathname);
5407
5408       return 0;
5409     }
5410 #endif
5411
5412   /* At this point, the new thread is stopped at it's first instruction, and
5413      the parent is stopped at the exit from lwp_create.  */
5414
5415   if (pi->new_child)            /* Child? */
5416     {                           /* Yes, just continue it */
5417 #ifdef UNIXWARE
5418       pctl.cmd = PCRUN;
5419       pctl.data = PRCFAULT;
5420
5421       if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
5422 #else /* !UNIXWARE */
5423       pi->prrun.pr_flags &= PRSTEP;
5424       pi->prrun.pr_flags |= PRCFAULT;
5425
5426       if ((pi->prstatus.pr_flags & PR_ISTOP)
5427           && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5428 #endif /* !UNIXWARE */
5429         perror_with_name (pi->pathname);
5430
5431       pi->new_child = 0;        /* No longer new */
5432
5433       return 0;
5434     }
5435
5436   /* We're the proud parent of a new thread.  Setup an exit trap for lwp_create
5437      in the child and continue the parent.  */
5438
5439   /* Third arg is pointer to new thread id. */
5440 #ifdef UNIXWARE
5441   lwp_id = read_memory_integer (pi->prstatus.pr_lwp.pr_sysarg[2], sizeof (int));
5442 #else
5443   lwp_id = read_memory_integer (pi->prstatus.pr_sysarg[2], sizeof (int));
5444 #endif
5445
5446   lwp_id = (lwp_id << 16) | PIDGET (pi->pid);
5447
5448   childpi = create_procinfo (lwp_id);
5449
5450   /* The new process has actually inherited the lwp_create syscall trap from
5451      it's parent, but we still have to call this to register handlers for
5452      that child.  */
5453
5454   procfs_set_inferior_syscall_traps (childpi);
5455   add_thread (lwp_id);
5456   printf_filtered ("[New %s]\n", target_pid_to_str (lwp_id));
5457
5458   /* Continue the parent */
5459 #ifdef UNIXWARE
5460   pctl.cmd = PCRUN;
5461   pctl.data = PRCFAULT;
5462
5463   if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
5464 #else
5465   pi->prrun.pr_flags &= PRSTEP;
5466   pi->prrun.pr_flags |= PRCFAULT;
5467   if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
5468 #endif
5469     perror_with_name (pi->pathname);
5470
5471   /* The new child may have been created in one of two states:
5472      SUSPENDED or RUNNABLE.  If runnable, we will simply signal it to run.
5473      If suspended, we flag it to be continued later, when it has an event.  */
5474
5475 #ifdef UNIXWARE
5476   if (childpi->prstatus.pr_lwp.pr_why == PR_SUSPENDED)
5477 #else
5478   if (childpi->prstatus.pr_why == PR_SUSPENDED)
5479 #endif
5480     childpi->new_child = 1;     /* Flag this as an unseen child process */
5481   else
5482     {
5483       /* Continue the child */
5484 #ifdef UNIXWARE
5485       pctl.cmd = PCRUN;
5486       pctl.data = PRCFAULT;
5487
5488       if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
5489 #else
5490       childpi->prrun.pr_flags &= PRSTEP;
5491       childpi->prrun.pr_flags |= PRCFAULT;
5492
5493       if (ioctl (childpi->ctl_fd, PIOCRUN, &childpi->prrun) != 0)
5494 #endif
5495         perror_with_name (childpi->pathname);
5496     }
5497   return 0;
5498 }
5499 #endif /* SYS_lwp_create */
5500
5501 /* Fork an inferior process, and start debugging it with /proc.  */
5502
5503 static void
5504 procfs_create_inferior (exec_file, allargs, env)
5505      char *exec_file;
5506      char *allargs;
5507      char **env;
5508 {
5509   char *shell_file = getenv ("SHELL");
5510   char *tryname;
5511   if (shell_file != NULL && strchr (shell_file, '/') == NULL)
5512     {
5513
5514       /* We will be looking down the PATH to find shell_file.  If we
5515          just do this the normal way (via execlp, which operates by
5516          attempting an exec for each element of the PATH until it
5517          finds one which succeeds), then there will be an exec for
5518          each failed attempt, each of which will cause a PR_SYSEXIT
5519          stop, and we won't know how to distinguish the PR_SYSEXIT's
5520          for these failed execs with the ones for successful execs
5521          (whether the exec has succeeded is stored at that time in the
5522          carry bit or some such architecture-specific and
5523          non-ABI-specified place).
5524
5525          So I can't think of anything better than to search the PATH
5526          now.  This has several disadvantages: (1) There is a race
5527          condition; if we find a file now and it is deleted before we
5528          exec it, we lose, even if the deletion leaves a valid file
5529          further down in the PATH, (2) there is no way to know exactly
5530          what an executable (in the sense of "capable of being
5531          exec'd") file is.  Using access() loses because it may lose
5532          if the caller is the superuser; failing to use it loses if
5533          there are ACLs or some such.  */
5534
5535       char *p;
5536       char *p1;
5537       /* FIXME-maybe: might want "set path" command so user can change what
5538          path is used from within GDB.  */
5539       char *path = getenv ("PATH");
5540       int len;
5541       struct stat statbuf;
5542
5543       if (path == NULL)
5544         path = "/bin:/usr/bin";
5545
5546       tryname = alloca (strlen (path) + strlen (shell_file) + 2);
5547       for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
5548         {
5549           p1 = strchr (p, ':');
5550           if (p1 != NULL)
5551             len = p1 - p;
5552           else
5553             len = strlen (p);
5554           strncpy (tryname, p, len);
5555           tryname[len] = '\0';
5556           strcat (tryname, "/");
5557           strcat (tryname, shell_file);
5558           if (access (tryname, X_OK) < 0)
5559             continue;
5560           if (stat (tryname, &statbuf) < 0)
5561             continue;
5562           if (!S_ISREG (statbuf.st_mode))
5563             /* We certainly need to reject directories.  I'm not quite
5564                as sure about FIFOs, sockets, etc., but I kind of doubt
5565                that people want to exec() these things.  */
5566             continue;
5567           break;
5568         }
5569       if (p == NULL)
5570         /* Not found.  This must be an error rather than merely passing
5571            the file to execlp(), because execlp() would try all the
5572            exec()s, causing GDB to get confused.  */
5573         error ("Can't find shell %s in PATH", shell_file);
5574
5575       shell_file = tryname;
5576     }
5577
5578   fork_inferior (exec_file, allargs, env,
5579                  proc_set_exec_trap, procfs_init_inferior, NULL, shell_file);
5580
5581   /* We are at the first instruction we care about.  */
5582   /* Pedal to the metal... */
5583
5584   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
5585 }
5586
5587 /* Clean up after the inferior dies.  */
5588
5589 static void
5590 procfs_mourn_inferior ()
5591 {
5592   struct procinfo *pi;
5593   struct procinfo *next_pi;
5594
5595   for (pi = procinfo_list; pi; pi = next_pi)
5596     {
5597       next_pi = pi->next;
5598       unconditionally_kill_inferior (pi);
5599     }
5600
5601   unpush_target (&procfs_ops);
5602   generic_mourn_inferior ();
5603 }
5604
5605
5606 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
5607 static int
5608 procfs_can_run ()
5609 {
5610   /* This variable is controlled by modules that sit atop procfs that may layer
5611      their own process structure atop that provided here.  sol-thread.c does
5612      this because of the Solaris two-level thread model.  */
5613
5614   return !procfs_suppress_run;
5615 }
5616 #ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
5617 #ifndef UNIXWARE
5618 \f
5619 /* Insert a watchpoint */
5620 int
5621 procfs_set_watchpoint(pid, addr, len, rw)
5622      int                pid;
5623      CORE_ADDR          addr;
5624      int                len;
5625      int                rw;
5626 {
5627   struct procinfo       *pi;
5628   prwatch_t             wpt;
5629
5630   pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
5631   wpt.pr_vaddr = (caddr_t)addr;
5632   wpt.pr_size = len;
5633   wpt.pr_wflags = ((rw & 1) ? MA_READ : 0) | ((rw & 2) ? MA_WRITE : 0);
5634   if (ioctl (pi->ctl_fd, PIOCSWATCH, &wpt) < 0)
5635     {
5636       if (errno == E2BIG)
5637         return -1;
5638       /* Currently it sometimes happens that the same watchpoint gets
5639          deleted twice - don't die in this case (FIXME please) */
5640       if (errno == ESRCH && len == 0)
5641         return 0;
5642       print_sys_errmsg (pi->pathname, errno);
5643       error ("PIOCSWATCH failed");
5644     }
5645   return 0;
5646 }
5647
5648 int
5649 procfs_stopped_by_watchpoint(pid)
5650     int                 pid;
5651 {
5652   struct procinfo       *pi;
5653   short                 what;
5654   short                 why;
5655
5656   pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
5657   if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
5658     {
5659       why = pi->prstatus.pr_why;
5660       what = pi->prstatus.pr_what;
5661       if (why == PR_FAULTED
5662 #if defined (FLTWATCH) && defined (FLTKWATCH)
5663           && (what == FLTWATCH || what == FLTKWATCH)
5664 #else
5665 #ifdef FLTWATCH
5666           && (what == FLTWATCH)
5667 #endif
5668 #ifdef FLTKWATCH
5669           && (what == FLTKWATCH)
5670 #endif
5671 #endif
5672           )
5673         return what;
5674     }
5675   return 0;
5676 }
5677 #endif /* !UNIXWARE */
5678 #endif /* TARGET_HAS_HARDWARE_WATCHPOINTS */
5679
5680 /* Why is this necessary?  Shouldn't dead threads just be removed from the
5681    thread database?  */
5682
5683 static int
5684 procfs_thread_alive (pid)
5685      int pid;
5686 {
5687   struct procinfo *pi, *next_pi;
5688
5689   for (pi = procinfo_list; pi; pi = next_pi)
5690     {
5691       next_pi = pi->next;
5692       if (pi -> pid == pid)
5693         if (procfs_read_status (pi))    /* alive */
5694           return 1;
5695         else                            /* defunct (exited) */
5696           {
5697             close_proc_file (pi);
5698             return 0;
5699           }
5700     }
5701   return 0;
5702 }
5703
5704 int
5705 procfs_first_available ()
5706 {
5707   struct procinfo *pi;
5708
5709   for (pi = procinfo_list; pi; pi = pi->next)
5710     {
5711       if (procfs_read_status (pi))
5712         return pi->pid;
5713     }
5714   return -1;
5715 }
5716
5717 int
5718 procfs_get_pid_fd (pid)
5719      int pid;
5720 {
5721   struct procinfo *pi = find_procinfo (pid, 1);
5722
5723   if (pi == NULL)
5724     return -1;
5725
5726   return pi->ctl_fd;
5727 }
5728
5729 /* Send a SIGINT to the process group.  This acts just like the user typed a
5730    ^C on the controlling terminal.
5731
5732    XXX - This may not be correct for all systems.  Some may want to use
5733    killpg() instead of kill (-pgrp). */
5734
5735 static void
5736 procfs_stop ()
5737 {
5738   extern pid_t inferior_process_group;
5739
5740   kill (-inferior_process_group, SIGINT);
5741 }
5742 \f
5743 /* Convert a pid to printable form. */
5744
5745 #ifdef TIDGET
5746 char *
5747 procfs_pid_to_str (pid)
5748      int pid;
5749 {
5750   static char buf[100];
5751
5752   sprintf (buf, "Kernel thread %d", TIDGET (pid));
5753
5754   return buf;
5755 }
5756 #endif /* TIDGET */
5757
5758 \f
5759 static void
5760 init_procfs_ops ()
5761 {
5762   procfs_ops.to_shortname = "procfs";
5763   procfs_ops.to_longname = "Unix /proc child process";
5764   procfs_ops.to_doc = "Unix /proc child process (started by the \"run\" command).";
5765   procfs_ops.to_open = procfs_open;
5766   procfs_ops.to_attach = procfs_attach;
5767   procfs_ops.to_detach = procfs_detach;
5768   procfs_ops.to_resume = procfs_resume;
5769   procfs_ops.to_wait = procfs_wait;
5770   procfs_ops.to_fetch_registers = procfs_fetch_registers;
5771   procfs_ops.to_store_registers = procfs_store_registers;
5772   procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
5773   procfs_ops.to_xfer_memory = procfs_xfer_memory;
5774   procfs_ops.to_files_info = procfs_files_info;
5775   procfs_ops.to_insert_breakpoint = memory_insert_breakpoint;
5776   procfs_ops.to_remove_breakpoint = memory_remove_breakpoint;
5777   procfs_ops.to_terminal_init = terminal_init_inferior;
5778   procfs_ops.to_terminal_inferior = terminal_inferior;
5779   procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
5780   procfs_ops.to_terminal_ours = terminal_ours;
5781   procfs_ops.to_terminal_info = child_terminal_info;
5782   procfs_ops.to_kill = procfs_kill_inferior;
5783   procfs_ops.to_create_inferior = procfs_create_inferior;
5784   procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
5785   procfs_ops.to_can_run = procfs_can_run;
5786   procfs_ops.to_notice_signals = procfs_notice_signals;
5787   procfs_ops.to_thread_alive = procfs_thread_alive;
5788   procfs_ops.to_stop = procfs_stop;
5789   procfs_ops.to_stratum = process_stratum;
5790   procfs_ops.to_has_all_memory = 1;
5791   procfs_ops.to_has_memory = 1;
5792   procfs_ops.to_has_stack = 1;
5793   procfs_ops.to_has_registers = 1;
5794   procfs_ops.to_has_execution = 1;
5795   procfs_ops.to_magic = OPS_MAGIC;
5796 }
5797
5798 void
5799 _initialize_procfs ()
5800 {
5801 #ifdef HAVE_OPTIONAL_PROC_FS
5802   char procname[MAX_PROC_NAME_SIZE];
5803   int fd;
5804
5805   /* If we have an optional /proc filesystem (e.g. under OSF/1),
5806      don't add procfs support if we cannot access the running
5807      GDB via /proc.  */
5808   sprintf (procname, STATUS_PROC_NAME_FMT, getpid ());
5809   if ((fd = open (procname, O_RDONLY)) < 0)
5810     return;
5811   close (fd);
5812 #endif
5813
5814   init_procfs_ops ();
5815   add_target (&procfs_ops);
5816
5817   add_info ("processes", info_proc,
5818 "Show process status information using /proc entry.\n\
5819 Specify process id or use current inferior by default.\n\
5820 Specify keywords for detailed information; default is summary.\n\
5821 Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
5822 `status', `syscalls', and `times'.\n\
5823 Unambiguous abbreviations may be used.");
5824
5825   init_syscall_table ();
5826 }