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