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