projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
use _filtered routines for printing so symbolic addresses show up in the right place
[deliverable/binutils-gdb.git] / gdb / procfs.c
CommitLineData
35f5886e 1/* Machine independent support for SVR4 /proc (process file system) for GDB.
ec8ceca3 2 Copyright 1991, 1992 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
FF		 36
37#ifdef USE_PROC_FS /* Entire file goes away if not using /proc */
38
407a8389 39#include <time.h>
35f5886e
FF		 40#include <sys/procfs.h>
41#include <fcntl.h>
42#include <errno.h>
51b57ded 43#include <string.h>
35f5886e 44
35f5886e
FF		 45#include "inferior.h"
46#include "target.h"
51b57ded 47#include "command.h"
cc221e76
FF		 48
49#define MAX_SYSCALLS 256 /* Maximum number of syscalls for table */
35f5886e
FF		 50
51#ifndef PROC_NAME_FMT
6c316cfd 52#define PROC_NAME_FMT "/proc/%05d"
35f5886e
FF		 53#endif
54
35f5886e
FF		 55#if 1 /* FIXME: Gross and ugly hack to resolve coredep.c global */
56CORE_ADDR kernel_u_addr;
57#endif
58
cc221e76
FF		 59#ifdef BROKEN_SIGINFO_H /* Workaround broken SGS <sys/siginfo.h> */
60#undef si_pid
61#define si_pid _data._proc.pid
62#undef si_uid
63#define si_uid _data._proc._pdata._kill.uid
64#endif /* BROKEN_SIGINFO_H */
65
35f5886e
FF		 66/* All access to the inferior, either one started by gdb or one that has
67 been attached to, is controlled by an instance of a procinfo structure,
68 defined below. Since gdb currently only handles one inferior at a time,
a39ad5ce
FF		 69 the procinfo structure for the inferior is statically allocated and
70 only one exists at any given time. There is a separate procinfo
71 structure for use by the "info proc" command, so that we can print
72 useful information about any random process without interfering with
73 the inferior's procinfo information. */
35f5886e
FF		 74
75struct procinfo {
76 int valid; /* Nonzero if pid, fd, & pathname are valid */
77 int pid; /* Process ID of inferior */
78 int fd; /* File descriptor for /proc entry */
79 char *pathname; /* Pathname to /proc entry */
80 int was_stopped; /* Nonzero if was stopped prior to attach */
d65eee73 81 int nopass_next_sigstop; /* Don't pass a sigstop on next resume */
35f5886e
FF		 82 prrun_t prrun; /* Control state when it is run */
83 prstatus_t prstatus; /* Current process status info */
84 gregset_t gregset; /* General register set */
85 fpregset_t fpregset; /* Floating point register set */
86 fltset_t fltset; /* Current traced hardware fault set */
87 sigset_t trace; /* Current traced signal set */
88 sysset_t exitset; /* Current traced system call exit set */
89 sysset_t entryset; /* Current traced system call entry set */
cc221e76
FF		 90 fltset_t saved_fltset; /* Saved traced hardware fault set */
91 sigset_t saved_trace; /* Saved traced signal set */
92 sigset_t saved_sighold; /* Saved held signal set */
93 sysset_t saved_exitset; /* Saved traced system call exit set */
94 sysset_t saved_entryset; /* Saved traced system call entry set */
a39ad5ce
FF		 95};
96
97static struct procinfo pi; /* Inferior's process information */
35f5886e 98
cc221e76
FF		 99/* Much of the information used in the /proc interface, particularly for
100 printing status information, is kept as tables of structures of the
101 following form. These tables can be used to map numeric values to
102 their symbolic names and to a string that describes their specific use. */
103
104struct trans {
105 int value; /* The numeric value */
106 char *name; /* The equivalent symbolic value */
107 char *desc; /* Short description of value */
108};
109
110/* Translate bits in the pr_flags member of the prstatus structure, into the
111 names and desc information. */
112
113static struct trans pr_flag_table[] =
114{
115#if defined (PR_STOPPED)
116 PR_STOPPED, "PR_STOPPED", "Process is stopped",
117#endif
118#if defined (PR_ISTOP)
119 PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest",
120#endif
121#if defined (PR_DSTOP)
122 PR_DSTOP, "PR_DSTOP", "A stop directive is in effect",
123#endif
124#if defined (PR_ASLEEP)
125 PR_ASLEEP, "PR_ASLEEP", "Sleeping in an interruptible system call",
126#endif
127#if defined (PR_FORK)
128 PR_FORK, "PR_FORK", "Inherit-on-fork is in effect",
129#endif
130#if defined (PR_RLC)
131 PR_RLC, "PR_RLC", "Run-on-last-close is in effect",
132#endif
133#if defined (PR_PTRACE)
134 PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace",
135#endif
136#if defined (PR_PCINVAL)
137 PR_PCINVAL, "PR_PCINVAL", "PC refers to an invalid virtual address",
138#endif
139#if defined (PR_ISSYS)
140 PR_ISSYS, "PR_ISSYS", "Is a system process",
5c1c5e67
FF		 141#endif
142#if defined (PR_STEP)
143 PR_STEP, "PR_STEP", "Process has single step pending",
144#endif
145#if defined (PR_KLC)
146 PR_KLC, "PR_KLC", "Kill-on-last-close is in effect",
147#endif
148#if defined (PR_ASYNC)
149 PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect",
150#endif
151#if defined (PR_PCOMPAT)
152 PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect",
cc221e76
FF		 153#endif
154 0, NULL, NULL
155};
156
157/* Translate values in the pr_why field of the prstatus struct. */
158
159static struct trans pr_why_table[] =
160{
161#if defined (PR_REQUESTED)
162 PR_REQUESTED, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP",
163#endif
164#if defined (PR_SIGNALLED)
165 PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal",
166#endif
167#if defined (PR_FAULTED)
168 PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault",
169#endif
170#if defined (PR_SYSENTRY)
171 PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call",
172#endif
173#if defined (PR_SYSEXIT)
174 PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call",
175#endif
176#if defined (PR_JOBCONTROL)
177 PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action",
5c1c5e67
FF		 178#endif
179#if defined (PR_SUSPENDED)
180 PR_SUSPENDED, "PR_SUSPENDED", "Process suspended",
cc221e76
FF		 181#endif
182 0, NULL, NULL
183};
184
185/* Hardware fault translation table. */
186
187static struct trans faults_table[] =
188{
189#if defined (FLTILL)
190 FLTILL, "FLTILL", "Illegal instruction",
191#endif
192#if defined (FLTPRIV)
193 FLTPRIV, "FLTPRIV", "Privileged instruction",
194#endif
195#if defined (FLTBPT)
196 FLTBPT, "FLTBPT", "Breakpoint trap",
197#endif
198#if defined (FLTTRACE)
199 FLTTRACE, "FLTTRACE", "Trace trap",
200#endif
201#if defined (FLTACCESS)
202 FLTACCESS, "FLTACCESS", "Memory access fault",
203#endif
204#if defined (FLTBOUNDS)
205 FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation",
206#endif
207#if defined (FLTIOVF)
208 FLTIOVF, "FLTIOVF", "Integer overflow",
209#endif
210#if defined (FLTIZDIV)
211 FLTIZDIV, "FLTIZDIV", "Integer zero divide",
212#endif
213#if defined (FLTFPE)
214 FLTFPE, "FLTFPE", "Floating-point exception",
215#endif
216#if defined (FLTSTACK)
217 FLTSTACK, "FLTSTACK", "Unrecoverable stack fault",
218#endif
219#if defined (FLTPAGE)
220 FLTPAGE, "FLTPAGE", "Recoverable page fault",
221#endif
222 0, NULL, NULL
223};
224
225/* Translation table for signal generation information. See UNIX System
226 V Release 4 Programmer's Reference Manual, siginfo(5). */
227
228static struct sigcode {
229 int signo;
230 int code;
231 char *codename;
232 char *desc;
233} siginfo_table[] = {
234#if defined (SIGILL) && defined (ILL_ILLOPC)
235 SIGILL, ILL_ILLOPC, "ILL_ILLOPC", "Illegal opcode",
236#endif
237#if defined (SIGILL) && defined (ILL_ILLOPN)
238 SIGILL, ILL_ILLOPN, "ILL_ILLOPN", "Illegal operand",
239#endif
240#if defined (SIGILL) && defined (ILL_ILLADR)
241 SIGILL, ILL_ILLADR, "ILL_ILLADR", "Illegal addressing mode",
242#endif
243#if defined (SIGILL) && defined (ILL_ILLTRP)
244 SIGILL, ILL_ILLTRP, "ILL_ILLTRP", "Illegal trap",
245#endif
246#if defined (SIGILL) && defined (ILL_PRVOPC)
247 SIGILL, ILL_PRVOPC, "ILL_PRVOPC", "Privileged opcode",
248#endif
249#if defined (SIGILL) && defined (ILL_PRVREG)
250 SIGILL, ILL_PRVREG, "ILL_PRVREG", "Privileged register",
251#endif
252#if defined (SIGILL) && defined (ILL_COPROC)
253 SIGILL, ILL_COPROC, "ILL_COPROC", "Coprocessor error",
254#endif
255#if defined (SIGILL) && defined (ILL_BADSTK)
256 SIGILL, ILL_BADSTK, "ILL_BADSTK", "Internal stack error",
257#endif
258#if defined (SIGFPE) && defined (FPE_INTDIV)
259 SIGFPE, FPE_INTDIV, "FPE_INTDIV", "Integer divide by zero",
260#endif
261#if defined (SIGFPE) && defined (FPE_INTOVF)
262 SIGFPE, FPE_INTOVF, "FPE_INTOVF", "Integer overflow",
263#endif
264#if defined (SIGFPE) && defined (FPE_FLTDIV)
265 SIGFPE, FPE_FLTDIV, "FPE_FLTDIV", "Floating point divide by zero",
266#endif
267#if defined (SIGFPE) && defined (FPE_FLTOVF)
268 SIGFPE, FPE_FLTOVF, "FPE_FLTOVF", "Floating point overflow",
269#endif
270#if defined (SIGFPE) && defined (FPE_FLTUND)
271 SIGFPE, FPE_FLTUND, "FPE_FLTUND", "Floating point underflow",
272#endif
273#if defined (SIGFPE) && defined (FPE_FLTRES)
274 SIGFPE, FPE_FLTRES, "FPE_FLTRES", "Floating point inexact result",
275#endif
276#if defined (SIGFPE) && defined (FPE_FLTINV)
277 SIGFPE, FPE_FLTINV, "FPE_FLTINV", "Invalid floating point operation",
278#endif
279#if defined (SIGFPE) && defined (FPE_FLTSUB)
280 SIGFPE, FPE_FLTSUB, "FPE_FLTSUB", "Subscript out of range",
281#endif
282#if defined (SIGSEGV) && defined (SEGV_MAPERR)
283 SIGSEGV, SEGV_MAPERR, "SEGV_MAPERR", "Address not mapped to object",
284#endif
285#if defined (SIGSEGV) && defined (SEGV_ACCERR)
286 SIGSEGV, SEGV_ACCERR, "SEGV_ACCERR", "Invalid permissions for object",
287#endif
288#if defined (SIGBUS) && defined (BUS_ADRALN)
289 SIGBUS, BUS_ADRALN, "BUS_ADRALN", "Invalid address alignment",
290#endif
291#if defined (SIGBUS) && defined (BUS_ADRERR)
292 SIGBUS, BUS_ADRERR, "BUS_ADRERR", "Non-existent physical address",
293#endif
294#if defined (SIGBUS) && defined (BUS_OBJERR)
295 SIGBUS, BUS_OBJERR, "BUS_OBJERR", "Object specific hardware error",
296#endif
297#if defined (SIGTRAP) && defined (TRAP_BRKPT)
298 SIGTRAP, TRAP_BRKPT, "TRAP_BRKPT", "Process breakpoint",
299#endif
300#if defined (SIGTRAP) && defined (TRAP_TRACE)
301 SIGTRAP, TRAP_TRACE, "TRAP_TRACE", "Process trace trap",
302#endif
303#if defined (SIGCLD) && defined (CLD_EXITED)
304 SIGCLD, CLD_EXITED, "CLD_EXITED", "Child has exited",
305#endif
306#if defined (SIGCLD) && defined (CLD_KILLED)
307 SIGCLD, CLD_KILLED, "CLD_KILLED", "Child was killed",
308#endif
309#if defined (SIGCLD) && defined (CLD_DUMPED)
310 SIGCLD, CLD_DUMPED, "CLD_DUMPED", "Child has terminated abnormally",
311#endif
312#if defined (SIGCLD) && defined (CLD_TRAPPED)
313 SIGCLD, CLD_TRAPPED, "CLD_TRAPPED", "Traced child has trapped",
314#endif
315#if defined (SIGCLD) && defined (CLD_STOPPED)
316 SIGCLD, CLD_STOPPED, "CLD_STOPPED", "Child has stopped",
317#endif
318#if defined (SIGCLD) && defined (CLD_CONTINUED)
319 SIGCLD, CLD_CONTINUED, "CLD_CONTINUED", "Stopped child had continued",
320#endif
321#if defined (SIGPOLL) && defined (POLL_IN)
322 SIGPOLL, POLL_IN, "POLL_IN", "Input input available",
323#endif
324#if defined (SIGPOLL) && defined (POLL_OUT)
325 SIGPOLL, POLL_OUT, "POLL_OUT", "Output buffers available",
326#endif
327#if defined (SIGPOLL) && defined (POLL_MSG)
328 SIGPOLL, POLL_MSG, "POLL_MSG", "Input message available",
329#endif
330#if defined (SIGPOLL) && defined (POLL_ERR)
331 SIGPOLL, POLL_ERR, "POLL_ERR", "I/O error",
332#endif
333#if defined (SIGPOLL) && defined (POLL_PRI)
334 SIGPOLL, POLL_PRI, "POLL_PRI", "High priority input available",
335#endif
336#if defined (SIGPOLL) && defined (POLL_HUP)
337 SIGPOLL, POLL_HUP, "POLL_HUP", "Device disconnected",
338#endif
339 0, 0, NULL, NULL
340};
341
cc221e76
FF		 342static char *syscall_table[MAX_SYSCALLS];
343
1ab3bf1b
JG		 344/* Prototypes for local functions */
345
6b801388
FF		 346static void
347set_proc_siginfo PARAMS ((struct procinfo *, int));
348
cc221e76
FF		 349static void
350init_syscall_table PARAMS ((void));
351
352static char *
353syscallname PARAMS ((int));
354
355static char *
356signalname PARAMS ((int));
357
4ace50a5
FF		 358static char *
359errnoname PARAMS ((int));
360
1ab3bf1b
JG		 361static int
362proc_address_to_fd PARAMS ((CORE_ADDR, int));
363
364static int
ec8ceca3 365open_proc_file PARAMS ((int, struct procinfo *, int));
1ab3bf1b
JG		 366
367static void
368close_proc_file PARAMS ((struct procinfo *));
369
370static void
371unconditionally_kill_inferior PARAMS ((void));
372
373static void
374proc_init_failed PARAMS ((char *));
375
376static void
cc221e76
FF		 377info_proc PARAMS ((char *, int));
378
379static void
380info_proc_flags PARAMS ((struct procinfo *, int));
381
382static void
383info_proc_stop PARAMS ((struct procinfo *, int));
1ab3bf1b
JG		 384
385static void
cc221e76
FF		 386info_proc_siginfo PARAMS ((struct procinfo *, int));
387
388static void
389info_proc_syscalls PARAMS ((struct procinfo *, int));
390
391static void
392info_proc_mappings PARAMS ((struct procinfo *, int));
393
394static void
395info_proc_signals PARAMS ((struct procinfo *, int));
396
397static void
398info_proc_faults PARAMS ((struct procinfo *, int));
1ab3bf1b
JG		 399
400static char *
401mappingflags PARAMS ((long));
402
cc221e76
FF		 403static char *
404lookupname PARAMS ((struct trans *, unsigned int, char *));
405
406static char *
407lookupdesc PARAMS ((struct trans *, unsigned int));
408
1ab3bf1b
JG		 409/* External function prototypes that can't be easily included in any
410 header file because the args are typedefs in system include files. */
411
412extern void
413supply_gregset PARAMS ((gregset_t *));
414
415extern void
416fill_gregset PARAMS ((gregset_t *, int));
417
418extern void
419supply_fpregset PARAMS ((fpregset_t *));
420
421extern void
422fill_fpregset PARAMS ((fpregset_t *, int));
35f5886e 423
cc221e76
FF		 424/*
425
426LOCAL FUNCTION
427
428 lookupdesc -- translate a value to a summary desc string
429
430SYNOPSIS
431
432 static char *lookupdesc (struct trans *transp, unsigned int val);
433
434DESCRIPTION
435
436 Given a pointer to a translation table and a value to be translated,
437 lookup the desc string and return it.
438 */
439
440static char *
441lookupdesc (transp, val)
442 struct trans *transp;
443 unsigned int val;
444{
445 char *desc;
446
447 for (desc = NULL; transp -> name != NULL; transp++)
448 {
449 if (transp -> value == val)
450 {
451 desc = transp -> desc;
452 break;
453 }
454 }
455
456 /* Didn't find a translation for the specified value, set a default one. */
457
458 if (desc == NULL)
459 {
460 desc = "Unknown";
461 }
462 return (desc);
463}
464
465/*
466
467LOCAL FUNCTION
468
469 lookupname -- translate a value to symbolic name
470
471SYNOPSIS
472
473 static char *lookupname (struct trans *transp, unsigned int val,
474 char *prefix);
475
476DESCRIPTION
477
478 Given a pointer to a translation table, a value to be translated,
479 and a default prefix to return if the value can't be translated,
480 match the value with one of the translation table entries and
481 return a pointer to the symbolic name.
482
483 If no match is found it just returns the value as a printable string,
484 with the given prefix. The previous such value, if any, is freed
485 at this time.
486 */
487
488static char *
489lookupname (transp, val, prefix)
490 struct trans *transp;
491 unsigned int val;
492 char *prefix;
493{
494 static char *locbuf;
495 char *name;
496
497 for (name = NULL; transp -> name != NULL; transp++)
498 {
499 if (transp -> value == val)
500 {
501 name = transp -> name;
502 break;
503 }
504 }
505
506 /* Didn't find a translation for the specified value, build a default
507 one using the specified prefix and return it. The lifetime of
508 the value is only until the next one is needed. */
509
510 if (name == NULL)
511 {
512 if (locbuf != NULL)
513 {
514 free (locbuf);
515 }
516 locbuf = xmalloc (strlen (prefix) + 16);
4ed3a9ea 517 sprintf (locbuf, "%s %u", prefix, val);
cc221e76
FF		 518 name = locbuf;
519 }
520 return (name);
521}
522
523static char *
524sigcodename (sip)
525 siginfo_t *sip;
526{
527 struct sigcode *scp;
528 char *name = NULL;
529 static char locbuf[32];
530
531 for (scp = siginfo_table; scp -> codename != NULL; scp++)
532 {
533 if ((scp -> signo == sip -> si_signo) &&
534 (scp -> code == sip -> si_code))
535 {
536 name = scp -> codename;
537 break;
538 }
539 }
540 if (name == NULL)
541 {
4ed3a9ea 542 sprintf (locbuf, "sigcode %u", sip -> si_signo);
cc221e76
FF		 543 name = locbuf;
544 }
545 return (name);
546}
547
548static char *sigcodedesc (sip)
549 siginfo_t *sip;
550{
551 struct sigcode *scp;
552 char *desc = NULL;
553
554 for (scp = siginfo_table; scp -> codename != NULL; scp++)
555 {
556 if ((scp -> signo == sip -> si_signo) &&
557 (scp -> code == sip -> si_code))
558 {
559 desc = scp -> desc;
560 break;
561 }
562 }
563 if (desc == NULL)
564 {
565 desc = "Unrecognized signal or trap use";
566 }
567 return (desc);
568}
569
570/*
571
572LOCAL FUNCTION
573
574 syscallname - translate a system call number into a system call name
575
576SYNOPSIS
577
578 char *syscallname (int syscallnum)
579
580DESCRIPTION
581
582 Given a system call number, translate it into the printable name
583 of a system call, or into "syscall <num>" if it is an unknown
584 number.
585 */
586
587static char *
588syscallname (syscallnum)
589 int syscallnum;
590{
591 static char locbuf[32];
592 char *rtnval;
593
594 if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS)
595 {
596 rtnval = syscall_table[syscallnum];
597 }
598 else
599 {
4ed3a9ea 600 sprintf (locbuf, "syscall %u", syscallnum);
cc221e76
FF		 601 rtnval = locbuf;
602 }
603 return (rtnval);
604}
605
606/*
607
608LOCAL FUNCTION
609
610 init_syscall_table - initialize syscall translation table
611
612SYNOPSIS
613
614 void init_syscall_table (void)
615
616DESCRIPTION
617
618 Dynamically initialize the translation table to convert system
619 call numbers into printable system call names. Done once per
620 gdb run, on initialization.
621
622NOTES
623
624 This is awfully ugly, but preprocessor tricks to make it prettier
625 tend to be nonportable.
626 */
627
628static void
629init_syscall_table ()
630{
cc221e76
FF		 631#if defined (SYS_exit)
632 syscall_table[SYS_exit] = "exit";
633#endif
634#if defined (SYS_fork)
635 syscall_table[SYS_fork] = "fork";
636#endif
637#if defined (SYS_read)
638 syscall_table[SYS_read] = "read";
639#endif
640#if defined (SYS_write)
641 syscall_table[SYS_write] = "write";
642#endif
643#if defined (SYS_open)
644 syscall_table[SYS_open] = "open";
645#endif
646#if defined (SYS_close)
647 syscall_table[SYS_close] = "close";
648#endif
649#if defined (SYS_wait)
650 syscall_table[SYS_wait] = "wait";
651#endif
652#if defined (SYS_creat)
653 syscall_table[SYS_creat] = "creat";
654#endif
655#if defined (SYS_link)
656 syscall_table[SYS_link] = "link";
657#endif
658#if defined (SYS_unlink)
659 syscall_table[SYS_unlink] = "unlink";
660#endif
661#if defined (SYS_exec)
662 syscall_table[SYS_exec] = "exec";
663#endif
664#if defined (SYS_execv)
665 syscall_table[SYS_execv] = "execv";
666#endif
667#if defined (SYS_execve)
668 syscall_table[SYS_execve] = "execve";
669#endif
670#if defined (SYS_chdir)
671 syscall_table[SYS_chdir] = "chdir";
672#endif
673#if defined (SYS_time)
674 syscall_table[SYS_time] = "time";
675#endif
676#if defined (SYS_mknod)
677 syscall_table[SYS_mknod] = "mknod";
678#endif
679#if defined (SYS_chmod)
680 syscall_table[SYS_chmod] = "chmod";
681#endif
682#if defined (SYS_chown)
683 syscall_table[SYS_chown] = "chown";
684#endif
685#if defined (SYS_brk)
686 syscall_table[SYS_brk] = "brk";
687#endif
688#if defined (SYS_stat)
689 syscall_table[SYS_stat] = "stat";
690#endif
691#if defined (SYS_lseek)
692 syscall_table[SYS_lseek] = "lseek";
693#endif
694#if defined (SYS_getpid)
695 syscall_table[SYS_getpid] = "getpid";
696#endif
697#if defined (SYS_mount)
698 syscall_table[SYS_mount] = "mount";
699#endif
700#if defined (SYS_umount)
701 syscall_table[SYS_umount] = "umount";
702#endif
703#if defined (SYS_setuid)
704 syscall_table[SYS_setuid] = "setuid";
705#endif
706#if defined (SYS_getuid)
707 syscall_table[SYS_getuid] = "getuid";
708#endif
709#if defined (SYS_stime)
710 syscall_table[SYS_stime] = "stime";
711#endif
712#if defined (SYS_ptrace)
713 syscall_table[SYS_ptrace] = "ptrace";
714#endif
715#if defined (SYS_alarm)
716 syscall_table[SYS_alarm] = "alarm";
717#endif
718#if defined (SYS_fstat)
719 syscall_table[SYS_fstat] = "fstat";
720#endif
721#if defined (SYS_pause)
722 syscall_table[SYS_pause] = "pause";
723#endif
724#if defined (SYS_utime)
725 syscall_table[SYS_utime] = "utime";
726#endif
727#if defined (SYS_stty)
728 syscall_table[SYS_stty] = "stty";
729#endif
730#if defined (SYS_gtty)
731 syscall_table[SYS_gtty] = "gtty";
732#endif
733#if defined (SYS_access)
734 syscall_table[SYS_access] = "access";
735#endif
736#if defined (SYS_nice)
737 syscall_table[SYS_nice] = "nice";
738#endif
739#if defined (SYS_statfs)
740 syscall_table[SYS_statfs] = "statfs";
741#endif
742#if defined (SYS_sync)
743 syscall_table[SYS_sync] = "sync";
744#endif
745#if defined (SYS_kill)
746 syscall_table[SYS_kill] = "kill";
747#endif
748#if defined (SYS_fstatfs)
749 syscall_table[SYS_fstatfs] = "fstatfs";
750#endif
751#if defined (SYS_pgrpsys)
752 syscall_table[SYS_pgrpsys] = "pgrpsys";
753#endif
754#if defined (SYS_xenix)
755 syscall_table[SYS_xenix] = "xenix";
756#endif
757#if defined (SYS_dup)
758 syscall_table[SYS_dup] = "dup";
759#endif
760#if defined (SYS_pipe)
761 syscall_table[SYS_pipe] = "pipe";
762#endif
763#if defined (SYS_times)
764 syscall_table[SYS_times] = "times";
765#endif
766#if defined (SYS_profil)
767 syscall_table[SYS_profil] = "profil";
768#endif
769#if defined (SYS_plock)
770 syscall_table[SYS_plock] = "plock";
771#endif
772#if defined (SYS_setgid)
773 syscall_table[SYS_setgid] = "setgid";
774#endif
775#if defined (SYS_getgid)
776 syscall_table[SYS_getgid] = "getgid";
777#endif
778#if defined (SYS_signal)
779 syscall_table[SYS_signal] = "signal";
780#endif
781#if defined (SYS_msgsys)
782 syscall_table[SYS_msgsys] = "msgsys";
783#endif
784#if defined (SYS_sys3b)
785 syscall_table[SYS_sys3b] = "sys3b";
786#endif
787#if defined (SYS_acct)
788 syscall_table[SYS_acct] = "acct";
789#endif
790#if defined (SYS_shmsys)
791 syscall_table[SYS_shmsys] = "shmsys";
792#endif
793#if defined (SYS_semsys)
794 syscall_table[SYS_semsys] = "semsys";
795#endif
796#if defined (SYS_ioctl)
797 syscall_table[SYS_ioctl] = "ioctl";
798#endif
799#if defined (SYS_uadmin)
800 syscall_table[SYS_uadmin] = "uadmin";
801#endif
802#if defined (SYS_utssys)
803 syscall_table[SYS_utssys] = "utssys";
804#endif
805#if defined (SYS_fsync)
806 syscall_table[SYS_fsync] = "fsync";
807#endif
808#if defined (SYS_umask)
809 syscall_table[SYS_umask] = "umask";
810#endif
811#if defined (SYS_chroot)
812 syscall_table[SYS_chroot] = "chroot";
813#endif
814#if defined (SYS_fcntl)
815 syscall_table[SYS_fcntl] = "fcntl";
816#endif
817#if defined (SYS_ulimit)
818 syscall_table[SYS_ulimit] = "ulimit";
819#endif
820#if defined (SYS_rfsys)
821 syscall_table[SYS_rfsys] = "rfsys";
822#endif
823#if defined (SYS_rmdir)
824 syscall_table[SYS_rmdir] = "rmdir";
825#endif
826#if defined (SYS_mkdir)
827 syscall_table[SYS_mkdir] = "mkdir";
828#endif
829#if defined (SYS_getdents)
830 syscall_table[SYS_getdents] = "getdents";
831#endif
832#if defined (SYS_sysfs)
833 syscall_table[SYS_sysfs] = "sysfs";
834#endif
835#if defined (SYS_getmsg)
836 syscall_table[SYS_getmsg] = "getmsg";
837#endif
838#if defined (SYS_putmsg)
839 syscall_table[SYS_putmsg] = "putmsg";
840#endif
841#if defined (SYS_poll)
842 syscall_table[SYS_poll] = "poll";
843#endif
844#if defined (SYS_lstat)
845 syscall_table[SYS_lstat] = "lstat";
846#endif
847#if defined (SYS_symlink)
848 syscall_table[SYS_symlink] = "symlink";
849#endif
850#if defined (SYS_readlink)
851 syscall_table[SYS_readlink] = "readlink";
852#endif
853#if defined (SYS_setgroups)
854 syscall_table[SYS_setgroups] = "setgroups";
855#endif
856#if defined (SYS_getgroups)
857 syscall_table[SYS_getgroups] = "getgroups";
858#endif
859#if defined (SYS_fchmod)
860 syscall_table[SYS_fchmod] = "fchmod";
861#endif
862#if defined (SYS_fchown)
863 syscall_table[SYS_fchown] = "fchown";
864#endif
865#if defined (SYS_sigprocmask)
866 syscall_table[SYS_sigprocmask] = "sigprocmask";
867#endif
868#if defined (SYS_sigsuspend)
869 syscall_table[SYS_sigsuspend] = "sigsuspend";
870#endif
871#if defined (SYS_sigaltstack)
872 syscall_table[SYS_sigaltstack] = "sigaltstack";
873#endif
874#if defined (SYS_sigaction)
875 syscall_table[SYS_sigaction] = "sigaction";
876#endif
877#if defined (SYS_sigpending)
878 syscall_table[SYS_sigpending] = "sigpending";
879#endif
880#if defined (SYS_context)
881 syscall_table[SYS_context] = "context";
882#endif
883#if defined (SYS_evsys)
884 syscall_table[SYS_evsys] = "evsys";
885#endif
886#if defined (SYS_evtrapret)
887 syscall_table[SYS_evtrapret] = "evtrapret";
888#endif
889#if defined (SYS_statvfs)
890 syscall_table[SYS_statvfs] = "statvfs";
891#endif
892#if defined (SYS_fstatvfs)
893 syscall_table[SYS_fstatvfs] = "fstatvfs";
894#endif
895#if defined (SYS_nfssys)
896 syscall_table[SYS_nfssys] = "nfssys";
897#endif
898#if defined (SYS_waitsys)
899 syscall_table[SYS_waitsys] = "waitsys";
900#endif
901#if defined (SYS_sigsendsys)
902 syscall_table[SYS_sigsendsys] = "sigsendsys";
903#endif
904#if defined (SYS_hrtsys)
905 syscall_table[SYS_hrtsys] = "hrtsys";
906#endif
907#if defined (SYS_acancel)
908 syscall_table[SYS_acancel] = "acancel";
909#endif
910#if defined (SYS_async)
911 syscall_table[SYS_async] = "async";
912#endif
913#if defined (SYS_priocntlsys)
914 syscall_table[SYS_priocntlsys] = "priocntlsys";
915#endif
916#if defined (SYS_pathconf)
917 syscall_table[SYS_pathconf] = "pathconf";
918#endif
919#if defined (SYS_mincore)
920 syscall_table[SYS_mincore] = "mincore";
921#endif
922#if defined (SYS_mmap)
923 syscall_table[SYS_mmap] = "mmap";
924#endif
925#if defined (SYS_mprotect)
926 syscall_table[SYS_mprotect] = "mprotect";
927#endif
928#if defined (SYS_munmap)
929 syscall_table[SYS_munmap] = "munmap";
930#endif
931#if defined (SYS_fpathconf)
932 syscall_table[SYS_fpathconf] = "fpathconf";
933#endif
934#if defined (SYS_vfork)
935 syscall_table[SYS_vfork] = "vfork";
936#endif
937#if defined (SYS_fchdir)
938 syscall_table[SYS_fchdir] = "fchdir";
939#endif
940#if defined (SYS_readv)
941 syscall_table[SYS_readv] = "readv";
942#endif
943#if defined (SYS_writev)
944 syscall_table[SYS_writev] = "writev";
945#endif
946#if defined (SYS_xstat)
947 syscall_table[SYS_xstat] = "xstat";
948#endif
949#if defined (SYS_lxstat)
950 syscall_table[SYS_lxstat] = "lxstat";
951#endif
952#if defined (SYS_fxstat)
953 syscall_table[SYS_fxstat] = "fxstat";
954#endif
955#if defined (SYS_xmknod)
956 syscall_table[SYS_xmknod] = "xmknod";
957#endif
958#if defined (SYS_clocal)
959 syscall_table[SYS_clocal] = "clocal";
960#endif
961#if defined (SYS_setrlimit)
962 syscall_table[SYS_setrlimit] = "setrlimit";
963#endif
964#if defined (SYS_getrlimit)
965 syscall_table[SYS_getrlimit] = "getrlimit";
966#endif
967#if defined (SYS_lchown)
968 syscall_table[SYS_lchown] = "lchown";
969#endif
970#if defined (SYS_memcntl)
971 syscall_table[SYS_memcntl] = "memcntl";
972#endif
973#if defined (SYS_getpmsg)
974 syscall_table[SYS_getpmsg] = "getpmsg";
975#endif
976#if defined (SYS_putpmsg)
977 syscall_table[SYS_putpmsg] = "putpmsg";
978#endif
979#if defined (SYS_rename)
980 syscall_table[SYS_rename] = "rename";
981#endif
982#if defined (SYS_uname)
983 syscall_table[SYS_uname] = "uname";
984#endif
985#if defined (SYS_setegid)
986 syscall_table[SYS_setegid] = "setegid";
987#endif
988#if defined (SYS_sysconfig)
989 syscall_table[SYS_sysconfig] = "sysconfig";
990#endif
991#if defined (SYS_adjtime)
992 syscall_table[SYS_adjtime] = "adjtime";
993#endif
994#if defined (SYS_systeminfo)
995 syscall_table[SYS_systeminfo] = "systeminfo";
996#endif
997#if defined (SYS_seteuid)
998 syscall_table[SYS_seteuid] = "seteuid";
999#endif
1000}
35f5886e
FF		 1001
1002/*
1003
1004GLOBAL FUNCTION
1005
1006 ptrace -- override library version to force errors for /proc version
1007
1008SYNOPSIS
1009
e676a15f 1010 int ptrace (int request, int pid, PTRACE_ARG3_TYPE arg3, int arg4)
35f5886e
FF		 1011
1012DESCRIPTION
1013
1014 When gdb is configured to use /proc, it should not be calling
1015 or otherwise attempting to use ptrace. In order to catch errors
1016 where use of /proc is configured, but some routine is still calling
1017 ptrace, we provide a local version of a function with that name
1018 that does nothing but issue an error message.
1019*/
1020
1021int
1ab3bf1b
JG		 1022ptrace (request, pid, arg3, arg4)
1023 int request;
1024 int pid;
e676a15f 1025 PTRACE_ARG3_TYPE arg3;
1ab3bf1b 1026 int arg4;
35f5886e
FF		 1027{
1028 error ("internal error - there is a call to ptrace() somewhere");
1029 /*NOTREACHED*/
1030}
1031
1032/*
1033
35f5886e
FF		 1034GLOBAL FUNCTION
1035
1036 kill_inferior - kill any currently inferior
1037
1038SYNOPSIS
1039
1040 void kill_inferior (void)
1041
1042DESCRIPTION
1043
1044 Kill any current inferior.
1045
1046NOTES
1047
1048 Kills even attached inferiors. Presumably the user has already
1049 been prompted that the inferior is an attached one rather than
1050 one started by gdb. (FIXME?)
1051
1052*/
1053
1054void
1ab3bf1b 1055kill_inferior ()
35f5886e
FF		 1056{
1057 if (inferior_pid != 0)
1058 {
1059 unconditionally_kill_inferior ();
1060 target_mourn_inferior ();
1061 }
1062}
1063
1064/*
1065
1066LOCAL FUNCTION
1067
1068 unconditionally_kill_inferior - terminate the inferior
1069
1070SYNOPSIS
1071
1072 static void unconditionally_kill_inferior (void)
1073
1074DESCRIPTION
1075
1076 Kill the current inferior. Should not be called until it
1077 is at least tested that there is an inferior.
1078
1079NOTE
1080
1081 A possibly useful enhancement would be to first try sending
1082 the inferior a terminate signal, politely asking it to commit
1083 suicide, before we murder it.
1084
1085*/
1086
1087static void
1ab3bf1b 1088unconditionally_kill_inferior ()
35f5886e
FF		 1089{
1090 int signo;
1091
1092 signo = SIGKILL;
4ed3a9ea 1093 ioctl (pi.fd, PIOCKILL, &signo);
a39ad5ce 1094 close_proc_file (&pi);
35f5886e
FF		 1095 wait ((int *) 0);
1096}
1097
1098/*
1099
1100GLOBAL FUNCTION
1101
1102 child_xfer_memory -- copy data to or from inferior memory space
1103
1104SYNOPSIS
1105
1106 int child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1107 int dowrite, struct target_ops target)
1108
1109DESCRIPTION
1110
1111 Copy LEN bytes to/from inferior's memory starting at MEMADDR
1112 from/to debugger memory starting at MYADDR. Copy from inferior
1113 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
1114
1115 Returns the length copied, which is either the LEN argument or
1116 zero. This xfer function does not do partial moves, since child_ops
1117 doesn't allow memory operations to cross below us in the target stack
1118 anyway.
1119
1120NOTES
1121
1122 The /proc interface makes this an almost trivial task.
1123 */
1124
1125
1126int
1ab3bf1b
JG		 1127child_xfer_memory (memaddr, myaddr, len, dowrite, target)
1128 CORE_ADDR memaddr;
1129 char *myaddr;
1130 int len;
1131 int dowrite;
1132 struct target_ops *target; /* ignored */
35f5886e
FF		 1133{
1134 int nbytes = 0;
1135
1136 if (lseek (pi.fd, (off_t) memaddr, 0) == (off_t) memaddr)
1137 {
1138 if (dowrite)
1139 {
1140 nbytes = write (pi.fd, myaddr, len);
1141 }
1142 else
1143 {
1144 nbytes = read (pi.fd, myaddr, len);
1145 }
1146 if (nbytes < 0)
1147 {
1148 nbytes = 0;
1149 }
1150 }
1151 return (nbytes);
1152}
1153
1154/*
1155
1156GLOBAL FUNCTION
1157
1158 store_inferior_registers -- copy register values back to inferior
1159
1160SYNOPSIS
1161
1162 void store_inferior_registers (int regno)
1163
1164DESCRIPTION
1165
1166 Store our current register values back into the inferior. If
1167 REGNO is -1 then store all the register, otherwise store just
1168 the value specified by REGNO.
1169
1170NOTES
1171
1172 If we are storing only a single register, we first have to get all
1173 the current values from the process, overwrite the desired register
1174 in the gregset with the one we want from gdb's registers, and then
1175 send the whole set back to the process. For writing all the
1176 registers, all we have to do is generate the gregset and send it to
1177 the process.
1178
1179 Also note that the process has to be stopped on an event of interest
1180 for this to work, which basically means that it has to have been
1181 run under the control of one of the other /proc ioctl calls and not
1182 ptrace. Since we don't use ptrace anyway, we don't worry about this
1183 fine point, but it is worth noting for future reference.
1184
1185 Gdb is confused about what this function is supposed to return.
1186 Some versions return a value, others return nothing. Some are
1187 declared to return a value and actually return nothing. Gdb ignores
1188 anything returned. (FIXME)
1189
1190 */
1191
1192void
1ab3bf1b
JG		 1193store_inferior_registers (regno)
1194 int regno;
35f5886e
FF		 1195{
1196 if (regno != -1)
1197 {
4ed3a9ea 1198 ioctl (pi.fd, PIOCGREG, &pi.gregset);
35f5886e
FF		 1199 }
1200 fill_gregset (&pi.gregset, regno);
4ed3a9ea 1201 ioctl (pi.fd, PIOCSREG, &pi.gregset);
35f5886e
FF		 1202
1203#if defined (FP0_REGNUM)
1204
1205 /* Now repeat everything using the floating point register set, if the
1206 target has floating point hardware. Since we ignore the returned value,
1207 we'll never know whether it worked or not anyway. */
1208
1209 if (regno != -1)
1210 {
4ed3a9ea 1211 ioctl (pi.fd, PIOCGFPREG, &pi.fpregset);
35f5886e
FF		 1212 }
1213 fill_fpregset (&pi.fpregset, regno);
4ed3a9ea 1214 ioctl (pi.fd, PIOCSFPREG, &pi.fpregset);
35f5886e
FF		 1215
1216#endif /* FP0_REGNUM */
1217
1218}
1219
1220/*
1221
1222GLOBAL FUNCTION
1223
1224 inferior_proc_init - initialize access to a /proc entry
1225
1226SYNOPSIS
1227
1228 void inferior_proc_init (int pid)
1229
1230DESCRIPTION
1231
1232 When gdb starts an inferior, this function is called in the parent
1233 process immediately after the fork. It waits for the child to stop
1234 on the return from the exec system call (the child itself takes care
1235 of ensuring that this is set up), then sets up the set of signals
1236 and faults that are to be traced.
1237
1238NOTES
1239
1240 If proc_init_failed ever gets called, control returns to the command
1241 processing loop via the standard error handling code.
cc221e76 1242
35f5886e
FF		 1243 */
1244
1245void
1ab3bf1b
JG		 1246inferior_proc_init (pid)
1247 int pid;
35f5886e 1248{
ec8ceca3 1249 if (!open_proc_file (pid, &pi, O_RDWR))
35f5886e
FF		 1250 {
1251 proc_init_failed ("can't open process file");
1252 }
1253 else
1254 {
4ed3a9ea 1255 memset ((char *) &pi.prrun, 0, sizeof (pi.prrun));
35f5886e 1256 prfillset (&pi.prrun.pr_trace);
cc221e76 1257 proc_signal_handling_change ();
35f5886e
FF		 1258 prfillset (&pi.prrun.pr_fault);
1259 prdelset (&pi.prrun.pr_fault, FLTPAGE);
1260 if (ioctl (pi.fd, PIOCWSTOP, &pi.prstatus) < 0)
1261 {
1262 proc_init_failed ("PIOCWSTOP failed");
1263 }
35f5886e
FF		 1264 else if (ioctl (pi.fd, PIOCSFAULT, &pi.prrun.pr_fault) < 0)
1265 {
1266 proc_init_failed ("PIOCSFAULT failed");
1267 }
1268 }
1269}
1270
1271/*
1272
cc221e76
FF		 1273GLOBAL FUNCTION
1274
1275 proc_signal_handling_change
1276
1277SYNOPSIS
1278
1279 void proc_signal_handling_change (void);
1280
1281DESCRIPTION
1282
1283 When the user changes the state of gdb's signal handling via the
1284 "handle" command, this function gets called to see if any change
1285 in the /proc interface is required. It is also called internally
1286 by other /proc interface functions to initialize the state of
1287 the traced signal set.
1288
1289 One thing it does is that signals for which the state is "nostop",
1290 "noprint", and "pass", have their trace bits reset in the pr_trace
1291 field, so that they are no longer traced. This allows them to be
1292 delivered directly to the inferior without the debugger ever being
1293 involved.
1294 */
1295
1296void
1297proc_signal_handling_change ()
1298{
1299 int signo;
1300
1301 if (pi.valid)
1302 {
1303 for (signo = 0; signo < NSIG; signo++)
1304 {
1305 if (signal_stop_state (signo) == 0 &&
1306 signal_print_state (signo) == 0 &&
1307 signal_pass_state (signo) == 1)
1308 {
1309 prdelset (&pi.prrun.pr_trace, signo);
1310 }
1311 else
1312 {
1313 praddset (&pi.prrun.pr_trace, signo);
1314 }
1315 }
1316 if (ioctl (pi.fd, PIOCSTRACE, &pi.prrun.pr_trace))
1317 {
1318 print_sys_errmsg ("PIOCSTRACE failed", errno);
1319 }
1320 }
1321}
1322
1323/*
1324
35f5886e
FF		 1325GLOBAL FUNCTION
1326
1327 proc_set_exec_trap -- arrange for exec'd child to halt at startup
1328
1329SYNOPSIS
1330
1331 void proc_set_exec_trap (void)
1332
1333DESCRIPTION
1334
1335 This function is called in the child process when starting up
1336 an inferior, prior to doing the exec of the actual inferior.
1337 It sets the child process's exitset to make exit from the exec
1338 system call an event of interest to stop on, and then simply
1339 returns. The child does the exec, the system call returns, and
1340 the child stops at the first instruction, ready for the gdb
1341 parent process to take control of it.
1342
1343NOTE
1344
1345 We need to use all local variables since the child may be sharing
1346 it's data space with the parent, if vfork was used rather than
1347 fork.
cc221e76
FF		 1348
1349 Also note that we want to turn off the inherit-on-fork flag in
1350 the child process so that any grand-children start with all
1351 tracing flags cleared.
35f5886e
FF		 1352 */
1353
1354void
1ab3bf1b 1355proc_set_exec_trap ()
35f5886e
FF		 1356{
1357 sysset_t exitset;
1358 auto char procname[32];
1359 int fd;
1360
4ed3a9ea 1361 sprintf (procname, PROC_NAME_FMT, getpid ());
35f5886e
FF		 1362 if ((fd = open (procname, O_RDWR)) < 0)
1363 {
1364 perror (procname);
1365 fflush (stderr);
1366 _exit (127);
1367 }
1368 premptyset (&exitset);
407a8389 1369
cc221e76
FF		 1370 /* GW: Rationale...
1371 Not all systems with /proc have all the exec* syscalls with the same
1372 names. On the SGI, for example, there is no SYS_exec, but there
1373 *is* a SYS_execv. So, we try to account for that. */
1374
407a8389 1375#ifdef SYS_exec
35f5886e 1376 praddset (&exitset, SYS_exec);
407a8389
SG		 1377#endif
1378#ifdef SYS_execve
35f5886e 1379 praddset (&exitset, SYS_execve);
407a8389
SG		 1380#endif
1381#ifdef SYS_execv
1382 praddset(&exitset, SYS_execv);
1383#endif
1384
35f5886e
FF		 1385 if (ioctl (fd, PIOCSEXIT, &exitset) < 0)
1386 {
1387 perror (procname);
1388 fflush (stderr);
1389 _exit (127);
1390 }
cc221e76
FF		 1391
1392 /* Turn off inherit-on-fork flag so that all grand-children of gdb
1393 start with tracing flags cleared. */
1394
5c1c5e67 1395#if defined (PIOCRESET) /* New method */
cc221e76
FF		 1396 {
1397 long pr_flags;
1398 pr_flags = PR_FORK;
4ed3a9ea 1399 ioctl (fd, PIOCRESET, &pr_flags);
cc221e76 1400 }
5c1c5e67
FF		 1401#else
1402#if defined (PIOCRFORK) /* Original method */
4ed3a9ea 1403 ioctl (fd, PIOCRFORK, NULL);
cc221e76 1404#endif
ec8ceca3
JG		 1405#endif
1406
1407 /* Turn on run-on-last-close flag so that this process will not hang
1408 if GDB goes away for some reason. */
1409
1410#if defined (PIOCSET) /* New method */
1411 {
1412 long pr_flags;
1413 pr_flags = PR_RLC;
1414 (void) ioctl (fd, PIOCSET, &pr_flags);
1415 }
1416#else
1417#if defined (PIOCSRLC) /* Original method */
1418 (void) ioctl (fd, PIOCSRLC, 0);
1419#endif
cc221e76 1420#endif
35f5886e
FF		 1421}
1422
f8b76e70
FF		 1423/*
1424
a39ad5ce
FF		 1425GLOBAL FUNCTION
1426
1427 proc_iterate_over_mappings -- call function for every mapped space
1428
1429SYNOPSIS
1430
1431 int proc_iterate_over_mappings (int (*func)())
1432
1433DESCRIPTION
1434
1435 Given a pointer to a function, call that function for every
1436 mapped address space, passing it an open file descriptor for
1437 the file corresponding to that mapped address space (if any)
1438 and the base address of the mapped space. Quit when we hit
1439 the end of the mappings or the function returns nonzero.
1440 */
1441
1442int
1ab3bf1b
JG		 1443proc_iterate_over_mappings (func)
1444 int (*func) PARAMS ((int, CORE_ADDR));
a39ad5ce
FF		 1445{
1446 int nmap;
1447 int fd;
1448 int funcstat = 0;
1449 struct prmap *prmaps;
1450 struct prmap *prmap;
a39ad5ce
FF		 1451
1452 if (pi.valid && (ioctl (pi.fd, PIOCNMAP, &nmap) == 0))
1453 {
1ab3bf1b 1454 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
a39ad5ce
FF		 1455 if (ioctl (pi.fd, PIOCMAP, prmaps) == 0)
1456 {
1457 for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
1458 {
1ab3bf1b
JG		 1459 fd = proc_address_to_fd ((CORE_ADDR) prmap -> pr_vaddr, 0);
1460 funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
a39ad5ce
FF		 1461 close (fd);
1462 }
1463 }
1464 }
1465 return (funcstat);
1466}
1467
1468/*
1469
f8b76e70
FF		 1470GLOBAL FUNCTION
1471
1472 proc_base_address -- find base address for segment containing address
1473
1474SYNOPSIS
1475
1476 CORE_ADDR proc_base_address (CORE_ADDR addr)
1477
1478DESCRIPTION
1479
1480 Given an address of a location in the inferior, find and return
1481 the base address of the mapped segment containing that address.
1482
1483 This is used for example, by the shared library support code,
1484 where we have the pc value for some location in the shared library
1485 where we are stopped, and need to know the base address of the
1486 segment containing that address.
1487*/
1488
1489
1ab3bf1b
JG		 1490#if 0 /* Currently unused */
1491
f8b76e70 1492CORE_ADDR
1ab3bf1b 1493proc_base_address (addr)
cc221e76 1494 CORE_ADDR addr;
f8b76e70
FF		 1495{
1496 int nmap;
1497 struct prmap *prmaps;
1498 struct prmap *prmap;
1499 CORE_ADDR baseaddr = 0;
1500
a39ad5ce 1501 if (pi.valid && (ioctl (pi.fd, PIOCNMAP, &nmap) == 0))
f8b76e70 1502 {
1ab3bf1b 1503 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
f8b76e70
FF		 1504 if (ioctl (pi.fd, PIOCMAP, prmaps) == 0)
1505 {
1506 for (prmap = prmaps; prmap -> pr_size; ++prmap)
1507 {
1508 if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
1509 (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
1510 {
1511 baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
1512 break;
1513 }
1514 }
1515 }
1516 }
1517 return (baseaddr);
1518}
1519
1ab3bf1b
JG		 1520#endif /* 0 */
1521
f8b76e70
FF		 1522/*
1523
cc221e76 1524LOCAL FUNCTION
f8b76e70
FF		 1525
1526 proc_address_to_fd -- return open fd for file mapped to address
1527
1528SYNOPSIS
1529
a39ad5ce 1530 int proc_address_to_fd (CORE_ADDR addr, complain)
f8b76e70
FF		 1531
1532DESCRIPTION
1533
1534 Given an address in the current inferior's address space, use the
1535 /proc interface to find an open file descriptor for the file that
1536 this address was mapped in from. Return -1 if there is no current
1537 inferior. Print a warning message if there is an inferior but
1538 the address corresponds to no file (IE a bogus address).
1539
1540*/
1541
1ab3bf1b
JG		 1542static int
1543proc_address_to_fd (addr, complain)
1544 CORE_ADDR addr;
1545 int complain;
f8b76e70
FF		 1546{
1547 int fd = -1;
1548
1549 if (pi.valid)
1550 {
1551 if ((fd = ioctl (pi.fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
1552 {
a39ad5ce
FF		 1553 if (complain)
1554 {
1555 print_sys_errmsg (pi.pathname, errno);
1556 warning ("can't find mapped file for address 0x%x", addr);
1557 }
f8b76e70
FF		 1558 }
1559 }
1560 return (fd);
1561}
1562
35f5886e
FF		 1563
1564#ifdef ATTACH_DETACH
1565
1566/*
1567
1568GLOBAL FUNCTION
1569
1570 attach -- attach to an already existing process
1571
1572SYNOPSIS
1573
1574 int attach (int pid)
1575
1576DESCRIPTION
1577
1578 Attach to an already existing process with the specified process
1579 id. If the process is not already stopped, query whether to
1580 stop it or not.
1581
1582NOTES
1583
1584 The option of stopping at attach time is specific to the /proc
1585 versions of gdb. Versions using ptrace force the attachee
ec8ceca3
JG		 1586 to stop. (I have changed this version to do so, too. All you
1587 have to do is "continue" to make it go on. -- gnu@cygnus.com)
35f5886e
FF		 1588
1589*/
1590
1591int
1ab3bf1b
JG		 1592attach (pid)
1593 int pid;
35f5886e 1594{
ec8ceca3
JG		 1595 int result;
1596
1597 if (!open_proc_file (pid, &pi, O_RDWR))
35f5886e
FF		 1598 {
1599 perror_with_name (pi.pathname);
1600 /* NOTREACHED */
1601 }
1602
1603 /* Get current status of process and if it is not already stopped,
1604 then stop it. Remember whether or not it was stopped when we first
1605 examined it. */
1606
1607 if (ioctl (pi.fd, PIOCSTATUS, &pi.prstatus) < 0)
1608 {
1609 print_sys_errmsg (pi.pathname, errno);
a39ad5ce 1610 close_proc_file (&pi);
35f5886e
FF		 1611 error ("PIOCSTATUS failed");
1612 }
1613 if (pi.prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
1614 {
1615 pi.was_stopped = 1;
1616 }
1617 else
1618 {
1619 pi.was_stopped = 0;
ec8ceca3 1620 if (1 || query ("Process is currently running, stop it? "))
35f5886e 1621 {
ec8ceca3
JG		 1622 /* Make it run again when we close it. */
1623#if defined (PIOCSET) /* New method */
1624 {
1625 long pr_flags;
1626 pr_flags = PR_RLC;
1627 result = ioctl (pi.fd, PIOCSET, &pr_flags);
1628 }
1629#else
1630#if defined (PIOCSRLC) /* Original method */
1631 result = ioctl (pi.fd, PIOCSRLC, 0);
1632#endif
1633#endif
1634 if (result < 0)
1635 {
1636 print_sys_errmsg (pi.pathname, errno);
1637 close_proc_file (&pi);
1638 error ("PIOCSRLC or PIOCSET failed");
1639 }
35f5886e
FF		 1640 if (ioctl (pi.fd, PIOCSTOP, &pi.prstatus) < 0)
1641 {
1642 print_sys_errmsg (pi.pathname, errno);
a39ad5ce 1643 close_proc_file (&pi);
35f5886e
FF		 1644 error ("PIOCSTOP failed");
1645 }
d65eee73
FF		 1646 pi.nopass_next_sigstop = 1;
1647 }
1648 else
1649 {
1650 printf ("Ok, gdb will wait for process %u to stop.\n", pid);
35f5886e
FF		 1651 }
1652 }
ec8ceca3 1653
35f5886e
FF		 1654 /* Remember some things about the inferior that we will, or might, change
1655 so that we can restore them when we detach. */
1656
4ed3a9ea
FF		 1657 ioctl (pi.fd, PIOCGTRACE, &pi.saved_trace);
1658 ioctl (pi.fd, PIOCGHOLD, &pi.saved_sighold);
1659 ioctl (pi.fd, PIOCGFAULT, &pi.saved_fltset);
1660 ioctl (pi.fd, PIOCGENTRY, &pi.saved_entryset);
1661 ioctl (pi.fd, PIOCGEXIT, &pi.saved_exitset);
35f5886e
FF		 1662
1663 /* Set up trace and fault sets, as gdb expects them. */
1664
4ed3a9ea 1665 memset (&pi.prrun, 0, sizeof (pi.prrun));
35f5886e 1666 prfillset (&pi.prrun.pr_trace);
cc221e76 1667 proc_signal_handling_change ();
35f5886e
FF		 1668 prfillset (&pi.prrun.pr_fault);
1669 prdelset (&pi.prrun.pr_fault, FLTPAGE);
1670 if (ioctl (pi.fd, PIOCSFAULT, &pi.prrun.pr_fault))
1671 {
f66f459f 1672 print_sys_errmsg ("PIOCSFAULT failed", errno);
35f5886e
FF		 1673 }
1674 if (ioctl (pi.fd, PIOCSTRACE, &pi.prrun.pr_trace))
1675 {
f66f459f 1676 print_sys_errmsg ("PIOCSTRACE failed", errno);
35f5886e
FF		 1677 }
1678 attach_flag = 1;
1679 return (pid);
1680}
1681
1682/*
1683
1684GLOBAL FUNCTION
1685
1686 detach -- detach from an attached-to process
1687
1688SYNOPSIS
1689
1690 void detach (int signal)
1691
1692DESCRIPTION
1693
1694 Detach from the current attachee.
1695
1696 If signal is non-zero, the attachee is started running again and sent
1697 the specified signal.
1698
1699 If signal is zero and the attachee was not already stopped when we
1700 attached to it, then we make it runnable again when we detach.
1701
1702 Otherwise, we query whether or not to make the attachee runnable
1703 again, since we may simply want to leave it in the state it was in
1704 when we attached.
1705
1706 We report any problems, but do not consider them errors, since we
1707 MUST detach even if some things don't seem to go right. This may not
1708 be the ideal situation. (FIXME).
1709 */
1710
1711void
1ab3bf1b
JG		 1712detach (signal)
1713 int signal;
35f5886e 1714{
ec8ceca3
JG		 1715 int result;
1716
35f5886e
FF		 1717 if (signal)
1718 {
6b801388 1719 set_proc_siginfo (&pi, signal);
35f5886e 1720 }
cc221e76 1721 if (ioctl (pi.fd, PIOCSEXIT, &pi.saved_exitset) < 0)
35f5886e
FF		 1722 {
1723 print_sys_errmsg (pi.pathname, errno);
1724 printf ("PIOCSEXIT failed.\n");
1725 }
cc221e76 1726 if (ioctl (pi.fd, PIOCSENTRY, &pi.saved_entryset) < 0)
35f5886e
FF		 1727 {
1728 print_sys_errmsg (pi.pathname, errno);
1729 printf ("PIOCSENTRY failed.\n");
1730 }
cc221e76 1731 if (ioctl (pi.fd, PIOCSTRACE, &pi.saved_trace) < 0)
35f5886e
FF		 1732 {
1733 print_sys_errmsg (pi.pathname, errno);
1734 printf ("PIOCSTRACE failed.\n");
1735 }
cc221e76
FF		 1736 if (ioctl (pi.fd, PIOCSHOLD, &pi.saved_sighold) < 0)
1737 {
1738 print_sys_errmsg (pi.pathname, errno);
1739 printf ("PIOSCHOLD failed.\n");
1740 }
1741 if (ioctl (pi.fd, PIOCSFAULT, &pi.saved_fltset) < 0)
35f5886e
FF		 1742 {
1743 print_sys_errmsg (pi.pathname, errno);
1744 printf ("PIOCSFAULT failed.\n");
1745 }
1746 if (ioctl (pi.fd, PIOCSTATUS, &pi.prstatus) < 0)
1747 {
1748 print_sys_errmsg (pi.pathname, errno);
1749 printf ("PIOCSTATUS failed.\n");
1750 }
1751 else
1752 {
1753 if (signal || (pi.prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
1754 {
1755 if (signal || !pi.was_stopped ||
1756 query ("Was stopped when attached, make it runnable again? "))
1757 {
ec8ceca3
JG		 1758 /* Clear any fault that might have stopped it. */
1759 if (ioctl (pi.fd, PIOCCFAULT, 0))
1760 {
1761 print_sys_errmsg (pi.pathname, errno);
1762 printf ("PIOCCFAULT failed.\n");
1763 }
1764
1765 /* Make it run again when we close it. */
1766#if defined (PIOCSET) /* New method */
1767 {
1768 long pr_flags;
1769 pr_flags = PR_RLC;
1770 result = ioctl (pi.fd, PIOCSET, &pr_flags);
1771 }
1772#else
1773#if defined (PIOCSRLC) /* Original method */
1774 result = ioctl (pi.fd, PIOCSRLC, 0);
1775#endif
1776#endif
1777 if (result)
35f5886e
FF		 1778 {
1779 print_sys_errmsg (pi.pathname, errno);
ec8ceca3 1780 printf ("PIOCSRLC or PIOCSET failed.\n");
35f5886e
FF		 1781 }
1782 }
1783 }
1784 }
a39ad5ce 1785 close_proc_file (&pi);
35f5886e
FF		 1786 attach_flag = 0;
1787}
1788
fb182850
FF		 1789#endif /* ATTACH_DETACH */
1790
35f5886e
FF		 1791/*
1792
1793GLOBAL FUNCTION
1794
1795 proc_wait -- emulate wait() as much as possible
1796
1797SYNOPSIS
1798
1799 int proc_wait (int *statloc)
1800
1801DESCRIPTION
1802
1803 Try to emulate wait() as much as possible. Not sure why we can't
1804 just use wait(), but it seems to have problems when applied to a
1805 process being controlled with the /proc interface.
1806
1807NOTES
1808
1809 We have a race problem here with no obvious solution. We need to let
1810 the inferior run until it stops on an event of interest, which means
1811 that we need to use the PIOCWSTOP ioctl. However, we cannot use this
1812 ioctl if the process is already stopped on something that is not an
1813 event of interest, or the call will hang indefinitely. Thus we first
1814 use PIOCSTATUS to see if the process is not stopped. If not, then we
1815 use PIOCWSTOP. But during the window between the two, if the process
1816 stops for any reason that is not an event of interest (such as a job
1817 control signal) then gdb will hang. One possible workaround is to set
1818 an alarm to wake up every minute of so and check to see if the process
1819 is still running, and if so, then reissue the PIOCWSTOP. But this is
1820 a real kludge, so has not been implemented. FIXME: investigate
1821 alternatives.
1822
1823 FIXME: Investigate why wait() seems to have problems with programs
1824 being control by /proc routines.
1825
1826 */
1827
1828int
1ab3bf1b
JG		 1829proc_wait (statloc)
1830 int *statloc;
35f5886e
FF		 1831{
1832 short what;
1833 short why;
1834 int statval = 0;
1835 int checkerr = 0;
1836 int rtnval = -1;
1837
1838 if (ioctl (pi.fd, PIOCSTATUS, &pi.prstatus) < 0)
1839 {
1840 checkerr++;
1841 }
1842 else if (!(pi.prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)))
1843 {
1844 if (ioctl (pi.fd, PIOCWSTOP, &pi.prstatus) < 0)
1845 {
1846 checkerr++;
1847 }
1848 }
1849 if (checkerr)
1850 {
1851 if (errno == ENOENT)
1852 {
1853 rtnval = wait (&statval);
1854 if (rtnval != inferior_pid)
1855 {
34da3608 1856 print_sys_errmsg (pi.pathname, errno);
35f5886e
FF		 1857 error ("PIOCWSTOP, wait failed, returned %d", rtnval);
1858 /* NOTREACHED */
1859 }
1860 }
1861 else
1862 {
1863 print_sys_errmsg (pi.pathname, errno);
1864 error ("PIOCSTATUS or PIOCWSTOP failed.");
1865 /* NOTREACHED */
1866 }
1867 }
1868 else if (pi.prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
1869 {
1870 rtnval = pi.prstatus.pr_pid;
1871 why = pi.prstatus.pr_why;
1872 what = pi.prstatus.pr_what;
1873 if (why == PR_SIGNALLED)
1874 {
1875 statval = (what << 8) | 0177;
1876 }
407a8389
SG		 1877 else if ((why == PR_SYSEXIT)
1878 &&
1879 (
1880#ifdef SYS_exec
1881 what == SYS_exec
1882#else
1883 0 == 0
1884#endif
1885#ifdef SYS_execve
1886 || what == SYS_execve
1887#endif
1888#ifdef SYS_execv
1889 || what == SYS_execv
1890#endif
1891 ))
35f5886e
FF		 1892 {
1893 statval = (SIGTRAP << 8) | 0177;
1894 }
1895 else if (why == PR_REQUESTED)
1896 {
1897 statval = (SIGSTOP << 8) | 0177;
1898 }
1899 else if (why == PR_JOBCONTROL)
1900 {
1901 statval = (what << 8) | 0177;
1902 }
1903 else if (why == PR_FAULTED)
1904 {
1905 switch (what)
1906 {
1907 case FLTPRIV:
1908 case FLTILL:
1909 statval = (SIGILL << 8) | 0177;
1910 break;
1911 case FLTBPT:
1912 case FLTTRACE:
1913 statval = (SIGTRAP << 8) | 0177;
1914 break;
1915 case FLTSTACK:
1916 case FLTACCESS:
1917 case FLTBOUNDS:
1918 statval = (SIGSEGV << 8) | 0177;
1919 break;
1920 case FLTIOVF:
1921 case FLTIZDIV:
1922 case FLTFPE:
1923 statval = (SIGFPE << 8) | 0177;
1924 break;
1925 case FLTPAGE: /* Recoverable page fault */
1926 default:
1927 rtnval = -1;
1928 error ("PIOCWSTOP, unknown why %d, what %d", why, what);
1929 /* NOTREACHED */
1930 }
1931 }
1932 else
1933 {
1934 rtnval = -1;
1935 error ("PIOCWSTOP, unknown why %d, what %d", why, what);
1936 /* NOTREACHED */
1937 }
1938 }
1939 else
1940 {
1941 error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
1942 pi.prstatus.pr_flags);
1943 /* NOTREACHED */
1944 }
1945 if (statloc)
1946 {
1947 *statloc = statval;
1948 }
1949 return (rtnval);
1950}
1951
1952/*
1953
6b801388
FF		 1954LOCAL FUNCTION
1955
1956 set_proc_siginfo - set a process's current signal info
1957
1958SYNOPSIS
1959
1960 void set_proc_siginfo (struct procinfo *pip, int signo);
1961
1962DESCRIPTION
1963
1964 Given a pointer to a process info struct in PIP and a signal number
1965 in SIGNO, set the process's current signal and its associated signal
1966 information. The signal will be delivered to the process immediately
1967 after execution is resumed, even if it is being held. In addition,
1968 this particular delivery will not cause another PR_SIGNALLED stop
1969 even if the signal is being traced.
1970
1971 If we are not delivering the same signal that the prstatus siginfo
1972 struct contains information about, then synthesize a siginfo struct
1973 to match the signal we are doing to deliver, make it of the type
1974 "generated by a user process", and send this synthesized copy. When
1975 used to set the inferior's signal state, this will be required if we
1976 are not currently stopped because of a traced signal, or if we decide
1977 to continue with a different signal.
1978
1979 Note that when continuing the inferior from a stop due to receipt
1980 of a traced signal, we either have set PRCSIG to clear the existing
1981 signal, or we have to call this function to do a PIOCSSIG with either
1982 the existing siginfo struct from pr_info, or one we have synthesized
1983 appropriately for the signal we want to deliver. Otherwise if the
1984 signal is still being traced, the inferior will immediately stop
1985 again.
1986
1987 See siginfo(5) for more details.
1988*/
1989
1990static void
1991set_proc_siginfo (pip, signo)
cc221e76
FF		 1992 struct procinfo *pip;
1993 int signo;
6b801388
FF		 1994{
1995 struct siginfo newsiginfo;
1996 struct siginfo *sip;
1997
1998 if (pip -> valid)
1999 {
2000 if (signo == pip -> prstatus.pr_info.si_signo)
2001 {
2002 sip = &pip -> prstatus.pr_info;
2003 }
2004 else
2005 {
4ed3a9ea 2006 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
6b801388
FF		 2007 sip = &newsiginfo;
2008 sip -> si_signo = signo;
2009 sip -> si_code = 0;
2010 sip -> si_errno = 0;
2011 sip -> si_pid = getpid ();
2012 sip -> si_uid = getuid ();
2013 }
2014 if (ioctl (pip -> fd, PIOCSSIG, sip) < 0)
2015 {
2016 print_sys_errmsg (pip -> pathname, errno);
2017 warning ("PIOCSSIG failed");
2018 }
2019 }
2020}
2021
2022/*
2023
35f5886e
FF		 2024GLOBAL FUNCTION
2025
2026 child_resume -- resume execution of the inferior process
2027
2028SYNOPSIS
2029
cc221e76 2030 void child_resume (int step, int signo)
35f5886e
FF		 2031
2032DESCRIPTION
2033
2034 Resume execution of the inferior process. If STEP is nozero, then
2035 just single step it. If SIGNAL is nonzero, restart it with that
2036 signal activated.
2037
2038NOTE
2039
2040 It may not be absolutely necessary to specify the PC value for
2041 restarting, but to be safe we use the value that gdb considers
2042 to be current. One case where this might be necessary is if the
2043 user explicitly changes the PC value that gdb considers to be
2044 current. FIXME: Investigate if this is necessary or not.
d65eee73
FF		 2045
2046 When attaching to a child process, if we forced it to stop with
2047 a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
2048 Upon resuming the first time after such a stop, we explicitly
2049 inhibit sending it another SIGSTOP, which would be the normal
2050 result of default signal handling. One potential drawback to
2051 this is that we will also ignore any attempt to by the user
2052 to explicitly continue after the attach with a SIGSTOP. Ultimately
2053 this problem should be dealt with by making the routines that
2054 deal with the inferior a little smarter, and possibly even allow
2055 an inferior to continue running at the same time as gdb. (FIXME?)
35f5886e
FF		 2056 */
2057
2058void
cc221e76 2059child_resume (step, signo)
1ab3bf1b 2060 int step;
cc221e76 2061 int signo;
35f5886e
FF		 2062{
2063 errno = 0;
99fd9e3e
SG		 2064 pi.prrun.pr_flags = PRSTRACE | PRSFAULT | PRCFAULT;
2065
c3192172 2066#ifdef PRSVADDR_BROKEN
99fd9e3e
SG		 2067/* Can't do this under Solaris running on a Sparc, as there seems to be no
2068 place to put nPC. In fact, if you use this, nPC seems to be set to some
2069 random garbage. We have to rely on the fact that PC and nPC have been
2070 written previously via PIOCSREG during a register flush. */
2071
35f5886e 2072 pi.prrun.pr_vaddr = (caddr_t) *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
99fd9e3e
SG		 2073 pi.prrun.pr_flags != PRSVADDR;
2074#endif
2075
d65eee73 2076 if (signo && !(signo == SIGSTOP && pi.nopass_next_sigstop))
35f5886e 2077 {
cc221e76 2078 set_proc_siginfo (&pi, signo);
35f5886e
FF		 2079 }
2080 else
2081 {
2082 pi.prrun.pr_flags |= PRCSIG;
2083 }
d65eee73 2084 pi.nopass_next_sigstop = 0;
35f5886e
FF		 2085 if (step)
2086 {
2087 pi.prrun.pr_flags |= PRSTEP;
2088 }
2089 if (ioctl (pi.fd, PIOCRUN, &pi.prrun) != 0)
2090 {
2091 perror_with_name (pi.pathname);
2092 /* NOTREACHED */
2093 }
2094}
2095
2096/*
2097
2098GLOBAL FUNCTION
2099
2100 fetch_inferior_registers -- fetch current registers from inferior
2101
2102SYNOPSIS
2103
1ab3bf1b 2104 void fetch_inferior_registers (int regno)
35f5886e
FF		 2105
2106DESCRIPTION
2107
2108 Read the current values of the inferior's registers, both the
2109 general register set and floating point registers (if supported)
2110 and update gdb's idea of their current values.
2111
2112*/
2113
2114void
1ab3bf1b
JG		 2115fetch_inferior_registers (regno)
2116 int regno;
35f5886e
FF		 2117{
2118 if (ioctl (pi.fd, PIOCGREG, &pi.gregset) != -1)
2119 {
2120 supply_gregset (&pi.gregset);
2121 }
2122#if defined (FP0_REGNUM)
2123 if (ioctl (pi.fd, PIOCGFPREG, &pi.fpregset) != -1)
2124 {
2125 supply_fpregset (&pi.fpregset);
2126 }
2127#endif
2128}
2129
fb182850
FF		 2130/*
2131
2132GLOBAL FUNCTION
2133
2134 fetch_core_registers -- fetch current registers from core file data
2135
2136SYNOPSIS
2137
2138 void fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
1ab3bf1b 2139 int which, unsigned in reg_addr)
fb182850
FF		 2140
2141DESCRIPTION
2142
2143 Read the values of either the general register set (WHICH equals 0)
2144 or the floating point register set (WHICH equals 2) from the core
2145 file data (pointed to by CORE_REG_SECT), and update gdb's idea of
2146 their current values. The CORE_REG_SIZE parameter is ignored.
2147
2148NOTES
2149
2150 Use the indicated sizes to validate the gregset and fpregset
2151 structures.
2152*/
2153
2154void
1ab3bf1b 2155fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
cc221e76
FF		 2156 char *core_reg_sect;
2157 unsigned core_reg_size;
2158 int which;
2159 unsigned int reg_addr; /* Unused in this version */
fb182850
FF		 2160{
2161
2162 if (which == 0)
2163 {
2164 if (core_reg_size != sizeof (pi.gregset))
2165 {
2166 warning ("wrong size gregset struct in core file");
2167 }
2168 else
2169 {
4ed3a9ea 2170 memcpy ((char *) &pi.gregset, core_reg_sect, sizeof (pi.gregset));
fb182850
FF		 2171 supply_gregset (&pi.gregset);
2172 }
2173 }
2174 else if (which == 2)
2175 {
2176 if (core_reg_size != sizeof (pi.fpregset))
2177 {
2178 warning ("wrong size fpregset struct in core file");
2179 }
2180 else
2181 {
4ed3a9ea 2182 memcpy ((char *) &pi.fpregset, core_reg_sect, sizeof (pi.fpregset));
fb182850
FF		 2183#if defined (FP0_REGNUM)
2184 supply_fpregset (&pi.fpregset);
2185#endif
2186 }
2187 }
2188}
35f5886e
FF		 2189
2190/*
2191
2192LOCAL FUNCTION
2193
2194 proc_init_failed - called whenever /proc access initialization fails
2195
2196SYNOPSIS
2197
2198 static void proc_init_failed (char *why)
2199
2200DESCRIPTION
2201
2202 This function is called whenever initialization of access to a /proc
2203 entry fails. It prints a suitable error message, does some cleanup,
2204 and then invokes the standard error processing routine which dumps
2205 us back into the command loop.
2206 */
2207
2208static void
1ab3bf1b
JG		 2209proc_init_failed (why)
2210 char *why;
35f5886e
FF		 2211{
2212 print_sys_errmsg (pi.pathname, errno);
4ed3a9ea 2213 kill (pi.pid, SIGKILL);
a39ad5ce 2214 close_proc_file (&pi);
35f5886e
FF		 2215 error (why);
2216 /* NOTREACHED */
2217}
2218
2219/*
2220
2221LOCAL FUNCTION
2222
2223 close_proc_file - close any currently open /proc entry
2224
2225SYNOPSIS
2226
a39ad5ce 2227 static void close_proc_file (struct procinfo *pip)
35f5886e
FF		 2228
2229DESCRIPTION
2230
2231 Close any currently open /proc entry and mark the process information
2232 entry as invalid. In order to ensure that we don't try to reuse any
2233 stale information, the pid, fd, and pathnames are explicitly
2234 invalidated, which may be overkill.
2235
2236 */
2237
2238static void
1ab3bf1b
JG		 2239close_proc_file (pip)
2240 struct procinfo *pip;
35f5886e 2241{
a39ad5ce
FF		 2242 pip -> pid = 0;
2243 if (pip -> valid)
35f5886e 2244 {
4ed3a9ea 2245 close (pip -> fd);
35f5886e 2246 }
a39ad5ce
FF		 2247 pip -> fd = -1;
2248 if (pip -> pathname)
35f5886e 2249 {
a39ad5ce
FF		 2250 free (pip -> pathname);
2251 pip -> pathname = NULL;
35f5886e 2252 }
a39ad5ce 2253 pip -> valid = 0;
35f5886e
FF		 2254}
2255
2256/*
2257
2258LOCAL FUNCTION
2259
2260 open_proc_file - open a /proc entry for a given process id
2261
2262SYNOPSIS
2263
ec8ceca3 2264 static int open_proc_file (int pid, struct procinfo *pip, int mode)
35f5886e
FF		 2265
2266DESCRIPTION
2267
ec8ceca3
JG		 2268 Given a process id and a mode, close the existing open /proc
2269 entry (if any) and open one for the new process id, in the
2270 specified mode. Once it is open, then mark the local process
2271 information structure as valid, which guarantees that the pid,
2272 fd, and pathname fields match an open /proc entry. Returns
2273 zero if the open fails, nonzero otherwise.
35f5886e
FF		 2274
2275 Note that the pathname is left intact, even when the open fails,
2276 so that callers can use it to construct meaningful error messages
2277 rather than just "file open failed".
2278 */
2279
2280static int
ec8ceca3 2281open_proc_file (pid, pip, mode)
1ab3bf1b
JG		 2282 int pid;
2283 struct procinfo *pip;
ec8ceca3 2284 int mode;
35f5886e 2285{
ec8ceca3 2286 pip -> valid = 0; /* FIXME, what is this? ?! */
a39ad5ce
FF		 2287 if (pip -> valid)
2288 {
4ed3a9ea 2289 close (pip -> fd);
a39ad5ce
FF		 2290 }
2291 if (pip -> pathname == NULL)
2292 {
2293 pip -> pathname = xmalloc (32);
2294 }
2295 sprintf (pip -> pathname, PROC_NAME_FMT, pid);
ec8ceca3 2296 if ((pip -> fd = open (pip -> pathname, mode)) >= 0)
a39ad5ce
FF		 2297 {
2298 pip -> valid = 1;
2299 pip -> pid = pid;
2300 }
2301 return (pip -> valid);
2302}
2303
f66f459f 2304static char *
1ab3bf1b
JG		 2305mappingflags (flags)
2306 long flags;
a39ad5ce 2307{
5c1c5e67 2308 static char asciiflags[8];
a39ad5ce 2309
5c1c5e67
FF		 2310 strcpy (asciiflags, "-------");
2311#if defined (MA_PHYS)
2312 if (flags & MA_PHYS) asciiflags[0] = 'd';
2313#endif
2314 if (flags & MA_STACK) asciiflags[1] = 's';
2315 if (flags & MA_BREAK) asciiflags[2] = 'b';
2316 if (flags & MA_SHARED) asciiflags[3] = 's';
2317 if (flags & MA_READ) asciiflags[4] = 'r';
2318 if (flags & MA_WRITE) asciiflags[5] = 'w';
2319 if (flags & MA_EXEC) asciiflags[6] = 'x';
a39ad5ce
FF		 2320 return (asciiflags);
2321}
2322
2323static void
cc221e76
FF		 2324info_proc_flags (pip, summary)
2325 struct procinfo *pip;
2326 int summary;
2327{
2328 struct trans *transp;
2329
2330 printf_filtered ("%-32s", "Process status flags:");
2331 if (!summary)
2332 {
2333 printf_filtered ("\n\n");
2334 }
2335 for (transp = pr_flag_table; transp -> name != NULL; transp++)
2336 {
2337 if (pip -> prstatus.pr_flags & transp -> value)
2338 {
2339 if (summary)
2340 {
2341 printf_filtered ("%s ", transp -> name);
2342 }
2343 else
2344 {
2345 printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
2346 }
2347 }
2348 }
2349 printf_filtered ("\n");
2350}
2351
2352static void
2353info_proc_stop (pip, summary)
2354 struct procinfo *pip;
2355 int summary;
2356{
2357 struct trans *transp;
2358 int why;
2359 int what;
2360
2361 why = pip -> prstatus.pr_why;
2362 what = pip -> prstatus.pr_what;
2363
2364 if (pip -> prstatus.pr_flags & PR_STOPPED)
2365 {
2366 printf_filtered ("%-32s", "Reason for stopping:");
2367 if (!summary)
2368 {
2369 printf_filtered ("\n\n");
2370 }
2371 for (transp = pr_why_table; transp -> name != NULL; transp++)
2372 {
2373 if (why == transp -> value)
2374 {
2375 if (summary)
2376 {
2377 printf_filtered ("%s ", transp -> name);
2378 }
2379 else
2380 {
2381 printf_filtered ("\t%-16s %s.\n",
2382 transp -> name, transp -> desc);
2383 }
2384 break;
2385 }
2386 }
2387
2388 /* Use the pr_why field to determine what the pr_what field means, and
2389 print more information. */
2390
2391 switch (why)
2392 {
2393 case PR_REQUESTED:
2394 /* pr_what is unused for this case */
2395 break;
2396 case PR_JOBCONTROL:
2397 case PR_SIGNALLED:
2398 if (summary)
2399 {
2400 printf_filtered ("%s ", signalname (what));
2401 }
2402 else
2403 {
2404 printf_filtered ("\t%-16s %s.\n", signalname (what),
4ace50a5 2405 safe_strsignal (what));
cc221e76
FF		 2406 }
2407 break;
2408 case PR_SYSENTRY:
2409 if (summary)
2410 {
2411 printf_filtered ("%s ", syscallname (what));
2412 }
2413 else
2414 {
2415 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2416 "Entered this system call");
2417 }
2418 break;
2419 case PR_SYSEXIT:
2420 if (summary)
2421 {
2422 printf_filtered ("%s ", syscallname (what));
2423 }
2424 else
2425 {
2426 printf_filtered ("\t%-16s %s.\n", syscallname (what),
2427 "Returned from this system call");
2428 }
2429 break;
2430 case PR_FAULTED:
2431 if (summary)
2432 {
2433 printf_filtered ("%s ",
2434 lookupname (faults_table, what, "fault"));
2435 }
2436 else
2437 {
2438 printf_filtered ("\t%-16s %s.\n",
2439 lookupname (faults_table, what, "fault"),
2440 lookupdesc (faults_table, what));
2441 }
2442 break;
2443 }
2444 printf_filtered ("\n");
2445 }
2446}
2447
2448static void
2449info_proc_siginfo (pip, summary)
2450 struct procinfo *pip;
2451 int summary;
2452{
2453 struct siginfo *sip;
2454
2455 if ((pip -> prstatus.pr_flags & PR_STOPPED) &&
2456 (pip -> prstatus.pr_why == PR_SIGNALLED ||
2457 pip -> prstatus.pr_why == PR_FAULTED))
2458 {
2459 printf_filtered ("%-32s", "Additional signal/fault info:");
2460 sip = &pip -> prstatus.pr_info;
2461 if (summary)
2462 {
2463 printf_filtered ("%s ", signalname (sip -> si_signo));
2464 if (sip -> si_errno > 0)
2465 {
4ace50a5 2466 printf_filtered ("%s ", errnoname (sip -> si_errno));
cc221e76
FF		 2467 }
2468 if (sip -> si_code <= 0)
2469 {
2470 printf_filtered ("sent by pid %d, uid %d ", sip -> si_pid,
2471 sip -> si_uid);
2472 }
2473 else
2474 {
2475 printf_filtered ("%s ", sigcodename (sip));
2476 if ((sip -> si_signo == SIGILL) ||
2477 (sip -> si_signo == SIGFPE) ||
2478 (sip -> si_signo == SIGSEGV) ||
2479 (sip -> si_signo == SIGBUS))
2480 {
2481 printf_filtered ("addr=%#x ", sip -> si_addr);
2482 }
2483 else if ((sip -> si_signo == SIGCHLD))
2484 {
2485 printf_filtered ("child pid %u, status %u ",
2486 sip -> si_pid,
2487 sip -> si_status);
2488 }
2489 else if ((sip -> si_signo == SIGPOLL))
2490 {
2491 printf_filtered ("band %u ", sip -> si_band);
2492 }
2493 }
2494 }
2495 else
2496 {
2497 printf_filtered ("\n\n");
2498 printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
4ace50a5 2499 safe_strsignal (sip -> si_signo));
cc221e76
FF		 2500 if (sip -> si_errno > 0)
2501 {
2502 printf_filtered ("\t%-16s %s.\n",
4ace50a5
FF		 2503 errnoname (sip -> si_errno),
2504 safe_strerror (sip -> si_errno));
cc221e76
FF		 2505 }
2506 if (sip -> si_code <= 0)
2507 {
2508 printf_filtered ("\t%-16u %s\n", sip -> si_pid,
2509 "PID of process sending signal");
2510 printf_filtered ("\t%-16u %s\n", sip -> si_uid,
2511 "UID of process sending signal");
2512 }
2513 else
2514 {
2515 printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
2516 sigcodedesc (sip));
2517 if ((sip -> si_signo == SIGILL) ||
2518 (sip -> si_signo == SIGFPE))
2519 {
2520 printf_filtered ("\t%-16#x %s.\n", sip -> si_addr,
2521 "Address of faulting instruction");
2522 }
2523 else if ((sip -> si_signo == SIGSEGV) ||
2524 (sip -> si_signo == SIGBUS))
2525 {
2526 printf_filtered ("\t%-16#x %s.\n", sip -> si_addr,
2527 "Address of faulting memory reference");
2528 }
2529 else if ((sip -> si_signo == SIGCHLD))
2530 {
2531 printf_filtered ("\t%-16u %s.\n", sip -> si_pid,
2532 "Child process ID");
2533 printf_filtered ("\t%-16u %s.\n", sip -> si_status,
2534 "Child process exit value or signal");
2535 }
2536 else if ((sip -> si_signo == SIGPOLL))
2537 {
2538 printf_filtered ("\t%-16u %s.\n", sip -> si_band,
2539 "Band event for POLL_{IN,OUT,MSG}");
2540 }
2541 }
2542 }
2543 printf_filtered ("\n");
2544 }
2545}
2546
2547static void
2548info_proc_syscalls (pip, summary)
2549 struct procinfo *pip;
2550 int summary;
2551{
2552 int syscallnum;
2553
2554 if (!summary)
2555 {
2556
2557#if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
2558 if (pip -> prstatus.pr_flags & PR_ASLEEP)
2559 {
2560 int syscallnum = pip -> prstatus.pr_reg[R_D0];
2561 if (summary)
2562 {
2563 printf_filtered ("%-32s", "Sleeping in system call:");
2564 printf_filtered ("%s", syscallname (syscallnum));
2565 }
2566 else
2567 {
2568 printf_filtered ("Sleeping in system call '%s'.\n",
2569 syscallname (syscallnum));
2570 }
2571 }
2572#endif
2573
2574 if (ioctl (pip -> fd, PIOCGENTRY, &pip -> entryset) < 0)
2575 {
2576 print_sys_errmsg (pip -> pathname, errno);
2577 error ("PIOCGENTRY failed");
2578 }
2579
2580 if (ioctl (pip -> fd, PIOCGEXIT, &pip -> exitset) < 0)
2581 {
2582 print_sys_errmsg (pip -> pathname, errno);
2583 error ("PIOCGEXIT failed");
2584 }
2585
2586 printf_filtered ("System call tracing information:\n\n");
2587
2588 printf_filtered ("\t%-12s %-8s %-8s\n",
2589 "System call",
2590 "Entry",
2591 "Exit");
2592 for (syscallnum = 0; syscallnum < MAX_SYSCALLS; syscallnum++)
2593 {
2594 QUIT;
2595 if (syscall_table[syscallnum] != NULL)
2596 {
2597 printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
2598 printf_filtered ("%-8s ",
2599 prismember (&pip -> entryset, syscallnum)
2600 ? "on" : "off");
2601 printf_filtered ("%-8s ",
2602 prismember (&pip -> exitset, syscallnum)
2603 ? "on" : "off");
2604 printf_filtered ("\n");
2605 }
2606 }
2607 printf_filtered ("\n");
2608 }
2609}
2610
2611static char *
2612signalname (signo)
2613 int signo;
2614{
4ace50a5
FF		 2615 char *name;
2616 static char locbuf[32];
2617
2618 name = strsigno (signo);
2619 if (name == NULL)
2620 {
2621 sprintf (locbuf, "Signal %d", signo);
2622 }
2623 else
2624 {
2625 sprintf (locbuf, "%s (%d)", name, signo);
2626 }
2627 return (locbuf);
2628}
2629
2630static char *
2631errnoname (errnum)
2632 int errnum;
2633{
2634 char *name;
cc221e76
FF		 2635 static char locbuf[32];
2636
4ace50a5
FF		 2637 name = strerrno (errnum);
2638 if (name == NULL)
cc221e76 2639 {
4ace50a5 2640 sprintf (locbuf, "Errno %d", errnum);
cc221e76
FF		 2641 }
2642 else
2643 {
4ace50a5 2644 sprintf (locbuf, "%s (%d)", name, errnum);
cc221e76
FF		 2645 }
2646 return (locbuf);
2647}
2648
2649static void
2650info_proc_signals (pip, summary)
2651 struct procinfo *pip;
2652 int summary;
2653{
2654 int signo;
2655
2656 if (!summary)
2657 {
2658 if (ioctl (pip -> fd, PIOCGTRACE, &pip -> trace) < 0)
2659 {
2660 print_sys_errmsg (pip -> pathname, errno);
2661 error ("PIOCGTRACE failed");
2662 }
2663
2664 printf_filtered ("Disposition of signals:\n\n");
2665 printf_filtered ("\t%-15s %-8s %-8s %-8s %s\n\n",
2666 "Signal", "Trace", "Hold", "Pending", "Description");
2667 for (signo = 0; signo < NSIG; signo++)
2668 {
2669 QUIT;
2670 printf_filtered ("\t%-15s ", signalname (signo));
2671 printf_filtered ("%-8s ",
2672 prismember (&pip -> trace, signo)
2673 ? "on" : "off");
2674 printf_filtered ("%-8s ",
2675 prismember (&pip -> prstatus.pr_sighold, signo)
2676 ? "on" : "off");
2677 printf_filtered ("%-8s ",
2678 prismember (&pip -> prstatus.pr_sigpend, signo)
2679 ? "yes" : "no");
4ace50a5 2680 printf_filtered (" %s\n", safe_strsignal (signo));
cc221e76
FF		 2681 }
2682 printf_filtered ("\n");
2683 }
2684}
2685
2686static void
2687info_proc_faults (pip, summary)
2688 struct procinfo *pip;
2689 int summary;
2690{
2691 struct trans *transp;
2692
2693 if (!summary)
2694 {
2695 if (ioctl (pip -> fd, PIOCGFAULT, &pip -> fltset) < 0)
2696 {
2697 print_sys_errmsg (pip -> pathname, errno);
2698 error ("PIOCGFAULT failed");
2699 }
2700
2701 printf_filtered ("Current traced hardware fault set:\n\n");
2702 printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
2703
2704 for (transp = faults_table; transp -> name != NULL; transp++)
2705 {
2706 QUIT;
2707 printf_filtered ("\t%-12s ", transp -> name);
2708 printf_filtered ("%-8s", prismember (&pip -> fltset, transp -> value)
2709 ? "on" : "off");
2710 printf_filtered ("\n");
2711 }
2712 printf_filtered ("\n");
2713 }
2714}
2715
2716static void
2717info_proc_mappings (pip, summary)
1ab3bf1b 2718 struct procinfo *pip;
cc221e76 2719 int summary;
a39ad5ce
FF		 2720{
2721 int nmap;
2722 struct prmap *prmaps;
2723 struct prmap *prmap;
2724
cc221e76 2725 if (!summary)
a39ad5ce 2726 {
cc221e76 2727 printf_filtered ("Mapped address spaces:\n\n");
5c1c5e67 2728 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
cc221e76
FF		 2729 "Start Addr",
2730 " End Addr",
2731 " Size",
2732 " Offset",
2733 "Flags");
2734 if (ioctl (pip -> fd, PIOCNMAP, &nmap) == 0)
a39ad5ce 2735 {
cc221e76
FF		 2736 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
2737 if (ioctl (pip -> fd, PIOCMAP, prmaps) == 0)
a39ad5ce 2738 {
cc221e76
FF		 2739 for (prmap = prmaps; prmap -> pr_size; ++prmap)
2740 {
5c1c5e67 2741 printf_filtered ("\t%#10x %#10x %#10x %#10x %7s\n",
cc221e76
FF		 2742 prmap -> pr_vaddr,
2743 prmap -> pr_vaddr + prmap -> pr_size - 1,
2744 prmap -> pr_size,
2745 prmap -> pr_off,
2746 mappingflags (prmap -> pr_mflags));
2747 }
a39ad5ce
FF		 2748 }
2749 }
cc221e76 2750 printf_filtered ("\n");
a39ad5ce 2751 }
a39ad5ce
FF		 2752}
2753
2754/*
2755
2756LOCAL FUNCTION
2757
cc221e76 2758 info_proc -- implement the "info proc" command
a39ad5ce
FF		 2759
2760SYNOPSIS
2761
cc221e76 2762 void info_proc (char *args, int from_tty)
a39ad5ce
FF		 2763
2764DESCRIPTION
2765
2766 Implement gdb's "info proc" command by using the /proc interface
2767 to print status information about any currently running process.
2768
2769 Examples of the use of "info proc" are:
2770
cc221e76
FF		 2771 info proc (prints summary info for current inferior)
2772 info proc 123 (prints summary info for process with pid 123)
2773 info proc mappings (prints address mappings)
2774 info proc times (prints process/children times)
2775 info proc id (prints pid, ppid, gid, sid, etc)
2776 info proc status (prints general process state info)
2777 info proc signals (prints info about signal handling)
2778 info proc all (prints all info)
a39ad5ce
FF		 2779
2780 */
2781
2782static void
cc221e76 2783info_proc (args, from_tty)
1ab3bf1b
JG		 2784 char *args;
2785 int from_tty;
a39ad5ce 2786{
a39ad5ce
FF		 2787 int pid;
2788 struct procinfo pii;
2789 struct procinfo *pip;
2790 struct cleanup *old_chain;
cc221e76
FF		 2791 char **argv;
2792 int argsize;
2793 int summary = 1;
2794 int flags = 0;
2795 int syscalls = 0;
2796 int signals = 0;
2797 int faults = 0;
2798 int mappings = 0;
2799 int times = 0;
2800 int id = 0;
2801 int status = 0;
2802 int all = 0;
a39ad5ce
FF		 2803
2804 old_chain = make_cleanup (null_cleanup, 0);
2805
2806 /* Default to using the current inferior if no pid specified */
2807
2808 pip = &pi;
2809
a39ad5ce 2810 if (args != NULL)
35f5886e 2811 {
cc221e76 2812 if ((argv = buildargv (args)) == NULL)
a39ad5ce 2813 {
cc221e76
FF		 2814 nomem (0);
2815 }
2816 make_cleanup (freeargv, (char *) argv);
2817
2818 while (*argv != NULL)
2819 {
2820 argsize = strlen (*argv);
2821 if (argsize >= 1 && strncmp (*argv, "all", argsize) == 0)
2822 {
2823 summary = 0;
2824 all = 1;
2825 }
2826 else if (argsize >= 2 && strncmp (*argv, "faults", argsize) == 0)
2827 {
2828 summary = 0;
2829 faults = 1;
2830 }
2831 else if (argsize >= 2 && strncmp (*argv, "flags", argsize) == 0)
2832 {
2833 summary = 0;
2834 flags = 1;
2835 }
2836 else if (argsize >= 1 && strncmp (*argv, "id", argsize) == 0)
2837 {
2838 summary = 0;
2839 id = 1;
2840 }
2841 else if (argsize >= 1 && strncmp (*argv, "mappings", argsize) == 0)
2842 {
2843 summary = 0;
2844 mappings = 1;
2845 }
2846 else if (argsize >= 2 && strncmp (*argv, "signals", argsize) == 0)
2847 {
2848 summary = 0;
2849 signals = 1;
2850 }
2851 else if (argsize >= 2 && strncmp (*argv, "status", argsize) == 0)
2852 {
2853 summary = 0;
2854 status = 1;
2855 }
2856 else if (argsize >= 2 && strncmp (*argv, "syscalls", argsize) == 0)
2857 {
2858 summary = 0;
2859 syscalls = 1;
2860 }
2861 else if (argsize >= 1 && strncmp (*argv, "times", argsize) == 0)
a39ad5ce 2862 {
cc221e76
FF		 2863 summary = 0;
2864 times = 1;
a39ad5ce 2865 }
cc221e76 2866 else if ((pii.pid = atoi (*argv)) > 0)
a39ad5ce
FF		 2867 {
2868 pid = pii.pid;
2869 pip = &pii;
4ed3a9ea 2870 memset (&pii, 0, sizeof (pii));
ec8ceca3 2871 if (!open_proc_file (pid, pip, O_RDONLY))
a39ad5ce
FF		 2872 {
2873 perror_with_name (pip -> pathname);
2874 /* NOTREACHED */
2875 }
2876 make_cleanup (close_proc_file, pip);
2877 }
cc221e76
FF		 2878 else if (**argv != '\000')
2879 {
2880 error ("Unrecognized or ambiguous keyword `%s'.", *argv);
2881 }
2882 argv++;
a39ad5ce 2883 }
35f5886e 2884 }
a39ad5ce
FF		 2885
2886 /* If we don't have a valid open process at this point, then we have no
2887 inferior or didn't specify a specific pid. */
2888
2889 if (!pip -> valid)
35f5886e 2890 {
a39ad5ce 2891 error ("No process. Run an inferior or specify an explicit pid.");
35f5886e 2892 }
a39ad5ce 2893 if (ioctl (pip -> fd, PIOCSTATUS, &(pip -> prstatus)) < 0)
35f5886e 2894 {
a39ad5ce
FF		 2895 print_sys_errmsg (pip -> pathname, errno);
2896 error ("PIOCSTATUS failed");
35f5886e 2897 }
a39ad5ce 2898
cc221e76
FF		 2899 /* Print verbose information of the requested type(s), or just a summary
2900 of the information for all types. */
2901
2902 printf_filtered ("\nInformation for %s:\n\n", pip -> pathname);
2903 if (summary || all || flags)
2904 {
2905 info_proc_flags (pip, summary);
2906 }
2907 if (summary || all)
2908 {
2909 info_proc_stop (pip, summary);
2910 }
2911 if (summary || all || signals || faults)
2912 {
2913 info_proc_siginfo (pip, summary);
2914 }
2915 if (summary || all || syscalls)
2916 {
2917 info_proc_syscalls (pip, summary);
2918 }
2919 if (summary || all || mappings)
2920 {
2921 info_proc_mappings (pip, summary);
2922 }
2923 if (summary || all || signals)
2924 {
2925 info_proc_signals (pip, summary);
2926 }
2927 if (summary || all || faults)
2928 {
2929 info_proc_faults (pip, summary);
2930 }
2931 printf_filtered ("\n");
a39ad5ce
FF		 2932
2933 /* All done, deal with closing any temporary process info structure,
2934 freeing temporary memory , etc. */
2935
2936 do_cleanups (old_chain);
2937}
2938
2939/*
2940
2941GLOBAL FUNCTION
2942
2943 _initialize_proc_fs -- initialize the process file system stuff
2944
2945SYNOPSIS
2946
2947 void _initialize_proc_fs (void)
2948
2949DESCRIPTION
2950
2951 Do required initializations during gdb startup for using the
2952 /proc file system interface.
2953
2954*/
2955
2956static char *proc_desc =
cc221e76
FF		 2957"Show process status information using /proc entry.\n\
2958Specify process id or use current inferior by default.\n\
2959Specify keywords for detailed information; default is summary.\n\
2960Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
2961`status', `syscalls', and `times'.\n\
2962Unambiguous abbreviations may be used.";
a39ad5ce
FF		 2963
2964void
2965_initialize_proc_fs ()
2966{
cc221e76
FF		 2967 add_info ("proc", info_proc, proc_desc);
2968 init_syscall_table ();
35f5886e
FF		 2969}
2970
2971#endif /* USE_PROC_FS */
GDB Binutils - Deliverables
This page took 0.197428 seconds and 4 git commands to generate.