projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
get rid of unused m4 files
[deliverable/binutils-gdb.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
b9e58503
PS		 1463#ifdef PROCFS_DONT_TRACE_FAULTS
1464 premptyset (&pi->prrun.pr_fault);
2592eef8
PS		 1465#endif
1466
de43d7d0
SG		 1467 if (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
1468 proc_init_failed (pi, "PIOCWSTOP failed");
1469
1470 if (ioctl (pi->fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0)
1471 proc_init_failed (pi, "PIOCSFAULT failed");
eca4a350
SG		 1472
1473 return pi;
de43d7d0
SG		 1474}
1475
1476/*
1477
1478LOCAL FUNCTION
1479
1480 procfs_init_inferior - initialize target vector and access to a
1481 /proc entry
35f5886e
FF		 1482
1483SYNOPSIS
1484
3fbdd536 1485 void procfs_init_inferior (int pid)
35f5886e
FF		 1486
1487DESCRIPTION
1488
1489 When gdb starts an inferior, this function is called in the parent
1490 process immediately after the fork. It waits for the child to stop
1491 on the return from the exec system call (the child itself takes care
1492 of ensuring that this is set up), then sets up the set of signals
1493 and faults that are to be traced.
1494
1495NOTES
1496
1497 If proc_init_failed ever gets called, control returns to the command
1498 processing loop via the standard error handling code.
cc221e76 1499
35f5886e
FF		 1500 */
1501
3fbdd536
JG		 1502static void
1503procfs_init_inferior (pid)
1ab3bf1b 1504 int pid;
35f5886e 1505{
3fbdd536
JG		 1506 push_target (&procfs_ops);
1507
de43d7d0
SG		 1508 create_procinfo (pid);
1509 add_thread (pid); /* Setup initial thread */
bc28a06c 1510
2592eef8
PS		 1511#ifdef START_INFERIOR_TRAPS_EXPECTED
1512 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
1513#else
bc28a06c
JK		 1514 /* One trap to exec the shell, one to exec the program being debugged. */
1515 startup_inferior (2);
2592eef8 1516#endif
35f5886e
FF		 1517}
1518
1519/*
1520
cc221e76
FF		 1521GLOBAL FUNCTION
1522
3950a34e 1523 procfs_notice_signals
cc221e76
FF		 1524
1525SYNOPSIS
1526
952a820e 1527 static void procfs_notice_signals (int pid);
cc221e76
FF		 1528
1529DESCRIPTION
1530
1531 When the user changes the state of gdb's signal handling via the
1532 "handle" command, this function gets called to see if any change
1533 in the /proc interface is required. It is also called internally
1534 by other /proc interface functions to initialize the state of
1535 the traced signal set.
1536
1537 One thing it does is that signals for which the state is "nostop",
1538 "noprint", and "pass", have their trace bits reset in the pr_trace
1539 field, so that they are no longer traced. This allows them to be
1540 delivered directly to the inferior without the debugger ever being
1541 involved.
1542 */
1543
3950a34e 1544static void
de43d7d0 1545procfs_notice_signals (pid)
952a820e 1546 int pid;
cc221e76
FF		 1547{
1548 int signo;
de43d7d0 1549 struct procinfo *pi;
cc221e76 1550
de43d7d0
SG		 1551 pi = find_procinfo (pid, 0);
1552
1553 for (signo = 0; signo < NSIG; signo++)
cc221e76 1554 {
67ac9759
JK		 1555 if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
1556 signal_print_state (target_signal_from_host (signo)) == 0 &&
1557 signal_pass_state (target_signal_from_host (signo)) == 1)
cc221e76 1558 {
de43d7d0 1559 prdelset (&pi->prrun.pr_trace, signo);
cc221e76 1560 }
de43d7d0 1561 else
cc221e76 1562 {
de43d7d0 1563 praddset (&pi->prrun.pr_trace, signo);
cc221e76
FF		 1564 }
1565 }
de43d7d0
SG		 1566 if (ioctl (pi->fd, PIOCSTRACE, &pi->prrun.pr_trace))
1567 {
1568 print_sys_errmsg ("PIOCSTRACE failed", errno);
1569 }
cc221e76
FF		 1570}
1571
1572/*
1573
3fbdd536 1574LOCAL FUNCTION
35f5886e
FF		 1575
1576 proc_set_exec_trap -- arrange for exec'd child to halt at startup
1577
1578SYNOPSIS
1579
1580 void proc_set_exec_trap (void)
1581
1582DESCRIPTION
1583
1584 This function is called in the child process when starting up
1585 an inferior, prior to doing the exec of the actual inferior.
1586 It sets the child process's exitset to make exit from the exec
1587 system call an event of interest to stop on, and then simply
1588 returns. The child does the exec, the system call returns, and
1589 the child stops at the first instruction, ready for the gdb
1590 parent process to take control of it.
1591
1592NOTE
1593
1594 We need to use all local variables since the child may be sharing
1595 it's data space with the parent, if vfork was used rather than
1596 fork.
cc221e76
FF		 1597
1598 Also note that we want to turn off the inherit-on-fork flag in
1599 the child process so that any grand-children start with all
1600 tracing flags cleared.
35f5886e
FF		 1601 */
1602
3fbdd536 1603static void
1ab3bf1b 1604proc_set_exec_trap ()
35f5886e
FF		 1605{
1606 sysset_t exitset;
fb63d460 1607 sysset_t entryset;
35f5886e
FF		 1608 auto char procname[32];
1609 int fd;
1610
4ed3a9ea 1611 sprintf (procname, PROC_NAME_FMT, getpid ());
35f5886e
FF		 1612 if ((fd = open (procname, O_RDWR)) < 0)
1613 {
1614 perror (procname);
199b2450 1615 gdb_flush (gdb_stderr);
35f5886e
FF		 1616 _exit (127);
1617 }
1618 premptyset (&exitset);
fb63d460 1619 premptyset (&entryset);
407a8389 1620
2592eef8
PS		 1621#ifdef PIOCSSPCACT
1622 /* Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
1623 exits from exec system calls because of the user level loader. */
1624 {
1625 int prfs_flags;
1626
1627 if (ioctl (fd, PIOCGSPCACT, &prfs_flags) < 0)
1628 {
1629 perror (procname);
1630 gdb_flush (gdb_stderr);
1631 _exit (127);
1632 }
1633 prfs_flags |= PRFS_STOPEXEC;
1634 if (ioctl (fd, PIOCSSPCACT, &prfs_flags) < 0)
1635 {
1636 perror (procname);
1637 gdb_flush (gdb_stderr);
1638 _exit (127);
1639 }
1640 }
1641#else
cc221e76
FF		 1642 /* GW: Rationale...
1643 Not all systems with /proc have all the exec* syscalls with the same
1644 names. On the SGI, for example, there is no SYS_exec, but there
1645 *is* a SYS_execv. So, we try to account for that. */
1646
407a8389 1647#ifdef SYS_exec
35f5886e 1648 praddset (&exitset, SYS_exec);
407a8389
SG		 1649#endif
1650#ifdef SYS_execve
35f5886e 1651 praddset (&exitset, SYS_execve);
407a8389
SG		 1652#endif
1653#ifdef SYS_execv
fb63d460 1654 praddset (&exitset, SYS_execv);
407a8389
SG		 1655#endif
1656
35f5886e
FF		 1657 if (ioctl (fd, PIOCSEXIT, &exitset) < 0)
1658 {
1659 perror (procname);
199b2450 1660 gdb_flush (gdb_stderr);
35f5886e
FF		 1661 _exit (127);
1662 }
2592eef8 1663#endif
cc221e76 1664
fb63d460
SG		 1665 praddset (&entryset, SYS_exit);
1666
1667 if (ioctl (fd, PIOCSENTRY, &entryset) < 0)
1668 {
1669 perror (procname);
199b2450 1670 gdb_flush (gdb_stderr);
fb63d460
SG		 1671 _exit (126);
1672 }
1673
cc221e76
FF		 1674 /* Turn off inherit-on-fork flag so that all grand-children of gdb
1675 start with tracing flags cleared. */
1676
5c1c5e67 1677#if defined (PIOCRESET) /* New method */
cc221e76
FF		 1678 {
1679 long pr_flags;
1680 pr_flags = PR_FORK;
4ed3a9ea 1681 ioctl (fd, PIOCRESET, &pr_flags);
cc221e76 1682 }
5c1c5e67
FF		 1683#else
1684#if defined (PIOCRFORK) /* Original method */
4ed3a9ea 1685 ioctl (fd, PIOCRFORK, NULL);
cc221e76 1686#endif
ec8ceca3
JG		 1687#endif
1688
1689 /* Turn on run-on-last-close flag so that this process will not hang
1690 if GDB goes away for some reason. */
1691
1692#if defined (PIOCSET) /* New method */
1693 {
1694 long pr_flags;
1695 pr_flags = PR_RLC;
1696 (void) ioctl (fd, PIOCSET, &pr_flags);
1697 }
1698#else
1699#if defined (PIOCSRLC) /* Original method */
1700 (void) ioctl (fd, PIOCSRLC, 0);
1701#endif
cc221e76 1702#endif
35f5886e
FF		 1703}
1704
f8b76e70
FF		 1705/*
1706
a39ad5ce
FF		 1707GLOBAL FUNCTION
1708
1709 proc_iterate_over_mappings -- call function for every mapped space
1710
1711SYNOPSIS
1712
1713 int proc_iterate_over_mappings (int (*func)())
1714
1715DESCRIPTION
1716
1717 Given a pointer to a function, call that function for every
1718 mapped address space, passing it an open file descriptor for
1719 the file corresponding to that mapped address space (if any)
1720 and the base address of the mapped space. Quit when we hit
1721 the end of the mappings or the function returns nonzero.
1722 */
1723
1724int
1ab3bf1b
JG		 1725proc_iterate_over_mappings (func)
1726 int (*func) PARAMS ((int, CORE_ADDR));
a39ad5ce
FF		 1727{
1728 int nmap;
1729 int fd;
1730 int funcstat = 0;
1731 struct prmap *prmaps;
1732 struct prmap *prmap;
de43d7d0
SG		 1733 struct procinfo *pi;
1734
1735 pi = current_procinfo;
a39ad5ce 1736
de43d7d0 1737 if (ioctl (pi->fd, PIOCNMAP, &nmap) == 0)
a39ad5ce 1738 {
1ab3bf1b 1739 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
de43d7d0 1740 if (ioctl (pi->fd, PIOCMAP, prmaps) == 0)
a39ad5ce
FF		 1741 {
1742 for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
1743 {
de43d7d0 1744 fd = proc_address_to_fd (pi, (CORE_ADDR) prmap -> pr_vaddr, 0);
1ab3bf1b 1745 funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
a39ad5ce
FF		 1746 close (fd);
1747 }
1748 }
1749 }
1750 return (funcstat);
1751}
1752
3fbdd536 1753#if 0 /* Currently unused */
a39ad5ce
FF		 1754/*
1755
f8b76e70
FF		 1756GLOBAL FUNCTION
1757
1758 proc_base_address -- find base address for segment containing address
1759
1760SYNOPSIS
1761
1762 CORE_ADDR proc_base_address (CORE_ADDR addr)
1763
1764DESCRIPTION
1765
1766 Given an address of a location in the inferior, find and return
1767 the base address of the mapped segment containing that address.
1768
1769 This is used for example, by the shared library support code,
1770 where we have the pc value for some location in the shared library
1771 where we are stopped, and need to know the base address of the
1772 segment containing that address.
1773*/
1774
f8b76e70 1775CORE_ADDR
1ab3bf1b 1776proc_base_address (addr)
cc221e76 1777 CORE_ADDR addr;
f8b76e70
FF		 1778{
1779 int nmap;
1780 struct prmap *prmaps;
1781 struct prmap *prmap;
1782 CORE_ADDR baseaddr = 0;
de43d7d0 1783 struct procinfo *pi;
f8b76e70 1784
de43d7d0
SG		 1785 pi = current_procinfo;
1786
1787 if (ioctl (pi->fd, PIOCNMAP, &nmap) == 0)
f8b76e70 1788 {
1ab3bf1b 1789 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
de43d7d0 1790 if (ioctl (pi->fd, PIOCMAP, prmaps) == 0)
f8b76e70
FF		 1791 {
1792 for (prmap = prmaps; prmap -> pr_size; ++prmap)
1793 {
1794 if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
1795 (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
1796 {
1797 baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
1798 break;
1799 }
1800 }
1801 }
1802 }
1803 return (baseaddr);
1804}
1805
1ab3bf1b
JG		 1806#endif /* 0 */
1807
f8b76e70
FF		 1808/*
1809
cc221e76 1810LOCAL FUNCTION
f8b76e70
FF		 1811
1812 proc_address_to_fd -- return open fd for file mapped to address
1813
1814SYNOPSIS
1815
de43d7d0 1816 int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
f8b76e70
FF		 1817
1818DESCRIPTION
1819
1820 Given an address in the current inferior's address space, use the
1821 /proc interface to find an open file descriptor for the file that
1822 this address was mapped in from. Return -1 if there is no current
1823 inferior. Print a warning message if there is an inferior but
1824 the address corresponds to no file (IE a bogus address).
1825
1826*/
1827
1ab3bf1b 1828static int
de43d7d0
SG		 1829proc_address_to_fd (pi, addr, complain)
1830 struct procinfo *pi;
1ab3bf1b
JG		 1831 CORE_ADDR addr;
1832 int complain;
f8b76e70
FF		 1833{
1834 int fd = -1;
1835
de43d7d0 1836 if ((fd = ioctl (pi->fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
f8b76e70 1837 {
de43d7d0 1838 if (complain)
f8b76e70 1839 {
de43d7d0
SG		 1840 print_sys_errmsg (pi->pathname, errno);
1841 warning ("can't find mapped file for address 0x%x", addr);
f8b76e70
FF		 1842 }
1843 }
1844 return (fd);
1845}
1846
35f5886e 1847
3fbdd536
JG		 1848/* Attach to process PID, then initialize for debugging it
1849 and wait for the trace-trap that results from attaching. */
1850
1851static void
1852procfs_attach (args, from_tty)
1853 char *args;
1854 int from_tty;
1855{
1856 char *exec_file;
1857 int pid;
1858
1859 if (!args)
1860 error_no_arg ("process-id to attach");
1861
1862 pid = atoi (args);
1863
1864 if (pid == getpid()) /* Trying to masturbate? */
1865 error ("I refuse to debug myself!");
1866
1867 if (from_tty)
1868 {
1869 exec_file = (char *) get_exec_file (0);
1870
1871 if (exec_file)
199b2450 1872 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, target_pid_to_str (pid));
3fbdd536 1873 else
199b2450 1874 printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
3fbdd536 1875
199b2450 1876 gdb_flush (gdb_stdout);
3fbdd536
JG		 1877 }
1878
1879 do_attach (pid);
1880 inferior_pid = pid;
1881 push_target (&procfs_ops);
1882}
1883
1884
1885/* Take a program previously attached to and detaches it.
1886 The program resumes execution and will no longer stop
1887 on signals, etc. We'd better not have left any breakpoints
1888 in the program or it'll die when it hits one. For this
1889 to work, it may be necessary for the process to have been
1890 previously attached. It *might* work if the program was
1891 started via the normal ptrace (PTRACE_TRACEME). */
1892
1893static void
1894procfs_detach (args, from_tty)
1895 char *args;
1896 int from_tty;
1897{
1898 int siggnal = 0;
1899
1900 if (from_tty)
1901 {
1902 char *exec_file = get_exec_file (0);
1903 if (exec_file == 0)
1904 exec_file = "";
199b2450 1905 printf_unfiltered ("Detaching from program: %s %s\n",
25286543 1906 exec_file, target_pid_to_str (inferior_pid));
199b2450 1907 gdb_flush (gdb_stdout);
3fbdd536
JG		 1908 }
1909 if (args)
1910 siggnal = atoi (args);
1911
1912 do_detach (siggnal);
1913 inferior_pid = 0;
1914 unpush_target (&procfs_ops); /* Pop out of handling an inferior */
1915}
1916
1917/* Get ready to modify the registers array. On machines which store
1918 individual registers, this doesn't need to do anything. On machines
1919 which store all the registers in one fell swoop, this makes sure
1920 that registers contains all the registers from the program being
1921 debugged. */
1922
1923static void
1924procfs_prepare_to_store ()
1925{
1926#ifdef CHILD_PREPARE_TO_STORE
1927 CHILD_PREPARE_TO_STORE ();
1928#endif
1929}
1930
1931/* Print status information about what we're accessing. */
1932
1933static void
1934procfs_files_info (ignore)
1935 struct target_ops *ignore;
1936{
199b2450 1937 printf_unfiltered ("\tUsing the running image of %s %s via /proc.\n",
25286543 1938 attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
3fbdd536
JG		 1939}
1940
1941/* ARGSUSED */
1942static void
1943procfs_open (arg, from_tty)
1944 char *arg;
1945 int from_tty;
1946{
1947 error ("Use the \"run\" command to start a Unix child process.");
1948}
35f5886e
FF		 1949
1950/*
1951
3fbdd536 1952LOCAL FUNCTION
35f5886e 1953
3fbdd536 1954 do_attach -- attach to an already existing process
35f5886e
FF		 1955
1956SYNOPSIS
1957
3fbdd536 1958 int do_attach (int pid)
35f5886e
FF		 1959
1960DESCRIPTION
1961
1962 Attach to an already existing process with the specified process
1963 id. If the process is not already stopped, query whether to
1964 stop it or not.
1965
1966NOTES
1967
1968 The option of stopping at attach time is specific to the /proc
1969 versions of gdb. Versions using ptrace force the attachee
ec8ceca3
JG		 1970 to stop. (I have changed this version to do so, too. All you
1971 have to do is "continue" to make it go on. -- gnu@cygnus.com)
35f5886e
FF		 1972
1973*/
1974
3fbdd536
JG		 1975static int
1976do_attach (pid)
1ab3bf1b 1977 int pid;
35f5886e 1978{
ec8ceca3 1979 int result;
de43d7d0
SG		 1980 struct procinfo *pi;
1981
1982 pi = (struct procinfo *) xmalloc (sizeof (struct procinfo));
ec8ceca3 1983
de43d7d0 1984 if (!open_proc_file (pid, pi, O_RDWR))
35f5886e 1985 {
de43d7d0
SG		 1986 free (pi);
1987 perror_with_name (pi->pathname);
35f5886e
FF		 1988 /* NOTREACHED */
1989 }
1990
de43d7d0
SG		 1991 /* Add new process to process info list */
1992
1993 pi->next = procinfo_list;
1994 procinfo_list = pi;
1995
1996 add_fd (pi); /* Add to list for poll/select */
1997
35f5886e
FF		 1998 /* Get current status of process and if it is not already stopped,
1999 then stop it. Remember whether or not it was stopped when we first
2000 examined it. */
2001
de43d7d0 2002 if (ioctl (pi->fd, PIOCSTATUS, &pi->prstatus) < 0)
35f5886e 2003 {
de43d7d0
SG		 2004 print_sys_errmsg (pi->pathname, errno);
2005 close_proc_file (pi);
35f5886e
FF		 2006 error ("PIOCSTATUS failed");
2007 }
de43d7d0 2008 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
35f5886e 2009 {
de43d7d0 2010 pi->was_stopped = 1;
35f5886e
FF		 2011 }
2012 else
2013 {
de43d7d0 2014 pi->was_stopped = 0;
ec8ceca3 2015 if (1 || query ("Process is currently running, stop it? "))
35f5886e 2016 {
ec8ceca3
JG		 2017 /* Make it run again when we close it. */
2018#if defined (PIOCSET) /* New method */
2019 {
2020 long pr_flags;
2021 pr_flags = PR_RLC;
de43d7d0 2022 result = ioctl (pi->fd, PIOCSET, &pr_flags);
ec8ceca3
JG		 2023 }
2024#else
2025#if defined (PIOCSRLC) /* Original method */
de43d7d0 2026 result = ioctl (pi->fd, PIOCSRLC, 0);
ec8ceca3
JG		 2027#endif
2028#endif
2029 if (result < 0)
2030 {
de43d7d0
SG		 2031 print_sys_errmsg (pi->pathname, errno);
2032 close_proc_file (pi);
ec8ceca3
JG		 2033 error ("PIOCSRLC or PIOCSET failed");
2034 }
de43d7d0 2035 if (ioctl (pi->fd, PIOCSTOP, &pi->prstatus) < 0)
35f5886e 2036 {
de43d7d0
SG		 2037 print_sys_errmsg (pi->pathname, errno);
2038 close_proc_file (pi);
35f5886e
FF		 2039 error ("PIOCSTOP failed");
2040 }
de43d7d0 2041 pi->nopass_next_sigstop = 1;
d65eee73
FF		 2042 }
2043 else
2044 {
199b2450 2045 printf_unfiltered ("Ok, gdb will wait for %s to stop.\n", target_pid_to_str (pid));
35f5886e
FF		 2046 }
2047 }
ec8ceca3 2048
35f5886e
FF		 2049 /* Remember some things about the inferior that we will, or might, change
2050 so that we can restore them when we detach. */
2051
de43d7d0
SG		 2052 ioctl (pi->fd, PIOCGTRACE, &pi->saved_trace);
2053 ioctl (pi->fd, PIOCGHOLD, &pi->saved_sighold);
2054 ioctl (pi->fd, PIOCGFAULT, &pi->saved_fltset);
2055 ioctl (pi->fd, PIOCGENTRY, &pi->saved_entryset);
2056 ioctl (pi->fd, PIOCGEXIT, &pi->saved_exitset);
35f5886e
FF		 2057
2058 /* Set up trace and fault sets, as gdb expects them. */
2059
de43d7d0
SG		 2060 memset (&pi->prrun, 0, sizeof (pi->prrun));
2061 prfillset (&pi->prrun.pr_trace);
2062 procfs_notice_signals (pid);
2063 prfillset (&pi->prrun.pr_fault);
2064 prdelset (&pi->prrun.pr_fault, FLTPAGE);
2592eef8 2065
b9e58503
PS		 2066#ifdef PROCFS_DONT_TRACE_FAULTS
2067 premptyset (&pi->prrun.pr_fault);
2592eef8
PS		 2068#endif
2069
de43d7d0 2070 if (ioctl (pi->fd, PIOCSFAULT, &pi->prrun.pr_fault))
35f5886e 2071 {
f66f459f 2072 print_sys_errmsg ("PIOCSFAULT failed", errno);
35f5886e 2073 }
de43d7d0 2074 if (ioctl (pi->fd, PIOCSTRACE, &pi->prrun.pr_trace))
35f5886e 2075 {
f66f459f 2076 print_sys_errmsg ("PIOCSTRACE failed", errno);
35f5886e
FF		 2077 }
2078 attach_flag = 1;
2079 return (pid);
2080}
2081
2082/*
2083
3fbdd536 2084LOCAL FUNCTION
35f5886e 2085
3fbdd536 2086 do_detach -- detach from an attached-to process
35f5886e
FF		 2087
2088SYNOPSIS
2089
3fbdd536 2090 void do_detach (int signal)
35f5886e
FF		 2091
2092DESCRIPTION
2093
2094 Detach from the current attachee.
2095
2096 If signal is non-zero, the attachee is started running again and sent
2097 the specified signal.
2098
2099 If signal is zero and the attachee was not already stopped when we
2100 attached to it, then we make it runnable again when we detach.
2101
2102 Otherwise, we query whether or not to make the attachee runnable
2103 again, since we may simply want to leave it in the state it was in
2104 when we attached.
2105
2106 We report any problems, but do not consider them errors, since we
2107 MUST detach even if some things don't seem to go right. This may not
2108 be the ideal situation. (FIXME).
2109 */
2110
3fbdd536
JG		 2111static void
2112do_detach (signal)
1ab3bf1b 2113 int signal;
35f5886e 2114{
ec8ceca3 2115 int result;
de43d7d0
SG		 2116 struct procinfo *pi;
2117
2118 pi = current_procinfo;
ec8ceca3 2119
35f5886e
FF		 2120 if (signal)
2121 {
de43d7d0 2122 set_proc_siginfo (pi, signal);
35f5886e 2123 }
de43d7d0 2124 if (ioctl (pi->fd, PIOCSEXIT, &pi->saved_exitset) < 0)
35f5886e 2125 {
de43d7d0 2126 print_sys_errmsg (pi->pathname, errno);
199b2450 2127 printf_unfiltered ("PIOCSEXIT failed.\n");
35f5886e 2128 }
de43d7d0 2129 if (ioctl (pi->fd, PIOCSENTRY, &pi->saved_entryset) < 0)
35f5886e 2130 {
de43d7d0 2131 print_sys_errmsg (pi->pathname, errno);
199b2450 2132 printf_unfiltered ("PIOCSENTRY failed.\n");
35f5886e 2133 }
de43d7d0 2134 if (ioctl (pi->fd, PIOCSTRACE, &pi->saved_trace) < 0)
35f5886e 2135 {
de43d7d0 2136 print_sys_errmsg (pi->pathname, errno);
199b2450 2137 printf_unfiltered ("PIOCSTRACE failed.\n");
35f5886e 2138 }
de43d7d0 2139 if (ioctl (pi->fd, PIOCSHOLD, &pi->saved_sighold) < 0)
cc221e76 2140 {
de43d7d0 2141 print_sys_errmsg (pi->pathname, errno);
199b2450 2142 printf_unfiltered ("PIOSCHOLD failed.\n");
cc221e76 2143 }
de43d7d0 2144 if (ioctl (pi->fd, PIOCSFAULT, &pi->saved_fltset) < 0)
35f5886e 2145 {
de43d7d0 2146 print_sys_errmsg (pi->pathname, errno);
199b2450 2147 printf_unfiltered ("PIOCSFAULT failed.\n");
35f5886e 2148 }
de43d7d0 2149 if (ioctl (pi->fd, PIOCSTATUS, &pi->prstatus) < 0)
35f5886e 2150 {
de43d7d0 2151 print_sys_errmsg (pi->pathname, errno);
199b2450 2152 printf_unfiltered ("PIOCSTATUS failed.\n");
35f5886e
FF		 2153 }
2154 else
2155 {
de43d7d0 2156 if (signal || (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
35f5886e 2157 {
de43d7d0 2158 if (signal || !pi->was_stopped ||
35f5886e
FF		 2159 query ("Was stopped when attached, make it runnable again? "))
2160 {
2592eef8
PS		 2161 /* Clear any pending signal if we want to detach without
2162 a signal. */
2163 if (signal == 0)
2164 set_proc_siginfo (pi, signal);
2165
ec8ceca3 2166 /* Clear any fault that might have stopped it. */
de43d7d0 2167 if (ioctl (pi->fd, PIOCCFAULT, 0))
eca4a350
SG		 2168 {
2169 print_sys_errmsg (pi->pathname, errno);
199b2450 2170 printf_unfiltered ("PIOCCFAULT failed.\n");
eca4a350 2171 }
ec8ceca3
JG		 2172
2173 /* Make it run again when we close it. */
eca4a350 2174#if defined (PIOCSET) /* New method */
ec8ceca3 2175 {
eca4a350
SG		 2176 long pr_flags;
2177 pr_flags = PR_RLC;
2178 result = ioctl (pi->fd, PIOCSET, &pr_flags);
ec8ceca3
JG		 2179 }
2180#else
eca4a350 2181#if defined (PIOCSRLC) /* Original method */
de43d7d0 2182 result = ioctl (pi->fd, PIOCSRLC, 0);
ec8ceca3
JG		 2183#endif
2184#endif
2185 if (result)
35f5886e 2186 {
de43d7d0 2187 print_sys_errmsg (pi->pathname, errno);
199b2450 2188 printf_unfiltered ("PIOCSRLC or PIOCSET failed.\n");
35f5886e
FF		 2189 }
2190 }
2191 }
2192 }
de43d7d0 2193 close_proc_file (pi);
35f5886e
FF		 2194 attach_flag = 0;
2195}
2196
45dc9be3
JK		 2197/* emulate wait() as much as possible.
2198 Wait for child to do something. Return pid of child, or -1 in case
2199 of error; store status in *OURSTATUS.
2200
2201 Not sure why we can't
2202 just use wait(), but it seems to have problems when applied to a
2203 process being controlled with the /proc interface.
2204
2205 We have a race problem here with no obvious solution. We need to let
2206 the inferior run until it stops on an event of interest, which means
2207 that we need to use the PIOCWSTOP ioctl. However, we cannot use this
2208 ioctl if the process is already stopped on something that is not an
2209 event of interest, or the call will hang indefinitely. Thus we first
2210 use PIOCSTATUS to see if the process is not stopped. If not, then we
2211 use PIOCWSTOP. But during the window between the two, if the process
2212 stops for any reason that is not an event of interest (such as a job
2213 control signal) then gdb will hang. One possible workaround is to set
2214 an alarm to wake up every minute of so and check to see if the process
2215 is still running, and if so, then reissue the PIOCWSTOP. But this is
2216 a real kludge, so has not been implemented. FIXME: investigate
2217 alternatives.
2218
2219 FIXME: Investigate why wait() seems to have problems with programs
2220 being control by /proc routines. */
35f5886e 2221
3fbdd536 2222static int
45dc9be3 2223procfs_wait (pid, ourstatus)
de43d7d0 2224 int pid;
67ac9759 2225 struct target_waitstatus *ourstatus;
35f5886e
FF		 2226{
2227 short what;
2228 short why;
2229 int statval = 0;
2230 int checkerr = 0;
2231 int rtnval = -1;
de43d7d0
SG		 2232 struct procinfo *pi;
2233
2234 if (pid != -1) /* Non-specific process? */
2235 pi = NULL;
2236 else
2237 for (pi = procinfo_list; pi; pi = pi->next)
2238 if (pi->had_event)
2239 break;
2240
de43d7d0 2241 if (!pi)
eca4a350
SG		 2242 {
2243 wait_again:
2244
2245 pi = wait_fd ();
2246 }
de43d7d0
SG		 2247
2248 if (pid != -1)
2249 for (pi = procinfo_list; pi; pi = pi->next)
2250 if (pi->pid == pid && pi->had_event)
2251 break;
2252
2253 if (!pi && !checkerr)
2254 goto wait_again;
2255
2256 if (!checkerr && !(pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
2257 {
2258 if (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
2259 {
2260 checkerr++;
2261 }
35f5886e
FF		 2262 }
2263 if (checkerr)
2264 {
2265 if (errno == ENOENT)
2266 {
2267 rtnval = wait (&statval);
2268 if (rtnval != inferior_pid)
2269 {
de43d7d0 2270 print_sys_errmsg (pi->pathname, errno);
35f5886e
FF		 2271 error ("PIOCWSTOP, wait failed, returned %d", rtnval);
2272 /* NOTREACHED */
2273 }
2274 }
2275 else
2276 {
de43d7d0 2277 print_sys_errmsg (pi->pathname, errno);
35f5886e
FF		 2278 error ("PIOCSTATUS or PIOCWSTOP failed.");
2279 /* NOTREACHED */
2280 }
2281 }
de43d7d0 2282 else if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
35f5886e 2283 {
de43d7d0
SG		 2284 rtnval = pi->prstatus.pr_pid;
2285 why = pi->prstatus.pr_why;
2286 what = pi->prstatus.pr_what;
2287
2288 switch (why)
35f5886e 2289 {
de43d7d0 2290 case PR_SIGNALLED:
35f5886e 2291 statval = (what << 8) | 0177;
fb63d460
SG		 2292 break;
2293 case PR_SYSENTRY:
2294 if (what != SYS_exit)
2295 error ("PR_SYSENTRY, unknown system call %d", what);
2296
2297 pi->prrun.pr_flags = PRCFAULT;
2298
2299 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2300 perror_with_name (pi->pathname);
2301
2302 rtnval = wait (&statval);
2303
de43d7d0
SG		 2304 break;
2305 case PR_SYSEXIT:
2306 switch (what)
2307 {
407a8389 2308#ifdef SYS_exec
de43d7d0 2309 case SYS_exec:
407a8389
SG		 2310#endif
2311#ifdef SYS_execve
de43d7d0 2312 case SYS_execve:
407a8389
SG		 2313#endif
2314#ifdef SYS_execv
de43d7d0 2315 case SYS_execv:
407a8389 2316#endif
de43d7d0
SG		 2317 statval = (SIGTRAP << 8) | 0177;
2318 break;
2319#ifdef SYS_sproc
2320 case SYS_sproc:
2321/* We've just detected the completion of an sproc system call. Now we need to
2322 setup a procinfo struct for this thread, and notify the thread system of the
2323 new arrival. */
2324
2325/* If sproc failed, then nothing interesting happened. Continue the process and
2326 go back to sleep. */
2327
2328 if (pi->prstatus.pr_errno != 0)
2329 {
2330 pi->prrun.pr_flags &= PRSTEP;
2331 pi->prrun.pr_flags |= PRCFAULT;
2332
2333 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2334 perror_with_name (pi->pathname);
2335
2336 goto wait_again;
2337 }
2338
2339/* At this point, the new thread is stopped at it's first instruction, and
2340 the parent is stopped at the exit from sproc. */
2341
2342/* Notify the caller of the arrival of a new thread. */
2343 create_procinfo (pi->prstatus.pr_rval1);
2344
2345 rtnval = pi->prstatus.pr_rval1;
2346 statval = (SIGTRAP << 8) | 0177;
2347
2348 break;
eca4a350
SG		 2349 case SYS_fork:
2350#ifdef SYS_vfork
2351 case SYS_vfork:
2352#endif
2353/* At this point, we've detected the completion of a fork (or vfork) call in
2354 our child. The grandchild is also stopped because we set inherit-on-fork
2355 earlier. (Note that nobody has the grandchilds' /proc file open at this
2356 point.) We will release the grandchild from the debugger by opening it's
2357 /proc file and then closing it. Since run-on-last-close is set, the
2358 grandchild continues on its' merry way. */
2359
2360 {
2361 struct procinfo *pitemp;
2362
2363 pitemp = create_procinfo (pi->prstatus.pr_rval1);
2364 if (pitemp)
2365 close_proc_file (pitemp);
2366
2367 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
2368 perror_with_name (pi->pathname);
2369 }
2370 goto wait_again;
de43d7d0
SG		 2371#endif /* SYS_sproc */
2372
2373 default:
2374 error ("PIOCSTATUS (PR_SYSEXIT): Unknown system call %d", what);
2375 }
2376 break;
2377 case PR_REQUESTED:
35f5886e 2378 statval = (SIGSTOP << 8) | 0177;
de43d7d0
SG		 2379 break;
2380 case PR_JOBCONTROL:
35f5886e 2381 statval = (what << 8) | 0177;
de43d7d0
SG		 2382 break;
2383 case PR_FAULTED:
35f5886e
FF		 2384 switch (what)
2385 {
e6b8a171 2386#ifdef FLTWATCH
999dd04b 2387 case FLTWATCH:
e6b8a171
JL		 2388 statval = (SIGTRAP << 8) | 0177;
2389 break;
2390#endif
2391#ifdef FLTKWATCH
999dd04b 2392 case FLTKWATCH:
35f5886e
FF		 2393 statval = (SIGTRAP << 8) | 0177;
2394 break;
e6b8a171 2395#endif
3f5e2fb5
JK		 2396#ifndef FAULTED_USE_SIGINFO
2397 /* Irix, contrary to the documentation, fills in 0 for si_signo.
2398 Solaris fills in si_signo. I'm not sure about others. */
2399 case FLTPRIV:
2400 case FLTILL:
2401 statval = (SIGILL << 8) | 0177;
2402 break;
2403 case FLTBPT:
2404 case FLTTRACE:
2405 statval = (SIGTRAP << 8) | 0177;
2406 break;
2407 case FLTSTACK:
2408 case FLTACCESS:
2409 case FLTBOUNDS:
2410 statval = (SIGSEGV << 8) | 0177;
2411 break;
2412 case FLTIOVF:
2413 case FLTIZDIV:
2414 case FLTFPE:
2415 statval = (SIGFPE << 8) | 0177;
2416 break;
2417 case FLTPAGE: /* Recoverable page fault */
2418#endif /* not FAULTED_USE_SIGINFO */
35f5886e 2419 default:
890634ed
JK		 2420 /* Use the signal which the kernel assigns. This is better than
2421 trying to second-guess it from the fault. In fact, I suspect
2422 that FLTACCESS can be either SIGSEGV or SIGBUS. */
2423 statval = ((pi->prstatus.pr_info.si_signo) << 8) | 0177;
2424 break;
35f5886e 2425 }
de43d7d0
SG		 2426 break;
2427 default:
35f5886e 2428 error ("PIOCWSTOP, unknown why %d, what %d", why, what);
35f5886e 2429 }
de43d7d0
SG		 2430/* Stop all the other threads when any of them stops. */
2431
2432 {
2433 struct procinfo *procinfo;
2434
2435 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2436 {
2437 if (!procinfo->had_event)
2438 if (ioctl (procinfo->fd, PIOCSTOP, &procinfo->prstatus) < 0)
2439 {
2440 print_sys_errmsg (procinfo->pathname, errno);
2441 error ("PIOCSTOP failed");
2442 }
2443 }
2444 }
35f5886e
FF		 2445 }
2446 else
2447 {
2448 error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
de43d7d0 2449 pi->prstatus.pr_flags);
35f5886e 2450 }
3fbdd536 2451
67ac9759 2452 store_waitstatus (ourstatus, statval);
3fbdd536
JG		 2453
2454 if (rtnval == -1) /* No more children to wait for */
2455 {
199b2450 2456 fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing.\n");
67ac9759
JK		 2457 /* Claim it exited with unknown signal. */
2458 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2459 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
3fbdd536
JG		 2460 return rtnval;
2461 }
2462
de43d7d0 2463 pi->had_event = 0; /* Indicate that we've seen this one */
35f5886e
FF		 2464 return (rtnval);
2465}
2466
2467/*
2468
6b801388
FF		 2469LOCAL FUNCTION
2470
2471 set_proc_siginfo - set a process's current signal info
2472
2473SYNOPSIS
2474
2475 void set_proc_siginfo (struct procinfo *pip, int signo);
2476
2477DESCRIPTION
2478
2479 Given a pointer to a process info struct in PIP and a signal number
2480 in SIGNO, set the process's current signal and its associated signal
2481 information. The signal will be delivered to the process immediately
2482 after execution is resumed, even if it is being held. In addition,
2483 this particular delivery will not cause another PR_SIGNALLED stop
2484 even if the signal is being traced.
2485
2486 If we are not delivering the same signal that the prstatus siginfo
2487 struct contains information about, then synthesize a siginfo struct
2488 to match the signal we are doing to deliver, make it of the type
2489 "generated by a user process", and send this synthesized copy. When
2490 used to set the inferior's signal state, this will be required if we
2491 are not currently stopped because of a traced signal, or if we decide
2492 to continue with a different signal.
2493
2494 Note that when continuing the inferior from a stop due to receipt
2495 of a traced signal, we either have set PRCSIG to clear the existing
2496 signal, or we have to call this function to do a PIOCSSIG with either
2497 the existing siginfo struct from pr_info, or one we have synthesized
2498 appropriately for the signal we want to deliver. Otherwise if the
2499 signal is still being traced, the inferior will immediately stop
2500 again.
2501
2502 See siginfo(5) for more details.
2503*/
2504
2505static void
2506set_proc_siginfo (pip, signo)
cc221e76
FF		 2507 struct procinfo *pip;
2508 int signo;
6b801388
FF		 2509{
2510 struct siginfo newsiginfo;
2511 struct siginfo *sip;
2512
2592eef8
PS		 2513#ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2514 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
a1a0d974 2515 receives a PIOCSSIG with a signal identical to the current signal,
2592eef8
PS		 2516 it messes up the current signal. Work around the kernel bug. */
2517 if (signo == pip -> prstatus.pr_cursig)
2518 return;
2519#endif
2520
de43d7d0 2521 if (signo == pip -> prstatus.pr_info.si_signo)
6b801388 2522 {
de43d7d0
SG		 2523 sip = &pip -> prstatus.pr_info;
2524 }
2525 else
2526 {
2527 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
2528 sip = &newsiginfo;
2529 sip -> si_signo = signo;
2530 sip -> si_code = 0;
2531 sip -> si_errno = 0;
2532 sip -> si_pid = getpid ();
2533 sip -> si_uid = getuid ();
2534 }
2535 if (ioctl (pip -> fd, PIOCSSIG, sip) < 0)
2536 {
2537 print_sys_errmsg (pip -> pathname, errno);
2538 warning ("PIOCSSIG failed");
6b801388
FF		 2539 }
2540}
2541
25286543 2542/* Resume execution of process PID. If STEP is nozero, then
59ba57da
JK		 2543 just single step it. If SIGNAL is nonzero, restart it with that
2544 signal activated. */
35f5886e 2545
3fbdd536 2546static void
25286543
SG		 2547procfs_resume (pid, step, signo)
2548 int pid;
1ab3bf1b 2549 int step;
67ac9759 2550 enum target_signal signo;
35f5886e 2551{
59ba57da 2552 int signal_to_pass;
de43d7d0
SG		 2553 struct procinfo *pi, *procinfo;
2554
2555 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
59ba57da 2556
35f5886e 2557 errno = 0;
de43d7d0 2558 pi->prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
99fd9e3e 2559
59ba57da
JK		 2560#if 0
2561 /* It should not be necessary. If the user explicitly changes the value,
2562 value_assign calls write_register_bytes, which writes it. */
2563/* It may not be absolutely necessary to specify the PC value for
2564 restarting, but to be safe we use the value that gdb considers
2565 to be current. One case where this might be necessary is if the
2566 user explicitly changes the PC value that gdb considers to be
2567 current. FIXME: Investigate if this is necessary or not. */
2568
c3192172 2569#ifdef PRSVADDR_BROKEN
99fd9e3e
SG		 2570/* Can't do this under Solaris running on a Sparc, as there seems to be no
2571 place to put nPC. In fact, if you use this, nPC seems to be set to some
2572 random garbage. We have to rely on the fact that PC and nPC have been
2573 written previously via PIOCSREG during a register flush. */
2574
de43d7d0
SG		 2575 pi->prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
2576 pi->prrun.pr_flags != PRSVADDR;
99fd9e3e 2577#endif
59ba57da
JK		 2578#endif
2579
67ac9759 2580 if (signo == TARGET_SIGNAL_STOP && pi->nopass_next_sigstop)
59ba57da
JK		 2581 /* When attaching to a child process, if we forced it to stop with
2582 a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
2583 Upon resuming the first time after such a stop, we explicitly
2584 inhibit sending it another SIGSTOP, which would be the normal
2585 result of default signal handling. One potential drawback to
2586 this is that we will also ignore any attempt to by the user
2587 to explicitly continue after the attach with a SIGSTOP. Ultimately
2588 this problem should be dealt with by making the routines that
2589 deal with the inferior a little smarter, and possibly even allow
2590 an inferior to continue running at the same time as gdb. (FIXME?) */
2591 signal_to_pass = 0;
67ac9759 2592 else if (signo == TARGET_SIGNAL_TSTP
de43d7d0
SG		 2593 && pi->prstatus.pr_cursig == SIGTSTP
2594 && pi->prstatus.pr_action.sa_handler == SIG_DFL)
59ba57da
JK		 2595
2596 /* We are about to pass the inferior a SIGTSTP whose action is
2597 SIG_DFL. The SIG_DFL action for a SIGTSTP is to stop
2598 (notifying the parent via wait()), and then keep going from the
2599 same place when the parent is ready for you to keep going. So
2600 under the debugger, it should do nothing (as if the program had
2601 been stopped and then later resumed. Under ptrace, this
2602 happens for us, but under /proc, the system obligingly stops
2603 the process, and wait_for_inferior would have no way of
2604 distinguishing that type of stop (which indicates that we
2605 should just start it again), with a stop due to the pr_trace
2606 field of the prrun_t struct.
2607
2608 Note that if the SIGTSTP is being caught, we *do* need to pass it,
2609 because the handler needs to get executed. */
2610 signal_to_pass = 0;
2611 else
67ac9759 2612 signal_to_pass = target_signal_to_host (signo);
99fd9e3e 2613
59ba57da 2614 if (signal_to_pass)
35f5886e 2615 {
de43d7d0 2616 set_proc_siginfo (pi, signal_to_pass);
35f5886e
FF		 2617 }
2618 else
2619 {
de43d7d0 2620 pi->prrun.pr_flags |= PRCSIG;
35f5886e 2621 }
de43d7d0 2622 pi->nopass_next_sigstop = 0;
35f5886e
FF		 2623 if (step)
2624 {
de43d7d0 2625 pi->prrun.pr_flags |= PRSTEP;
35f5886e 2626 }
de43d7d0 2627 if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
35f5886e 2628 {
de43d7d0 2629 perror_with_name (pi->pathname);
35f5886e
FF		 2630 /* NOTREACHED */
2631 }
de43d7d0
SG		 2632
2633 pi->had_event = 0;
2634
2635 /* Continue all the other threads that haven't had an event of
2636 interest. */
2637
2638 if (pid == -1)
2639 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2640 {
2641 if (pi != procinfo && !procinfo->had_event)
2642 {
2643 procinfo->prrun.pr_flags &= PRSTEP;
2644 procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG;
2645 ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus);
2646 if (ioctl (procinfo->fd, PIOCRUN, &procinfo->prrun) < 0)
2647 {
2648 if (ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus) < 0)
2649 {
199b2450 2650 fprintf_unfiltered(gdb_stderr, "PIOCSTATUS failed, errno=%d\n", errno);
de43d7d0
SG		 2651 }
2652 print_sys_errmsg (procinfo->pathname, errno);
2653 error ("PIOCRUN failed");
2654 }
2655 ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus);
2656 }
2657 }
35f5886e
FF		 2658}
2659
2660/*
2661
3fbdd536 2662LOCAL FUNCTION
35f5886e 2663
3fbdd536 2664 procfs_fetch_registers -- fetch current registers from inferior
35f5886e
FF		 2665
2666SYNOPSIS
2667
3fbdd536 2668 void procfs_fetch_registers (int regno)
35f5886e
FF		 2669
2670DESCRIPTION
2671
2672 Read the current values of the inferior's registers, both the
2673 general register set and floating point registers (if supported)
2674 and update gdb's idea of their current values.
2675
2676*/
2677
3fbdd536
JG		 2678static void
2679procfs_fetch_registers (regno)
1ab3bf1b 2680 int regno;
35f5886e 2681{
de43d7d0
SG		 2682 struct procinfo *pi;
2683
2684 pi = current_procinfo;
2685
2686 if (ioctl (pi->fd, PIOCGREG, &pi->gregset) != -1)
35f5886e 2687 {
de43d7d0 2688 supply_gregset (&pi->gregset);
35f5886e
FF		 2689 }
2690#if defined (FP0_REGNUM)
de43d7d0 2691 if (ioctl (pi->fd, PIOCGFPREG, &pi->fpregset) != -1)
35f5886e 2692 {
de43d7d0 2693 supply_fpregset (&pi->fpregset);
35f5886e
FF		 2694 }
2695#endif
2696}
2697
fb182850
FF		 2698/*
2699
35f5886e
FF		 2700LOCAL FUNCTION
2701
de43d7d0
SG		 2702 proc_init_failed - called whenever /proc access initialization
2703fails
35f5886e
FF		 2704
2705SYNOPSIS
2706
de43d7d0 2707 static void proc_init_failed (struct procinfo *pi, char *why)
35f5886e
FF		 2708
2709DESCRIPTION
2710
2711 This function is called whenever initialization of access to a /proc
2712 entry fails. It prints a suitable error message, does some cleanup,
2713 and then invokes the standard error processing routine which dumps
2714 us back into the command loop.
2715 */
2716
2717static void
de43d7d0
SG		 2718proc_init_failed (pi, why)
2719 struct procinfo *pi;
1ab3bf1b 2720 char *why;
35f5886e 2721{
de43d7d0
SG		 2722 print_sys_errmsg (pi->pathname, errno);
2723 kill (pi->pid, SIGKILL);
2724 close_proc_file (pi);
35f5886e
FF		 2725 error (why);
2726 /* NOTREACHED */
2727}
2728
2729/*
2730
2731LOCAL FUNCTION
2732
2733 close_proc_file - close any currently open /proc entry
2734
2735SYNOPSIS
2736
a39ad5ce 2737 static void close_proc_file (struct procinfo *pip)
35f5886e
FF		 2738
2739DESCRIPTION
2740
2741 Close any currently open /proc entry and mark the process information
2742 entry as invalid. In order to ensure that we don't try to reuse any
2743 stale information, the pid, fd, and pathnames are explicitly
2744 invalidated, which may be overkill.
2745
2746 */
2747
2748static void
1ab3bf1b
JG		 2749close_proc_file (pip)
2750 struct procinfo *pip;
35f5886e 2751{
de43d7d0
SG		 2752 struct procinfo *procinfo;
2753
2754 remove_fd (pip); /* Remove fd from poll/select list */
2755
2756 close (pip -> fd);
2757
2758 free (pip -> pathname);
2759
2760 /* Unlink pip from the procinfo chain. Note pip might not be on the list. */
2761
2762 if (procinfo_list == pip)
2763 procinfo_list = pip->next;
2764 else
2765 for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
2766 if (procinfo->next == pip)
2767 procinfo->next = pip->next;
2768
2769 free (pip);
35f5886e
FF		 2770}
2771
2772/*
2773
2774LOCAL FUNCTION
2775
2776 open_proc_file - open a /proc entry for a given process id
2777
2778SYNOPSIS
2779
ec8ceca3 2780 static int open_proc_file (int pid, struct procinfo *pip, int mode)
35f5886e
FF		 2781
2782DESCRIPTION
2783
ec8ceca3
JG		 2784 Given a process id and a mode, close the existing open /proc
2785 entry (if any) and open one for the new process id, in the
2786 specified mode. Once it is open, then mark the local process
2787 information structure as valid, which guarantees that the pid,
2788 fd, and pathname fields match an open /proc entry. Returns
2789 zero if the open fails, nonzero otherwise.
35f5886e
FF		 2790
2791 Note that the pathname is left intact, even when the open fails,
2792 so that callers can use it to construct meaningful error messages
2793 rather than just "file open failed".
2794 */
2795
2796static int
ec8ceca3 2797open_proc_file (pid, pip, mode)
1ab3bf1b
JG		 2798 int pid;
2799 struct procinfo *pip;
ec8ceca3 2800 int mode;
35f5886e 2801{
de43d7d0
SG		 2802 pip -> next = NULL;
2803 pip -> had_event = 0;
2804 pip -> pathname = xmalloc (32);
2805 pip -> pid = pid;
2806
a39ad5ce 2807 sprintf (pip -> pathname, PROC_NAME_FMT, pid);
de43d7d0
SG		 2808 if ((pip -> fd = open (pip -> pathname, mode)) < 0)
2809 return 0;
2810
2811 return 1;
a39ad5ce
FF		 2812}
2813
f66f459f 2814static char *
1ab3bf1b
JG		 2815mappingflags (flags)
2816 long flags;
a39ad5ce 2817{
5c1c5e67 2818 static char asciiflags[8];
a39ad5ce 2819
5c1c5e67
FF		 2820 strcpy (asciiflags, "-------");
2821#if defined (MA_PHYS)
2822 if (flags & MA_PHYS) asciiflags[0] = 'd';
2823#endif
2824 if (flags & MA_STACK) asciiflags[1] = 's';
2825 if (flags & MA_BREAK) asciiflags[2] = 'b';
2826 if (flags & MA_SHARED) asciiflags[3] = 's';
2827 if (flags & MA_READ) asciiflags[4] = 'r';
2828 if (flags & MA_WRITE) asciiflags[5] = 'w';
2829 if (flags & MA_EXEC) asciiflags[6] = 'x';
a39ad5ce
FF		 2830 return (asciiflags);
2831}
2832
2833static void
cc221e76
FF		 2834info_proc_flags (pip, summary)
2835 struct procinfo *pip;
2836 int summary;
2837{
2838 struct trans *transp;
2839
2840 printf_filtered ("%-32s", "Process status flags:");
2841 if (!summary)
2842 {
2843 printf_filtered ("\n\n");
2844 }
2845 for (transp = pr_flag_table; transp -> name != NULL; transp++)
2846 {
2847 if (pip -> prstatus.pr_flags & transp -> value)
2848 {
2849 if (summary)
2850 {
2851 printf_filtered ("%s ", transp -> name);
2852 }
2853 else
2854 {
2855 printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
2856 }
2857 }
2858 }
2859 printf_filtered ("\n");
2860}
2861
2862static void
2863info_proc_stop (pip, summary)
2864 struct procinfo *pip;
2865 int summary;
2866{
2867 struct trans *transp;
2868 int why;
2869 int what;
2870
2871 why = pip -> prstatus.pr_why;
2872 what = pip -> prstatus.pr_what;
2873
2874 if (pip -> prstatus.pr_flags & PR_STOPPED)
2875 {
2876 printf_filtered ("%-32s", "Reason for stopping:");
2877 if (!summary)
2878 {
2879 printf_filtered ("\n\n");
2880 }
2881 for (transp = pr_why_table; transp -> name != NULL; transp++)
2882 {
2883 if (why == transp -> value)
2884 {
2885 if (summary)
2886 {
2887 printf_filtered ("%s ", transp -> name);
2888 }
2889 else
2890 {
2891 printf_filtered ("\t%-16s %s.\n",
2892 transp -> name, transp -> desc);
2893 }
2894 break;
2895 }
2896 }
2897
2898 /* Use the pr_why field to determine what the pr_what field means, and
2899 print more information. */
2900
2901 switch (why)
2902 {
2903 case PR_REQUESTED:
2904 /* pr_what is unused for this case */
2905 break;
2906 case PR_JOBCONTROL:
2907 case PR_SIGNALLED:
2908 if (summary)
2909 {
2910 printf_filtered ("%s ", signalname (what));
2911 }
2912 else
2913 {
2914 printf_filtered ("\t%-16s %s.\n", signalname (what),
4ace50a5 2915 safe_strsignal (what));
cc221e76
FF		 2916 }
2917 break;
2918 case PR_SYSENTRY:
2919 if (summary)
2920 {
2921 printf_filtered ("%s ", syscallname (what));
2922 }
2923 else
2924 {
2925 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2926 "Entered this system call");
2927 }
2928 break;
2929 case PR_SYSEXIT:
2930 if (summary)
2931 {
2932 printf_filtered ("%s ", syscallname (what));
2933 }
2934 else
2935 {
2936 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2937 "Returned from this system call");
2938 }
2939 break;
2940 case PR_FAULTED:
2941 if (summary)
2942 {
2943 printf_filtered ("%s ",
2944 lookupname (faults_table, what, "fault"));
2945 }
2946 else
2947 {
2948 printf_filtered ("\t%-16s %s.\n",
2949 lookupname (faults_table, what, "fault"),
2950 lookupdesc (faults_table, what));
2951 }
2952 break;
2953 }
2954 printf_filtered ("\n");
2955 }
2956}
2957
2958static void
2959info_proc_siginfo (pip, summary)
2960 struct procinfo *pip;
2961 int summary;
2962{
2963 struct siginfo *sip;
2964
2965 if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
2966 (pip -> prstatus.pr_why == PR_SIGNALLED ||
2967 pip -> prstatus.pr_why == PR_FAULTED))
2968 {
2969 printf_filtered ("%-32s", "Additional signal/fault info:");
2970 sip = &pip -> prstatus.pr_info;
2971 if (summary)
2972 {
2973 printf_filtered ("%s ", signalname (sip -> si_signo));
2974 if (sip -> si_errno > 0)
2975 {
4ace50a5 2976 printf_filtered ("%s ", errnoname (sip -> si_errno));
cc221e76
FF		 2977 }
2978 if (sip -> si_code <= 0)
2979 {
25286543
SG		 2980 printf_filtered ("sent by %s, uid %d ",
2981 target_pid_to_str (sip -> si_pid),
cc221e76
FF		 2982 sip -> si_uid);
2983 }
2984 else
2985 {
2986 printf_filtered ("%s ", sigcodename (sip));
2987 if ((sip -> si_signo == SIGILL) ||
2988 (sip -> si_signo == SIGFPE) ||
2989 (sip -> si_signo == SIGSEGV) ||
2990 (sip -> si_signo == SIGBUS))
2991 {
b9e58503
PS		 2992 printf_filtered ("addr=%#lx ",
2993 (unsigned long) sip -> si_addr);
cc221e76
FF		 2994 }
2995 else if ((sip -> si_signo == SIGCHLD))
2996 {
25286543
SG		 2997 printf_filtered ("child %s, status %u ",
2998 target_pid_to_str (sip -> si_pid),
cc221e76
FF		 2999 sip -> si_status);
3000 }
3001 else if ((sip -> si_signo == SIGPOLL))
3002 {
3003 printf_filtered ("band %u ", sip -> si_band);
3004 }
3005 }
3006 }
3007 else
3008 {
3009 printf_filtered ("\n\n");
3010 printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
4ace50a5 3011 safe_strsignal (sip -> si_signo));
cc221e76
FF		 3012 if (sip -> si_errno > 0)
3013 {
3014 printf_filtered ("\t%-16s %s.\n",
4ace50a5
FF		 3015 errnoname (sip -> si_errno),
3016 safe_strerror (sip -> si_errno));
cc221e76
FF		 3017 }
3018 if (sip -> si_code <= 0)
3019 {
25286543 3020 printf_filtered ("\t%-16u %s\n", sip -> si_pid, /* XXX need target_pid_to_str() */
cc221e76
FF		 3021 "PID of process sending signal");
3022 printf_filtered ("\t%-16u %s\n", sip -> si_uid,
3023 "UID of process sending signal");
3024 }
3025 else
3026 {
3027 printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
3028 sigcodedesc (sip));
3029 if ((sip -> si_signo == SIGILL) ||
3030 (sip -> si_signo == SIGFPE))
3031 {
b9e58503
PS		 3032 printf_filtered ("\t%#-16lx %s.\n",
3033 (unsigned long) sip -> si_addr,
cc221e76
FF		 3034 "Address of faulting instruction");
3035 }
3036 else if ((sip -> si_signo == SIGSEGV) ||
3037 (sip -> si_signo == SIGBUS))
3038 {
b9e58503
PS		 3039 printf_filtered ("\t%#-16lx %s.\n",
3040 (unsigned long) sip -> si_addr,
cc221e76
FF		 3041 "Address of faulting memory reference");
3042 }
3043 else if ((sip -> si_signo == SIGCHLD))
3044 {
25286543 3045 printf_filtered ("\t%-16u %s.\n", sip -> si_pid, /* XXX need target_pid_to_str() */
cc221e76
FF		 3046 "Child process ID");
3047 printf_filtered ("\t%-16u %s.\n", sip -> si_status,
3048 "Child process exit value or signal");
3049 }
3050 else if ((sip -> si_signo == SIGPOLL))
3051 {
3052 printf_filtered ("\t%-16u %s.\n", sip -> si_band,
3053 "Band event for POLL_{IN,OUT,MSG}");
3054 }
3055 }
3056 }
3057 printf_filtered ("\n");
3058 }
3059}
3060
3061static void
3062info_proc_syscalls (pip, summary)
3063 struct procinfo *pip;
3064 int summary;
3065{
3066 int syscallnum;
3067
3068 if (!summary)
3069 {
3070
3071#if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
3072 if (pip -> prstatus.pr_flags & PR_ASLEEP)
3073 {
3074 int syscallnum = pip -> prstatus.pr_reg[R_D0];
3075 if (summary)
3076 {
3077 printf_filtered ("%-32s", "Sleeping in system call:");
3078 printf_filtered ("%s", syscallname (syscallnum));
3079 }
3080 else
3081 {
3082 printf_filtered ("Sleeping in system call '%s'.\n",
3083 syscallname (syscallnum));
3084 }
3085 }
3086#endif
3087
3088 if (ioctl (pip -> fd, PIOCGENTRY, &pip -> entryset) < 0)
3089 {
3090 print_sys_errmsg (pip -> pathname, errno);
3091 error ("PIOCGENTRY failed");
3092 }
3093
3094 if (ioctl (pip -> fd, PIOCGEXIT, &pip -> exitset) < 0)
3095 {
3096 print_sys_errmsg (pip -> pathname, errno);
3097 error ("PIOCGEXIT failed");
3098 }
3099
3100 printf_filtered ("System call tracing information:\n\n");
3101
3102 printf_filtered ("\t%-12s %-8s %-8s\n",
3103 "System call",
3104 "Entry",
3105 "Exit");
3106 for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
3107 {
3108 QUIT;
3109 if (syscall_table[syscallnum] != NULL)
3110 {
3111 printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
3112 printf_filtered ("%-8s ",
3113 prismember (&pip -> entryset, syscallnum)
3114 ? "on" : "off");
3115 printf_filtered ("%-8s ",
3116 prismember (&pip -> exitset, syscallnum)
3117 ? "on" : "off");
3118 printf_filtered ("\n");
3119 }
3120 }
3121 printf_filtered ("\n");
3122 }
3123}
3124
3125static char *
3126signalname (signo)
3127 int signo;
3128{
26a859ec 3129 const char *name;
4ace50a5
FF		 3130 static char locbuf[32];
3131
3132 name = strsigno (signo);
3133 if (name == NULL)
3134 {
3135 sprintf (locbuf, "Signal %d", signo);
3136 }
3137 else
3138 {
3139 sprintf (locbuf, "%s (%d)", name, signo);
3140 }
3141 return (locbuf);
3142}
3143
3144static char *
3145errnoname (errnum)
3146 int errnum;
3147{
26a859ec 3148 const char *name;
cc221e76
FF		 3149 static char locbuf[32];
3150
4ace50a5
FF		 3151 name = strerrno (errnum);
3152 if (name == NULL)
cc221e76 3153 {
4ace50a5 3154 sprintf (locbuf, "Errno %d", errnum);
cc221e76
FF		 3155 }
3156 else
3157 {
4ace50a5 3158 sprintf (locbuf, "%s (%d)", name, errnum);
cc221e76
FF		 3159 }
3160 return (locbuf);
3161}
3162
3163static void
3164info_proc_signals (pip, summary)
3165 struct procinfo *pip;
3166 int summary;
3167{
3168 int signo;
3169
3170 if (!summary)
3171 {
3172 if (ioctl (pip -> fd, PIOCGTRACE, &pip -> trace) < 0)
3173 {
3174 print_sys_errmsg (pip -> pathname, errno);
3175 error ("PIOCGTRACE failed");
3176 }
3177
3178 printf_filtered ("Disposition of signals:\n\n");
3179 printf_filtered ("\t%-15s %-8s %-8s %-8s %s\n\n",
3180 "Signal", "Trace", "Hold", "Pending", "Description");
3181 for (signo = 0; signo < NSIG; signo++)
3182 {
3183 QUIT;
3184 printf_filtered ("\t%-15s ", signalname (signo));
3185 printf_filtered ("%-8s ",
3186 prismember (&pip -> trace, signo)
3187 ? "on" : "off");
3188 printf_filtered ("%-8s ",
3189 prismember (&pip -> prstatus.pr_sighold, signo)
3190 ? "on" : "off");
2592eef8
PS		 3191
3192#ifdef PROCFS_SIGPEND_OFFSET
3193 /* Alpha OSF/1 numbers the pending signals from 1. */
3194 printf_filtered ("%-8s ",
3195 (signo ? prismember (&pip -> prstatus.pr_sigpend,
3196 signo - 1)
3197 : 0)
3198 ? "yes" : "no");
3199#else
cc221e76
FF		 3200 printf_filtered ("%-8s ",
3201 prismember (&pip -> prstatus.pr_sigpend, signo)
3202 ? "yes" : "no");
2592eef8 3203#endif
4ace50a5 3204 printf_filtered (" %s\n", safe_strsignal (signo));
cc221e76
FF		 3205 }
3206 printf_filtered ("\n");
3207 }
3208}
3209
3210static void
3211info_proc_faults (pip, summary)
3212 struct procinfo *pip;
3213 int summary;
3214{
3215 struct trans *transp;
3216
3217 if (!summary)
3218 {
3219 if (ioctl (pip -> fd, PIOCGFAULT, &pip -> fltset) < 0)
3220 {
3221 print_sys_errmsg (pip -> pathname, errno);
3222 error ("PIOCGFAULT failed");
3223 }
3224
3225 printf_filtered ("Current traced hardware fault set:\n\n");
3226 printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
3227
3228 for (transp = faults_table; transp -> name != NULL; transp++)
3229 {
3230 QUIT;
3231 printf_filtered ("\t%-12s ", transp -> name);
3232 printf_filtered ("%-8s", prismember (&pip -> fltset, transp -> value)
3233 ? "on" : "off");
3234 printf_filtered ("\n");
3235 }
3236 printf_filtered ("\n");
3237 }
3238}
3239
3240static void
3241info_proc_mappings (pip, summary)
1ab3bf1b 3242 struct procinfo *pip;
cc221e76 3243 int summary;
a39ad5ce
FF		 3244{
3245 int nmap;
3246 struct prmap *prmaps;
3247 struct prmap *prmap;
3248
cc221e76 3249 if (!summary)
a39ad5ce 3250 {
cc221e76 3251 printf_filtered ("Mapped address spaces:\n\n");
2592eef8
PS		 3252#ifdef BFD_HOST_64_BIT
3253 printf_filtered (" %18s %18s %10s %10s %7s\n",
3254#else
5c1c5e67 3255 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
2592eef8 3256#endif
cc221e76
FF		 3257 "Start Addr",
3258 " End Addr",
3259 " Size",
3260 " Offset",
3261 "Flags");
3262 if (ioctl (pip -> fd, PIOCNMAP, &nmap) == 0)
a39ad5ce 3263 {
cc221e76
FF		 3264 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
3265 if (ioctl (pip -> fd, PIOCMAP, prmaps) == 0)
a39ad5ce 3266 {
cc221e76
FF		 3267 for (prmap = prmaps; prmap -> pr_size; ++prmap)
3268 {
2592eef8
PS		 3269#ifdef BFD_HOST_64_BIT
3270 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3271#else
3272 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3273#endif
3274 (unsigned long)prmap -> pr_vaddr,
3275 (unsigned long)prmap -> pr_vaddr
3276 + prmap -> pr_size - 1,
cc221e76
FF		 3277 prmap -> pr_size,
3278 prmap -> pr_off,
3279 mappingflags (prmap -> pr_mflags));
3280 }
a39ad5ce
FF		 3281 }
3282 }
cc221e76 3283 printf_filtered ("\n");
a39ad5ce 3284 }
a39ad5ce
FF		 3285}
3286
3287/*
3288
3289LOCAL FUNCTION
3290
cc221e76 3291 info_proc -- implement the "info proc" command
a39ad5ce
FF		 3292
3293SYNOPSIS
3294
cc221e76 3295 void info_proc (char *args, int from_tty)
a39ad5ce
FF		 3296
3297DESCRIPTION
3298
3299 Implement gdb's "info proc" command by using the /proc interface
3300 to print status information about any currently running process.
3301
3302 Examples of the use of "info proc" are:
3303
cc221e76
FF		 3304 info proc (prints summary info for current inferior)
3305 info proc 123 (prints summary info for process with pid 123)
3306 info proc mappings (prints address mappings)
3307 info proc times (prints process/children times)
3308 info proc id (prints pid, ppid, gid, sid, etc)
3fbdd536 3309 FIXME: i proc id not implemented.
cc221e76 3310 info proc status (prints general process state info)
3fbdd536 3311 FIXME: i proc status not implemented.
cc221e76
FF		 3312 info proc signals (prints info about signal handling)
3313 info proc all (prints all info)
a39ad5ce
FF		 3314
3315 */
3316
3317static void
cc221e76 3318info_proc (args, from_tty)
1ab3bf1b
JG		 3319 char *args;
3320 int from_tty;
a39ad5ce 3321{
a39ad5ce 3322 int pid;
a39ad5ce
FF		 3323 struct procinfo *pip;
3324 struct cleanup *old_chain;
cc221e76
FF		 3325 char **argv;
3326 int argsize;
3327 int summary = 1;
3328 int flags = 0;
3329 int syscalls = 0;
3330 int signals = 0;
3331 int faults = 0;
3332 int mappings = 0;
3333 int times = 0;
3334 int id = 0;
3335 int status = 0;
3336 int all = 0;
a39ad5ce
FF		 3337
3338 old_chain = make_cleanup (null_cleanup, 0);
3339
de43d7d0
SG		 3340 /* Default to using the current inferior if no pid specified. Note
3341 that inferior_pid may be 0, hence we set okerr. */
a39ad5ce 3342
de43d7d0 3343 pip = find_procinfo (inferior_pid, 1);
a39ad5ce 3344
a39ad5ce 3345 if (args != NULL)
35f5886e 3346 {
cc221e76 3347 if ((argv = buildargv (args)) == NULL)
a39ad5ce 3348 {
cc221e76
FF		 3349 nomem (0);
3350 }
3351 make_cleanup (freeargv, (char *) argv);
3352
3353 while (*argv != NULL)
3354 {
3355 argsize = strlen (*argv);
3356 if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
3357 {
3358 summary = 0;
3359 all = 1;
3360 }
3361 else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
3362 {
3363 summary = 0;
3364 faults = 1;
3365 }
3366 else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
3367 {
3368 summary = 0;
3369 flags = 1;
3370 }
3371 else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
3372 {
3373 summary = 0;
3374 id = 1;
3375 }
3376 else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
3377 {
3378 summary = 0;
3379 mappings = 1;
3380 }
3381 else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
3382 {
3383 summary = 0;
3384 signals = 1;
3385 }
3386 else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
3387 {
3388 summary = 0;
3389 status = 1;
3390 }
3391 else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
3392 {
3393 summary = 0;
3394 syscalls = 1;
3395 }
3396 else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
a39ad5ce 3397 {
cc221e76
FF		 3398 summary = 0;
3399 times = 1;
a39ad5ce 3400 }
de43d7d0 3401 else if ((pid = atoi (*argv)) > 0)
a39ad5ce 3402 {
de43d7d0
SG		 3403 pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
3404 memset (pip, 0, sizeof (*pip));
3405
3406 pip->pid = pid;
ec8ceca3 3407 if (!open_proc_file (pid, pip, O_RDONLY))
a39ad5ce
FF		 3408 {
3409 perror_with_name (pip -> pathname);
3410 /* NOTREACHED */
3411 }
3412 make_cleanup (close_proc_file, pip);
3413 }
cc221e76
FF		 3414 else if (**argv != '\000')
3415 {
3416 error ("Unrecognized or ambiguous keyword `%s'.", *argv);
3417 }
3418 argv++;
a39ad5ce 3419 }
35f5886e 3420 }
a39ad5ce
FF		 3421
3422 /* If we don't have a valid open process at this point, then we have no
3423 inferior or didn't specify a specific pid. */
3424
de43d7d0 3425 if (!pip)
35f5886e 3426 {
6fe90fc8
JK		 3427 error ("\
3428No process. Start debugging a program or specify an explicit process ID.");
35f5886e 3429 }
a39ad5ce 3430 if (ioctl (pip -> fd, PIOCSTATUS, &(pip -> prstatus)) < 0)
35f5886e 3431 {
a39ad5ce
FF		 3432 print_sys_errmsg (pip -> pathname, errno);
3433 error ("PIOCSTATUS failed");
35f5886e 3434 }
a39ad5ce 3435
cc221e76
FF		 3436 /* Print verbose information of the requested type(s), or just a summary
3437 of the information for all types. */
3438
3439 printf_filtered ("\nInformation for %s:\n\n", pip -> pathname);
3440 if (summary || all || flags)
3441 {
3442 info_proc_flags (pip, summary);
3443 }
3444 if (summary || all)
3445 {
3446 info_proc_stop (pip, summary);
3447 }
3448 if (summary || all || signals || faults)
3449 {
3450 info_proc_siginfo (pip, summary);
3451 }
3452 if (summary || all || syscalls)
3453 {
3454 info_proc_syscalls (pip, summary);
3455 }
3456 if (summary || all || mappings)
3457 {
3458 info_proc_mappings (pip, summary);
3459 }
3460 if (summary || all || signals)
3461 {
3462 info_proc_signals (pip, summary);
3463 }
3464 if (summary || all || faults)
3465 {
3466 info_proc_faults (pip, summary);
3467 }
3468 printf_filtered ("\n");
a39ad5ce
FF		 3469
3470 /* All done, deal with closing any temporary process info structure,
3471 freeing temporary memory , etc. */
3472
3473 do_cleanups (old_chain);
3474}
3475
de43d7d0
SG		 3476/*
3477
3478LOCAL FUNCTION
3479
eca4a350 3480 procfs_set_sproc_trap -- arrange for child to stop on sproc().
de43d7d0
SG		 3481
3482SYNOPSIS
3483
eca4a350 3484 void procfs_set_sproc_trap (struct procinfo *)
de43d7d0
SG		 3485
3486DESCRIPTION
3487
3488 This function sets up a trap on sproc system call exits so that we can
eca4a350 3489 detect the arrival of a new thread. We are called with the new thread
de43d7d0
SG		 3490 stopped prior to it's first instruction.
3491
3492 Also note that we turn on the inherit-on-fork flag in the child process
3493 so that any grand-children start with all tracing flags set.
3494 */
3495
952a820e
SG		 3496#ifdef SYS_sproc
3497
de43d7d0
SG		 3498static void
3499procfs_set_sproc_trap (pi)
3500 struct procinfo *pi;
3501{
3502 sysset_t exitset;
3503
3504 if (ioctl (pi->fd, PIOCGEXIT, &exitset) < 0)
3505 {
3506 print_sys_errmsg (pi->pathname, errno);
3507 error ("PIOCGEXIT failed");
3508 }
3509
de43d7d0 3510 praddset (&exitset, SYS_sproc);
de43d7d0 3511
eca4a350
SG		 3512 /* We trap on fork() and vfork() in order to disable debugging in our grand-
3513 children and descendant processes. At this time, GDB can only handle
3514 threads (multiple processes, one address space). forks (and execs) result
3515 in the creation of multiple address spaces, which GDB can't handle yet. */
3516
3517 praddset (&exitset, SYS_fork);
3518#ifdef SYS_vfork
3519 praddset (&exitset, SYS_vfork);
3520#endif
3521
de43d7d0
SG		 3522 if (ioctl (pi->fd, PIOCSEXIT, &exitset) < 0)
3523 {
3524 print_sys_errmsg (pi->pathname, errno);
3525 error ("PIOCSEXIT failed");
3526 }
3527
3528 /* Turn on inherit-on-fork flag so that all grand-children of gdb start with
3529 tracing flags set. */
3530
3531#ifdef PIOCSET /* New method */
3532 {
3533 long pr_flags;
3534 pr_flags = PR_FORK;
3535 ioctl (pi->fd, PIOCSET, &pr_flags);
3536 }
3537#else
3538#ifdef PIOCSFORK /* Original method */
3539 ioctl (pi->fd, PIOCSFORK, NULL);
3540#endif
3541#endif
3542}
952a820e 3543#endif /* SYS_sproc */
de43d7d0 3544
3fbdd536
JG		 3545/* Fork an inferior process, and start debugging it with /proc. */
3546
3547static void
3548procfs_create_inferior (exec_file, allargs, env)
3549 char *exec_file;
3550 char *allargs;
3551 char **env;
3552{
08f74b92
JK		 3553 char *shell_file = getenv ("SHELL");
3554 char *tryname;
3555 if (shell_file != NULL && strchr (shell_file, '/') == NULL)
3556 {
3557
3558 /* We will be looking down the PATH to find shell_file. If we
3559 just do this the normal way (via execlp, which operates by
3560 attempting an exec for each element of the PATH until it
3561 finds one which succeeds), then there will be an exec for
3562 each failed attempt, each of which will cause a PR_SYSEXIT
3563 stop, and we won't know how to distinguish the PR_SYSEXIT's
3564 for these failed execs with the ones for successful execs
3565 (whether the exec has succeeded is stored at that time in the
3566 carry bit or some such architecture-specific and
3567 non-ABI-specified place).
3568
3569 So I can't think of anything better than to search the PATH
3570 now. This has several disadvantages: (1) There is a race
3571 condition; if we find a file now and it is deleted before we
3572 exec it, we lose, even if the deletion leaves a valid file
3573 further down in the PATH, (2) there is no way to know exactly
3574 what an executable (in the sense of "capable of being
3575 exec'd") file is. Using access() loses because it may lose
3576 if the caller is the superuser; failing to use it loses if
3577 there are ACLs or some such. */
3578
3579 char *p;
3580 char *p1;
f93b941b
JK		 3581 /* FIXME-maybe: might want "set path" command so user can change what
3582 path is used from within GDB. */
08f74b92
JK		 3583 char *path = getenv ("PATH");
3584 int len;
3585 struct stat statbuf;
3586
3587 if (path == NULL)
3588 path = "/bin:/usr/bin";
3589
3590 tryname = alloca (strlen (path) + strlen (shell_file) + 2);
3591 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
3592 {
3593 p1 = strchr (p, ':');
3594 if (p1 != NULL)
3595 len = p1 - p;
3596 else
3597 len = strlen (p);
3598 strncpy (tryname, p, len);
3599 tryname[len] = '\0';
3600 strcat (tryname, "/");
3601 strcat (tryname, shell_file);
3602 if (access (tryname, X_OK) < 0)
3603 continue;
3604 if (stat (tryname, &statbuf) < 0)
3605 continue;
3606 if (!S_ISREG (statbuf.st_mode))
3607 /* We certainly need to reject directories. I'm not quite
3608 as sure about FIFOs, sockets, etc., but I kind of doubt
3609 that people want to exec() these things. */
3610 continue;
3611 break;
3612 }
3613 if (p == NULL)
3614 /* Not found. This must be an error rather than merely passing
3615 the file to execlp(), because execlp() would try all the
3616 exec()s, causing GDB to get confused. */
3617 error ("Can't find shell %s in PATH", shell_file);
3618
3619 shell_file = tryname;
3620 }
3621
3fbdd536 3622 fork_inferior (exec_file, allargs, env,
08f74b92
JK		 3623 proc_set_exec_trap, procfs_init_inferior, shell_file);
3624
3fbdd536
JG		 3625 /* We are at the first instruction we care about. */
3626 /* Pedal to the metal... */
de43d7d0
SG		 3627
3628 /* Setup traps on exit from sproc() */
3629
952a820e
SG		 3630#ifdef SYS_sproc
3631 procfs_set_sproc_trap (current_procinfo);
3632#endif
de43d7d0 3633
67ac9759 3634 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
3fbdd536
JG		 3635}
3636
3637/* Clean up after the inferior dies. */
3638
3639static void
3640procfs_mourn_inferior ()
3641{
fb63d460 3642 struct procinfo *pi;
cd4104e0 3643 struct procinfo *next_pi;
fb63d460 3644
cd4104e0
TL		 3645 for (pi = procinfo_list; pi; pi = next_pi)
3646 {
3647 next_pi = pi->next;
3648 unconditionally_kill_inferior (pi);
3649 }
fb63d460 3650
3fbdd536
JG		 3651 unpush_target (&procfs_ops);
3652 generic_mourn_inferior ();
3653}
3654
cd4104e0 3655
3fbdd536
JG		 3656/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
3657static int
3658procfs_can_run ()
3659{
3660 return(1);
3661}
f5a8f1a6 3662#ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
999dd04b
JL		 3663\f
3664/* Insert a watchpoint */
3665int
3666procfs_set_watchpoint(pid, addr, len, rw)
3667 int pid;
3668 CORE_ADDR addr;
3669 int len;
3670 int rw;
3671{
3672 struct procinfo *pi;
3673 prwatch_t wpt;
3674
3675 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3676 wpt.pr_vaddr = (caddr_t)addr;
3677 wpt.pr_size = len;
3678 wpt.pr_wflags = ((rw & 1) ? MA_READ : 0) | ((rw & 2) ? MA_WRITE : 0);
3679 if (ioctl (pi->fd, PIOCSWATCH, &wpt) < 0)
3680 {
3681 if (errno == E2BIG)
3682 return -1;
3683 /* Currently it sometimes happens that the same watchpoint gets
3684 deleted twice - don't die in this case (FIXME please) */
3685 if (errno == ESRCH && len == 0)
3686 return 0;
3687 print_sys_errmsg (pi->pathname, errno);
3688 error ("PIOCSWATCH failed");
3689 }
3690 return 0;
3691}
3692
3693int
3694procfs_stopped_by_watchpoint(pid)
3695 int pid;
3696{
3697 struct procinfo *pi;
3698 short what;
3699 short why;
3700
3701 pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
3702 if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
3703 {
3704 why = pi->prstatus.pr_why;
3705 what = pi->prstatus.pr_what;
3706 if (why == PR_FAULTED
6bc194d2
JL		 3707#if defined (FLTWATCH) && defined (FLTKWATCH)
3708 && (what == FLTWATCH) || (what == FLTKWATCH)
3709#else
3710#ifdef FLTWATCH
3711 && (what == FLTWATCH)
3712#endif
3713#ifdef FLTKWATCH
3714 && (what == FLTKWATCH)
3715#endif
72b8ca51 3716#endif
6bc194d2 3717 )
999dd04b
JL		 3718 return what;
3719 }
3720 return 0;
3721}
6bc194d2 3722#endif
999dd04b 3723
78b459a7
SG		 3724/* Send a SIGINT to the process group. This acts just like the user typed a
3725 ^C on the controlling terminal.
3726
3727 XXX - This may not be correct for all systems. Some may want to use
3728 killpg() instead of kill (-pgrp). */
3729
3730void
2592eef8 3731procfs_stop ()
78b459a7
SG		 3732{
3733 extern pid_t inferior_process_group;
3734
3735 kill (-inferior_process_group, SIGINT);
3736}
3737
3fbdd536
JG		 3738\f
3739struct target_ops procfs_ops = {
3740 "procfs", /* to_shortname */
3741 "Unix /proc child process", /* to_longname */
3742 "Unix /proc child process (started by the \"run\" command).", /* to_doc */
3743 procfs_open, /* to_open */
3744 0, /* to_close */
3745 procfs_attach, /* to_attach */
3746 procfs_detach, /* to_detach */
3747 procfs_resume, /* to_resume */
3748 procfs_wait, /* to_wait */
3749 procfs_fetch_registers, /* to_fetch_registers */
3750 procfs_store_registers, /* to_store_registers */
3751 procfs_prepare_to_store, /* to_prepare_to_store */
3752 procfs_xfer_memory, /* to_xfer_memory */
3753 procfs_files_info, /* to_files_info */
3754 memory_insert_breakpoint, /* to_insert_breakpoint */
3755 memory_remove_breakpoint, /* to_remove_breakpoint */
3756 terminal_init_inferior, /* to_terminal_init */
3757 terminal_inferior, /* to_terminal_inferior */
3758 terminal_ours_for_output, /* to_terminal_ours_for_output */
3759 terminal_ours, /* to_terminal_ours */
3760 child_terminal_info, /* to_terminal_info */
3761 procfs_kill_inferior, /* to_kill */
3762 0, /* to_load */
3763 0, /* to_lookup_symbol */
3764 procfs_create_inferior, /* to_create_inferior */
3765 procfs_mourn_inferior, /* to_mourn_inferior */
3766 procfs_can_run, /* to_can_run */
3950a34e 3767 procfs_notice_signals, /* to_notice_signals */
2592eef8 3768 procfs_stop, /* to_stop */
3fbdd536
JG		 3769 process_stratum, /* to_stratum */
3770 0, /* to_next */
3771 1, /* to_has_all_memory */
3772 1, /* to_has_memory */
3773 1, /* to_has_stack */
3774 1, /* to_has_registers */
3775 1, /* to_has_execution */
3776 0, /* sections */
3777 0, /* sections_end */
3778 OPS_MAGIC /* to_magic */
3779};
3780
3fbdd536
JG		 3781void
3782_initialize_procfs ()
3783{
2592eef8
PS		 3784#ifdef HAVE_OPTIONAL_PROC_FS
3785 char procname[32];
3786 int fd;
3787
3788 /* If we have an optional /proc filesystem (e.g. under OSF/1),
3789 don't add procfs support if we cannot access the running
3790 GDB via /proc. */
3791 sprintf (procname, PROC_NAME_FMT, getpid ());
3792 if ((fd = open (procname, O_RDONLY)) < 0)
3793 return;
3794 close (fd);
3795#endif
3796
3fbdd536
JG		 3797 add_target (&procfs_ops);
3798
3799 add_info ("proc", info_proc,
cc221e76
FF		 3800"Show process status information using /proc entry.\n\
3801Specify process id or use current inferior by default.\n\
3802Specify keywords for detailed information; default is summary.\n\
3803Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
3804`status', `syscalls', and `times'.\n\
3fbdd536 3805Unambiguous abbreviations may be used.");
a39ad5ce 3806
cc221e76 3807 init_syscall_table ();
35f5886e 3808}
GDB Binutils - Deliverables
This page took 0.391245 seconds and 4 git commands to generate.