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