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