gdb/procfs.c

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