gdb/procfs.c

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