gdb/procfs.c

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