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