gdb/procfs.c

   1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
   2    Copyright 1991, 1992 Free Software Foundation, Inc.
   3    Written by Fred Fish at Cygnus Support.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21
  22 /*                      N  O  T  E  S
  23
  24 For information on the details of using /proc consult section proc(4)
  25 in the UNIX System V Release 4 System Administrator's Reference Manual.
  26
  27 The general register and floating point register sets are manipulated by
  28 separate ioctl's.  This file makes the assumption that if FP0_REGNUM is
  29 defined, then support for the floating point register set is desired,
  30 regardless of whether or not the actual target has floating point hardware.
  31
  32  */
  33
  34
  35 #include "defs.h"
  36
  37 #include <time.h>
  38 #include <sys/procfs.h>
  39 #include <fcntl.h>
  40 #include <errno.h>
  41 #include <string.h>
  42
  43 #include "inferior.h"
  44 #include "target.h"
  45 #include "command.h"
  46 #include "gdbcore.h"
  47
  48 #define MAX_SYSCALLS    256     /* Maximum number of syscalls for table */
  49
  50 #ifndef PROC_NAME_FMT
  51 #define PROC_NAME_FMT "/proc/%05d"
  52 #endif
  53
  54 extern struct target_ops procfs_ops;            /* Forward declaration */
  55
  56 #if 1   /* FIXME: Gross and ugly hack to resolve coredep.c global */
  57 CORE_ADDR kernel_u_addr;
  58 #endif
  59
  60 #ifdef BROKEN_SIGINFO_H         /* Workaround broken SGS <sys/siginfo.h> */
  61 #undef si_pid
  62 #define si_pid _data._proc.pid
  63 #undef si_uid
  64 #define si_uid _data._proc._pdata._kill.uid
  65 #endif /* BROKEN_SIGINFO_H */
  66
  67 /*  All access to the inferior, either one started by gdb or one that has
  68     been attached to, is controlled by an instance of a procinfo structure,
  69     defined below.  Since gdb currently only handles one inferior at a time,
  70     the procinfo structure for the inferior is statically allocated and
  71     only one exists at any given time.  There is a separate procinfo
  72     structure for use by the "info proc" command, so that we can print
  73     useful information about any random process without interfering with
  74     the inferior's procinfo information. */
  75
  76 struct procinfo {
  77   int valid;                    /* Nonzero if pid, fd, & pathname are valid */
  78   int pid;                      /* Process ID of inferior */
  79   int fd;                       /* File descriptor for /proc entry */
  80   char *pathname;               /* Pathname to /proc entry */
  81   int was_stopped;              /* Nonzero if was stopped prior to attach */
  82   int nopass_next_sigstop;      /* Don't pass a sigstop on next resume */
  83   prrun_t prrun;                /* Control state when it is run */
  84   prstatus_t prstatus;          /* Current process status info */
  85   gregset_t gregset;            /* General register set */
  86   fpregset_t fpregset;          /* Floating point register set */
  87   fltset_t fltset;              /* Current traced hardware fault set */
  88   sigset_t trace;               /* Current traced signal set */
  89   sysset_t exitset;             /* Current traced system call exit set */
  90   sysset_t entryset;            /* Current traced system call entry set */
  91   fltset_t saved_fltset;        /* Saved traced hardware fault set */
  92   sigset_t saved_trace;         /* Saved traced signal set */
  93   sigset_t saved_sighold;       /* Saved held signal set */
  94   sysset_t saved_exitset;       /* Saved traced system call exit set */
  95   sysset_t saved_entryset;      /* Saved traced system call entry set */
  96 };
  97
  98 static struct procinfo pi;      /* Inferior's process information */
  99
 100 /*  Much of the information used in the /proc interface, particularly for
 101     printing status information, is kept as tables of structures of the
 102     following form.  These tables can be used to map numeric values to
 103     their symbolic names and to a string that describes their specific use. */
 104
 105 struct trans {
 106   int value;                    /* The numeric value */
 107   char *name;                   /* The equivalent symbolic value */
 108   char *desc;                   /* Short description of value */
 109 };
 110
 111 /*  Translate bits in the pr_flags member of the prstatus structure, into the
 112     names and desc information. */
 113
 114 static struct trans pr_flag_table[] =
 115 {
 116 #if defined (PR_STOPPED)
 117   PR_STOPPED, "PR_STOPPED", "Process is stopped",
 118 #endif
 119 #if defined (PR_ISTOP)
 120   PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest",
 121 #endif
 122 #if defined (PR_DSTOP)
 123   PR_DSTOP, "PR_DSTOP", "A stop directive is in effect",
 124 #endif
 125 #if defined (PR_ASLEEP)
 126   PR_ASLEEP, "PR_ASLEEP", "Sleeping in an interruptible system call",
 127 #endif
 128 #if defined (PR_FORK)
 129   PR_FORK, "PR_FORK", "Inherit-on-fork is in effect",
 130 #endif
 131 #if defined (PR_RLC)
 132   PR_RLC, "PR_RLC", "Run-on-last-close is in effect",
 133 #endif
 134 #if defined (PR_PTRACE)
 135   PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace",
 136 #endif
 137 #if defined (PR_PCINVAL)
 138   PR_PCINVAL, "PR_PCINVAL", "PC refers to an invalid virtual address",
 139 #endif
 140 #if defined (PR_ISSYS)
 141   PR_ISSYS, "PR_ISSYS", "Is a system process",
 142 #endif
 143 #if defined (PR_STEP)
 144   PR_STEP, "PR_STEP", "Process has single step pending",
 145 #endif
 146 #if defined (PR_KLC)
 147   PR_KLC, "PR_KLC", "Kill-on-last-close is in effect",
 148 #endif
 149 #if defined (PR_ASYNC)
 150   PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect",
 151 #endif
 152 #if defined (PR_PCOMPAT)
 153   PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect",
 154 #endif
 155  0, NULL, NULL
 156 };
 157
 158 /*  Translate values in the pr_why field of the prstatus struct. */
 159
 160 static struct trans pr_why_table[] =
 161 {
 162 #if defined (PR_REQUESTED)
 163  PR_REQUESTED, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP",
 164 #endif
 165 #if defined (PR_SIGNALLED)
 166  PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal",
 167 #endif
 168 #if defined (PR_FAULTED)
 169  PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault",
 170 #endif
 171 #if defined (PR_SYSENTRY)
 172  PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call",
 173 #endif
 174 #if defined (PR_SYSEXIT)
 175  PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call",
 176 #endif
 177 #if defined (PR_JOBCONTROL)
 178  PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action",
 179 #endif
 180 #if defined (PR_SUSPENDED)
 181  PR_SUSPENDED, "PR_SUSPENDED", "Process suspended",
 182 #endif
 183  0, NULL, NULL
 184 };
 185
 186 /*  Hardware fault translation table. */
 187
 188 static struct trans faults_table[] =
 189 {
 190 #if defined (FLTILL)
 191  FLTILL, "FLTILL", "Illegal instruction",
 192 #endif
 193 #if defined (FLTPRIV)
 194  FLTPRIV, "FLTPRIV", "Privileged instruction",
 195 #endif
 196 #if defined (FLTBPT)
 197  FLTBPT, "FLTBPT", "Breakpoint trap",
 198 #endif
 199 #if defined (FLTTRACE)
 200  FLTTRACE, "FLTTRACE", "Trace trap",
 201 #endif
 202 #if defined (FLTACCESS)
 203  FLTACCESS, "FLTACCESS", "Memory access fault",
 204 #endif
 205 #if defined (FLTBOUNDS)
 206  FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation",
 207 #endif
 208 #if defined (FLTIOVF)
 209  FLTIOVF, "FLTIOVF", "Integer overflow",
 210 #endif
 211 #if defined (FLTIZDIV)
 212  FLTIZDIV, "FLTIZDIV", "Integer zero divide",
 213 #endif
 214 #if defined (FLTFPE)
 215  FLTFPE, "FLTFPE", "Floating-point exception",
 216 #endif
 217 #if defined (FLTSTACK)
 218  FLTSTACK, "FLTSTACK", "Unrecoverable stack fault",
 219 #endif
 220 #if defined (FLTPAGE)
 221  FLTPAGE, "FLTPAGE", "Recoverable page fault",
 222 #endif
 223  0, NULL, NULL
 224 };
 225
 226 /* Translation table for signal generation information.  See UNIX System
 227    V Release 4 Programmer's Reference Manual, siginfo(5).  */
 228
 229 static struct sigcode {
 230   int signo;
 231   int code;
 232   char *codename;
 233   char *desc;
 234 } siginfo_table[] = {
 235 #if defined (SIGILL) && defined (ILL_ILLOPC)
 236   SIGILL, ILL_ILLOPC, "ILL_ILLOPC", "Illegal opcode",
 237 #endif
 238 #if defined (SIGILL) && defined (ILL_ILLOPN)
 239   SIGILL, ILL_ILLOPN, "ILL_ILLOPN", "Illegal operand",
 240 #endif
 241 #if defined (SIGILL) && defined (ILL_ILLADR)
 242   SIGILL, ILL_ILLADR, "ILL_ILLADR", "Illegal addressing mode",
 243 #endif
 244 #if defined (SIGILL) && defined (ILL_ILLTRP)
 245   SIGILL, ILL_ILLTRP, "ILL_ILLTRP", "Illegal trap",
 246 #endif
 247 #if defined (SIGILL) && defined (ILL_PRVOPC)
 248   SIGILL, ILL_PRVOPC, "ILL_PRVOPC", "Privileged opcode",
 249 #endif
 250 #if defined (SIGILL) && defined (ILL_PRVREG)
 251   SIGILL, ILL_PRVREG, "ILL_PRVREG", "Privileged register",
 252 #endif
 253 #if defined (SIGILL) && defined (ILL_COPROC)
 254   SIGILL, ILL_COPROC, "ILL_COPROC", "Coprocessor error",
 255 #endif
 256 #if defined (SIGILL) && defined (ILL_BADSTK)
 257   SIGILL, ILL_BADSTK, "ILL_BADSTK", "Internal stack error",
 258 #endif
 259 #if defined (SIGFPE) && defined (FPE_INTDIV)
 260   SIGFPE, FPE_INTDIV, "FPE_INTDIV", "Integer divide by zero",
 261 #endif
 262 #if defined (SIGFPE) && defined (FPE_INTOVF)
 263   SIGFPE, FPE_INTOVF, "FPE_INTOVF", "Integer overflow",
 264 #endif
 265 #if defined (SIGFPE) && defined (FPE_FLTDIV)
 266   SIGFPE, FPE_FLTDIV, "FPE_FLTDIV", "Floating point divide by zero",
 267 #endif
 268 #if defined (SIGFPE) && defined (FPE_FLTOVF)
 269   SIGFPE, FPE_FLTOVF, "FPE_FLTOVF", "Floating point overflow",
 270 #endif
 271 #if defined (SIGFPE) && defined (FPE_FLTUND)
 272   SIGFPE, FPE_FLTUND, "FPE_FLTUND", "Floating point underflow",
 273 #endif
 274 #if defined (SIGFPE) && defined (FPE_FLTRES)
 275   SIGFPE, FPE_FLTRES, "FPE_FLTRES", "Floating point inexact result",
 276 #endif
 277 #if defined (SIGFPE) && defined (FPE_FLTINV)
 278   SIGFPE, FPE_FLTINV, "FPE_FLTINV", "Invalid floating point operation",
 279 #endif
 280 #if defined (SIGFPE) && defined (FPE_FLTSUB)
 281   SIGFPE, FPE_FLTSUB, "FPE_FLTSUB", "Subscript out of range",
 282 #endif
 283 #if defined (SIGSEGV) && defined (SEGV_MAPERR)
 284   SIGSEGV, SEGV_MAPERR, "SEGV_MAPERR", "Address not mapped to object",
 285 #endif
 286 #if defined (SIGSEGV) && defined (SEGV_ACCERR)
 287   SIGSEGV, SEGV_ACCERR, "SEGV_ACCERR", "Invalid permissions for object",
 288 #endif
 289 #if defined (SIGBUS) && defined (BUS_ADRALN)
 290   SIGBUS, BUS_ADRALN, "BUS_ADRALN", "Invalid address alignment",
 291 #endif
 292 #if defined (SIGBUS) && defined (BUS_ADRERR)
 293   SIGBUS, BUS_ADRERR, "BUS_ADRERR", "Non-existent physical address",
 294 #endif
 295 #if defined (SIGBUS) && defined (BUS_OBJERR)
 296   SIGBUS, BUS_OBJERR, "BUS_OBJERR", "Object specific hardware error",
 297 #endif
 298 #if defined (SIGTRAP) && defined (TRAP_BRKPT)
 299   SIGTRAP, TRAP_BRKPT, "TRAP_BRKPT", "Process breakpoint",
 300 #endif
 301 #if defined (SIGTRAP) && defined (TRAP_TRACE)
 302   SIGTRAP, TRAP_TRACE, "TRAP_TRACE", "Process trace trap",
 303 #endif
 304 #if defined (SIGCLD) && defined (CLD_EXITED)
 305   SIGCLD, CLD_EXITED, "CLD_EXITED", "Child has exited",
 306 #endif
 307 #if defined (SIGCLD) && defined (CLD_KILLED)
 308   SIGCLD, CLD_KILLED, "CLD_KILLED", "Child was killed",
 309 #endif
 310 #if defined (SIGCLD) && defined (CLD_DUMPED)
 311   SIGCLD, CLD_DUMPED, "CLD_DUMPED", "Child has terminated abnormally",
 312 #endif
 313 #if defined (SIGCLD) && defined (CLD_TRAPPED)
 314   SIGCLD, CLD_TRAPPED, "CLD_TRAPPED", "Traced child has trapped",
 315 #endif
 316 #if defined (SIGCLD) && defined (CLD_STOPPED)
 317   SIGCLD, CLD_STOPPED, "CLD_STOPPED", "Child has stopped",
 318 #endif
 319 #if defined (SIGCLD) && defined (CLD_CONTINUED)
 320   SIGCLD, CLD_CONTINUED, "CLD_CONTINUED", "Stopped child had continued",
 321 #endif
 322 #if defined (SIGPOLL) && defined (POLL_IN)
 323   SIGPOLL, POLL_IN, "POLL_IN", "Input input available",
 324 #endif
 325 #if defined (SIGPOLL) && defined (POLL_OUT)
 326   SIGPOLL, POLL_OUT, "POLL_OUT", "Output buffers available",
 327 #endif
 328 #if defined (SIGPOLL) && defined (POLL_MSG)
 329   SIGPOLL, POLL_MSG, "POLL_MSG", "Input message available",
 330 #endif
 331 #if defined (SIGPOLL) && defined (POLL_ERR)
 332   SIGPOLL, POLL_ERR, "POLL_ERR", "I/O error",
 333 #endif
 334 #if defined (SIGPOLL) && defined (POLL_PRI)
 335   SIGPOLL, POLL_PRI, "POLL_PRI", "High priority input available",
 336 #endif
 337 #if defined (SIGPOLL) && defined (POLL_HUP)
 338   SIGPOLL, POLL_HUP, "POLL_HUP", "Device disconnected",
 339 #endif
 340   0, 0, NULL, NULL
 341 };
 342
 343 static char *syscall_table[MAX_SYSCALLS];
 344
 345 /* Prototypes for local functions */
 346
 347 static void
 348 set_proc_siginfo PARAMS ((struct procinfo *, int));
 349
 350 static void
 351 init_syscall_table PARAMS ((void));
 352
 353 static char *
 354 syscallname PARAMS ((int));
 355
 356 static char *
 357 signalname PARAMS ((int));
 358
 359 static char *
 360 errnoname PARAMS ((int));
 361
 362 static int
 363 proc_address_to_fd PARAMS ((CORE_ADDR, int));
 364
 365 static int
 366 open_proc_file PARAMS ((int, struct procinfo *, int));
 367
 368 static void
 369 close_proc_file PARAMS ((struct procinfo *));
 370
 371 static void
 372 unconditionally_kill_inferior PARAMS ((void));
 373
 374 static void
 375 proc_init_failed PARAMS ((char *));
 376
 377 static void
 378 info_proc PARAMS ((char *, int));
 379
 380 static void
 381 info_proc_flags PARAMS ((struct procinfo *, int));
 382
 383 static void
 384 info_proc_stop PARAMS ((struct procinfo *, int));
 385
 386 static void
 387 info_proc_siginfo PARAMS ((struct procinfo *, int));
 388
 389 static void
 390 info_proc_syscalls PARAMS ((struct procinfo *, int));
 391
 392 static void
 393 info_proc_mappings PARAMS ((struct procinfo *, int));
 394
 395 static void
 396 info_proc_signals PARAMS ((struct procinfo *, int));
 397
 398 static void
 399 info_proc_faults PARAMS ((struct procinfo *, int));
 400
 401 static char *
 402 mappingflags PARAMS ((long));
 403
 404 static char *
 405 lookupname PARAMS ((struct trans *, unsigned int, char *));
 406
 407 static char *
 408 lookupdesc PARAMS ((struct trans *, unsigned int));
 409
 410 static int
 411 do_attach PARAMS ((int pid));
 412
 413 static void
 414 do_detach PARAMS ((int siggnal));
 415
 416 static void
 417 procfs_create_inferior PARAMS ((char *, char *, char **));
 418
 419 static void
 420 procfs_notice_signals PARAMS ((void));
 421
 422 /* External function prototypes that can't be easily included in any
 423    header file because the args are typedefs in system include files. */
 424
 425 extern void
 426 supply_gregset PARAMS ((gregset_t *));
 427
 428 extern void
 429 fill_gregset PARAMS ((gregset_t *, int));
 430
 431 extern void
 432 supply_fpregset PARAMS ((fpregset_t *));
 433
 434 extern void
 435 fill_fpregset PARAMS ((fpregset_t *, int));
 436
 437 /*
 438
 439 LOCAL FUNCTION
 440
 441         lookupdesc -- translate a value to a summary desc string
 442
 443 SYNOPSIS
 444
 445         static char *lookupdesc (struct trans *transp, unsigned int val);
 446
 447 DESCRIPTION
 448
 449         Given a pointer to a translation table and a value to be translated,
 450         lookup the desc string and return it.
 451  */
 452
 453 static char *
 454 lookupdesc (transp, val)
 455      struct trans *transp;
 456      unsigned int val;
 457 {
 458   char *desc;
 459
 460   for (desc = NULL; transp -> name != NULL; transp++)
 461     {
 462       if (transp -> value == val)
 463         {
 464           desc = transp -> desc;
 465           break;
 466         }
 467     }
 468
 469   /* Didn't find a translation for the specified value, set a default one. */
 470
 471   if (desc == NULL)
 472     {
 473       desc = "Unknown";
 474     }
 475   return (desc);
 476 }
 477
 478 /*
 479
 480 LOCAL FUNCTION
 481
 482         lookupname -- translate a value to symbolic name
 483
 484 SYNOPSIS
 485
 486         static char *lookupname (struct trans *transp, unsigned int val,
 487                                  char *prefix);
 488
 489 DESCRIPTION
 490
 491         Given a pointer to a translation table, a value to be translated,
 492         and a default prefix to return if the value can't be translated,
 493         match the value with one of the translation table entries and
 494         return a pointer to the symbolic name.
 495
 496         If no match is found it just returns the value as a printable string,
 497         with the given prefix.  The previous such value, if any, is freed
 498         at this time.
 499  */
 500
 501 static char *
 502 lookupname (transp, val, prefix)
 503      struct trans *transp;
 504      unsigned int val;
 505      char *prefix;
 506 {
 507   static char *locbuf;
 508   char *name;
 509
 510   for (name = NULL; transp -> name != NULL; transp++)
 511     {
 512       if (transp -> value == val)
 513         {
 514           name = transp -> name;
 515           break;
 516         }
 517     }
 518
 519   /* Didn't find a translation for the specified value, build a default
 520      one using the specified prefix and return it.  The lifetime of
 521      the value is only until the next one is needed. */
 522
 523   if (name == NULL)
 524     {
 525       if (locbuf != NULL)
 526         {
 527           free (locbuf);
 528         }
 529       locbuf = xmalloc (strlen (prefix) + 16);
 530       sprintf (locbuf, "%s %u", prefix, val);
 531       name = locbuf;
 532     }
 533   return (name);
 534 }
 535
 536 static char *
 537 sigcodename (sip)
 538      siginfo_t *sip;
 539 {
 540   struct sigcode *scp;
 541   char *name = NULL;
 542   static char locbuf[32];
 543
 544   for (scp = siginfo_table; scp -> codename != NULL; scp++)
 545     {
 546       if ((scp -> signo == sip -> si_signo) &&
 547           (scp -> code == sip -> si_code))
 548         {
 549           name = scp -> codename;
 550           break;
 551         }
 552     }
 553   if (name == NULL)
 554     {
 555       sprintf (locbuf, "sigcode %u", sip -> si_signo);
 556       name = locbuf;
 557     }
 558   return (name);
 559 }
 560
 561 static char *
 562 sigcodedesc (sip)
 563      siginfo_t *sip;
 564 {
 565   struct sigcode *scp;
 566   char *desc = NULL;
 567
 568   for (scp = siginfo_table; scp -> codename != NULL; scp++)
 569     {
 570       if ((scp -> signo == sip -> si_signo) &&
 571           (scp -> code == sip -> si_code))
 572         {
 573           desc = scp -> desc;
 574           break;
 575         }
 576     }
 577   if (desc == NULL)
 578     {
 579       desc = "Unrecognized signal or trap use";
 580     }
 581   return (desc);
 582 }
 583
 584 /*
 585
 586 LOCAL FUNCTION
 587
 588         syscallname - translate a system call number into a system call name
 589
 590 SYNOPSIS
 591
 592         char *syscallname (int syscallnum)
 593
 594 DESCRIPTION
 595
 596         Given a system call number, translate it into the printable name
 597         of a system call, or into "syscall <num>" if it is an unknown
 598         number.
 599  */
 600
 601 static char *
 602 syscallname (syscallnum)
 603      int syscallnum;
 604 {
 605   static char locbuf[32];
 606   char *rtnval;
 607
 608   if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS)
 609     {
 610       rtnval = syscall_table[syscallnum];
 611     }
 612   else
 613     {
 614       sprintf (locbuf, "syscall %u", syscallnum);
 615       rtnval = locbuf;
 616     }
 617   return (rtnval);
 618 }
 619
 620 /*
 621
 622 LOCAL FUNCTION
 623
 624         init_syscall_table - initialize syscall translation table
 625
 626 SYNOPSIS
 627
 628         void init_syscall_table (void)
 629
 630 DESCRIPTION
 631
 632         Dynamically initialize the translation table to convert system
 633         call numbers into printable system call names.  Done once per
 634         gdb run, on initialization.
 635
 636 NOTES
 637
 638         This is awfully ugly, but preprocessor tricks to make it prettier
 639         tend to be nonportable.
 640  */
 641
 642 static void
 643 init_syscall_table ()
 644 {
 645 #if defined (SYS_exit)
 646   syscall_table[SYS_exit] = "exit";
 647 #endif
 648 #if defined (SYS_fork)
 649   syscall_table[SYS_fork] = "fork";
 650 #endif
 651 #if defined (SYS_read)
 652   syscall_table[SYS_read] = "read";
 653 #endif
 654 #if defined (SYS_write)
 655   syscall_table[SYS_write] = "write";
 656 #endif
 657 #if defined (SYS_open)
 658   syscall_table[SYS_open] = "open";
 659 #endif
 660 #if defined (SYS_close)
 661   syscall_table[SYS_close] = "close";
 662 #endif
 663 #if defined (SYS_wait)
 664   syscall_table[SYS_wait] = "wait";
 665 #endif
 666 #if defined (SYS_creat)
 667   syscall_table[SYS_creat] = "creat";
 668 #endif
 669 #if defined (SYS_link)
 670   syscall_table[SYS_link] = "link";
 671 #endif
 672 #if defined (SYS_unlink)
 673   syscall_table[SYS_unlink] = "unlink";
 674 #endif
 675 #if defined (SYS_exec)
 676   syscall_table[SYS_exec] = "exec";
 677 #endif
 678 #if defined (SYS_execv)
 679   syscall_table[SYS_execv] = "execv";
 680 #endif
 681 #if defined (SYS_execve)
 682   syscall_table[SYS_execve] = "execve";
 683 #endif
 684 #if defined (SYS_chdir)
 685   syscall_table[SYS_chdir] = "chdir";
 686 #endif
 687 #if defined (SYS_time)
 688   syscall_table[SYS_time] = "time";
 689 #endif
 690 #if defined (SYS_mknod)
 691   syscall_table[SYS_mknod] = "mknod";
 692 #endif
 693 #if defined (SYS_chmod)
 694   syscall_table[SYS_chmod] = "chmod";
 695 #endif
 696 #if defined (SYS_chown)
 697   syscall_table[SYS_chown] = "chown";
 698 #endif
 699 #if defined (SYS_brk)
 700   syscall_table[SYS_brk] = "brk";
 701 #endif
 702 #if defined (SYS_stat)
 703   syscall_table[SYS_stat] = "stat";
 704 #endif
 705 #if defined (SYS_lseek)
 706   syscall_table[SYS_lseek] = "lseek";
 707 #endif
 708 #if defined (SYS_getpid)
 709   syscall_table[SYS_getpid] = "getpid";
 710 #endif
 711 #if defined (SYS_mount)
 712   syscall_table[SYS_mount] = "mount";
 713 #endif
 714 #if defined (SYS_umount)
 715   syscall_table[SYS_umount] = "umount";
 716 #endif
 717 #if defined (SYS_setuid)
 718   syscall_table[SYS_setuid] = "setuid";
 719 #endif
 720 #if defined (SYS_getuid)
 721   syscall_table[SYS_getuid] = "getuid";
 722 #endif
 723 #if defined (SYS_stime)
 724   syscall_table[SYS_stime] = "stime";
 725 #endif
 726 #if defined (SYS_ptrace)
 727   syscall_table[SYS_ptrace] = "ptrace";
 728 #endif
 729 #if defined (SYS_alarm)
 730   syscall_table[SYS_alarm] = "alarm";
 731 #endif
 732 #if defined (SYS_fstat)
 733   syscall_table[SYS_fstat] = "fstat";
 734 #endif
 735 #if defined (SYS_pause)
 736   syscall_table[SYS_pause] = "pause";
 737 #endif
 738 #if defined (SYS_utime)
 739   syscall_table[SYS_utime] = "utime";
 740 #endif
 741 #if defined (SYS_stty)
 742   syscall_table[SYS_stty] = "stty";
 743 #endif
 744 #if defined (SYS_gtty)
 745   syscall_table[SYS_gtty] = "gtty";
 746 #endif
 747 #if defined (SYS_access)
 748   syscall_table[SYS_access] = "access";
 749 #endif
 750 #if defined (SYS_nice)
 751   syscall_table[SYS_nice] = "nice";
 752 #endif
 753 #if defined (SYS_statfs)
 754   syscall_table[SYS_statfs] = "statfs";
 755 #endif
 756 #if defined (SYS_sync)
 757   syscall_table[SYS_sync] = "sync";
 758 #endif
 759 #if defined (SYS_kill)
 760   syscall_table[SYS_kill] = "kill";
 761 #endif
 762 #if defined (SYS_fstatfs)
 763   syscall_table[SYS_fstatfs] = "fstatfs";
 764 #endif
 765 #if defined (SYS_pgrpsys)
 766   syscall_table[SYS_pgrpsys] = "pgrpsys";
 767 #endif
 768 #if defined (SYS_xenix)
 769   syscall_table[SYS_xenix] = "xenix";
 770 #endif
 771 #if defined (SYS_dup)
 772   syscall_table[SYS_dup] = "dup";
 773 #endif
 774 #if defined (SYS_pipe)
 775   syscall_table[SYS_pipe] = "pipe";
 776 #endif
 777 #if defined (SYS_times)
 778   syscall_table[SYS_times] = "times";
 779 #endif
 780 #if defined (SYS_profil)
 781   syscall_table[SYS_profil] = "profil";
 782 #endif
 783 #if defined (SYS_plock)
 784   syscall_table[SYS_plock] = "plock";
 785 #endif
 786 #if defined (SYS_setgid)
 787   syscall_table[SYS_setgid] = "setgid";
 788 #endif
 789 #if defined (SYS_getgid)
 790   syscall_table[SYS_getgid] = "getgid";
 791 #endif
 792 #if defined (SYS_signal)
 793   syscall_table[SYS_signal] = "signal";
 794 #endif
 795 #if defined (SYS_msgsys)
 796   syscall_table[SYS_msgsys] = "msgsys";
 797 #endif
 798 #if defined (SYS_sys3b)
 799   syscall_table[SYS_sys3b] = "sys3b";
 800 #endif
 801 #if defined (SYS_acct)
 802   syscall_table[SYS_acct] = "acct";
 803 #endif
 804 #if defined (SYS_shmsys)
 805   syscall_table[SYS_shmsys] = "shmsys";
 806 #endif
 807 #if defined (SYS_semsys)
 808   syscall_table[SYS_semsys] = "semsys";
 809 #endif
 810 #if defined (SYS_ioctl)
 811   syscall_table[SYS_ioctl] = "ioctl";
 812 #endif
 813 #if defined (SYS_uadmin)
 814   syscall_table[SYS_uadmin] = "uadmin";
 815 #endif
 816 #if defined (SYS_utssys)
 817   syscall_table[SYS_utssys] = "utssys";
 818 #endif
 819 #if defined (SYS_fsync)
 820   syscall_table[SYS_fsync] = "fsync";
 821 #endif
 822 #if defined (SYS_umask)
 823   syscall_table[SYS_umask] = "umask";
 824 #endif
 825 #if defined (SYS_chroot)
 826   syscall_table[SYS_chroot] = "chroot";
 827 #endif
 828 #if defined (SYS_fcntl)
 829   syscall_table[SYS_fcntl] = "fcntl";
 830 #endif
 831 #if defined (SYS_ulimit)
 832   syscall_table[SYS_ulimit] = "ulimit";
 833 #endif
 834 #if defined (SYS_rfsys)
 835   syscall_table[SYS_rfsys] = "rfsys";
 836 #endif
 837 #if defined (SYS_rmdir)
 838   syscall_table[SYS_rmdir] = "rmdir";
 839 #endif
 840 #if defined (SYS_mkdir)
 841   syscall_table[SYS_mkdir] = "mkdir";
 842 #endif
 843 #if defined (SYS_getdents)
 844   syscall_table[SYS_getdents] = "getdents";
 845 #endif
 846 #if defined (SYS_sysfs)
 847   syscall_table[SYS_sysfs] = "sysfs";
 848 #endif
 849 #if defined (SYS_getmsg)
 850   syscall_table[SYS_getmsg] = "getmsg";
 851 #endif
 852 #if defined (SYS_putmsg)
 853   syscall_table[SYS_putmsg] = "putmsg";
 854 #endif
 855 #if defined (SYS_poll)
 856   syscall_table[SYS_poll] = "poll";
 857 #endif
 858 #if defined (SYS_lstat)
 859   syscall_table[SYS_lstat] = "lstat";
 860 #endif
 861 #if defined (SYS_symlink)
 862   syscall_table[SYS_symlink] = "symlink";
 863 #endif
 864 #if defined (SYS_readlink)
 865   syscall_table[SYS_readlink] = "readlink";
 866 #endif
 867 #if defined (SYS_setgroups)
 868   syscall_table[SYS_setgroups] = "setgroups";
 869 #endif
 870 #if defined (SYS_getgroups)
 871   syscall_table[SYS_getgroups] = "getgroups";
 872 #endif
 873 #if defined (SYS_fchmod)
 874   syscall_table[SYS_fchmod] = "fchmod";
 875 #endif
 876 #if defined (SYS_fchown)
 877   syscall_table[SYS_fchown] = "fchown";
 878 #endif
 879 #if defined (SYS_sigprocmask)
 880   syscall_table[SYS_sigprocmask] = "sigprocmask";
 881 #endif
 882 #if defined (SYS_sigsuspend)
 883   syscall_table[SYS_sigsuspend] = "sigsuspend";
 884 #endif
 885 #if defined (SYS_sigaltstack)
 886   syscall_table[SYS_sigaltstack] = "sigaltstack";
 887 #endif
 888 #if defined (SYS_sigaction)
 889   syscall_table[SYS_sigaction] = "sigaction";
 890 #endif
 891 #if defined (SYS_sigpending)
 892   syscall_table[SYS_sigpending] = "sigpending";
 893 #endif
 894 #if defined (SYS_context)
 895   syscall_table[SYS_context] = "context";
 896 #endif
 897 #if defined (SYS_evsys)
 898   syscall_table[SYS_evsys] = "evsys";
 899 #endif
 900 #if defined (SYS_evtrapret)
 901   syscall_table[SYS_evtrapret] = "evtrapret";
 902 #endif
 903 #if defined (SYS_statvfs)
 904   syscall_table[SYS_statvfs] = "statvfs";
 905 #endif
 906 #if defined (SYS_fstatvfs)
 907   syscall_table[SYS_fstatvfs] = "fstatvfs";
 908 #endif
 909 #if defined (SYS_nfssys)
 910   syscall_table[SYS_nfssys] = "nfssys";
 911 #endif
 912 #if defined (SYS_waitsys)
 913   syscall_table[SYS_waitsys] = "waitsys";
 914 #endif
 915 #if defined (SYS_sigsendsys)
 916   syscall_table[SYS_sigsendsys] = "sigsendsys";
 917 #endif
 918 #if defined (SYS_hrtsys)
 919   syscall_table[SYS_hrtsys] = "hrtsys";
 920 #endif
 921 #if defined (SYS_acancel)
 922   syscall_table[SYS_acancel] = "acancel";
 923 #endif
 924 #if defined (SYS_async)
 925   syscall_table[SYS_async] = "async";
 926 #endif
 927 #if defined (SYS_priocntlsys)
 928   syscall_table[SYS_priocntlsys] = "priocntlsys";
 929 #endif
 930 #if defined (SYS_pathconf)
 931   syscall_table[SYS_pathconf] = "pathconf";
 932 #endif
 933 #if defined (SYS_mincore)
 934   syscall_table[SYS_mincore] = "mincore";
 935 #endif
 936 #if defined (SYS_mmap)
 937   syscall_table[SYS_mmap] = "mmap";
 938 #endif
 939 #if defined (SYS_mprotect)
 940   syscall_table[SYS_mprotect] = "mprotect";
 941 #endif
 942 #if defined (SYS_munmap)
 943   syscall_table[SYS_munmap] = "munmap";
 944 #endif
 945 #if defined (SYS_fpathconf)
 946   syscall_table[SYS_fpathconf] = "fpathconf";
 947 #endif
 948 #if defined (SYS_vfork)
 949   syscall_table[SYS_vfork] = "vfork";
 950 #endif
 951 #if defined (SYS_fchdir)
 952   syscall_table[SYS_fchdir] = "fchdir";
 953 #endif
 954 #if defined (SYS_readv)
 955   syscall_table[SYS_readv] = "readv";
 956 #endif
 957 #if defined (SYS_writev)
 958   syscall_table[SYS_writev] = "writev";
 959 #endif
 960 #if defined (SYS_xstat)
 961   syscall_table[SYS_xstat] = "xstat";
 962 #endif
 963 #if defined (SYS_lxstat)
 964   syscall_table[SYS_lxstat] = "lxstat";
 965 #endif
 966 #if defined (SYS_fxstat)
 967   syscall_table[SYS_fxstat] = "fxstat";
 968 #endif
 969 #if defined (SYS_xmknod)
 970   syscall_table[SYS_xmknod] = "xmknod";
 971 #endif
 972 #if defined (SYS_clocal)
 973   syscall_table[SYS_clocal] = "clocal";
 974 #endif
 975 #if defined (SYS_setrlimit)
 976   syscall_table[SYS_setrlimit] = "setrlimit";
 977 #endif
 978 #if defined (SYS_getrlimit)
 979   syscall_table[SYS_getrlimit] = "getrlimit";
 980 #endif
 981 #if defined (SYS_lchown)
 982   syscall_table[SYS_lchown] = "lchown";
 983 #endif
 984 #if defined (SYS_memcntl)
 985   syscall_table[SYS_memcntl] = "memcntl";
 986 #endif
 987 #if defined (SYS_getpmsg)
 988   syscall_table[SYS_getpmsg] = "getpmsg";
 989 #endif
 990 #if defined (SYS_putpmsg)
 991   syscall_table[SYS_putpmsg] = "putpmsg";
 992 #endif
 993 #if defined (SYS_rename)
 994   syscall_table[SYS_rename] = "rename";
 995 #endif
 996 #if defined (SYS_uname)
 997   syscall_table[SYS_uname] = "uname";
 998 #endif
 999 #if defined (SYS_setegid)
1000   syscall_table[SYS_setegid] = "setegid";
1001 #endif
1002 #if defined (SYS_sysconfig)
1003   syscall_table[SYS_sysconfig] = "sysconfig";
1004 #endif
1005 #if defined (SYS_adjtime)
1006   syscall_table[SYS_adjtime] = "adjtime";
1007 #endif
1008 #if defined (SYS_systeminfo)
1009   syscall_table[SYS_systeminfo] = "systeminfo";
1010 #endif
1011 #if defined (SYS_seteuid)
1012   syscall_table[SYS_seteuid] = "seteuid";
1013 #endif
1014 }
1015
1016 /*
1017
1018 GLOBAL FUNCTION
1019
1020         ptrace -- override library version to force errors for /proc version
1021
1022 SYNOPSIS
1023
1024         int ptrace (int request, int pid, PTRACE_ARG3_TYPE arg3, int arg4)
1025
1026 DESCRIPTION
1027
1028         When gdb is configured to use /proc, it should not be calling
1029         or otherwise attempting to use ptrace.  In order to catch errors
1030         where use of /proc is configured, but some routine is still calling
1031         ptrace, we provide a local version of a function with that name
1032         that does nothing but issue an error message.
1033 */
1034
1035 int
1036 ptrace (request, pid, arg3, arg4)
1037      int request;
1038      int pid;
1039      PTRACE_ARG3_TYPE arg3;
1040      int arg4;
1041 {
1042   error ("internal error - there is a call to ptrace() somewhere");
1043   /*NOTREACHED*/
1044 }
1045
1046 /*
1047
1048 LOCAL FUNCTION
1049
1050         procfs_kill_inferior - kill any currently inferior
1051
1052 SYNOPSIS
1053
1054         void procfs_kill_inferior (void)
1055
1056 DESCRIPTION
1057
1058         Kill any current inferior.
1059
1060 NOTES
1061
1062         Kills even attached inferiors.  Presumably the user has already
1063         been prompted that the inferior is an attached one rather than
1064         one started by gdb.  (FIXME?)
1065
1066 */
1067
1068 static void
1069 procfs_kill_inferior ()
1070 {
1071   if (inferior_pid != 0)
1072     {
1073       unconditionally_kill_inferior ();
1074       target_mourn_inferior ();
1075     }
1076 }
1077
1078 /*
1079
1080 LOCAL FUNCTION
1081
1082         unconditionally_kill_inferior - terminate the inferior
1083
1084 SYNOPSIS
1085
1086         static void unconditionally_kill_inferior (void)
1087
1088 DESCRIPTION
1089
1090         Kill the current inferior.  Should not be called until it
1091         is at least tested that there is an inferior.
1092
1093 NOTE
1094
1095         A possibly useful enhancement would be to first try sending
1096         the inferior a terminate signal, politely asking it to commit
1097         suicide, before we murder it.
1098
1099 */
1100
1101 static void
1102 unconditionally_kill_inferior ()
1103 {
1104   int signo;
1105
1106   signo = SIGKILL;
1107   ioctl (pi.fd, PIOCKILL, &signo);
1108   close_proc_file (&pi);
1109   wait ((int *) 0);
1110 }
1111
1112 /*
1113
1114 LOCAL FUNCTION
1115
1116         procfs_xfer_memory -- copy data to or from inferior memory space
1117
1118 SYNOPSIS
1119
1120         int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1121                 int dowrite, struct target_ops target)
1122
1123 DESCRIPTION
1124
1125         Copy LEN bytes to/from inferior's memory starting at MEMADDR
1126         from/to debugger memory starting at MYADDR.  Copy from inferior
1127         if DOWRITE is zero or to inferior if DOWRITE is nonzero.
1128
1129         Returns the length copied, which is either the LEN argument or
1130         zero.  This xfer function does not do partial moves, since procfs_ops
1131         doesn't allow memory operations to cross below us in the target stack
1132         anyway.
1133
1134 NOTES
1135
1136         The /proc interface makes this an almost trivial task.
1137  */
1138
1139 static int
1140 procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
1141      CORE_ADDR memaddr;
1142      char *myaddr;
1143      int len;
1144      int dowrite;
1145      struct target_ops *target; /* ignored */
1146 {
1147   int nbytes = 0;
1148
1149   if (lseek (pi.fd, (off_t) memaddr, 0) == (off_t) memaddr)
1150     {
1151       if (dowrite)
1152         {
1153           nbytes = write (pi.fd, myaddr, len);
1154         }
1155       else
1156         {
1157           nbytes = read (pi.fd, myaddr, len);
1158         }
1159       if (nbytes < 0)
1160         {
1161           nbytes = 0;
1162         }
1163     }
1164   return (nbytes);
1165 }
1166
1167 /*
1168
1169 LOCAL FUNCTION
1170
1171         procfs_store_registers -- copy register values back to inferior
1172
1173 SYNOPSIS
1174
1175         void procfs_store_registers (int regno)
1176
1177 DESCRIPTION
1178
1179         Store our current register values back into the inferior.  If
1180         REGNO is -1 then store all the register, otherwise store just
1181         the value specified by REGNO.
1182
1183 NOTES
1184
1185         If we are storing only a single register, we first have to get all
1186         the current values from the process, overwrite the desired register
1187         in the gregset with the one we want from gdb's registers, and then
1188         send the whole set back to the process.  For writing all the
1189         registers, all we have to do is generate the gregset and send it to
1190         the process.
1191
1192         Also note that the process has to be stopped on an event of interest
1193         for this to work, which basically means that it has to have been
1194         run under the control of one of the other /proc ioctl calls and not
1195         ptrace.  Since we don't use ptrace anyway, we don't worry about this
1196         fine point, but it is worth noting for future reference.
1197
1198         Gdb is confused about what this function is supposed to return.
1199         Some versions return a value, others return nothing.  Some are
1200         declared to return a value and actually return nothing.  Gdb ignores
1201         anything returned.  (FIXME)
1202
1203  */
1204
1205 static void
1206 procfs_store_registers (regno)
1207      int regno;
1208 {
1209   if (regno != -1)
1210     {
1211       ioctl (pi.fd, PIOCGREG, &pi.gregset);
1212     }
1213   fill_gregset (&pi.gregset, regno);
1214   ioctl (pi.fd, PIOCSREG, &pi.gregset);
1215
1216 #if defined (FP0_REGNUM)
1217
1218   /* Now repeat everything using the floating point register set, if the
1219      target has floating point hardware. Since we ignore the returned value,
1220      we'll never know whether it worked or not anyway. */
1221
1222   if (regno != -1)
1223     {
1224       ioctl (pi.fd, PIOCGFPREG, &pi.fpregset);
1225     }
1226   fill_fpregset (&pi.fpregset, regno);
1227   ioctl (pi.fd, PIOCSFPREG, &pi.fpregset);
1228
1229 #endif  /* FP0_REGNUM */
1230
1231 }
1232
1233 /*
1234
1235 LOCAL FUNCTION
1236
1237         procfs_init_inferior - initialize access to a /proc entry
1238
1239 SYNOPSIS
1240
1241         void procfs_init_inferior (int pid)
1242
1243 DESCRIPTION
1244
1245         When gdb starts an inferior, this function is called in the parent
1246         process immediately after the fork.  It waits for the child to stop
1247         on the return from the exec system call (the child itself takes care
1248         of ensuring that this is set up), then sets up the set of signals
1249         and faults that are to be traced.
1250
1251 NOTES
1252
1253         If proc_init_failed ever gets called, control returns to the command
1254         processing loop via the standard error handling code.
1255
1256  */
1257
1258 static void
1259 procfs_init_inferior (pid)
1260      int pid;
1261 {
1262
1263   push_target (&procfs_ops);
1264
1265   if (!open_proc_file (pid, &pi, O_RDWR))
1266     {
1267       proc_init_failed ("can't open process file");
1268     }
1269   else
1270     {
1271       memset ((char *) &pi.prrun, 0, sizeof (pi.prrun));
1272       prfillset (&pi.prrun.pr_trace);
1273       procfs_notice_signals ();
1274       prfillset (&pi.prrun.pr_fault);
1275       prdelset (&pi.prrun.pr_fault, FLTPAGE);
1276       if (ioctl (pi.fd, PIOCWSTOP, &pi.prstatus) < 0)
1277         {
1278           proc_init_failed ("PIOCWSTOP failed");
1279         }
1280       else if (ioctl (pi.fd, PIOCSFAULT, &pi.prrun.pr_fault) < 0)
1281         {
1282           proc_init_failed ("PIOCSFAULT failed");
1283         }
1284     }
1285 }
1286
1287 /*
1288
1289 GLOBAL FUNCTION
1290
1291         procfs_notice_signals
1292
1293 SYNOPSIS
1294
1295         static void procfs_notice_signals (void);
1296
1297 DESCRIPTION
1298
1299         When the user changes the state of gdb's signal handling via the
1300         "handle" command, this function gets called to see if any change
1301         in the /proc interface is required.  It is also called internally
1302         by other /proc interface functions to initialize the state of
1303         the traced signal set.
1304
1305         One thing it does is that signals for which the state is "nostop",
1306         "noprint", and "pass", have their trace bits reset in the pr_trace
1307         field, so that they are no longer traced.  This allows them to be
1308         delivered directly to the inferior without the debugger ever being
1309         involved.
1310  */
1311
1312 static void
1313 procfs_notice_signals ()
1314 {
1315   int signo;
1316
1317   if (pi.valid)
1318     {
1319       for (signo = 0; signo < NSIG; signo++)
1320         {
1321           if (signal_stop_state (signo) == 0 &&
1322               signal_print_state (signo) == 0 &&
1323               signal_pass_state (signo) == 1)
1324             {
1325               prdelset (&pi.prrun.pr_trace, signo);
1326             }
1327           else
1328             {
1329               praddset (&pi.prrun.pr_trace, signo);
1330             }
1331         }
1332       if (ioctl (pi.fd, PIOCSTRACE, &pi.prrun.pr_trace))
1333         {
1334           print_sys_errmsg ("PIOCSTRACE failed", errno);
1335         }
1336     }
1337 }
1338
1339 /*
1340
1341 LOCAL FUNCTION
1342
1343         proc_set_exec_trap -- arrange for exec'd child to halt at startup
1344
1345 SYNOPSIS
1346
1347         void proc_set_exec_trap (void)
1348
1349 DESCRIPTION
1350
1351         This function is called in the child process when starting up
1352         an inferior, prior to doing the exec of the actual inferior.
1353         It sets the child process's exitset to make exit from the exec
1354         system call an event of interest to stop on, and then simply
1355         returns.  The child does the exec, the system call returns, and
1356         the child stops at the first instruction, ready for the gdb
1357         parent process to take control of it.
1358
1359 NOTE
1360
1361         We need to use all local variables since the child may be sharing
1362         it's data space with the parent, if vfork was used rather than
1363         fork.
1364
1365         Also note that we want to turn off the inherit-on-fork flag in
1366         the child process so that any grand-children start with all
1367         tracing flags cleared.
1368  */
1369
1370 static void
1371 proc_set_exec_trap ()
1372 {
1373   sysset_t exitset;
1374   auto char procname[32];
1375   int fd;
1376
1377   sprintf (procname, PROC_NAME_FMT, getpid ());
1378   if ((fd = open (procname, O_RDWR)) < 0)
1379     {
1380       perror (procname);
1381       fflush (stderr);
1382       _exit (127);
1383     }
1384   premptyset (&exitset);
1385
1386   /* GW: Rationale...
1387      Not all systems with /proc have all the exec* syscalls with the same
1388      names.  On the SGI, for example, there is no SYS_exec, but there
1389      *is* a SYS_execv.  So, we try to account for that. */
1390
1391 #ifdef SYS_exec
1392   praddset (&exitset, SYS_exec);
1393 #endif
1394 #ifdef SYS_execve
1395   praddset (&exitset, SYS_execve);
1396 #endif
1397 #ifdef SYS_execv
1398   praddset(&exitset, SYS_execv);
1399 #endif
1400
1401   if (ioctl (fd, PIOCSEXIT, &exitset) < 0)
1402     {
1403       perror (procname);
1404       fflush (stderr);
1405       _exit (127);
1406     }
1407
1408   /* Turn off inherit-on-fork flag so that all grand-children of gdb
1409      start with tracing flags cleared. */
1410
1411 #if defined (PIOCRESET) /* New method */
1412   {
1413       long pr_flags;
1414       pr_flags = PR_FORK;
1415       ioctl (fd, PIOCRESET, &pr_flags);
1416   }
1417 #else
1418 #if defined (PIOCRFORK) /* Original method */
1419   ioctl (fd, PIOCRFORK, NULL);
1420 #endif
1421 #endif
1422
1423   /* Turn on run-on-last-close flag so that this process will not hang
1424      if GDB goes away for some reason.  */
1425
1426 #if defined (PIOCSET)   /* New method */
1427   {
1428       long pr_flags;
1429       pr_flags = PR_RLC;
1430       (void) ioctl (fd, PIOCSET, &pr_flags);
1431   }
1432 #else
1433 #if defined (PIOCSRLC)  /* Original method */
1434   (void) ioctl (fd, PIOCSRLC, 0);
1435 #endif
1436 #endif
1437 }
1438
1439 /*
1440
1441 GLOBAL FUNCTION
1442
1443         proc_iterate_over_mappings -- call function for every mapped space
1444
1445 SYNOPSIS
1446
1447         int proc_iterate_over_mappings (int (*func)())
1448
1449 DESCRIPTION
1450
1451         Given a pointer to a function, call that function for every
1452         mapped address space, passing it an open file descriptor for
1453         the file corresponding to that mapped address space (if any)
1454         and the base address of the mapped space.  Quit when we hit
1455         the end of the mappings or the function returns nonzero.
1456  */
1457
1458 int
1459 proc_iterate_over_mappings (func)
1460      int (*func) PARAMS ((int, CORE_ADDR));
1461 {
1462   int nmap;
1463   int fd;
1464   int funcstat = 0;
1465   struct prmap *prmaps;
1466   struct prmap *prmap;
1467
1468   if (pi.valid && (ioctl (pi.fd, PIOCNMAP, &nmap) == 0))
1469     {
1470       prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
1471       if (ioctl (pi.fd, PIOCMAP, prmaps) == 0)
1472         {
1473           for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
1474             {
1475               fd = proc_address_to_fd ((CORE_ADDR) prmap -> pr_vaddr, 0);
1476               funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
1477               close (fd);
1478             }
1479         }
1480     }
1481   return (funcstat);
1482 }
1483
1484 #if 0   /* Currently unused */
1485 /*
1486
1487 GLOBAL FUNCTION
1488
1489         proc_base_address -- find base address for segment containing address
1490
1491 SYNOPSIS
1492
1493         CORE_ADDR proc_base_address (CORE_ADDR addr)
1494
1495 DESCRIPTION
1496
1497         Given an address of a location in the inferior, find and return
1498         the base address of the mapped segment containing that address.
1499
1500         This is used for example, by the shared library support code,
1501         where we have the pc value for some location in the shared library
1502         where we are stopped, and need to know the base address of the
1503         segment containing that address.
1504 */
1505
1506 CORE_ADDR
1507 proc_base_address (addr)
1508      CORE_ADDR addr;
1509 {
1510   int nmap;
1511   struct prmap *prmaps;
1512   struct prmap *prmap;
1513   CORE_ADDR baseaddr = 0;
1514
1515   if (pi.valid && (ioctl (pi.fd, PIOCNMAP, &nmap) == 0))
1516     {
1517       prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
1518       if (ioctl (pi.fd, PIOCMAP, prmaps) == 0)
1519         {
1520           for (prmap = prmaps; prmap -> pr_size; ++prmap)
1521             {
1522               if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
1523                   (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
1524                 {
1525                   baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
1526                   break;
1527                 }
1528             }
1529         }
1530     }
1531   return (baseaddr);
1532 }
1533
1534 #endif  /* 0 */
1535
1536 /*
1537
1538 LOCAL FUNCTION
1539
1540         proc_address_to_fd -- return open fd for file mapped to address
1541
1542 SYNOPSIS
1543
1544         int proc_address_to_fd (CORE_ADDR addr, complain)
1545
1546 DESCRIPTION
1547
1548         Given an address in the current inferior's address space, use the
1549         /proc interface to find an open file descriptor for the file that
1550         this address was mapped in from.  Return -1 if there is no current
1551         inferior.  Print a warning message if there is an inferior but
1552         the address corresponds to no file (IE a bogus address).
1553
1554 */
1555
1556 static int
1557 proc_address_to_fd (addr, complain)
1558      CORE_ADDR addr;
1559      int complain;
1560 {
1561   int fd = -1;
1562
1563   if (pi.valid)
1564     {
1565       if ((fd = ioctl (pi.fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
1566         {
1567           if (complain)
1568             {
1569               print_sys_errmsg (pi.pathname, errno);
1570               warning ("can't find mapped file for address 0x%x", addr);
1571             }
1572         }
1573     }
1574   return (fd);
1575 }
1576
1577
1578 /* Attach to process PID, then initialize for debugging it
1579    and wait for the trace-trap that results from attaching.  */
1580
1581 static void
1582 procfs_attach (args, from_tty)
1583      char *args;
1584      int from_tty;
1585 {
1586   char *exec_file;
1587   int pid;
1588
1589   if (!args)
1590     error_no_arg ("process-id to attach");
1591
1592   pid = atoi (args);
1593
1594   if (pid == getpid())          /* Trying to masturbate? */
1595     error ("I refuse to debug myself!");
1596
1597   if (from_tty)
1598     {
1599       exec_file = (char *) get_exec_file (0);
1600
1601       if (exec_file)
1602         printf ("Attaching program `%s', pid %d\n", exec_file, pid);
1603       else
1604         printf ("Attaching pid %d\n", pid);
1605
1606       fflush (stdout);
1607     }
1608
1609   do_attach (pid);
1610   inferior_pid = pid;
1611   push_target (&procfs_ops);
1612 }
1613
1614
1615 /* Take a program previously attached to and detaches it.
1616    The program resumes execution and will no longer stop
1617    on signals, etc.  We'd better not have left any breakpoints
1618    in the program or it'll die when it hits one.  For this
1619    to work, it may be necessary for the process to have been
1620    previously attached.  It *might* work if the program was
1621    started via the normal ptrace (PTRACE_TRACEME).  */
1622
1623 static void
1624 procfs_detach (args, from_tty)
1625      char *args;
1626      int from_tty;
1627 {
1628   int siggnal = 0;
1629
1630   if (from_tty)
1631     {
1632       char *exec_file = get_exec_file (0);
1633       if (exec_file == 0)
1634         exec_file = "";
1635       printf ("Detaching program: %s pid %d\n",
1636               exec_file, inferior_pid);
1637       fflush (stdout);
1638     }
1639   if (args)
1640     siggnal = atoi (args);
1641
1642   do_detach (siggnal);
1643   inferior_pid = 0;
1644   unpush_target (&procfs_ops);          /* Pop out of handling an inferior */
1645 }
1646
1647 /* Get ready to modify the registers array.  On machines which store
1648    individual registers, this doesn't need to do anything.  On machines
1649    which store all the registers in one fell swoop, this makes sure
1650    that registers contains all the registers from the program being
1651    debugged.  */
1652
1653 static void
1654 procfs_prepare_to_store ()
1655 {
1656 #ifdef CHILD_PREPARE_TO_STORE
1657   CHILD_PREPARE_TO_STORE ();
1658 #endif
1659 }
1660
1661 /* Print status information about what we're accessing.  */
1662
1663 static void
1664 procfs_files_info (ignore)
1665      struct target_ops *ignore;
1666 {
1667   printf ("\tUsing the running image of %s process %d via /proc.\n",
1668           attach_flag? "attached": "child", inferior_pid);
1669 }
1670
1671 /* ARGSUSED */
1672 static void
1673 procfs_open (arg, from_tty)
1674      char *arg;
1675      int from_tty;
1676 {
1677   error ("Use the \"run\" command to start a Unix child process.");
1678 }
1679
1680 /*
1681
1682 LOCAL FUNCTION
1683
1684         do_attach -- attach to an already existing process
1685
1686 SYNOPSIS
1687
1688         int do_attach (int pid)
1689
1690 DESCRIPTION
1691
1692         Attach to an already existing process with the specified process
1693         id.  If the process is not already stopped, query whether to
1694         stop it or not.
1695
1696 NOTES
1697
1698         The option of stopping at attach time is specific to the /proc
1699         versions of gdb.  Versions using ptrace force the attachee
1700         to stop.  (I have changed this version to do so, too.  All you
1701         have to do is "continue" to make it go on. -- gnu@cygnus.com)
1702
1703 */
1704
1705 static int
1706 do_attach (pid)
1707      int pid;
1708 {
1709   int result;
1710
1711   if (!open_proc_file (pid, &pi, O_RDWR))
1712     {
1713       perror_with_name (pi.pathname);
1714       /* NOTREACHED */
1715     }
1716
1717   /*  Get current status of process and if it is not already stopped,
1718       then stop it.  Remember whether or not it was stopped when we first
1719       examined it. */
1720
1721   if (ioctl (pi.fd, PIOCSTATUS, &pi.prstatus) < 0)
1722     {
1723       print_sys_errmsg (pi.pathname, errno);
1724       close_proc_file (&pi);
1725       error ("PIOCSTATUS failed");
1726     }
1727   if (pi.prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
1728     {
1729       pi.was_stopped = 1;
1730     }
1731   else
1732     {
1733       pi.was_stopped = 0;
1734       if (1 || query ("Process is currently running, stop it? "))
1735         {
1736           /* Make it run again when we close it.  */
1737 #if defined (PIOCSET)   /* New method */
1738           {
1739               long pr_flags;
1740               pr_flags = PR_RLC;
1741               result = ioctl (pi.fd, PIOCSET, &pr_flags);
1742           }
1743 #else
1744 #if defined (PIOCSRLC)  /* Original method */
1745           result = ioctl (pi.fd, PIOCSRLC, 0);
1746 #endif
1747 #endif
1748           if (result < 0)
1749             {
1750               print_sys_errmsg (pi.pathname, errno);
1751               close_proc_file (&pi);
1752               error ("PIOCSRLC or PIOCSET failed");
1753             }
1754           if (ioctl (pi.fd, PIOCSTOP, &pi.prstatus) < 0)
1755             {
1756               print_sys_errmsg (pi.pathname, errno);
1757               close_proc_file (&pi);
1758               error ("PIOCSTOP failed");
1759             }
1760           pi.nopass_next_sigstop = 1;
1761         }
1762       else
1763         {
1764           printf ("Ok, gdb will wait for process %u to stop.\n", pid);
1765         }
1766     }
1767
1768   /*  Remember some things about the inferior that we will, or might, change
1769       so that we can restore them when we detach. */
1770
1771   ioctl (pi.fd, PIOCGTRACE, &pi.saved_trace);
1772   ioctl (pi.fd, PIOCGHOLD, &pi.saved_sighold);
1773   ioctl (pi.fd, PIOCGFAULT, &pi.saved_fltset);
1774   ioctl (pi.fd, PIOCGENTRY, &pi.saved_entryset);
1775   ioctl (pi.fd, PIOCGEXIT, &pi.saved_exitset);
1776
1777   /* Set up trace and fault sets, as gdb expects them. */
1778
1779   memset (&pi.prrun, 0, sizeof (pi.prrun));
1780   prfillset (&pi.prrun.pr_trace);
1781   procfs_notice_signals ();
1782   prfillset (&pi.prrun.pr_fault);
1783   prdelset (&pi.prrun.pr_fault, FLTPAGE);
1784   if (ioctl (pi.fd, PIOCSFAULT, &pi.prrun.pr_fault))
1785     {
1786       print_sys_errmsg ("PIOCSFAULT failed", errno);
1787     }
1788   if (ioctl (pi.fd, PIOCSTRACE, &pi.prrun.pr_trace))
1789     {
1790       print_sys_errmsg ("PIOCSTRACE failed", errno);
1791     }
1792   attach_flag = 1;
1793   return (pid);
1794 }
1795
1796 /*
1797
1798 LOCAL FUNCTION
1799
1800         do_detach -- detach from an attached-to process
1801
1802 SYNOPSIS
1803
1804         void do_detach (int signal)
1805
1806 DESCRIPTION
1807
1808         Detach from the current attachee.
1809
1810         If signal is non-zero, the attachee is started running again and sent
1811         the specified signal.
1812
1813         If signal is zero and the attachee was not already stopped when we
1814         attached to it, then we make it runnable again when we detach.
1815
1816         Otherwise, we query whether or not to make the attachee runnable
1817         again, since we may simply want to leave it in the state it was in
1818         when we attached.
1819
1820         We report any problems, but do not consider them errors, since we
1821         MUST detach even if some things don't seem to go right.  This may not
1822         be the ideal situation.  (FIXME).
1823  */
1824
1825 static void
1826 do_detach (signal)
1827      int signal;
1828 {
1829   int result;
1830
1831   if (signal)
1832     {
1833       set_proc_siginfo (&pi, signal);
1834     }
1835   if (ioctl (pi.fd, PIOCSEXIT, &pi.saved_exitset) < 0)
1836     {
1837       print_sys_errmsg (pi.pathname, errno);
1838       printf ("PIOCSEXIT failed.\n");
1839     }
1840   if (ioctl (pi.fd, PIOCSENTRY, &pi.saved_entryset) < 0)
1841     {
1842       print_sys_errmsg (pi.pathname, errno);
1843       printf ("PIOCSENTRY failed.\n");
1844     }
1845   if (ioctl (pi.fd, PIOCSTRACE, &pi.saved_trace) < 0)
1846     {
1847       print_sys_errmsg (pi.pathname, errno);
1848       printf ("PIOCSTRACE failed.\n");
1849     }
1850   if (ioctl (pi.fd, PIOCSHOLD, &pi.saved_sighold) < 0)
1851     {
1852       print_sys_errmsg (pi.pathname, errno);
1853       printf ("PIOSCHOLD failed.\n");
1854     }
1855   if (ioctl (pi.fd, PIOCSFAULT, &pi.saved_fltset) < 0)
1856     {
1857       print_sys_errmsg (pi.pathname, errno);
1858       printf ("PIOCSFAULT failed.\n");
1859     }
1860   if (ioctl (pi.fd, PIOCSTATUS, &pi.prstatus) < 0)
1861     {
1862       print_sys_errmsg (pi.pathname, errno);
1863       printf ("PIOCSTATUS failed.\n");
1864     }
1865   else
1866     {
1867       if (signal || (pi.prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
1868         {
1869           if (signal || !pi.was_stopped ||
1870               query ("Was stopped when attached, make it runnable again? "))
1871             {
1872               /* Clear any fault that might have stopped it.  */
1873               if (ioctl (pi.fd, PIOCCFAULT, 0))
1874                 {
1875                   print_sys_errmsg (pi.pathname, errno);
1876                   printf ("PIOCCFAULT failed.\n");
1877                 }
1878
1879               /* Make it run again when we close it.  */
1880 #if defined (PIOCSET)   /* New method */
1881               {
1882                   long pr_flags;
1883                   pr_flags = PR_RLC;
1884                   result = ioctl (pi.fd, PIOCSET, &pr_flags);
1885               }
1886 #else
1887 #if defined (PIOCSRLC)  /* Original method */
1888               result = ioctl (pi.fd, PIOCSRLC, 0);
1889 #endif
1890 #endif
1891               if (result)
1892                 {
1893                   print_sys_errmsg (pi.pathname, errno);
1894                   printf ("PIOCSRLC or PIOCSET failed.\n");
1895                 }
1896             }
1897         }
1898     }
1899   close_proc_file (&pi);
1900   attach_flag = 0;
1901 }
1902
1903 /*
1904
1905 LOCAL FUNCTION
1906
1907         procfs_wait -- emulate wait() as much as possible
1908         Wait for child to do something.  Return pid of child, or -1 in case
1909         of error; store status through argument pointer STATUS.
1910
1911
1912 SYNOPSIS
1913
1914         int procfs_wait (int *statloc)
1915
1916 DESCRIPTION
1917
1918         Try to emulate wait() as much as possible.  Not sure why we can't
1919         just use wait(), but it seems to have problems when applied to a
1920         process being controlled with the /proc interface.
1921
1922 NOTES
1923
1924         We have a race problem here with no obvious solution.  We need to let
1925         the inferior run until it stops on an event of interest, which means
1926         that we need to use the PIOCWSTOP ioctl.  However, we cannot use this
1927         ioctl if the process is already stopped on something that is not an
1928         event of interest, or the call will hang indefinitely.  Thus we first
1929         use PIOCSTATUS to see if the process is not stopped.  If not, then we
1930         use PIOCWSTOP.  But during the window between the two, if the process
1931         stops for any reason that is not an event of interest (such as a job
1932         control signal) then gdb will hang.  One possible workaround is to set
1933         an alarm to wake up every minute of so and check to see if the process
1934         is still running, and if so, then reissue the PIOCWSTOP.  But this is
1935         a real kludge, so has not been implemented.  FIXME: investigate
1936         alternatives.
1937
1938         FIXME:  Investigate why wait() seems to have problems with programs
1939         being control by /proc routines.
1940
1941  */
1942
1943 static int
1944 procfs_wait (statloc)
1945      int *statloc;
1946 {
1947   short what;
1948   short why;
1949   int statval = 0;
1950   int checkerr = 0;
1951   int rtnval = -1;
1952
1953   if (ioctl (pi.fd, PIOCSTATUS, &pi.prstatus) < 0)
1954     {
1955       checkerr++;
1956     }
1957   else if (!(pi.prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
1958     {
1959       if (attach_flag)
1960         set_sigint_trap();      /* Causes SIGINT to be passed on to the
1961                                    attached process. */
1962
1963       if (ioctl (pi.fd, PIOCWSTOP, &pi.prstatus) < 0)
1964         {
1965           checkerr++;
1966         }
1967
1968       if (attach_flag)
1969         clear_sigint_trap();
1970     }
1971   if (checkerr)
1972     {
1973       if (errno == ENOENT)
1974         {
1975           rtnval = wait (&statval);
1976           if (rtnval != inferior_pid)
1977             {
1978               print_sys_errmsg (pi.pathname, errno);
1979               error ("PIOCWSTOP, wait failed, returned %d", rtnval);
1980               /* NOTREACHED */
1981             }
1982         }
1983       else
1984         {
1985           print_sys_errmsg (pi.pathname, errno);
1986           error ("PIOCSTATUS or PIOCWSTOP failed.");
1987           /* NOTREACHED */
1988         }
1989     }
1990   else if (pi.prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
1991     {
1992       rtnval = pi.prstatus.pr_pid;
1993       why = pi.prstatus.pr_why;
1994       what = pi.prstatus.pr_what;
1995       if (why == PR_SIGNALLED)
1996         {
1997           statval = (what << 8) | 0177;
1998         }
1999       else if ((why == PR_SYSEXIT)
2000                &&
2001                (
2002 #ifdef SYS_exec
2003                 what == SYS_exec
2004 #else
2005                 0 == 0
2006 #endif
2007 #ifdef SYS_execve
2008                 || what == SYS_execve
2009 #endif
2010 #ifdef SYS_execv
2011                 || what == SYS_execv
2012 #endif
2013                 ))
2014         {
2015           statval = (SIGTRAP << 8) | 0177;
2016         }
2017       else if (why == PR_REQUESTED)
2018         {
2019           statval = (SIGSTOP << 8) | 0177;
2020         }
2021       else if (why == PR_JOBCONTROL)
2022         {
2023           statval = (what << 8) | 0177;
2024         }
2025       else if (why == PR_FAULTED)
2026         {
2027           switch (what)
2028             {
2029             case FLTPRIV:
2030             case FLTILL:
2031               statval = (SIGILL << 8) | 0177;
2032               break;
2033             case FLTBPT:
2034             case FLTTRACE:
2035               statval = (SIGTRAP << 8) | 0177;
2036               break;
2037             case FLTSTACK:
2038             case FLTACCESS:
2039             case FLTBOUNDS:
2040               statval = (SIGSEGV << 8) | 0177;
2041               break;
2042             case FLTIOVF:
2043             case FLTIZDIV:
2044             case FLTFPE:
2045               statval = (SIGFPE << 8) | 0177;
2046               break;
2047             case FLTPAGE:               /* Recoverable page fault */
2048             default:
2049               rtnval = -1;
2050               error ("PIOCWSTOP, unknown why %d, what %d", why, what);
2051               /* NOTREACHED */
2052             }
2053         }
2054       else
2055         {
2056           rtnval = -1;
2057           error ("PIOCWSTOP, unknown why %d, what %d", why, what);
2058           /* NOTREACHED */
2059         }
2060     }
2061   else
2062     {
2063       error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
2064              pi.prstatus.pr_flags);
2065           /* NOTREACHED */
2066     }
2067
2068   if (statloc)
2069     {
2070       *statloc = statval;
2071     }
2072
2073   if (rtnval == -1)             /* No more children to wait for */
2074     {
2075       fprintf (stderr, "Child process unexpectedly missing.\n");
2076       *statloc = 42;    /* Claim it exited with signal 42 */
2077       return rtnval;
2078     }
2079
2080   return (rtnval);
2081 }
2082
2083 /*
2084
2085 LOCAL FUNCTION
2086
2087         set_proc_siginfo - set a process's current signal info
2088
2089 SYNOPSIS
2090
2091         void set_proc_siginfo (struct procinfo *pip, int signo);
2092
2093 DESCRIPTION
2094
2095         Given a pointer to a process info struct in PIP and a signal number
2096         in SIGNO, set the process's current signal and its associated signal
2097         information.  The signal will be delivered to the process immediately
2098         after execution is resumed, even if it is being held.  In addition,
2099         this particular delivery will not cause another PR_SIGNALLED stop
2100         even if the signal is being traced.
2101
2102         If we are not delivering the same signal that the prstatus siginfo
2103         struct contains information about, then synthesize a siginfo struct
2104         to match the signal we are doing to deliver, make it of the type
2105         "generated by a user process", and send this synthesized copy.  When
2106         used to set the inferior's signal state, this will be required if we
2107         are not currently stopped because of a traced signal, or if we decide
2108         to continue with a different signal.
2109
2110         Note that when continuing the inferior from a stop due to receipt
2111         of a traced signal, we either have set PRCSIG to clear the existing
2112         signal, or we have to call this function to do a PIOCSSIG with either
2113         the existing siginfo struct from pr_info, or one we have synthesized
2114         appropriately for the signal we want to deliver.  Otherwise if the
2115         signal is still being traced, the inferior will immediately stop
2116         again.
2117
2118         See siginfo(5) for more details.
2119 */
2120
2121 static void
2122 set_proc_siginfo (pip, signo)
2123      struct procinfo *pip;
2124      int signo;
2125 {
2126   struct siginfo newsiginfo;
2127   struct siginfo *sip;
2128
2129   if (pip -> valid)
2130     {
2131       if (signo == pip -> prstatus.pr_info.si_signo)
2132         {
2133           sip = &pip -> prstatus.pr_info;
2134         }
2135       else
2136         {
2137           memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
2138           sip = &newsiginfo;
2139           sip -> si_signo = signo;
2140           sip -> si_code = 0;
2141           sip -> si_errno = 0;
2142           sip -> si_pid = getpid ();
2143           sip -> si_uid = getuid ();
2144         }
2145       if (ioctl (pip -> fd, PIOCSSIG, sip) < 0)
2146         {
2147           print_sys_errmsg (pip -> pathname, errno);
2148           warning ("PIOCSSIG failed");
2149         }
2150     }
2151 }
2152
2153 /* Resume execution of the inferior process.  If STEP is nozero, then
2154    just single step it.  If SIGNAL is nonzero, restart it with that
2155    signal activated.  */
2156
2157 static void
2158 procfs_resume (step, signo)
2159      int step;
2160      int signo;
2161 {
2162   int signal_to_pass;
2163
2164   errno = 0;
2165   pi.prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
2166
2167 #if 0
2168   /* It should not be necessary.  If the user explicitly changes the value,
2169      value_assign calls write_register_bytes, which writes it.  */
2170 /*      It may not be absolutely necessary to specify the PC value for
2171         restarting, but to be safe we use the value that gdb considers
2172         to be current.  One case where this might be necessary is if the
2173         user explicitly changes the PC value that gdb considers to be
2174         current.  FIXME:  Investigate if this is necessary or not.  */
2175
2176 #ifdef PRSVADDR_BROKEN
2177 /* Can't do this under Solaris running on a Sparc, as there seems to be no
2178    place to put nPC.  In fact, if you use this, nPC seems to be set to some
2179    random garbage.  We have to rely on the fact that PC and nPC have been
2180    written previously via PIOCSREG during a register flush. */
2181
2182   pi.prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
2183   pi.prrun.pr_flags != PRSVADDR;
2184 #endif
2185 #endif
2186
2187   if (signo == SIGSTOP && pi.nopass_next_sigstop)
2188     /* When attaching to a child process, if we forced it to stop with
2189        a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
2190        Upon resuming the first time after such a stop, we explicitly
2191        inhibit sending it another SIGSTOP, which would be the normal
2192        result of default signal handling.  One potential drawback to
2193        this is that we will also ignore any attempt to by the user
2194        to explicitly continue after the attach with a SIGSTOP.  Ultimately
2195        this problem should be dealt with by making the routines that
2196        deal with the inferior a little smarter, and possibly even allow
2197        an inferior to continue running at the same time as gdb.  (FIXME?)  */
2198     signal_to_pass = 0;
2199   else if (signo == SIGTSTP
2200            && pi.prstatus.pr_cursig == SIGTSTP
2201            && pi.prstatus.pr_action.sa_handler == SIG_DFL)
2202
2203     /* We are about to pass the inferior a SIGTSTP whose action is
2204        SIG_DFL.  The SIG_DFL action for a SIGTSTP is to stop
2205        (notifying the parent via wait()), and then keep going from the
2206        same place when the parent is ready for you to keep going.  So
2207        under the debugger, it should do nothing (as if the program had
2208        been stopped and then later resumed.  Under ptrace, this
2209        happens for us, but under /proc, the system obligingly stops
2210        the process, and wait_for_inferior would have no way of
2211        distinguishing that type of stop (which indicates that we
2212        should just start it again), with a stop due to the pr_trace
2213        field of the prrun_t struct.
2214
2215        Note that if the SIGTSTP is being caught, we *do* need to pass it,
2216        because the handler needs to get executed.  */
2217     signal_to_pass = 0;
2218   else
2219     signal_to_pass = signo;
2220
2221   if (signal_to_pass)
2222     {
2223       set_proc_siginfo (&pi, signal_to_pass);
2224     }
2225   else
2226     {
2227       pi.prrun.pr_flags |= PRCSIG;
2228     }
2229   pi.nopass_next_sigstop = 0;
2230   if (step)
2231     {
2232       pi.prrun.pr_flags |= PRSTEP;
2233     }
2234   if (ioctl (pi.fd, PIOCRUN, &pi.prrun) != 0)
2235     {
2236       perror_with_name (pi.pathname);
2237       /* NOTREACHED */
2238     }
2239 }
2240
2241 /*
2242
2243 LOCAL FUNCTION
2244
2245         procfs_fetch_registers -- fetch current registers from inferior
2246
2247 SYNOPSIS
2248
2249         void procfs_fetch_registers (int regno)
2250
2251 DESCRIPTION
2252
2253         Read the current values of the inferior's registers, both the
2254         general register set and floating point registers (if supported)
2255         and update gdb's idea of their current values.
2256
2257 */
2258
2259 static void
2260 procfs_fetch_registers (regno)
2261      int regno;
2262 {
2263   if (ioctl (pi.fd, PIOCGREG, &pi.gregset) != -1)
2264     {
2265       supply_gregset (&pi.gregset);
2266     }
2267 #if defined (FP0_REGNUM)
2268   if (ioctl (pi.fd, PIOCGFPREG, &pi.fpregset) != -1)
2269     {
2270       supply_fpregset (&pi.fpregset);
2271     }
2272 #endif
2273 }
2274
2275 /*
2276
2277 LOCAL FUNCTION
2278
2279         proc_init_failed - called whenever /proc access initialization fails
2280
2281 SYNOPSIS
2282
2283         static void proc_init_failed (char *why)
2284
2285 DESCRIPTION
2286
2287         This function is called whenever initialization of access to a /proc
2288         entry fails.  It prints a suitable error message, does some cleanup,
2289         and then invokes the standard error processing routine which dumps
2290         us back into the command loop.
2291  */
2292
2293 static void
2294 proc_init_failed (why)
2295      char *why;
2296 {
2297   print_sys_errmsg (pi.pathname, errno);
2298   kill (pi.pid, SIGKILL);
2299   close_proc_file (&pi);
2300   error (why);
2301   /* NOTREACHED */
2302 }
2303
2304 /*
2305
2306 LOCAL FUNCTION
2307
2308         close_proc_file - close any currently open /proc entry
2309
2310 SYNOPSIS
2311
2312         static void close_proc_file (struct procinfo *pip)
2313
2314 DESCRIPTION
2315
2316         Close any currently open /proc entry and mark the process information
2317         entry as invalid.  In order to ensure that we don't try to reuse any
2318         stale information, the pid, fd, and pathnames are explicitly
2319         invalidated, which may be overkill.
2320
2321  */
2322
2323 static void
2324 close_proc_file (pip)
2325      struct procinfo *pip;
2326 {
2327   pip -> pid = 0;
2328   if (pip -> valid)
2329     {
2330       close (pip -> fd);
2331     }
2332   pip -> fd = -1;
2333   if (pip -> pathname)
2334     {
2335       free (pip -> pathname);
2336       pip -> pathname = NULL;
2337     }
2338   pip -> valid = 0;
2339 }
2340
2341 /*
2342
2343 LOCAL FUNCTION
2344
2345         open_proc_file - open a /proc entry for a given process id
2346
2347 SYNOPSIS
2348
2349         static int open_proc_file (int pid, struct procinfo *pip, int mode)
2350
2351 DESCRIPTION
2352
2353         Given a process id and a mode, close the existing open /proc
2354         entry (if any) and open one for the new process id, in the
2355         specified mode.  Once it is open, then mark the local process
2356         information structure as valid, which guarantees that the pid,
2357         fd, and pathname fields match an open /proc entry.  Returns
2358         zero if the open fails, nonzero otherwise.
2359
2360         Note that the pathname is left intact, even when the open fails,
2361         so that callers can use it to construct meaningful error messages
2362         rather than just "file open failed".
2363  */
2364
2365 static int
2366 open_proc_file (pid, pip, mode)
2367      int pid;
2368      struct procinfo *pip;
2369      int mode;
2370 {
2371   pip -> valid = 0;             /* FIXME, what is this? ?!  */
2372   if (pip -> valid)
2373     {
2374       close (pip -> fd);
2375     }
2376   if (pip -> pathname == NULL)
2377     {
2378       pip -> pathname = xmalloc (32);
2379     }
2380   sprintf (pip -> pathname, PROC_NAME_FMT, pid);
2381   if ((pip -> fd = open (pip -> pathname, mode)) >= 0)
2382     {
2383       pip -> valid = 1;
2384       pip -> pid = pid;
2385     }
2386   return (pip -> valid);
2387 }
2388
2389 static char *
2390 mappingflags (flags)
2391      long flags;
2392 {
2393   static char asciiflags[8];
2394
2395   strcpy (asciiflags, "-------");
2396 #if defined (MA_PHYS)
2397   if (flags & MA_PHYS)   asciiflags[0] = 'd';
2398 #endif
2399   if (flags & MA_STACK)  asciiflags[1] = 's';
2400   if (flags & MA_BREAK)  asciiflags[2] = 'b';
2401   if (flags & MA_SHARED) asciiflags[3] = 's';
2402   if (flags & MA_READ)   asciiflags[4] = 'r';
2403   if (flags & MA_WRITE)  asciiflags[5] = 'w';
2404   if (flags & MA_EXEC)   asciiflags[6] = 'x';
2405   return (asciiflags);
2406 }
2407
2408 static void
2409 info_proc_flags (pip, summary)
2410      struct procinfo *pip;
2411      int summary;
2412 {
2413   struct trans *transp;
2414
2415   printf_filtered ("%-32s", "Process status flags:");
2416   if (!summary)
2417     {
2418       printf_filtered ("\n\n");
2419     }
2420   for (transp = pr_flag_table; transp -> name != NULL; transp++)
2421     {
2422       if (pip -> prstatus.pr_flags & transp -> value)
2423         {
2424           if (summary)
2425             {
2426               printf_filtered ("%s ", transp -> name);
2427             }
2428           else
2429             {
2430               printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
2431             }
2432         }
2433     }
2434   printf_filtered ("\n");
2435 }
2436
2437 static void
2438 info_proc_stop (pip, summary)
2439      struct procinfo *pip;
2440      int summary;
2441 {
2442   struct trans *transp;
2443   int why;
2444   int what;
2445
2446   why = pip -> prstatus.pr_why;
2447   what = pip -> prstatus.pr_what;
2448
2449   if (pip -> prstatus.pr_flags & PR_STOPPED)
2450     {
2451       printf_filtered ("%-32s", "Reason for stopping:");
2452       if (!summary)
2453         {
2454           printf_filtered ("\n\n");
2455         }
2456       for (transp = pr_why_table; transp -> name != NULL; transp++)
2457         {
2458           if (why == transp -> value)
2459             {
2460               if (summary)
2461                 {
2462                   printf_filtered ("%s ", transp -> name);
2463                 }
2464               else
2465                 {
2466                   printf_filtered ("\t%-16s %s.\n",
2467                                    transp -> name, transp -> desc);
2468                 }
2469               break;
2470             }
2471         }
2472
2473       /* Use the pr_why field to determine what the pr_what field means, and
2474          print more information. */
2475
2476       switch (why)
2477         {
2478           case PR_REQUESTED:
2479             /* pr_what is unused for this case */
2480             break;
2481           case PR_JOBCONTROL:
2482           case PR_SIGNALLED:
2483             if (summary)
2484               {
2485                 printf_filtered ("%s ", signalname (what));
2486               }
2487             else
2488               {
2489                 printf_filtered ("\t%-16s %s.\n", signalname (what),
2490                                  safe_strsignal (what));
2491               }
2492             break;
2493           case PR_SYSENTRY:
2494             if (summary)
2495               {
2496                 printf_filtered ("%s ", syscallname (what));
2497               }
2498             else
2499               {
2500                 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2501                                  "Entered this system call");
2502               }
2503             break;
2504           case PR_SYSEXIT:
2505             if (summary)
2506               {
2507                 printf_filtered ("%s ", syscallname (what));
2508               }
2509             else
2510               {
2511                 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2512                                  "Returned from this system call");
2513               }
2514             break;
2515           case PR_FAULTED:
2516             if (summary)
2517               {
2518                 printf_filtered ("%s ",
2519                                  lookupname (faults_table, what, "fault"));
2520               }
2521             else
2522               {
2523                 printf_filtered ("\t%-16s %s.\n",
2524                                  lookupname (faults_table, what, "fault"),
2525                                  lookupdesc (faults_table, what));
2526               }
2527             break;
2528           }
2529       printf_filtered ("\n");
2530     }
2531 }
2532
2533 static void
2534 info_proc_siginfo (pip, summary)
2535      struct procinfo *pip;
2536      int summary;
2537 {
2538   struct siginfo *sip;
2539
2540   if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
2541       (pip -> prstatus.pr_why == PR_SIGNALLED ||
2542        pip -> prstatus.pr_why == PR_FAULTED))
2543     {
2544       printf_filtered ("%-32s", "Additional signal/fault info:");
2545       sip = &pip -> prstatus.pr_info;
2546       if (summary)
2547         {
2548           printf_filtered ("%s ", signalname (sip -> si_signo));
2549           if (sip -> si_errno > 0)
2550             {
2551               printf_filtered ("%s ", errnoname (sip -> si_errno));
2552             }
2553           if (sip -> si_code <= 0)
2554             {
2555               printf_filtered ("sent by pid %d, uid %d ", sip -> si_pid,
2556                                sip -> si_uid);
2557             }
2558           else
2559             {
2560               printf_filtered ("%s ", sigcodename (sip));
2561               if ((sip -> si_signo == SIGILL) ||
2562                   (sip -> si_signo == SIGFPE) ||
2563                   (sip -> si_signo == SIGSEGV) ||
2564                   (sip -> si_signo == SIGBUS))
2565                 {
2566                   printf_filtered ("addr=%#x ", sip -> si_addr);
2567                 }
2568               else if ((sip -> si_signo == SIGCHLD))
2569                 {
2570                   printf_filtered ("child pid %u, status %u ",
2571                                    sip -> si_pid,
2572                                    sip -> si_status);
2573                 }
2574               else if ((sip -> si_signo == SIGPOLL))
2575                 {
2576                   printf_filtered ("band %u ", sip -> si_band);
2577                 }
2578             }
2579         }
2580       else
2581         {
2582           printf_filtered ("\n\n");
2583           printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
2584                            safe_strsignal (sip -> si_signo));
2585           if (sip -> si_errno > 0)
2586             {
2587               printf_filtered ("\t%-16s %s.\n",
2588                                errnoname (sip -> si_errno),
2589                                safe_strerror (sip -> si_errno));
2590             }
2591           if (sip -> si_code <= 0)
2592             {
2593               printf_filtered ("\t%-16u %s\n", sip -> si_pid,
2594                                "PID of process sending signal");
2595               printf_filtered ("\t%-16u %s\n", sip -> si_uid,
2596                                "UID of process sending signal");
2597             }
2598           else
2599             {
2600               printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
2601                                sigcodedesc (sip));
2602               if ((sip -> si_signo == SIGILL) ||
2603                   (sip -> si_signo == SIGFPE))
2604                 {
2605                   printf_filtered ("\t%-16#x %s.\n", sip -> si_addr,
2606                                    "Address of faulting instruction");
2607                 }
2608               else if ((sip -> si_signo == SIGSEGV) ||
2609                        (sip -> si_signo == SIGBUS))
2610                 {
2611                   printf_filtered ("\t%-16#x %s.\n", sip -> si_addr,
2612                                    "Address of faulting memory reference");
2613                 }
2614               else if ((sip -> si_signo == SIGCHLD))
2615                 {
2616                   printf_filtered ("\t%-16u %s.\n", sip -> si_pid,
2617                                    "Child process ID");
2618                   printf_filtered ("\t%-16u %s.\n", sip -> si_status,
2619                                    "Child process exit value or signal");
2620                 }
2621               else if ((sip -> si_signo == SIGPOLL))
2622                 {
2623                   printf_filtered ("\t%-16u %s.\n", sip -> si_band,
2624                                    "Band event for POLL_{IN,OUT,MSG}");
2625                 }
2626             }
2627         }
2628       printf_filtered ("\n");
2629     }
2630 }
2631
2632 static void
2633 info_proc_syscalls (pip, summary)
2634      struct procinfo *pip;
2635      int summary;
2636 {
2637   int syscallnum;
2638
2639   if (!summary)
2640     {
2641
2642 #if 0   /* FIXME:  Needs to use gdb-wide configured info about system calls. */
2643       if (pip -> prstatus.pr_flags & PR_ASLEEP)
2644         {
2645           int syscallnum = pip -> prstatus.pr_reg[R_D0];
2646           if (summary)
2647             {
2648               printf_filtered ("%-32s", "Sleeping in system call:");
2649               printf_filtered ("%s", syscallname (syscallnum));
2650             }
2651           else
2652             {
2653               printf_filtered ("Sleeping in system call '%s'.\n",
2654                                syscallname (syscallnum));
2655             }
2656         }
2657 #endif
2658
2659       if (ioctl (pip -> fd, PIOCGENTRY, &pip -> entryset) < 0)
2660         {
2661           print_sys_errmsg (pip -> pathname, errno);
2662           error ("PIOCGENTRY failed");
2663         }
2664
2665       if (ioctl (pip -> fd, PIOCGEXIT, &pip -> exitset) < 0)
2666         {
2667           print_sys_errmsg (pip -> pathname, errno);
2668           error ("PIOCGEXIT failed");
2669         }
2670
2671       printf_filtered ("System call tracing information:\n\n");
2672
2673       printf_filtered ("\t%-12s %-8s %-8s\n",
2674                        "System call",
2675                        "Entry",
2676                        "Exit");
2677       for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
2678         {
2679           QUIT;
2680           if (syscall_table[syscallnum] != NULL)
2681             {
2682               printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
2683               printf_filtered ("%-8s ",
2684                                prismember (&pip -> entryset, syscallnum)
2685                                ? "on" : "off");
2686               printf_filtered ("%-8s ",
2687                                prismember (&pip -> exitset, syscallnum)
2688                                ? "on" : "off");
2689               printf_filtered ("\n");
2690             }
2691           }
2692       printf_filtered ("\n");
2693     }
2694 }
2695
2696 static char *
2697 signalname (signo)
2698      int signo;
2699 {
2700   char *name;
2701   static char locbuf[32];
2702
2703   name = strsigno (signo);
2704   if (name == NULL)
2705     {
2706       sprintf (locbuf, "Signal %d", signo);
2707     }
2708   else
2709     {
2710       sprintf (locbuf, "%s (%d)", name, signo);
2711     }
2712   return (locbuf);
2713 }
2714
2715 static char *
2716 errnoname (errnum)
2717      int errnum;
2718 {
2719   char *name;
2720   static char locbuf[32];
2721
2722   name = strerrno (errnum);
2723   if (name == NULL)
2724     {
2725       sprintf (locbuf, "Errno %d", errnum);
2726     }
2727   else
2728     {
2729       sprintf (locbuf, "%s (%d)", name, errnum);
2730     }
2731   return (locbuf);
2732 }
2733
2734 static void
2735 info_proc_signals (pip, summary)
2736      struct procinfo *pip;
2737      int summary;
2738 {
2739   int signo;
2740
2741   if (!summary)
2742     {
2743       if (ioctl (pip -> fd, PIOCGTRACE, &pip -> trace) < 0)
2744         {
2745           print_sys_errmsg (pip -> pathname, errno);
2746           error ("PIOCGTRACE failed");
2747         }
2748
2749       printf_filtered ("Disposition of signals:\n\n");
2750       printf_filtered ("\t%-15s %-8s %-8s %-8s  %s\n\n",
2751                        "Signal", "Trace", "Hold", "Pending", "Description");
2752       for (signo = 0; signo < NSIG; signo++)
2753         {
2754           QUIT;
2755           printf_filtered ("\t%-15s ", signalname (signo));
2756           printf_filtered ("%-8s ",
2757                            prismember (&pip -> trace, signo)
2758                            ? "on" : "off");
2759           printf_filtered ("%-8s ",
2760                            prismember (&pip -> prstatus.pr_sighold, signo)
2761                            ? "on" : "off");
2762           printf_filtered ("%-8s ",
2763                            prismember (&pip -> prstatus.pr_sigpend, signo)
2764                            ? "yes" : "no");
2765           printf_filtered (" %s\n", safe_strsignal (signo));
2766         }
2767       printf_filtered ("\n");
2768     }
2769 }
2770
2771 static void
2772 info_proc_faults (pip, summary)
2773      struct procinfo *pip;
2774      int summary;
2775 {
2776   struct trans *transp;
2777
2778   if (!summary)
2779     {
2780       if (ioctl (pip -> fd, PIOCGFAULT, &pip -> fltset) < 0)
2781         {
2782           print_sys_errmsg (pip -> pathname, errno);
2783           error ("PIOCGFAULT failed");
2784         }
2785
2786       printf_filtered ("Current traced hardware fault set:\n\n");
2787       printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
2788
2789       for (transp = faults_table; transp -> name != NULL; transp++)
2790         {
2791           QUIT;
2792           printf_filtered ("\t%-12s ", transp -> name);
2793           printf_filtered ("%-8s", prismember (&pip -> fltset, transp -> value)
2794                            ? "on" : "off");
2795           printf_filtered ("\n");
2796         }
2797       printf_filtered ("\n");
2798     }
2799 }
2800
2801 static void
2802 info_proc_mappings (pip, summary)
2803      struct procinfo *pip;
2804      int summary;
2805 {
2806   int nmap;
2807   struct prmap *prmaps;
2808   struct prmap *prmap;
2809
2810   if (!summary)
2811     {
2812       printf_filtered ("Mapped address spaces:\n\n");
2813       printf_filtered ("\t%10s %10s %10s %10s %7s\n",
2814                        "Start Addr",
2815                        "  End Addr",
2816                        "      Size",
2817                        "    Offset",
2818                        "Flags");
2819       if (ioctl (pip -> fd, PIOCNMAP, &nmap) == 0)
2820         {
2821           prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
2822           if (ioctl (pip -> fd, PIOCMAP, prmaps) == 0)
2823             {
2824               for (prmap = prmaps; prmap -> pr_size; ++prmap)
2825                 {
2826                   printf_filtered ("\t%#10x %#10x %#10x %#10x %7s\n",
2827                                    prmap -> pr_vaddr,
2828                                    prmap -> pr_vaddr + prmap -> pr_size - 1,
2829                                    prmap -> pr_size,
2830                                    prmap -> pr_off,
2831                                    mappingflags (prmap -> pr_mflags));
2832                 }
2833             }
2834         }
2835       printf_filtered ("\n");
2836     }
2837 }
2838
2839 /*
2840
2841 LOCAL FUNCTION
2842
2843         info_proc -- implement the "info proc" command
2844
2845 SYNOPSIS
2846
2847         void info_proc (char *args, int from_tty)
2848
2849 DESCRIPTION
2850
2851         Implement gdb's "info proc" command by using the /proc interface
2852         to print status information about any currently running process.
2853
2854         Examples of the use of "info proc" are:
2855
2856         info proc               (prints summary info for current inferior)
2857         info proc 123           (prints summary info for process with pid 123)
2858         info proc mappings      (prints address mappings)
2859         info proc times         (prints process/children times)
2860         info proc id            (prints pid, ppid, gid, sid, etc)
2861                 FIXME:  i proc id not implemented.
2862         info proc status        (prints general process state info)
2863                 FIXME:  i proc status not implemented.
2864         info proc signals       (prints info about signal handling)
2865         info proc all           (prints all info)
2866
2867  */
2868
2869 static void
2870 info_proc (args, from_tty)
2871      char *args;
2872      int from_tty;
2873 {
2874   int pid;
2875   struct procinfo pii;
2876   struct procinfo *pip;
2877   struct cleanup *old_chain;
2878   char **argv;
2879   int argsize;
2880   int summary = 1;
2881   int flags = 0;
2882   int syscalls = 0;
2883   int signals = 0;
2884   int faults = 0;
2885   int mappings = 0;
2886   int times = 0;
2887   int id = 0;
2888   int status = 0;
2889   int all = 0;
2890
2891   old_chain = make_cleanup (null_cleanup, 0);
2892
2893   /* Default to using the current inferior if no pid specified */
2894
2895   pip = &pi;
2896
2897   if (args != NULL)
2898     {
2899       if ((argv = buildargv (args)) == NULL)
2900         {
2901           nomem (0);
2902         }
2903       make_cleanup (freeargv, (char *) argv);
2904
2905       while (*argv != NULL)
2906         {
2907           argsize = strlen (*argv);
2908           if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
2909             {
2910               summary = 0;
2911               all = 1;
2912             }
2913           else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
2914             {
2915               summary = 0;
2916               faults = 1;
2917             }
2918           else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
2919             {
2920               summary = 0;
2921               flags = 1;
2922             }
2923           else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
2924             {
2925               summary = 0;
2926               id = 1;
2927             }
2928           else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
2929             {
2930               summary = 0;
2931               mappings = 1;
2932             }
2933           else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
2934             {
2935               summary = 0;
2936               signals = 1;
2937             }
2938           else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
2939             {
2940               summary = 0;
2941               status = 1;
2942             }
2943           else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
2944             {
2945               summary = 0;
2946               syscalls = 1;
2947             }
2948           else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
2949             {
2950               summary = 0;
2951               times = 1;
2952             }
2953           else if ((pii.pid = atoi (*argv)) > 0)
2954             {
2955               pid = pii.pid;
2956               pip = &pii;
2957               memset (&pii, 0, sizeof (pii));
2958               if (!open_proc_file (pid, pip, O_RDONLY))
2959                 {
2960                   perror_with_name (pip -> pathname);
2961                   /* NOTREACHED */
2962                 }
2963               make_cleanup (close_proc_file, pip);
2964             }
2965           else if (**argv != '\000')
2966             {
2967               error ("Unrecognized or ambiguous keyword `%s'.", *argv);
2968             }
2969           argv++;
2970         }
2971     }
2972
2973   /* If we don't have a valid open process at this point, then we have no
2974      inferior or didn't specify a specific pid. */
2975
2976   if (!pip -> valid)
2977     {
2978       error ("\
2979 No process.  Start debugging a program or specify an explicit process ID.");
2980     }
2981   if (ioctl (pip -> fd, PIOCSTATUS, &(pip -> prstatus)) < 0)
2982     {
2983       print_sys_errmsg (pip -> pathname, errno);
2984       error ("PIOCSTATUS failed");
2985     }
2986
2987   /* Print verbose information of the requested type(s), or just a summary
2988      of the information for all types. */
2989
2990   printf_filtered ("\nInformation for %s:\n\n", pip -> pathname);
2991   if (summary || all || flags)
2992     {
2993       info_proc_flags (pip, summary);
2994     }
2995   if (summary || all)
2996     {
2997       info_proc_stop (pip, summary);
2998     }
2999   if (summary || all || signals || faults)
3000     {
3001       info_proc_siginfo (pip, summary);
3002     }
3003   if (summary || all || syscalls)
3004     {
3005       info_proc_syscalls (pip, summary);
3006     }
3007   if (summary || all || mappings)
3008     {
3009       info_proc_mappings (pip, summary);
3010     }
3011   if (summary || all || signals)
3012     {
3013       info_proc_signals (pip, summary);
3014     }
3015   if (summary || all || faults)
3016     {
3017       info_proc_faults (pip, summary);
3018     }
3019   printf_filtered ("\n");
3020
3021   /* All done, deal with closing any temporary process info structure,
3022      freeing temporary memory , etc. */
3023
3024   do_cleanups (old_chain);
3025 }
3026
3027 /* Fork an inferior process, and start debugging it with /proc.  */
3028
3029 static void
3030 procfs_create_inferior (exec_file, allargs, env)
3031      char *exec_file;
3032      char *allargs;
3033      char **env;
3034 {
3035   fork_inferior (exec_file, allargs, env,
3036                  proc_set_exec_trap, procfs_init_inferior);
3037   /* We are at the first instruction we care about.  */
3038   /* Pedal to the metal... */
3039   proceed ((CORE_ADDR) -1, 0, 0);
3040 }
3041
3042 /* Clean up after the inferior dies.  */
3043
3044 static void
3045 procfs_mourn_inferior ()
3046 {
3047   unpush_target (&procfs_ops);
3048   generic_mourn_inferior ();
3049 }
3050
3051 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
3052 static int
3053 procfs_can_run ()
3054 {
3055   return(1);
3056 }
3057 \f
3058 struct target_ops procfs_ops = {
3059   "procfs",                     /* to_shortname */
3060   "Unix /proc child process",   /* to_longname */
3061   "Unix /proc child process (started by the \"run\" command).", /* to_doc */
3062   procfs_open,                  /* to_open */
3063   0,                            /* to_close */
3064   procfs_attach,                        /* to_attach */
3065   procfs_detach,                /* to_detach */
3066   procfs_resume,                        /* to_resume */
3067   procfs_wait,                  /* to_wait */
3068   procfs_fetch_registers,       /* to_fetch_registers */
3069   procfs_store_registers,       /* to_store_registers */
3070   procfs_prepare_to_store,      /* to_prepare_to_store */
3071   procfs_xfer_memory,           /* to_xfer_memory */
3072   procfs_files_info,            /* to_files_info */
3073   memory_insert_breakpoint,     /* to_insert_breakpoint */
3074   memory_remove_breakpoint,     /* to_remove_breakpoint */
3075   terminal_init_inferior,       /* to_terminal_init */
3076   terminal_inferior,            /* to_terminal_inferior */
3077   terminal_ours_for_output,     /* to_terminal_ours_for_output */
3078   terminal_ours,                /* to_terminal_ours */
3079   child_terminal_info,          /* to_terminal_info */
3080   procfs_kill_inferior,         /* to_kill */
3081   0,                            /* to_load */
3082   0,                            /* to_lookup_symbol */
3083   procfs_create_inferior,       /* to_create_inferior */
3084   procfs_mourn_inferior,        /* to_mourn_inferior */
3085   procfs_can_run,               /* to_can_run */
3086   procfs_notice_signals,        /* to_notice_signals */
3087   process_stratum,              /* to_stratum */
3088   0,                            /* to_next */
3089   1,                            /* to_has_all_memory */
3090   1,                            /* to_has_memory */
3091   1,                            /* to_has_stack */
3092   1,                            /* to_has_registers */
3093   1,                            /* to_has_execution */
3094   0,                            /* sections */
3095   0,                            /* sections_end */
3096   OPS_MAGIC                     /* to_magic */
3097 };
3098
3099 /*
3100
3101 GLOBAL FUNCTION
3102
3103         _initialize_procfs -- initialize the process file system stuff
3104
3105 SYNOPSIS
3106
3107         void _initialize_procfs (void)
3108
3109 DESCRIPTION
3110
3111         Do required initializations during gdb startup for using the
3112         /proc file system interface.
3113
3114 */
3115
3116 void
3117 _initialize_procfs ()
3118 {
3119   add_target (&procfs_ops);
3120
3121   add_info ("proc", info_proc,
3122 "Show process status information using /proc entry.\n\
3123 Specify process id or use current inferior by default.\n\
3124 Specify keywords for detailed information; default is summary.\n\
3125 Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
3126 `status', `syscalls', and `times'.\n\
3127 Unambiguous abbreviations may be used.");
3128
3129   init_syscall_table ();
3130 }