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