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. -- [email protected])
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 /*
2154
2155 LOCAL FUNCTION
2156
2157         procfs_resume -- resume execution of the inferior process
2158
2159 SYNOPSIS
2160
2161         void procfs_resume (int step, int signo)
2162
2163 DESCRIPTION
2164
2165         Resume execution of the inferior process.  If STEP is nozero, then
2166         just single step it.  If SIGNAL is nonzero, restart it with that
2167         signal activated.
2168
2169 NOTE
2170
2171         It may not be absolutely necessary to specify the PC value for
2172         restarting, but to be safe we use the value that gdb considers
2173         to be current.  One case where this might be necessary is if the
2174         user explicitly changes the PC value that gdb considers to be
2175         current.  FIXME:  Investigate if this is necessary or not.
2176
2177         When attaching to a child process, if we forced it to stop with
2178         a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
2179         Upon resuming the first time after such a stop, we explicitly
2180         inhibit sending it another SIGSTOP, which would be the normal
2181         result of default signal handling.  One potential drawback to
2182         this is that we will also ignore any attempt to by the user
2183         to explicitly continue after the attach with a SIGSTOP.  Ultimately
2184         this problem should be dealt with by making the routines that
2185         deal with the inferior a little smarter, and possibly even allow
2186         an inferior to continue running at the same time as gdb.  (FIXME?)
2187  */
2188
2189 static void
2190 procfs_resume (step, signo)
2191      int step;
2192      int signo;
2193 {
2194   errno = 0;
2195   pi.prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
2196
2197 #ifdef PRSVADDR_BROKEN
2198 /* Can't do this under Solaris running on a Sparc, as there seems to be no
2199    place to put nPC.  In fact, if you use this, nPC seems to be set to some
2200    random garbage.  We have to rely on the fact that PC and nPC have been
2201    written previously via PIOCSREG during a register flush. */
2202
2203   pi.prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
2204   pi.prrun.pr_flags != PRSVADDR;
2205 #endif
2206
2207   if (signo && !(signo == SIGSTOP && pi.nopass_next_sigstop))
2208     {
2209       set_proc_siginfo (&pi, signo);
2210     }
2211   else
2212     {
2213       pi.prrun.pr_flags |= PRCSIG;
2214     }
2215   pi.nopass_next_sigstop = 0;
2216   if (step)
2217     {
2218       pi.prrun.pr_flags |= PRSTEP;
2219     }
2220   if (ioctl (pi.fd, PIOCRUN, &pi.prrun) != 0)
2221     {
2222       perror_with_name (pi.pathname);
2223       /* NOTREACHED */
2224     }
2225 }
2226
2227 /*
2228
2229 LOCAL FUNCTION
2230
2231         procfs_fetch_registers -- fetch current registers from inferior
2232
2233 SYNOPSIS
2234
2235         void procfs_fetch_registers (int regno)
2236
2237 DESCRIPTION
2238
2239         Read the current values of the inferior's registers, both the
2240         general register set and floating point registers (if supported)
2241         and update gdb's idea of their current values.
2242
2243 */
2244
2245 static void
2246 procfs_fetch_registers (regno)
2247      int regno;
2248 {
2249   if (ioctl (pi.fd, PIOCGREG, &pi.gregset) != -1)
2250     {
2251       supply_gregset (&pi.gregset);
2252     }
2253 #if defined (FP0_REGNUM)
2254   if (ioctl (pi.fd, PIOCGFPREG, &pi.fpregset) != -1)
2255     {
2256       supply_fpregset (&pi.fpregset);
2257     }
2258 #endif
2259 }
2260
2261 /*
2262
2263 LOCAL FUNCTION
2264
2265         proc_init_failed - called whenever /proc access initialization fails
2266
2267 SYNOPSIS
2268
2269         static void proc_init_failed (char *why)
2270
2271 DESCRIPTION
2272
2273         This function is called whenever initialization of access to a /proc
2274         entry fails.  It prints a suitable error message, does some cleanup,
2275         and then invokes the standard error processing routine which dumps
2276         us back into the command loop.
2277  */
2278
2279 static void
2280 proc_init_failed (why)
2281      char *why;
2282 {
2283   print_sys_errmsg (pi.pathname, errno);
2284   kill (pi.pid, SIGKILL);
2285   close_proc_file (&pi);
2286   error (why);
2287   /* NOTREACHED */
2288 }
2289
2290 /*
2291
2292 LOCAL FUNCTION
2293
2294         close_proc_file - close any currently open /proc entry
2295
2296 SYNOPSIS
2297
2298         static void close_proc_file (struct procinfo *pip)
2299
2300 DESCRIPTION
2301
2302         Close any currently open /proc entry and mark the process information
2303         entry as invalid.  In order to ensure that we don't try to reuse any
2304         stale information, the pid, fd, and pathnames are explicitly
2305         invalidated, which may be overkill.
2306
2307  */
2308
2309 static void
2310 close_proc_file (pip)
2311      struct procinfo *pip;
2312 {
2313   pip -> pid = 0;
2314   if (pip -> valid)
2315     {
2316       close (pip -> fd);
2317     }
2318   pip -> fd = -1;
2319   if (pip -> pathname)
2320     {
2321       free (pip -> pathname);
2322       pip -> pathname = NULL;
2323     }
2324   pip -> valid = 0;
2325 }
2326
2327 /*
2328
2329 LOCAL FUNCTION
2330
2331         open_proc_file - open a /proc entry for a given process id
2332
2333 SYNOPSIS
2334
2335         static int open_proc_file (int pid, struct procinfo *pip, int mode)
2336
2337 DESCRIPTION
2338
2339         Given a process id and a mode, close the existing open /proc
2340         entry (if any) and open one for the new process id, in the
2341         specified mode.  Once it is open, then mark the local process
2342         information structure as valid, which guarantees that the pid,
2343         fd, and pathname fields match an open /proc entry.  Returns
2344         zero if the open fails, nonzero otherwise.
2345
2346         Note that the pathname is left intact, even when the open fails,
2347         so that callers can use it to construct meaningful error messages
2348         rather than just "file open failed".
2349  */
2350
2351 static int
2352 open_proc_file (pid, pip, mode)
2353      int pid;
2354      struct procinfo *pip;
2355      int mode;
2356 {
2357   pip -> valid = 0;             /* FIXME, what is this? ?!  */
2358   if (pip -> valid)
2359     {
2360       close (pip -> fd);
2361     }
2362   if (pip -> pathname == NULL)
2363     {
2364       pip -> pathname = xmalloc (32);
2365     }
2366   sprintf (pip -> pathname, PROC_NAME_FMT, pid);
2367   if ((pip -> fd = open (pip -> pathname, mode)) >= 0)
2368     {
2369       pip -> valid = 1;
2370       pip -> pid = pid;
2371     }
2372   return (pip -> valid);
2373 }
2374
2375 static char *
2376 mappingflags (flags)
2377      long flags;
2378 {
2379   static char asciiflags[8];
2380
2381   strcpy (asciiflags, "-------");
2382 #if defined (MA_PHYS)
2383   if (flags & MA_PHYS)   asciiflags[0] = 'd';
2384 #endif
2385   if (flags & MA_STACK)  asciiflags[1] = 's';
2386   if (flags & MA_BREAK)  asciiflags[2] = 'b';
2387   if (flags & MA_SHARED) asciiflags[3] = 's';
2388   if (flags & MA_READ)   asciiflags[4] = 'r';
2389   if (flags & MA_WRITE)  asciiflags[5] = 'w';
2390   if (flags & MA_EXEC)   asciiflags[6] = 'x';
2391   return (asciiflags);
2392 }
2393
2394 static void
2395 info_proc_flags (pip, summary)
2396      struct procinfo *pip;
2397      int summary;
2398 {
2399   struct trans *transp;
2400
2401   printf_filtered ("%-32s", "Process status flags:");
2402   if (!summary)
2403     {
2404       printf_filtered ("\n\n");
2405     }
2406   for (transp = pr_flag_table; transp -> name != NULL; transp++)
2407     {
2408       if (pip -> prstatus.pr_flags & transp -> value)
2409         {
2410           if (summary)
2411             {
2412               printf_filtered ("%s ", transp -> name);
2413             }
2414           else
2415             {
2416               printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
2417             }
2418         }
2419     }
2420   printf_filtered ("\n");
2421 }
2422
2423 static void
2424 info_proc_stop (pip, summary)
2425      struct procinfo *pip;
2426      int summary;
2427 {
2428   struct trans *transp;
2429   int why;
2430   int what;
2431
2432   why = pip -> prstatus.pr_why;
2433   what = pip -> prstatus.pr_what;
2434
2435   if (pip -> prstatus.pr_flags & PR_STOPPED)
2436     {
2437       printf_filtered ("%-32s", "Reason for stopping:");
2438       if (!summary)
2439         {
2440           printf_filtered ("\n\n");
2441         }
2442       for (transp = pr_why_table; transp -> name != NULL; transp++)
2443         {
2444           if (why == transp -> value)
2445             {
2446               if (summary)
2447                 {
2448                   printf_filtered ("%s ", transp -> name);
2449                 }
2450               else
2451                 {
2452                   printf_filtered ("\t%-16s %s.\n",
2453                                    transp -> name, transp -> desc);
2454                 }
2455               break;
2456             }
2457         }
2458
2459       /* Use the pr_why field to determine what the pr_what field means, and
2460          print more information. */
2461
2462       switch (why)
2463         {
2464           case PR_REQUESTED:
2465             /* pr_what is unused for this case */
2466             break;
2467           case PR_JOBCONTROL:
2468           case PR_SIGNALLED:
2469             if (summary)
2470               {
2471                 printf_filtered ("%s ", signalname (what));
2472               }
2473             else
2474               {
2475                 printf_filtered ("\t%-16s %s.\n", signalname (what),
2476                                  safe_strsignal (what));
2477               }
2478             break;
2479           case PR_SYSENTRY:
2480             if (summary)
2481               {
2482                 printf_filtered ("%s ", syscallname (what));
2483               }
2484             else
2485               {
2486                 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2487                                  "Entered this system call");
2488               }
2489             break;
2490           case PR_SYSEXIT:
2491             if (summary)
2492               {
2493                 printf_filtered ("%s ", syscallname (what));
2494               }
2495             else
2496               {
2497                 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2498                                  "Returned from this system call");
2499               }
2500             break;
2501           case PR_FAULTED:
2502             if (summary)
2503               {
2504                 printf_filtered ("%s ",
2505                                  lookupname (faults_table, what, "fault"));
2506               }
2507             else
2508               {
2509                 printf_filtered ("\t%-16s %s.\n",
2510                                  lookupname (faults_table, what, "fault"),
2511                                  lookupdesc (faults_table, what));
2512               }
2513             break;
2514           }
2515       printf_filtered ("\n");
2516     }
2517 }
2518
2519 static void
2520 info_proc_siginfo (pip, summary)
2521      struct procinfo *pip;
2522      int summary;
2523 {
2524   struct siginfo *sip;
2525
2526   if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
2527       (pip -> prstatus.pr_why == PR_SIGNALLED ||
2528        pip -> prstatus.pr_why == PR_FAULTED))
2529     {
2530       printf_filtered ("%-32s", "Additional signal/fault info:");
2531       sip = &pip -> prstatus.pr_info;
2532       if (summary)
2533         {
2534           printf_filtered ("%s ", signalname (sip -> si_signo));
2535           if (sip -> si_errno > 0)
2536             {
2537               printf_filtered ("%s ", errnoname (sip -> si_errno));
2538             }
2539           if (sip -> si_code <= 0)
2540             {
2541               printf_filtered ("sent by pid %d, uid %d ", sip -> si_pid,
2542                                sip -> si_uid);
2543             }
2544           else
2545             {
2546               printf_filtered ("%s ", sigcodename (sip));
2547               if ((sip -> si_signo == SIGILL) ||
2548                   (sip -> si_signo == SIGFPE) ||
2549                   (sip -> si_signo == SIGSEGV) ||
2550                   (sip -> si_signo == SIGBUS))
2551                 {
2552                   printf_filtered ("addr=%#x ", sip -> si_addr);
2553                 }
2554               else if ((sip -> si_signo == SIGCHLD))
2555                 {
2556                   printf_filtered ("child pid %u, status %u ",
2557                                    sip -> si_pid,
2558                                    sip -> si_status);
2559                 }
2560               else if ((sip -> si_signo == SIGPOLL))
2561                 {
2562                   printf_filtered ("band %u ", sip -> si_band);
2563                 }
2564             }
2565         }
2566       else
2567         {
2568           printf_filtered ("\n\n");
2569           printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
2570                            safe_strsignal (sip -> si_signo));
2571           if (sip -> si_errno > 0)
2572             {
2573               printf_filtered ("\t%-16s %s.\n",
2574                                errnoname (sip -> si_errno),
2575                                safe_strerror (sip -> si_errno));
2576             }
2577           if (sip -> si_code <= 0)
2578             {
2579               printf_filtered ("\t%-16u %s\n", sip -> si_pid,
2580                                "PID of process sending signal");
2581               printf_filtered ("\t%-16u %s\n", sip -> si_uid,
2582                                "UID of process sending signal");
2583             }
2584           else
2585             {
2586               printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
2587                                sigcodedesc (sip));
2588               if ((sip -> si_signo == SIGILL) ||
2589                   (sip -> si_signo == SIGFPE))
2590                 {
2591                   printf_filtered ("\t%-16#x %s.\n", sip -> si_addr,
2592                                    "Address of faulting instruction");
2593                 }
2594               else if ((sip -> si_signo == SIGSEGV) ||
2595                        (sip -> si_signo == SIGBUS))
2596                 {
2597                   printf_filtered ("\t%-16#x %s.\n", sip -> si_addr,
2598                                    "Address of faulting memory reference");
2599                 }
2600               else if ((sip -> si_signo == SIGCHLD))
2601                 {
2602                   printf_filtered ("\t%-16u %s.\n", sip -> si_pid,
2603                                    "Child process ID");
2604                   printf_filtered ("\t%-16u %s.\n", sip -> si_status,
2605                                    "Child process exit value or signal");
2606                 }
2607               else if ((sip -> si_signo == SIGPOLL))
2608                 {
2609                   printf_filtered ("\t%-16u %s.\n", sip -> si_band,
2610                                    "Band event for POLL_{IN,OUT,MSG}");
2611                 }
2612             }
2613         }
2614       printf_filtered ("\n");
2615     }
2616 }
2617
2618 static void
2619 info_proc_syscalls (pip, summary)
2620      struct procinfo *pip;
2621      int summary;
2622 {
2623   int syscallnum;
2624
2625   if (!summary)
2626     {
2627
2628 #if 0   /* FIXME:  Needs to use gdb-wide configured info about system calls. */
2629       if (pip -> prstatus.pr_flags & PR_ASLEEP)
2630         {
2631           int syscallnum = pip -> prstatus.pr_reg[R_D0];
2632           if (summary)
2633             {
2634               printf_filtered ("%-32s", "Sleeping in system call:");
2635               printf_filtered ("%s", syscallname (syscallnum));
2636             }
2637           else
2638             {
2639               printf_filtered ("Sleeping in system call '%s'.\n",
2640                                syscallname (syscallnum));
2641             }
2642         }
2643 #endif
2644
2645       if (ioctl (pip -> fd, PIOCGENTRY, &pip -> entryset) < 0)
2646         {
2647           print_sys_errmsg (pip -> pathname, errno);
2648           error ("PIOCGENTRY failed");
2649         }
2650
2651       if (ioctl (pip -> fd, PIOCGEXIT, &pip -> exitset) < 0)
2652         {
2653           print_sys_errmsg (pip -> pathname, errno);
2654           error ("PIOCGEXIT failed");
2655         }
2656
2657       printf_filtered ("System call tracing information:\n\n");
2658
2659       printf_filtered ("\t%-12s %-8s %-8s\n",
2660                        "System call",
2661                        "Entry",
2662                        "Exit");
2663       for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
2664         {
2665           QUIT;
2666           if (syscall_table[syscallnum] != NULL)
2667             {
2668               printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
2669               printf_filtered ("%-8s ",
2670                                prismember (&pip -> entryset, syscallnum)
2671                                ? "on" : "off");
2672               printf_filtered ("%-8s ",
2673                                prismember (&pip -> exitset, syscallnum)
2674                                ? "on" : "off");
2675               printf_filtered ("\n");
2676             }
2677           }
2678       printf_filtered ("\n");
2679     }
2680 }
2681
2682 static char *
2683 signalname (signo)
2684      int signo;
2685 {
2686   char *name;
2687   static char locbuf[32];
2688
2689   name = strsigno (signo);
2690   if (name == NULL)
2691     {
2692       sprintf (locbuf, "Signal %d", signo);
2693     }
2694   else
2695     {
2696       sprintf (locbuf, "%s (%d)", name, signo);
2697     }
2698   return (locbuf);
2699 }
2700
2701 static char *
2702 errnoname (errnum)
2703      int errnum;
2704 {
2705   char *name;
2706   static char locbuf[32];
2707
2708   name = strerrno (errnum);
2709   if (name == NULL)
2710     {
2711       sprintf (locbuf, "Errno %d", errnum);
2712     }
2713   else
2714     {
2715       sprintf (locbuf, "%s (%d)", name, errnum);
2716     }
2717   return (locbuf);
2718 }
2719
2720 static void
2721 info_proc_signals (pip, summary)
2722      struct procinfo *pip;
2723      int summary;
2724 {
2725   int signo;
2726
2727   if (!summary)
2728     {
2729       if (ioctl (pip -> fd, PIOCGTRACE, &pip -> trace) < 0)
2730         {
2731           print_sys_errmsg (pip -> pathname, errno);
2732           error ("PIOCGTRACE failed");
2733         }
2734
2735       printf_filtered ("Disposition of signals:\n\n");
2736       printf_filtered ("\t%-15s %-8s %-8s %-8s  %s\n\n",
2737                        "Signal", "Trace", "Hold", "Pending", "Description");
2738       for (signo = 0; signo < NSIG; signo++)
2739         {
2740           QUIT;
2741           printf_filtered ("\t%-15s ", signalname (signo));
2742           printf_filtered ("%-8s ",
2743                            prismember (&pip -> trace, signo)
2744                            ? "on" : "off");
2745           printf_filtered ("%-8s ",
2746                            prismember (&pip -> prstatus.pr_sighold, signo)
2747                            ? "on" : "off");
2748           printf_filtered ("%-8s ",
2749                            prismember (&pip -> prstatus.pr_sigpend, signo)
2750                            ? "yes" : "no");
2751           printf_filtered (" %s\n", safe_strsignal (signo));
2752         }
2753       printf_filtered ("\n");
2754     }
2755 }
2756
2757 static void
2758 info_proc_faults (pip, summary)
2759      struct procinfo *pip;
2760      int summary;
2761 {
2762   struct trans *transp;
2763
2764   if (!summary)
2765     {
2766       if (ioctl (pip -> fd, PIOCGFAULT, &pip -> fltset) < 0)
2767         {
2768           print_sys_errmsg (pip -> pathname, errno);
2769           error ("PIOCGFAULT failed");
2770         }
2771
2772       printf_filtered ("Current traced hardware fault set:\n\n");
2773       printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
2774
2775       for (transp = faults_table; transp -> name != NULL; transp++)
2776         {
2777           QUIT;
2778           printf_filtered ("\t%-12s ", transp -> name);
2779           printf_filtered ("%-8s", prismember (&pip -> fltset, transp -> value)
2780                            ? "on" : "off");
2781           printf_filtered ("\n");
2782         }
2783       printf_filtered ("\n");
2784     }
2785 }
2786
2787 static void
2788 info_proc_mappings (pip, summary)
2789      struct procinfo *pip;
2790      int summary;
2791 {
2792   int nmap;
2793   struct prmap *prmaps;
2794   struct prmap *prmap;
2795
2796   if (!summary)
2797     {
2798       printf_filtered ("Mapped address spaces:\n\n");
2799       printf_filtered ("\t%10s %10s %10s %10s %7s\n",
2800                        "Start Addr",
2801                        "  End Addr",
2802                        "      Size",
2803                        "    Offset",
2804                        "Flags");
2805       if (ioctl (pip -> fd, PIOCNMAP, &nmap) == 0)
2806         {
2807           prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
2808           if (ioctl (pip -> fd, PIOCMAP, prmaps) == 0)
2809             {
2810               for (prmap = prmaps; prmap -> pr_size; ++prmap)
2811                 {
2812                   printf_filtered ("\t%#10x %#10x %#10x %#10x %7s\n",
2813                                    prmap -> pr_vaddr,
2814                                    prmap -> pr_vaddr + prmap -> pr_size - 1,
2815                                    prmap -> pr_size,
2816                                    prmap -> pr_off,
2817                                    mappingflags (prmap -> pr_mflags));
2818                 }
2819             }
2820         }
2821       printf_filtered ("\n");
2822     }
2823 }
2824
2825 /*
2826
2827 LOCAL FUNCTION
2828
2829         info_proc -- implement the "info proc" command
2830
2831 SYNOPSIS
2832
2833         void info_proc (char *args, int from_tty)
2834
2835 DESCRIPTION
2836
2837         Implement gdb's "info proc" command by using the /proc interface
2838         to print status information about any currently running process.
2839
2840         Examples of the use of "info proc" are:
2841
2842         info proc               (prints summary info for current inferior)
2843         info proc 123           (prints summary info for process with pid 123)
2844         info proc mappings      (prints address mappings)
2845         info proc times         (prints process/children times)
2846         info proc id            (prints pid, ppid, gid, sid, etc)
2847                 FIXME:  i proc id not implemented.
2848         info proc status        (prints general process state info)
2849                 FIXME:  i proc status not implemented.
2850         info proc signals       (prints info about signal handling)
2851         info proc all           (prints all info)
2852
2853  */
2854
2855 static void
2856 info_proc (args, from_tty)
2857      char *args;
2858      int from_tty;
2859 {
2860   int pid;
2861   struct procinfo pii;
2862   struct procinfo *pip;
2863   struct cleanup *old_chain;
2864   char **argv;
2865   int argsize;
2866   int summary = 1;
2867   int flags = 0;
2868   int syscalls = 0;
2869   int signals = 0;
2870   int faults = 0;
2871   int mappings = 0;
2872   int times = 0;
2873   int id = 0;
2874   int status = 0;
2875   int all = 0;
2876
2877   old_chain = make_cleanup (null_cleanup, 0);
2878
2879   /* Default to using the current inferior if no pid specified */
2880
2881   pip = &pi;
2882
2883   if (args != NULL)
2884     {
2885       if ((argv = buildargv (args)) == NULL)
2886         {
2887           nomem (0);
2888         }
2889       make_cleanup (freeargv, (char *) argv);
2890
2891       while (*argv != NULL)
2892         {
2893           argsize = strlen (*argv);
2894           if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
2895             {
2896               summary = 0;
2897               all = 1;
2898             }
2899           else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
2900             {
2901               summary = 0;
2902               faults = 1;
2903             }
2904           else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
2905             {
2906               summary = 0;
2907               flags = 1;
2908             }
2909           else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
2910             {
2911               summary = 0;
2912               id = 1;
2913             }
2914           else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
2915             {
2916               summary = 0;
2917               mappings = 1;
2918             }
2919           else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
2920             {
2921               summary = 0;
2922               signals = 1;
2923             }
2924           else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
2925             {
2926               summary = 0;
2927               status = 1;
2928             }
2929           else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
2930             {
2931               summary = 0;
2932               syscalls = 1;
2933             }
2934           else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
2935             {
2936               summary = 0;
2937               times = 1;
2938             }
2939           else if ((pii.pid = atoi (*argv)) > 0)
2940             {
2941               pid = pii.pid;
2942               pip = &pii;
2943               memset (&pii, 0, sizeof (pii));
2944               if (!open_proc_file (pid, pip, O_RDONLY))
2945                 {
2946                   perror_with_name (pip -> pathname);
2947                   /* NOTREACHED */
2948                 }
2949               make_cleanup (close_proc_file, pip);
2950             }
2951           else if (**argv != '\000')
2952             {
2953               error ("Unrecognized or ambiguous keyword `%s'.", *argv);
2954             }
2955           argv++;
2956         }
2957     }
2958
2959   /* If we don't have a valid open process at this point, then we have no
2960      inferior or didn't specify a specific pid. */
2961
2962   if (!pip -> valid)
2963     {
2964       error ("No process.  Run an inferior or specify an explicit pid.");
2965     }
2966   if (ioctl (pip -> fd, PIOCSTATUS, &(pip -> prstatus)) < 0)
2967     {
2968       print_sys_errmsg (pip -> pathname, errno);
2969       error ("PIOCSTATUS failed");
2970     }
2971
2972   /* Print verbose information of the requested type(s), or just a summary
2973      of the information for all types. */
2974
2975   printf_filtered ("\nInformation for %s:\n\n", pip -> pathname);
2976   if (summary || all || flags)
2977     {
2978       info_proc_flags (pip, summary);
2979     }
2980   if (summary || all)
2981     {
2982       info_proc_stop (pip, summary);
2983     }
2984   if (summary || all || signals || faults)
2985     {
2986       info_proc_siginfo (pip, summary);
2987     }
2988   if (summary || all || syscalls)
2989     {
2990       info_proc_syscalls (pip, summary);
2991     }
2992   if (summary || all || mappings)
2993     {
2994       info_proc_mappings (pip, summary);
2995     }
2996   if (summary || all || signals)
2997     {
2998       info_proc_signals (pip, summary);
2999     }
3000   if (summary || all || faults)
3001     {
3002       info_proc_faults (pip, summary);
3003     }
3004   printf_filtered ("\n");
3005
3006   /* All done, deal with closing any temporary process info structure,
3007      freeing temporary memory , etc. */
3008
3009   do_cleanups (old_chain);
3010 }
3011
3012 /* Fork an inferior process, and start debugging it with /proc.  */
3013
3014 static void
3015 procfs_create_inferior (exec_file, allargs, env)
3016      char *exec_file;
3017      char *allargs;
3018      char **env;
3019 {
3020   fork_inferior (exec_file, allargs, env,
3021                  proc_set_exec_trap, procfs_init_inferior);
3022   /* We are at the first instruction we care about.  */
3023   /* Pedal to the metal... */
3024   proceed ((CORE_ADDR) -1, 0, 0);
3025 }
3026
3027 /* Clean up after the inferior dies.  */
3028
3029 static void
3030 procfs_mourn_inferior ()
3031 {
3032   unpush_target (&procfs_ops);
3033   generic_mourn_inferior ();
3034 }
3035
3036 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
3037 static int
3038 procfs_can_run ()
3039 {
3040   return(1);
3041 }
3042 \f
3043 struct target_ops procfs_ops = {
3044   "procfs",                     /* to_shortname */
3045   "Unix /proc child process",   /* to_longname */
3046   "Unix /proc child process (started by the \"run\" command).", /* to_doc */
3047   procfs_open,                  /* to_open */
3048   0,                            /* to_close */
3049   procfs_attach,                        /* to_attach */
3050   procfs_detach,                /* to_detach */
3051   procfs_resume,                        /* to_resume */
3052   procfs_wait,                  /* to_wait */
3053   procfs_fetch_registers,       /* to_fetch_registers */
3054   procfs_store_registers,       /* to_store_registers */
3055   procfs_prepare_to_store,      /* to_prepare_to_store */
3056   procfs_xfer_memory,           /* to_xfer_memory */
3057   procfs_files_info,            /* to_files_info */
3058   memory_insert_breakpoint,     /* to_insert_breakpoint */
3059   memory_remove_breakpoint,     /* to_remove_breakpoint */
3060   terminal_init_inferior,       /* to_terminal_init */
3061   terminal_inferior,            /* to_terminal_inferior */
3062   terminal_ours_for_output,     /* to_terminal_ours_for_output */
3063   terminal_ours,                /* to_terminal_ours */
3064   child_terminal_info,          /* to_terminal_info */
3065   procfs_kill_inferior,         /* to_kill */
3066   0,                            /* to_load */
3067   0,                            /* to_lookup_symbol */
3068   procfs_create_inferior,       /* to_create_inferior */
3069   procfs_mourn_inferior,        /* to_mourn_inferior */
3070   procfs_can_run,               /* to_can_run */
3071   procfs_notice_signals,        /* to_notice_signals */
3072   process_stratum,              /* to_stratum */
3073   0,                            /* to_next */
3074   1,                            /* to_has_all_memory */
3075   1,                            /* to_has_memory */
3076   1,                            /* to_has_stack */
3077   1,                            /* to_has_registers */
3078   1,                            /* to_has_execution */
3079   0,                            /* sections */
3080   0,                            /* sections_end */
3081   OPS_MAGIC                     /* to_magic */
3082 };
3083
3084 /*
3085
3086 GLOBAL FUNCTION
3087
3088         _initialize_procfs -- initialize the process file system stuff
3089
3090 SYNOPSIS
3091
3092         void _initialize_procfs (void)
3093
3094 DESCRIPTION
3095
3096         Do required initializations during gdb startup for using the
3097         /proc file system interface.
3098
3099 */
3100
3101 void
3102 _initialize_procfs ()
3103 {
3104   add_target (&procfs_ops);
3105
3106   add_info ("proc", info_proc,
3107 "Show process status information using /proc entry.\n\
3108 Specify process id or use current inferior by default.\n\
3109 Specify keywords for detailed information; default is summary.\n\
3110 Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
3111 `status', `syscalls', and `times'.\n\
3112 Unambiguous abbreviations may be used.");
3113
3114   init_syscall_table ();
3115 }