1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 For information on the details of using /proc consult section proc(4)
25 in the UNIX System V Release 4 System Administrator's Reference Manual.
27 The general register and floating point register sets are manipulated by
28 separate ioctl's. This file makes the assumption that if FP0_REGNUM is
29 defined, then support for the floating point register set is desired,
30 regardless of whether or not the actual target has floating point hardware.
37 #include <sys/types.h>
39 #include <sys/fault.h>
40 #include <sys/syscall.h>
41 #include <sys/procfs.h>
44 #include "gdb_string.h"
54 #include "gdbthread.h"
56 #define MAX_SYSCALLS 256 /* Maximum number of syscalls for table */
59 #define PROC_NAME_FMT "/proc/%05d"
62 extern struct target_ops procfs_ops
; /* Forward declaration */
64 int procfs_suppress_run
= 0; /* Non-zero if procfs should pretend not to
65 be a runnable target. Used by targets
66 that can sit atop procfs, such as solaris
69 #if 1 /* FIXME: Gross and ugly hack to resolve coredep.c global */
70 CORE_ADDR kernel_u_addr
;
73 #ifdef BROKEN_SIGINFO_H /* Workaround broken SGS <sys/siginfo.h> */
75 #define si_pid _data._proc.pid
77 #define si_uid _data._proc._pdata._kill.uid
78 #endif /* BROKEN_SIGINFO_H */
80 /* All access to the inferior, either one started by gdb or one that has
81 been attached to, is controlled by an instance of a procinfo structure,
82 defined below. Since gdb currently only handles one inferior at a time,
83 the procinfo structure for the inferior is statically allocated and
84 only one exists at any given time. There is a separate procinfo
85 structure for use by the "info proc" command, so that we can print
86 useful information about any random process without interfering with
87 the inferior's procinfo information. */
90 struct procinfo
*next
;
91 int pid
; /* Process ID of inferior */
92 int fd
; /* File descriptor for /proc entry */
93 char *pathname
; /* Pathname to /proc entry */
94 int had_event
; /* poll/select says something happened */
95 int was_stopped
; /* Nonzero if was stopped prior to attach */
96 int nopass_next_sigstop
; /* Don't pass a sigstop on next resume */
97 prrun_t prrun
; /* Control state when it is run */
98 prstatus_t prstatus
; /* Current process status info */
99 gregset_t gregset
; /* General register set */
100 fpregset_t fpregset
; /* Floating point register set */
101 fltset_t fltset
; /* Current traced hardware fault set */
102 sigset_t trace
; /* Current traced signal set */
103 sysset_t exitset
; /* Current traced system call exit set */
104 sysset_t entryset
; /* Current traced system call entry set */
105 fltset_t saved_fltset
; /* Saved traced hardware fault set */
106 sigset_t saved_trace
; /* Saved traced signal set */
107 sigset_t saved_sighold
; /* Saved held signal set */
108 sysset_t saved_exitset
; /* Saved traced system call exit set */
109 sysset_t saved_entryset
; /* Saved traced system call entry set */
110 int num_syscall_handlers
; /* Number of syscall handlers currently installed */
111 struct procfs_syscall_handler
*syscall_handlers
; /* Pointer to list of syscall trap handlers */
112 int new_child
; /* Non-zero if it's a new thread */
115 /* List of inferior process information */
116 static struct procinfo
*procinfo_list
= NULL
;
118 static struct pollfd
*poll_list
; /* pollfds used for waiting on /proc */
120 static int num_poll_list
= 0; /* Number of entries in poll_list */
122 /* Much of the information used in the /proc interface, particularly for
123 printing status information, is kept as tables of structures of the
124 following form. These tables can be used to map numeric values to
125 their symbolic names and to a string that describes their specific use. */
128 int value
; /* The numeric value */
129 char *name
; /* The equivalent symbolic value */
130 char *desc
; /* Short description of value */
133 /* Translate bits in the pr_flags member of the prstatus structure, into the
134 names and desc information. */
136 static struct trans pr_flag_table
[] =
138 #if defined (PR_STOPPED)
139 { PR_STOPPED
, "PR_STOPPED", "Process is stopped" },
141 #if defined (PR_ISTOP)
142 { PR_ISTOP
, "PR_ISTOP", "Stopped on an event of interest" },
144 #if defined (PR_DSTOP)
145 { PR_DSTOP
, "PR_DSTOP", "A stop directive is in effect" },
147 #if defined (PR_ASLEEP)
148 { PR_ASLEEP
, "PR_ASLEEP", "Sleeping in an interruptible system call" },
150 #if defined (PR_FORK)
151 { PR_FORK
, "PR_FORK", "Inherit-on-fork is in effect" },
154 { PR_RLC
, "PR_RLC", "Run-on-last-close is in effect" },
156 #if defined (PR_PTRACE)
157 { PR_PTRACE
, "PR_PTRACE", "Process is being controlled by ptrace" },
159 #if defined (PR_PCINVAL)
160 { PR_PCINVAL
, "PR_PCINVAL", "PC refers to an invalid virtual address" },
162 #if defined (PR_ISSYS)
163 { PR_ISSYS
, "PR_ISSYS", "Is a system process" },
165 #if defined (PR_STEP)
166 { PR_STEP
, "PR_STEP", "Process has single step pending" },
169 { PR_KLC
, "PR_KLC", "Kill-on-last-close is in effect" },
171 #if defined (PR_ASYNC)
172 { PR_ASYNC
, "PR_ASYNC", "Asynchronous stop is in effect" },
174 #if defined (PR_PCOMPAT)
175 { PR_PCOMPAT
, "PR_PCOMPAT", "Ptrace compatibility mode in effect" },
180 /* Translate values in the pr_why field of the prstatus struct. */
182 static struct trans pr_why_table
[] =
184 #if defined (PR_REQUESTED)
185 { PR_REQUESTED
, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP" },
187 #if defined (PR_SIGNALLED)
188 { PR_SIGNALLED
, "PR_SIGNALLED", "Receipt of a traced signal" },
190 #if defined (PR_FAULTED)
191 { PR_FAULTED
, "PR_FAULTED", "Incurred a traced hardware fault" },
193 #if defined (PR_SYSENTRY)
194 { PR_SYSENTRY
, "PR_SYSENTRY", "Entry to a traced system call" },
196 #if defined (PR_SYSEXIT)
197 { PR_SYSEXIT
, "PR_SYSEXIT", "Exit from a traced system call" },
199 #if defined (PR_JOBCONTROL)
200 { PR_JOBCONTROL
, "PR_JOBCONTROL", "Default job control stop signal action" },
202 #if defined (PR_SUSPENDED)
203 { PR_SUSPENDED
, "PR_SUSPENDED", "Process suspended" },
208 /* Hardware fault translation table. */
210 static struct trans faults_table
[] =
213 { FLTILL
, "FLTILL", "Illegal instruction" },
215 #if defined (FLTPRIV)
216 { FLTPRIV
, "FLTPRIV", "Privileged instruction" },
219 { FLTBPT
, "FLTBPT", "Breakpoint trap" },
221 #if defined (FLTTRACE)
222 { FLTTRACE
, "FLTTRACE", "Trace trap" },
224 #if defined (FLTACCESS)
225 { FLTACCESS
, "FLTACCESS", "Memory access fault" },
227 #if defined (FLTBOUNDS)
228 { FLTBOUNDS
, "FLTBOUNDS", "Memory bounds violation" },
230 #if defined (FLTIOVF)
231 { FLTIOVF
, "FLTIOVF", "Integer overflow" },
233 #if defined (FLTIZDIV)
234 { FLTIZDIV
, "FLTIZDIV", "Integer zero divide" },
237 { FLTFPE
, "FLTFPE", "Floating-point exception" },
239 #if defined (FLTSTACK)
240 { FLTSTACK
, "FLTSTACK", "Unrecoverable stack fault" },
242 #if defined (FLTPAGE)
243 { FLTPAGE
, "FLTPAGE", "Recoverable page fault" },
248 /* Translation table for signal generation information. See UNIX System
249 V Release 4 Programmer's Reference Manual, siginfo(5). */
251 static struct sigcode
{
256 } siginfo_table
[] = {
257 #if defined (SIGILL) && defined (ILL_ILLOPC)
258 { SIGILL
, ILL_ILLOPC
, "ILL_ILLOPC", "Illegal opcode" },
260 #if defined (SIGILL) && defined (ILL_ILLOPN)
261 { SIGILL
, ILL_ILLOPN
, "ILL_ILLOPN", "Illegal operand", },
263 #if defined (SIGILL) && defined (ILL_ILLADR)
264 { SIGILL
, ILL_ILLADR
, "ILL_ILLADR", "Illegal addressing mode" },
266 #if defined (SIGILL) && defined (ILL_ILLTRP)
267 { SIGILL
, ILL_ILLTRP
, "ILL_ILLTRP", "Illegal trap" },
269 #if defined (SIGILL) && defined (ILL_PRVOPC)
270 { SIGILL
, ILL_PRVOPC
, "ILL_PRVOPC", "Privileged opcode" },
272 #if defined (SIGILL) && defined (ILL_PRVREG)
273 { SIGILL
, ILL_PRVREG
, "ILL_PRVREG", "Privileged register" },
275 #if defined (SIGILL) && defined (ILL_COPROC)
276 { SIGILL
, ILL_COPROC
, "ILL_COPROC", "Coprocessor error" },
278 #if defined (SIGILL) && defined (ILL_BADSTK)
279 { SIGILL
, ILL_BADSTK
, "ILL_BADSTK", "Internal stack error" },
281 #if defined (SIGFPE) && defined (FPE_INTDIV)
282 { SIGFPE
, FPE_INTDIV
, "FPE_INTDIV", "Integer divide by zero" },
284 #if defined (SIGFPE) && defined (FPE_INTOVF)
285 { SIGFPE
, FPE_INTOVF
, "FPE_INTOVF", "Integer overflow" },
287 #if defined (SIGFPE) && defined (FPE_FLTDIV)
288 { SIGFPE
, FPE_FLTDIV
, "FPE_FLTDIV", "Floating point divide by zero" },
290 #if defined (SIGFPE) && defined (FPE_FLTOVF)
291 { SIGFPE
, FPE_FLTOVF
, "FPE_FLTOVF", "Floating point overflow" },
293 #if defined (SIGFPE) && defined (FPE_FLTUND)
294 { SIGFPE
, FPE_FLTUND
, "FPE_FLTUND", "Floating point underflow" },
296 #if defined (SIGFPE) && defined (FPE_FLTRES)
297 { SIGFPE
, FPE_FLTRES
, "FPE_FLTRES", "Floating point inexact result" },
299 #if defined (SIGFPE) && defined (FPE_FLTINV)
300 { SIGFPE
, FPE_FLTINV
, "FPE_FLTINV", "Invalid floating point operation" },
302 #if defined (SIGFPE) && defined (FPE_FLTSUB)
303 { SIGFPE
, FPE_FLTSUB
, "FPE_FLTSUB", "Subscript out of range" },
305 #if defined (SIGSEGV) && defined (SEGV_MAPERR)
306 { SIGSEGV
, SEGV_MAPERR
, "SEGV_MAPERR", "Address not mapped to object" },
308 #if defined (SIGSEGV) && defined (SEGV_ACCERR)
309 { SIGSEGV
, SEGV_ACCERR
, "SEGV_ACCERR", "Invalid permissions for object" },
311 #if defined (SIGBUS) && defined (BUS_ADRALN)
312 { SIGBUS
, BUS_ADRALN
, "BUS_ADRALN", "Invalid address alignment" },
314 #if defined (SIGBUS) && defined (BUS_ADRERR)
315 { SIGBUS
, BUS_ADRERR
, "BUS_ADRERR", "Non-existent physical address" },
317 #if defined (SIGBUS) && defined (BUS_OBJERR)
318 { SIGBUS
, BUS_OBJERR
, "BUS_OBJERR", "Object specific hardware error" },
320 #if defined (SIGTRAP) && defined (TRAP_BRKPT)
321 { SIGTRAP
, TRAP_BRKPT
, "TRAP_BRKPT", "Process breakpoint" },
323 #if defined (SIGTRAP) && defined (TRAP_TRACE)
324 { SIGTRAP
, TRAP_TRACE
, "TRAP_TRACE", "Process trace trap" },
326 #if defined (SIGCLD) && defined (CLD_EXITED)
327 { SIGCLD
, CLD_EXITED
, "CLD_EXITED", "Child has exited" },
329 #if defined (SIGCLD) && defined (CLD_KILLED)
330 { SIGCLD
, CLD_KILLED
, "CLD_KILLED", "Child was killed" },
332 #if defined (SIGCLD) && defined (CLD_DUMPED)
333 { SIGCLD
, CLD_DUMPED
, "CLD_DUMPED", "Child has terminated abnormally" },
335 #if defined (SIGCLD) && defined (CLD_TRAPPED)
336 { SIGCLD
, CLD_TRAPPED
, "CLD_TRAPPED", "Traced child has trapped" },
338 #if defined (SIGCLD) && defined (CLD_STOPPED)
339 { SIGCLD
, CLD_STOPPED
, "CLD_STOPPED", "Child has stopped" },
341 #if defined (SIGCLD) && defined (CLD_CONTINUED)
342 { SIGCLD
, CLD_CONTINUED
, "CLD_CONTINUED", "Stopped child had continued" },
344 #if defined (SIGPOLL) && defined (POLL_IN)
345 { SIGPOLL
, POLL_IN
, "POLL_IN", "Input input available" },
347 #if defined (SIGPOLL) && defined (POLL_OUT)
348 { SIGPOLL
, POLL_OUT
, "POLL_OUT", "Output buffers available" },
350 #if defined (SIGPOLL) && defined (POLL_MSG)
351 { SIGPOLL
, POLL_MSG
, "POLL_MSG", "Input message available" },
353 #if defined (SIGPOLL) && defined (POLL_ERR)
354 { SIGPOLL
, POLL_ERR
, "POLL_ERR", "I/O error" },
356 #if defined (SIGPOLL) && defined (POLL_PRI)
357 { SIGPOLL
, POLL_PRI
, "POLL_PRI", "High priority input available" },
359 #if defined (SIGPOLL) && defined (POLL_HUP)
360 { SIGPOLL
, POLL_HUP
, "POLL_HUP", "Device disconnected" },
365 static char *syscall_table
[MAX_SYSCALLS
];
367 /* Prototypes for local functions */
369 static void procfs_stop
PARAMS ((void));
371 static int procfs_thread_alive
PARAMS ((int));
373 static int procfs_can_run
PARAMS ((void));
375 static void procfs_mourn_inferior
PARAMS ((void));
377 static void procfs_fetch_registers
PARAMS ((int));
379 static int procfs_wait
PARAMS ((int, struct target_waitstatus
*));
381 static void procfs_open
PARAMS ((char *, int));
383 static void procfs_files_info
PARAMS ((struct target_ops
*));
385 static void procfs_prepare_to_store
PARAMS ((void));
387 static void procfs_detach
PARAMS ((char *, int));
389 static void procfs_attach
PARAMS ((char *, int));
391 static void proc_set_exec_trap
PARAMS ((void));
393 static int procfs_init_inferior
PARAMS ((int));
395 static struct procinfo
*create_procinfo
PARAMS ((int));
397 static void procfs_store_registers
PARAMS ((int));
399 static int procfs_xfer_memory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
401 static void procfs_kill_inferior
PARAMS ((void));
403 static char *sigcodedesc
PARAMS ((siginfo_t
*));
405 static char *sigcodename
PARAMS ((siginfo_t
*));
407 static struct procinfo
*wait_fd
PARAMS ((void));
409 static void remove_fd
PARAMS ((struct procinfo
*));
411 static void add_fd
PARAMS ((struct procinfo
*));
413 static void set_proc_siginfo
PARAMS ((struct procinfo
*, int));
415 static void init_syscall_table
PARAMS ((void));
417 static char *syscallname
PARAMS ((int));
419 static char *signalname
PARAMS ((int));
421 static char *errnoname
PARAMS ((int));
423 static int proc_address_to_fd
PARAMS ((struct procinfo
*, CORE_ADDR
, int));
425 static int open_proc_file
PARAMS ((int, struct procinfo
*, int));
427 static void close_proc_file
PARAMS ((struct procinfo
*));
429 static void unconditionally_kill_inferior
PARAMS ((struct procinfo
*));
431 static NORETURN
void proc_init_failed
PARAMS ((struct procinfo
*, char *)) ATTR_NORETURN
;
433 static void info_proc
PARAMS ((char *, int));
435 static void info_proc_flags
PARAMS ((struct procinfo
*, int));
437 static void info_proc_stop
PARAMS ((struct procinfo
*, int));
439 static void info_proc_siginfo
PARAMS ((struct procinfo
*, int));
441 static void info_proc_syscalls
PARAMS ((struct procinfo
*, int));
443 static void info_proc_mappings
PARAMS ((struct procinfo
*, int));
445 static void info_proc_signals
PARAMS ((struct procinfo
*, int));
447 static void info_proc_faults
PARAMS ((struct procinfo
*, int));
449 static char *mappingflags
PARAMS ((long));
451 static char *lookupname
PARAMS ((struct trans
*, unsigned int, char *));
453 static char *lookupdesc
PARAMS ((struct trans
*, unsigned int));
455 static int do_attach
PARAMS ((int pid
));
457 static void do_detach
PARAMS ((int siggnal
));
459 static void procfs_create_inferior
PARAMS ((char *, char *, char **));
461 static void procfs_notice_signals
PARAMS ((int pid
));
463 static struct procinfo
*find_procinfo
PARAMS ((pid_t pid
, int okfail
));
465 typedef int syscall_func_t
PARAMS ((struct procinfo
*pi
, int syscall_num
,
466 int why
, int *rtnval
, int *statval
));
468 static void procfs_set_syscall_trap
PARAMS ((struct procinfo
*pi
,
469 int syscall_num
, int flags
,
470 syscall_func_t
*func
));
472 static void procfs_clear_syscall_trap
PARAMS ((struct procinfo
*pi
,
473 int syscall_num
, int errok
));
475 #define PROCFS_SYSCALL_ENTRY 0x1 /* Trap on entry to sys call */
476 #define PROCFS_SYSCALL_EXIT 0x2 /* Trap on exit from sys call */
478 static syscall_func_t procfs_exit_handler
;
480 static syscall_func_t procfs_exec_handler
;
483 static syscall_func_t procfs_sproc_handler
;
484 static syscall_func_t procfs_fork_handler
;
487 #ifdef SYS_lwp_create
488 static syscall_func_t procfs_lwp_creation_handler
;
491 static void modify_inherit_on_fork_flag
PARAMS ((int fd
, int flag
));
492 static void modify_run_on_last_close_flag
PARAMS ((int fd
, int flag
));
496 struct procfs_syscall_handler
498 int syscall_num
; /* The number of the system call being handled */
499 /* The function to be called */
500 syscall_func_t
*func
;
503 static void procfs_resume
PARAMS ((int pid
, int step
,
504 enum target_signal signo
));
506 /* External function prototypes that can't be easily included in any
507 header file because the args are typedefs in system include files. */
509 extern void supply_gregset
PARAMS ((gregset_t
*));
511 extern void fill_gregset
PARAMS ((gregset_t
*, int));
513 extern void supply_fpregset
PARAMS ((fpregset_t
*));
515 extern void fill_fpregset
PARAMS ((fpregset_t
*, int));
521 find_procinfo -- convert a process id to a struct procinfo
525 static struct procinfo * find_procinfo (pid_t pid, int okfail);
529 Given a process id, look it up in the procinfo chain. Returns
530 a struct procinfo *. If can't find pid, then call error(),
531 unless okfail is set, in which case, return NULL;
534 static struct procinfo
*
535 find_procinfo (pid
, okfail
)
539 struct procinfo
*procinfo
;
541 for (procinfo
= procinfo_list
; procinfo
; procinfo
= procinfo
->next
)
542 if (procinfo
->pid
== pid
)
548 error ("procfs (find_procinfo): Couldn't locate pid %d", pid
);
555 current_procinfo -- convert inferior_pid to a struct procinfo
559 static struct procinfo * current_procinfo;
563 Looks up inferior_pid in the procinfo chain. Always returns a
564 struct procinfo *. If process can't be found, we error() out.
567 #define current_procinfo find_procinfo (inferior_pid, 0)
573 add_fd -- Add the fd to the poll/select list
577 static void add_fd (struct procinfo *);
581 Add the fd of the supplied procinfo to the list of fds used for
582 poll/select operations.
589 if (num_poll_list
<= 0)
590 poll_list
= (struct pollfd
*) xmalloc (sizeof (struct pollfd
));
592 poll_list
= (struct pollfd
*) xrealloc (poll_list
,
594 * sizeof (struct pollfd
));
595 poll_list
[num_poll_list
].fd
= pi
->fd
;
596 poll_list
[num_poll_list
].events
= POLLPRI
;
607 for (i
= 0; i
< num_poll_list
; i
++)
609 if (poll_list
[i
].fd
== pi
->fd
)
611 if (i
!= num_poll_list
- 1)
612 memcpy (poll_list
+ i
, poll_list
+ i
+ 1,
613 (num_poll_list
- i
- 1) * sizeof (struct pollfd
));
617 if (num_poll_list
== 0)
620 poll_list
= (struct pollfd
*) xrealloc (poll_list
,
622 * sizeof (struct pollfd
));
628 static struct procinfo
*
637 set_sigint_trap (); /* Causes SIGINT to be passed on to the
642 num_fds
= poll (poll_list
, num_poll_list
, -1);
644 pi
= current_procinfo
;
646 while (ioctl (pi
->fd
, PIOCWSTOP
, &pi
->prstatus
) < 0)
650 /* Process exited. */
651 pi
->prstatus
.pr_flags
= 0;
654 else if (errno
!= EINTR
)
656 print_sys_errmsg (pi
->pathname
, errno
);
657 error ("PIOCWSTOP failed");
663 clear_sigint_trap ();
670 print_sys_errmsg ("poll failed\n", errno
);
671 error ("Poll failed, returned %d", num_fds
);
674 for (i
= 0; i
< num_poll_list
&& num_fds
> 0; i
++)
676 if ((poll_list
[i
].revents
& (POLLPRI
|POLLERR
|POLLHUP
|POLLNVAL
)) == 0)
678 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
680 if (poll_list
[i
].fd
== pi
->fd
)
682 if (ioctl (pi
->fd
, PIOCSTATUS
, &pi
->prstatus
) < 0)
684 print_sys_errmsg (pi
->pathname
, errno
);
685 error ("PIOCSTATUS failed");
693 error ("wait_fd: Couldn't find procinfo for fd %d\n",
696 #endif /* LOSING_POLL */
705 lookupdesc -- translate a value to a summary desc string
709 static char *lookupdesc (struct trans *transp, unsigned int val);
713 Given a pointer to a translation table and a value to be translated,
714 lookup the desc string and return it.
718 lookupdesc (transp
, val
)
719 struct trans
*transp
;
724 for (desc
= NULL
; transp
-> name
!= NULL
; transp
++)
726 if (transp
-> value
== val
)
728 desc
= transp
-> desc
;
733 /* Didn't find a translation for the specified value, set a default one. */
746 lookupname -- translate a value to symbolic name
750 static char *lookupname (struct trans *transp, unsigned int val,
755 Given a pointer to a translation table, a value to be translated,
756 and a default prefix to return if the value can't be translated,
757 match the value with one of the translation table entries and
758 return a pointer to the symbolic name.
760 If no match is found it just returns the value as a printable string,
761 with the given prefix. The previous such value, if any, is freed
766 lookupname (transp
, val
, prefix
)
767 struct trans
*transp
;
774 for (name
= NULL
; transp
-> name
!= NULL
; transp
++)
776 if (transp
-> value
== val
)
778 name
= transp
-> name
;
783 /* Didn't find a translation for the specified value, build a default
784 one using the specified prefix and return it. The lifetime of
785 the value is only until the next one is needed. */
793 locbuf
= xmalloc (strlen (prefix
) + 16);
794 sprintf (locbuf
, "%s %u", prefix
, val
);
806 static char locbuf
[32];
808 for (scp
= siginfo_table
; scp
-> codename
!= NULL
; scp
++)
810 if ((scp
-> signo
== sip
-> si_signo
) &&
811 (scp
-> code
== sip
-> si_code
))
813 name
= scp
-> codename
;
819 sprintf (locbuf
, "sigcode %u", sip
-> si_signo
);
832 for (scp
= siginfo_table
; scp
-> codename
!= NULL
; scp
++)
834 if ((scp
-> signo
== sip
-> si_signo
) &&
835 (scp
-> code
== sip
-> si_code
))
843 desc
= "Unrecognized signal or trap use";
852 syscallname - translate a system call number into a system call name
856 char *syscallname (int syscallnum)
860 Given a system call number, translate it into the printable name
861 of a system call, or into "syscall <num>" if it is an unknown
866 syscallname (syscallnum
)
869 static char locbuf
[32];
871 if (syscallnum
>= 0 && syscallnum
< MAX_SYSCALLS
872 && syscall_table
[syscallnum
] != NULL
)
873 return syscall_table
[syscallnum
];
876 sprintf (locbuf
, "syscall %u", syscallnum
);
885 init_syscall_table - initialize syscall translation table
889 void init_syscall_table (void)
893 Dynamically initialize the translation table to convert system
894 call numbers into printable system call names. Done once per
895 gdb run, on initialization.
899 This is awfully ugly, but preprocessor tricks to make it prettier
900 tend to be nonportable.
904 init_syscall_table ()
906 #if defined (SYS_exit)
907 syscall_table
[SYS_exit
] = "exit";
909 #if defined (SYS_fork)
910 syscall_table
[SYS_fork
] = "fork";
912 #if defined (SYS_read)
913 syscall_table
[SYS_read
] = "read";
915 #if defined (SYS_write)
916 syscall_table
[SYS_write
] = "write";
918 #if defined (SYS_open)
919 syscall_table
[SYS_open
] = "open";
921 #if defined (SYS_close)
922 syscall_table
[SYS_close
] = "close";
924 #if defined (SYS_wait)
925 syscall_table
[SYS_wait
] = "wait";
927 #if defined (SYS_creat)
928 syscall_table
[SYS_creat
] = "creat";
930 #if defined (SYS_link)
931 syscall_table
[SYS_link
] = "link";
933 #if defined (SYS_unlink)
934 syscall_table
[SYS_unlink
] = "unlink";
936 #if defined (SYS_exec)
937 syscall_table
[SYS_exec
] = "exec";
939 #if defined (SYS_execv)
940 syscall_table
[SYS_execv
] = "execv";
942 #if defined (SYS_execve)
943 syscall_table
[SYS_execve
] = "execve";
945 #if defined (SYS_chdir)
946 syscall_table
[SYS_chdir
] = "chdir";
948 #if defined (SYS_time)
949 syscall_table
[SYS_time
] = "time";
951 #if defined (SYS_mknod)
952 syscall_table
[SYS_mknod
] = "mknod";
954 #if defined (SYS_chmod)
955 syscall_table
[SYS_chmod
] = "chmod";
957 #if defined (SYS_chown)
958 syscall_table
[SYS_chown
] = "chown";
960 #if defined (SYS_brk)
961 syscall_table
[SYS_brk
] = "brk";
963 #if defined (SYS_stat)
964 syscall_table
[SYS_stat
] = "stat";
966 #if defined (SYS_lseek)
967 syscall_table
[SYS_lseek
] = "lseek";
969 #if defined (SYS_getpid)
970 syscall_table
[SYS_getpid
] = "getpid";
972 #if defined (SYS_mount)
973 syscall_table
[SYS_mount
] = "mount";
975 #if defined (SYS_umount)
976 syscall_table
[SYS_umount
] = "umount";
978 #if defined (SYS_setuid)
979 syscall_table
[SYS_setuid
] = "setuid";
981 #if defined (SYS_getuid)
982 syscall_table
[SYS_getuid
] = "getuid";
984 #if defined (SYS_stime)
985 syscall_table
[SYS_stime
] = "stime";
987 #if defined (SYS_ptrace)
988 syscall_table
[SYS_ptrace
] = "ptrace";
990 #if defined (SYS_alarm)
991 syscall_table
[SYS_alarm
] = "alarm";
993 #if defined (SYS_fstat)
994 syscall_table
[SYS_fstat
] = "fstat";
996 #if defined (SYS_pause)
997 syscall_table
[SYS_pause
] = "pause";
999 #if defined (SYS_utime)
1000 syscall_table
[SYS_utime
] = "utime";
1002 #if defined (SYS_stty)
1003 syscall_table
[SYS_stty
] = "stty";
1005 #if defined (SYS_gtty)
1006 syscall_table
[SYS_gtty
] = "gtty";
1008 #if defined (SYS_access)
1009 syscall_table
[SYS_access
] = "access";
1011 #if defined (SYS_nice)
1012 syscall_table
[SYS_nice
] = "nice";
1014 #if defined (SYS_statfs)
1015 syscall_table
[SYS_statfs
] = "statfs";
1017 #if defined (SYS_sync)
1018 syscall_table
[SYS_sync
] = "sync";
1020 #if defined (SYS_kill)
1021 syscall_table
[SYS_kill
] = "kill";
1023 #if defined (SYS_fstatfs)
1024 syscall_table
[SYS_fstatfs
] = "fstatfs";
1026 #if defined (SYS_pgrpsys)
1027 syscall_table
[SYS_pgrpsys
] = "pgrpsys";
1029 #if defined (SYS_xenix)
1030 syscall_table
[SYS_xenix
] = "xenix";
1032 #if defined (SYS_dup)
1033 syscall_table
[SYS_dup
] = "dup";
1035 #if defined (SYS_pipe)
1036 syscall_table
[SYS_pipe
] = "pipe";
1038 #if defined (SYS_times)
1039 syscall_table
[SYS_times
] = "times";
1041 #if defined (SYS_profil)
1042 syscall_table
[SYS_profil
] = "profil";
1044 #if defined (SYS_plock)
1045 syscall_table
[SYS_plock
] = "plock";
1047 #if defined (SYS_setgid)
1048 syscall_table
[SYS_setgid
] = "setgid";
1050 #if defined (SYS_getgid)
1051 syscall_table
[SYS_getgid
] = "getgid";
1053 #if defined (SYS_signal)
1054 syscall_table
[SYS_signal
] = "signal";
1056 #if defined (SYS_msgsys)
1057 syscall_table
[SYS_msgsys
] = "msgsys";
1059 #if defined (SYS_sys3b)
1060 syscall_table
[SYS_sys3b
] = "sys3b";
1062 #if defined (SYS_acct)
1063 syscall_table
[SYS_acct
] = "acct";
1065 #if defined (SYS_shmsys)
1066 syscall_table
[SYS_shmsys
] = "shmsys";
1068 #if defined (SYS_semsys)
1069 syscall_table
[SYS_semsys
] = "semsys";
1071 #if defined (SYS_ioctl)
1072 syscall_table
[SYS_ioctl
] = "ioctl";
1074 #if defined (SYS_uadmin)
1075 syscall_table
[SYS_uadmin
] = "uadmin";
1077 #if defined (SYS_utssys)
1078 syscall_table
[SYS_utssys
] = "utssys";
1080 #if defined (SYS_fsync)
1081 syscall_table
[SYS_fsync
] = "fsync";
1083 #if defined (SYS_umask)
1084 syscall_table
[SYS_umask
] = "umask";
1086 #if defined (SYS_chroot)
1087 syscall_table
[SYS_chroot
] = "chroot";
1089 #if defined (SYS_fcntl)
1090 syscall_table
[SYS_fcntl
] = "fcntl";
1092 #if defined (SYS_ulimit)
1093 syscall_table
[SYS_ulimit
] = "ulimit";
1095 #if defined (SYS_rfsys)
1096 syscall_table
[SYS_rfsys
] = "rfsys";
1098 #if defined (SYS_rmdir)
1099 syscall_table
[SYS_rmdir
] = "rmdir";
1101 #if defined (SYS_mkdir)
1102 syscall_table
[SYS_mkdir
] = "mkdir";
1104 #if defined (SYS_getdents)
1105 syscall_table
[SYS_getdents
] = "getdents";
1107 #if defined (SYS_sysfs)
1108 syscall_table
[SYS_sysfs
] = "sysfs";
1110 #if defined (SYS_getmsg)
1111 syscall_table
[SYS_getmsg
] = "getmsg";
1113 #if defined (SYS_putmsg)
1114 syscall_table
[SYS_putmsg
] = "putmsg";
1116 #if defined (SYS_poll)
1117 syscall_table
[SYS_poll
] = "poll";
1119 #if defined (SYS_lstat)
1120 syscall_table
[SYS_lstat
] = "lstat";
1122 #if defined (SYS_symlink)
1123 syscall_table
[SYS_symlink
] = "symlink";
1125 #if defined (SYS_readlink)
1126 syscall_table
[SYS_readlink
] = "readlink";
1128 #if defined (SYS_setgroups)
1129 syscall_table
[SYS_setgroups
] = "setgroups";
1131 #if defined (SYS_getgroups)
1132 syscall_table
[SYS_getgroups
] = "getgroups";
1134 #if defined (SYS_fchmod)
1135 syscall_table
[SYS_fchmod
] = "fchmod";
1137 #if defined (SYS_fchown)
1138 syscall_table
[SYS_fchown
] = "fchown";
1140 #if defined (SYS_sigprocmask)
1141 syscall_table
[SYS_sigprocmask
] = "sigprocmask";
1143 #if defined (SYS_sigsuspend)
1144 syscall_table
[SYS_sigsuspend
] = "sigsuspend";
1146 #if defined (SYS_sigaltstack)
1147 syscall_table
[SYS_sigaltstack
] = "sigaltstack";
1149 #if defined (SYS_sigaction)
1150 syscall_table
[SYS_sigaction
] = "sigaction";
1152 #if defined (SYS_sigpending)
1153 syscall_table
[SYS_sigpending
] = "sigpending";
1155 #if defined (SYS_context)
1156 syscall_table
[SYS_context
] = "context";
1158 #if defined (SYS_evsys)
1159 syscall_table
[SYS_evsys
] = "evsys";
1161 #if defined (SYS_evtrapret)
1162 syscall_table
[SYS_evtrapret
] = "evtrapret";
1164 #if defined (SYS_statvfs)
1165 syscall_table
[SYS_statvfs
] = "statvfs";
1167 #if defined (SYS_fstatvfs)
1168 syscall_table
[SYS_fstatvfs
] = "fstatvfs";
1170 #if defined (SYS_nfssys)
1171 syscall_table
[SYS_nfssys
] = "nfssys";
1173 #if defined (SYS_waitsys)
1174 syscall_table
[SYS_waitsys
] = "waitsys";
1176 #if defined (SYS_sigsendsys)
1177 syscall_table
[SYS_sigsendsys
] = "sigsendsys";
1179 #if defined (SYS_hrtsys)
1180 syscall_table
[SYS_hrtsys
] = "hrtsys";
1182 #if defined (SYS_acancel)
1183 syscall_table
[SYS_acancel
] = "acancel";
1185 #if defined (SYS_async)
1186 syscall_table
[SYS_async
] = "async";
1188 #if defined (SYS_priocntlsys)
1189 syscall_table
[SYS_priocntlsys
] = "priocntlsys";
1191 #if defined (SYS_pathconf)
1192 syscall_table
[SYS_pathconf
] = "pathconf";
1194 #if defined (SYS_mincore)
1195 syscall_table
[SYS_mincore
] = "mincore";
1197 #if defined (SYS_mmap)
1198 syscall_table
[SYS_mmap
] = "mmap";
1200 #if defined (SYS_mprotect)
1201 syscall_table
[SYS_mprotect
] = "mprotect";
1203 #if defined (SYS_munmap)
1204 syscall_table
[SYS_munmap
] = "munmap";
1206 #if defined (SYS_fpathconf)
1207 syscall_table
[SYS_fpathconf
] = "fpathconf";
1209 #if defined (SYS_vfork)
1210 syscall_table
[SYS_vfork
] = "vfork";
1212 #if defined (SYS_fchdir)
1213 syscall_table
[SYS_fchdir
] = "fchdir";
1215 #if defined (SYS_readv)
1216 syscall_table
[SYS_readv
] = "readv";
1218 #if defined (SYS_writev)
1219 syscall_table
[SYS_writev
] = "writev";
1221 #if defined (SYS_xstat)
1222 syscall_table
[SYS_xstat
] = "xstat";
1224 #if defined (SYS_lxstat)
1225 syscall_table
[SYS_lxstat
] = "lxstat";
1227 #if defined (SYS_fxstat)
1228 syscall_table
[SYS_fxstat
] = "fxstat";
1230 #if defined (SYS_xmknod)
1231 syscall_table
[SYS_xmknod
] = "xmknod";
1233 #if defined (SYS_clocal)
1234 syscall_table
[SYS_clocal
] = "clocal";
1236 #if defined (SYS_setrlimit)
1237 syscall_table
[SYS_setrlimit
] = "setrlimit";
1239 #if defined (SYS_getrlimit)
1240 syscall_table
[SYS_getrlimit
] = "getrlimit";
1242 #if defined (SYS_lchown)
1243 syscall_table
[SYS_lchown
] = "lchown";
1245 #if defined (SYS_memcntl)
1246 syscall_table
[SYS_memcntl
] = "memcntl";
1248 #if defined (SYS_getpmsg)
1249 syscall_table
[SYS_getpmsg
] = "getpmsg";
1251 #if defined (SYS_putpmsg)
1252 syscall_table
[SYS_putpmsg
] = "putpmsg";
1254 #if defined (SYS_rename)
1255 syscall_table
[SYS_rename
] = "rename";
1257 #if defined (SYS_uname)
1258 syscall_table
[SYS_uname
] = "uname";
1260 #if defined (SYS_setegid)
1261 syscall_table
[SYS_setegid
] = "setegid";
1263 #if defined (SYS_sysconfig)
1264 syscall_table
[SYS_sysconfig
] = "sysconfig";
1266 #if defined (SYS_adjtime)
1267 syscall_table
[SYS_adjtime
] = "adjtime";
1269 #if defined (SYS_systeminfo)
1270 syscall_table
[SYS_systeminfo
] = "systeminfo";
1272 #if defined (SYS_seteuid)
1273 syscall_table
[SYS_seteuid
] = "seteuid";
1275 #if defined (SYS_sproc)
1276 syscall_table
[SYS_sproc
] = "sproc";
1284 procfs_kill_inferior - kill any currently inferior
1288 void procfs_kill_inferior (void)
1292 Kill any current inferior.
1296 Kills even attached inferiors. Presumably the user has already
1297 been prompted that the inferior is an attached one rather than
1298 one started by gdb. (FIXME?)
1303 procfs_kill_inferior ()
1305 target_mourn_inferior ();
1312 unconditionally_kill_inferior - terminate the inferior
1316 static void unconditionally_kill_inferior (struct procinfo *)
1320 Kill the specified inferior.
1324 A possibly useful enhancement would be to first try sending
1325 the inferior a terminate signal, politely asking it to commit
1326 suicide, before we murder it (we could call that
1327 politely_kill_inferior()).
1332 unconditionally_kill_inferior (pi
)
1333 struct procinfo
*pi
;
1338 ppid
= pi
->prstatus
.pr_ppid
;
1342 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
1343 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
1344 before the PIOCKILL, otherwise it might generate a corrupted core
1345 file for the inferior. */
1346 ioctl (pi
->fd
, PIOCSSIG
, NULL
);
1348 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
1349 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
1350 to kill the inferior, otherwise it might remain stopped with a
1352 We do not check the result of the PIOCSSIG, the inferior might have
1355 struct siginfo newsiginfo
;
1357 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
1358 newsiginfo
.si_signo
= signo
;
1359 newsiginfo
.si_code
= 0;
1360 newsiginfo
.si_errno
= 0;
1361 newsiginfo
.si_pid
= getpid ();
1362 newsiginfo
.si_uid
= getuid ();
1363 ioctl (pi
->fd
, PIOCSSIG
, &newsiginfo
);
1366 ioctl (pi
->fd
, PIOCKILL
, &signo
);
1369 close_proc_file (pi
);
1371 /* Only wait() for our direct children. Our grandchildren zombies are killed
1372 by the death of their parents. */
1374 if (ppid
== getpid())
1382 procfs_xfer_memory -- copy data to or from inferior memory space
1386 int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1387 int dowrite, struct target_ops target)
1391 Copy LEN bytes to/from inferior's memory starting at MEMADDR
1392 from/to debugger memory starting at MYADDR. Copy from inferior
1393 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
1395 Returns the length copied, which is either the LEN argument or
1396 zero. This xfer function does not do partial moves, since procfs_ops
1397 doesn't allow memory operations to cross below us in the target stack
1402 The /proc interface makes this an almost trivial task.
1406 procfs_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
1411 struct target_ops
*target
; /* ignored */
1414 struct procinfo
*pi
;
1416 pi
= current_procinfo
;
1418 if (lseek(pi
->fd
, (off_t
) memaddr
, 0) == (off_t
) memaddr
)
1422 nbytes
= write (pi
->fd
, myaddr
, len
);
1426 nbytes
= read (pi
->fd
, myaddr
, len
);
1440 procfs_store_registers -- copy register values back to inferior
1444 void procfs_store_registers (int regno)
1448 Store our current register values back into the inferior. If
1449 REGNO is -1 then store all the register, otherwise store just
1450 the value specified by REGNO.
1454 If we are storing only a single register, we first have to get all
1455 the current values from the process, overwrite the desired register
1456 in the gregset with the one we want from gdb's registers, and then
1457 send the whole set back to the process. For writing all the
1458 registers, all we have to do is generate the gregset and send it to
1461 Also note that the process has to be stopped on an event of interest
1462 for this to work, which basically means that it has to have been
1463 run under the control of one of the other /proc ioctl calls and not
1464 ptrace. Since we don't use ptrace anyway, we don't worry about this
1465 fine point, but it is worth noting for future reference.
1467 Gdb is confused about what this function is supposed to return.
1468 Some versions return a value, others return nothing. Some are
1469 declared to return a value and actually return nothing. Gdb ignores
1470 anything returned. (FIXME)
1475 procfs_store_registers (regno
)
1478 struct procinfo
*pi
;
1480 pi
= current_procinfo
;
1484 ioctl (pi
->fd
, PIOCGREG
, &pi
->gregset
);
1486 fill_gregset (&pi
->gregset
, regno
);
1487 ioctl (pi
->fd
, PIOCSREG
, &pi
->gregset
);
1489 #if defined (FP0_REGNUM)
1491 /* Now repeat everything using the floating point register set, if the
1492 target has floating point hardware. Since we ignore the returned value,
1493 we'll never know whether it worked or not anyway. */
1497 ioctl (pi
->fd
, PIOCGFPREG
, &pi
->fpregset
);
1499 fill_fpregset (&pi
->fpregset
, regno
);
1500 ioctl (pi
->fd
, PIOCSFPREG
, &pi
->fpregset
);
1502 #endif /* FP0_REGNUM */
1510 create_procinfo - initialize access to a /proc entry
1514 struct procinfo * create_procinfo (int pid)
1518 Allocate a procinfo structure, open the /proc file and then set up the
1519 set of signals and faults that are to be traced. Returns a pointer to
1520 the new procinfo structure.
1524 If proc_init_failed ever gets called, control returns to the command
1525 processing loop via the standard error handling code.
1529 static struct procinfo
*
1530 create_procinfo (pid
)
1533 struct procinfo
*pi
;
1535 pi
= find_procinfo (pid
, 1);
1537 return pi
; /* All done! It already exists */
1539 pi
= (struct procinfo
*) xmalloc (sizeof (struct procinfo
));
1541 if (!open_proc_file (pid
, pi
, O_RDWR
))
1542 proc_init_failed (pi
, "can't open process file");
1544 /* open_proc_file may modify pid. */
1548 /* Add new process to process info list */
1550 pi
->next
= procinfo_list
;
1553 add_fd (pi
); /* Add to list for poll/select */
1555 pi
->num_syscall_handlers
= 0;
1556 pi
->syscall_handlers
= NULL
;
1557 memset ((char *) &pi
->prrun
, 0, sizeof (pi
->prrun
));
1558 prfillset (&pi
->prrun
.pr_trace
);
1559 procfs_notice_signals (pid
);
1560 prfillset (&pi
->prrun
.pr_fault
);
1561 prdelset (&pi
->prrun
.pr_fault
, FLTPAGE
);
1563 #ifdef PROCFS_DONT_TRACE_FAULTS
1564 premptyset (&pi
->prrun
.pr_fault
);
1567 if (ioctl (pi
->fd
, PIOCSTATUS
, &pi
->prstatus
) < 0)
1568 proc_init_failed (pi
, "PIOCSTATUS failed");
1570 /* A bug in Solaris (2.5 at least) causes PIOCWSTOP to hang on LWPs that are
1571 already stopped, even if they all have PR_ASYNC set. */
1573 if (!(pi
->prstatus
.pr_flags
& PR_STOPPED
))
1574 if (ioctl (pi
->fd
, PIOCWSTOP
, &pi
->prstatus
) < 0)
1575 proc_init_failed (pi
, "PIOCWSTOP failed");
1577 if (ioctl (pi
->fd
, PIOCSFAULT
, &pi
->prrun
.pr_fault
) < 0)
1578 proc_init_failed (pi
, "PIOCSFAULT failed");
1587 procfs_exit_handler - handle entry into the _exit syscall
1591 int procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
1595 This routine is called when an inferior process enters the _exit()
1596 system call. It continues the process, and then collects the exit
1597 status and pid which are returned in *statvalp and *rtnvalp. After
1598 that it returns non-zero to indicate that procfs_wait should wake up.
1601 There is probably a better way to do this.
1606 procfs_exit_handler (pi
, syscall_num
, why
, rtnvalp
, statvalp
)
1607 struct procinfo
*pi
;
1613 pi
->prrun
.pr_flags
= PRCFAULT
;
1615 if (ioctl (pi
->fd
, PIOCRUN
, &pi
->prrun
) != 0)
1616 perror_with_name (pi
->pathname
);
1618 *rtnvalp
= wait (statvalp
);
1629 procfs_exec_handler - handle exit from the exec family of syscalls
1633 int procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
1637 This routine is called when an inferior process is about to finish any
1638 of the exec() family of system calls. It pretends that we got a
1639 SIGTRAP (for compatibility with ptrace behavior), and returns non-zero
1640 to tell procfs_wait to wake up.
1643 This need for compatibility with ptrace is questionable. In the
1644 future, it shouldn't be necessary.
1649 procfs_exec_handler (pi
, syscall_num
, why
, rtnvalp
, statvalp
)
1650 struct procinfo
*pi
;
1656 *statvalp
= (SIGTRAP
<< 8) | 0177;
1661 #ifdef SYS_sproc /* IRIX lwp creation system call */
1667 procfs_sproc_handler - handle exit from the sproc syscall
1671 int procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
1675 This routine is called when an inferior process is about to finish an
1676 sproc() system call. This is the system call that IRIX uses to create
1677 a lightweight process. When the target process gets this event, we can
1678 look at rval1 to find the new child processes ID, and create a new
1679 procinfo struct from that.
1681 After that, it pretends that we got a SIGTRAP, and returns non-zero
1682 to tell procfs_wait to wake up. Subsequently, wait_for_inferior gets
1683 woken up, sees the new process and continues it.
1686 We actually never see the child exiting from sproc because we will
1687 shortly stop the child with PIOCSTOP, which is then registered as the
1692 procfs_sproc_handler (pi
, syscall_num
, why
, rtnvalp
, statvalp
)
1693 struct procinfo
*pi
;
1699 /* We've just detected the completion of an sproc system call. Now we need to
1700 setup a procinfo struct for this thread, and notify the thread system of the
1703 /* If sproc failed, then nothing interesting happened. Continue the process
1704 and go back to sleep. */
1706 if (pi
->prstatus
.pr_errno
!= 0)
1708 pi
->prrun
.pr_flags
&= PRSTEP
;
1709 pi
->prrun
.pr_flags
|= PRCFAULT
;
1711 if (ioctl (pi
->fd
, PIOCRUN
, &pi
->prrun
) != 0)
1712 perror_with_name (pi
->pathname
);
1717 /* At this point, the new thread is stopped at it's first instruction, and
1718 the parent is stopped at the exit from sproc. */
1720 /* Notify the caller of the arrival of a new thread. */
1721 create_procinfo (pi
->prstatus
.pr_rval1
);
1723 *rtnvalp
= pi
->prstatus
.pr_rval1
;
1724 *statvalp
= (SIGTRAP
<< 8) | 0177;
1733 procfs_fork_handler - handle exit from the fork syscall
1737 int procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
1741 This routine is called when an inferior process is about to finish a
1742 fork() system call. We will open up the new process, and then close
1743 it, which releases it from the clutches of the debugger.
1745 After that, we continue the target process as though nothing had
1749 This is necessary for IRIX because we have to set PR_FORK in order
1750 to catch the creation of lwps (via sproc()). When an actual fork
1751 occurs, it becomes necessary to reset the forks debugger flags and
1752 continue it because we can't hack multiple processes yet.
1756 procfs_fork_handler (pi
, syscall_num
, why
, rtnvalp
, statvalp
)
1757 struct procinfo
*pi
;
1763 struct procinfo
*pitemp
;
1765 /* At this point, we've detected the completion of a fork (or vfork) call in
1766 our child. The grandchild is also stopped because we set inherit-on-fork
1767 earlier. (Note that nobody has the grandchilds' /proc file open at this
1768 point.) We will release the grandchild from the debugger by opening it's
1769 /proc file and then closing it. Since run-on-last-close is set, the
1770 grandchild continues on its' merry way. */
1773 pitemp
= create_procinfo (pi
->prstatus
.pr_rval1
);
1775 close_proc_file (pitemp
);
1777 if (ioctl (pi
->fd
, PIOCRUN
, &pi
->prrun
) != 0)
1778 perror_with_name (pi
->pathname
);
1782 #endif /* SYS_sproc */
1788 procfs_init_inferior - initialize target vector and access to a
1793 int procfs_init_inferior (int pid)
1797 When gdb starts an inferior, this function is called in the parent
1798 process immediately after the fork. It waits for the child to stop
1799 on the return from the exec system call (the child itself takes care
1800 of ensuring that this is set up), then sets up the set of signals
1801 and faults that are to be traced. Returns the pid, which may have had
1802 the thread-id added to it.
1806 If proc_init_failed ever gets called, control returns to the command
1807 processing loop via the standard error handling code.
1812 procfs_init_inferior (pid
)
1815 struct procinfo
*pip
;
1817 push_target (&procfs_ops
);
1819 pip
= create_procinfo (pid
);
1822 procfs_set_syscall_trap (pip
, SYS_exit
, PROCFS_SYSCALL_ENTRY
,
1823 procfs_exit_handler
);
1826 procfs_set_syscall_trap (pip
, SYS_exec
, PROCFS_SYSCALL_EXIT
,
1827 procfs_exec_handler
);
1830 procfs_set_syscall_trap (pip
, SYS_execv
, PROCFS_SYSCALL_EXIT
,
1831 procfs_exec_handler
);
1834 procfs_set_syscall_trap (pip
, SYS_execve
, PROCFS_SYSCALL_EXIT
,
1835 procfs_exec_handler
);
1837 #endif /* PIOCSSPCACT */
1839 /* Setup traps on exit from sproc() */
1842 procfs_set_syscall_trap (pip
, SYS_sproc
, PROCFS_SYSCALL_EXIT
,
1843 procfs_sproc_handler
);
1844 procfs_set_syscall_trap (pip
, SYS_fork
, PROCFS_SYSCALL_EXIT
,
1845 procfs_fork_handler
);
1847 procfs_set_syscall_trap (pip
, SYS_vfork
, PROCFS_SYSCALL_EXIT
,
1848 procfs_fork_handler
);
1850 /* Turn on inherit-on-fork flag so that all children of the target process
1851 start with tracing flags set. This allows us to trap lwp creation. Note
1852 that we also have to trap on fork and vfork in order to disable all tracing
1853 in the targets child processes. */
1855 modify_inherit_on_fork_flag (pip
->fd
, 1);
1858 #ifdef SYS_lwp_create
1859 procfs_set_syscall_trap (pip
, SYS_lwp_create
, PROCFS_SYSCALL_EXIT
,
1860 procfs_lwp_creation_handler
);
1863 /* create_procinfo may change the pid, so we have to update inferior_pid
1864 here before calling other gdb routines that need the right pid. */
1869 add_thread (pip
-> pid
); /* Setup initial thread */
1871 #ifdef START_INFERIOR_TRAPS_EXPECTED
1872 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
1874 /* One trap to exec the shell, one to exec the program being debugged. */
1875 startup_inferior (2);
1885 procfs_notice_signals
1889 static void procfs_notice_signals (int pid);
1893 When the user changes the state of gdb's signal handling via the
1894 "handle" command, this function gets called to see if any change
1895 in the /proc interface is required. It is also called internally
1896 by other /proc interface functions to initialize the state of
1897 the traced signal set.
1899 One thing it does is that signals for which the state is "nostop",
1900 "noprint", and "pass", have their trace bits reset in the pr_trace
1901 field, so that they are no longer traced. This allows them to be
1902 delivered directly to the inferior without the debugger ever being
1907 procfs_notice_signals (pid
)
1911 struct procinfo
*pi
;
1913 pi
= find_procinfo (pid
, 0);
1915 for (signo
= 0; signo
< NSIG
; signo
++)
1917 if (signal_stop_state (target_signal_from_host (signo
)) == 0 &&
1918 signal_print_state (target_signal_from_host (signo
)) == 0 &&
1919 signal_pass_state (target_signal_from_host (signo
)) == 1)
1921 prdelset (&pi
->prrun
.pr_trace
, signo
);
1925 praddset (&pi
->prrun
.pr_trace
, signo
);
1928 if (ioctl (pi
->fd
, PIOCSTRACE
, &pi
->prrun
.pr_trace
))
1930 print_sys_errmsg ("PIOCSTRACE failed", errno
);
1938 proc_set_exec_trap -- arrange for exec'd child to halt at startup
1942 void proc_set_exec_trap (void)
1946 This function is called in the child process when starting up
1947 an inferior, prior to doing the exec of the actual inferior.
1948 It sets the child process's exitset to make exit from the exec
1949 system call an event of interest to stop on, and then simply
1950 returns. The child does the exec, the system call returns, and
1951 the child stops at the first instruction, ready for the gdb
1952 parent process to take control of it.
1956 We need to use all local variables since the child may be sharing
1957 it's data space with the parent, if vfork was used rather than
1960 Also note that we want to turn off the inherit-on-fork flag in
1961 the child process so that any grand-children start with all
1962 tracing flags cleared.
1966 proc_set_exec_trap ()
1970 auto char procname
[32];
1973 sprintf (procname
, PROC_NAME_FMT
, getpid ());
1974 if ((fd
= open (procname
, O_RDWR
)) < 0)
1977 gdb_flush (gdb_stderr
);
1980 premptyset (&exitset
);
1981 premptyset (&entryset
);
1984 /* Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
1985 exits from exec system calls because of the user level loader.
1986 Starting with OSF/1-4.0, tracing the entry to the exit system
1987 call no longer works. So we have to use PRFS_STOPTERM to trace
1988 termination of the inferior. */
1992 if (ioctl (fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
1995 gdb_flush (gdb_stderr
);
1998 prfs_flags
|= PRFS_STOPEXEC
| PRFS_STOPTERM
;
1999 if (ioctl (fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
2002 gdb_flush (gdb_stderr
);
2006 #else /* PIOCSSPCACT */
2008 Not all systems with /proc have all the exec* syscalls with the same
2009 names. On the SGI, for example, there is no SYS_exec, but there
2010 *is* a SYS_execv. So, we try to account for that. */
2013 praddset (&exitset
, SYS_exec
);
2016 praddset (&exitset
, SYS_execve
);
2019 praddset (&exitset
, SYS_execv
);
2022 if (ioctl (fd
, PIOCSEXIT
, &exitset
) < 0)
2025 gdb_flush (gdb_stderr
);
2029 praddset (&entryset
, SYS_exit
);
2031 if (ioctl (fd
, PIOCSENTRY
, &entryset
) < 0)
2034 gdb_flush (gdb_stderr
);
2037 #endif /* PIOCSSPCACT */
2039 /* Turn off inherit-on-fork flag so that all grand-children of gdb
2040 start with tracing flags cleared. */
2042 modify_inherit_on_fork_flag (fd
, 0);
2044 /* Turn on run-on-last-close flag so that this process will not hang
2045 if GDB goes away for some reason. */
2047 modify_run_on_last_close_flag (fd
, 1);
2053 /* Solaris needs this to make procfs treat all threads seperately. Without
2054 this, all threads halt whenever something happens to any thread. Since
2055 GDB wants to control all this itself, it needs to set PR_ASYNC. */
2057 pr_flags
= PR_ASYNC
;
2059 ioctl (fd
, PIOCSET
, &pr_flags
);
2061 #endif /* PR_ASYNC */
2068 proc_iterate_over_mappings -- call function for every mapped space
2072 int proc_iterate_over_mappings (int (*func)())
2076 Given a pointer to a function, call that function for every
2077 mapped address space, passing it an open file descriptor for
2078 the file corresponding to that mapped address space (if any)
2079 and the base address of the mapped space. Quit when we hit
2080 the end of the mappings or the function returns nonzero.
2084 proc_iterate_over_mappings (func
)
2085 int (*func
) PARAMS ((int, CORE_ADDR
));
2090 struct prmap
*prmaps
;
2091 struct prmap
*prmap
;
2092 struct procinfo
*pi
;
2094 pi
= current_procinfo
;
2096 if (ioctl (pi
->fd
, PIOCNMAP
, &nmap
) == 0)
2098 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
2099 if (ioctl (pi
->fd
, PIOCMAP
, prmaps
) == 0)
2101 for (prmap
= prmaps
; prmap
-> pr_size
&& funcstat
== 0; ++prmap
)
2103 fd
= proc_address_to_fd (pi
, (CORE_ADDR
) prmap
-> pr_vaddr
, 0);
2104 funcstat
= (*func
) (fd
, (CORE_ADDR
) prmap
-> pr_vaddr
);
2112 #if 0 /* Currently unused */
2117 proc_base_address -- find base address for segment containing address
2121 CORE_ADDR proc_base_address (CORE_ADDR addr)
2125 Given an address of a location in the inferior, find and return
2126 the base address of the mapped segment containing that address.
2128 This is used for example, by the shared library support code,
2129 where we have the pc value for some location in the shared library
2130 where we are stopped, and need to know the base address of the
2131 segment containing that address.
2135 proc_base_address (addr
)
2139 struct prmap
*prmaps
;
2140 struct prmap
*prmap
;
2141 CORE_ADDR baseaddr
= 0;
2142 struct procinfo
*pi
;
2144 pi
= current_procinfo
;
2146 if (ioctl (pi
->fd
, PIOCNMAP
, &nmap
) == 0)
2148 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
2149 if (ioctl (pi
->fd
, PIOCMAP
, prmaps
) == 0)
2151 for (prmap
= prmaps
; prmap
-> pr_size
; ++prmap
)
2153 if ((prmap
-> pr_vaddr
<= (caddr_t
) addr
) &&
2154 (prmap
-> pr_vaddr
+ prmap
-> pr_size
> (caddr_t
) addr
))
2156 baseaddr
= (CORE_ADDR
) prmap
-> pr_vaddr
;
2171 proc_address_to_fd -- return open fd for file mapped to address
2175 int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
2179 Given an address in the current inferior's address space, use the
2180 /proc interface to find an open file descriptor for the file that
2181 this address was mapped in from. Return -1 if there is no current
2182 inferior. Print a warning message if there is an inferior but
2183 the address corresponds to no file (IE a bogus address).
2188 proc_address_to_fd (pi
, addr
, complain
)
2189 struct procinfo
*pi
;
2195 if ((fd
= ioctl (pi
->fd
, PIOCOPENM
, (caddr_t
*) &addr
)) < 0)
2199 print_sys_errmsg (pi
->pathname
, errno
);
2200 warning ("can't find mapped file for address 0x%x", addr
);
2207 /* Attach to process PID, then initialize for debugging it
2208 and wait for the trace-trap that results from attaching. */
2211 procfs_attach (args
, from_tty
)
2219 error_no_arg ("process-id to attach");
2223 if (pid
== getpid()) /* Trying to masturbate? */
2224 error ("I refuse to debug myself!");
2228 exec_file
= (char *) get_exec_file (0);
2231 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
, target_pid_to_str (pid
));
2233 printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid
));
2235 gdb_flush (gdb_stdout
);
2238 inferior_pid
= pid
= do_attach (pid
);
2239 push_target (&procfs_ops
);
2243 /* Take a program previously attached to and detaches it.
2244 The program resumes execution and will no longer stop
2245 on signals, etc. We'd better not have left any breakpoints
2246 in the program or it'll die when it hits one. For this
2247 to work, it may be necessary for the process to have been
2248 previously attached. It *might* work if the program was
2249 started via the normal ptrace (PTRACE_TRACEME). */
2252 procfs_detach (args
, from_tty
)
2260 char *exec_file
= get_exec_file (0);
2263 printf_unfiltered ("Detaching from program: %s %s\n",
2264 exec_file
, target_pid_to_str (inferior_pid
));
2265 gdb_flush (gdb_stdout
);
2268 siggnal
= atoi (args
);
2270 do_detach (siggnal
);
2272 unpush_target (&procfs_ops
); /* Pop out of handling an inferior */
2275 /* Get ready to modify the registers array. On machines which store
2276 individual registers, this doesn't need to do anything. On machines
2277 which store all the registers in one fell swoop, this makes sure
2278 that registers contains all the registers from the program being
2282 procfs_prepare_to_store ()
2284 #ifdef CHILD_PREPARE_TO_STORE
2285 CHILD_PREPARE_TO_STORE ();
2289 /* Print status information about what we're accessing. */
2292 procfs_files_info (ignore
)
2293 struct target_ops
*ignore
;
2295 printf_unfiltered ("\tUsing the running image of %s %s via /proc.\n",
2296 attach_flag
? "attached": "child", target_pid_to_str (inferior_pid
));
2301 procfs_open (arg
, from_tty
)
2305 error ("Use the \"run\" command to start a Unix child process.");
2312 do_attach -- attach to an already existing process
2316 int do_attach (int pid)
2320 Attach to an already existing process with the specified process
2321 id. If the process is not already stopped, query whether to
2326 The option of stopping at attach time is specific to the /proc
2327 versions of gdb. Versions using ptrace force the attachee
2328 to stop. (I have changed this version to do so, too. All you
2329 have to do is "continue" to make it go on. -- gnu@cygnus.com)
2337 struct procinfo
*pi
;
2339 pi
= (struct procinfo
*) xmalloc (sizeof (struct procinfo
));
2341 if (!open_proc_file (pid
, pi
, O_RDWR
))
2344 perror_with_name (pi
->pathname
);
2350 /* Add new process to process info list */
2352 pi
->next
= procinfo_list
;
2355 add_fd (pi
); /* Add to list for poll/select */
2357 /* Get current status of process and if it is not already stopped,
2358 then stop it. Remember whether or not it was stopped when we first
2361 if (ioctl (pi
->fd
, PIOCSTATUS
, &pi
->prstatus
) < 0)
2363 print_sys_errmsg (pi
->pathname
, errno
);
2364 close_proc_file (pi
);
2365 error ("PIOCSTATUS failed");
2367 if (pi
->prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
))
2369 pi
->was_stopped
= 1;
2373 pi
->was_stopped
= 0;
2374 if (1 || query ("Process is currently running, stop it? "))
2376 /* Make it run again when we close it. */
2378 modify_run_on_last_close_flag (pi
->fd
, 1);
2380 if (ioctl (pi
->fd
, PIOCSTOP
, &pi
->prstatus
) < 0)
2382 print_sys_errmsg (pi
->pathname
, errno
);
2383 close_proc_file (pi
);
2384 error ("PIOCSTOP failed");
2386 pi
->nopass_next_sigstop
= 1;
2390 printf_unfiltered ("Ok, gdb will wait for %s to stop.\n", target_pid_to_str (pid
));
2394 /* Remember some things about the inferior that we will, or might, change
2395 so that we can restore them when we detach. */
2397 ioctl (pi
->fd
, PIOCGTRACE
, &pi
->saved_trace
);
2398 ioctl (pi
->fd
, PIOCGHOLD
, &pi
->saved_sighold
);
2399 ioctl (pi
->fd
, PIOCGFAULT
, &pi
->saved_fltset
);
2400 ioctl (pi
->fd
, PIOCGENTRY
, &pi
->saved_entryset
);
2401 ioctl (pi
->fd
, PIOCGEXIT
, &pi
->saved_exitset
);
2403 /* Set up trace and fault sets, as gdb expects them. */
2405 memset (&pi
->prrun
, 0, sizeof (pi
->prrun
));
2406 prfillset (&pi
->prrun
.pr_trace
);
2407 procfs_notice_signals (pid
);
2408 prfillset (&pi
->prrun
.pr_fault
);
2409 prdelset (&pi
->prrun
.pr_fault
, FLTPAGE
);
2411 #ifdef PROCFS_DONT_TRACE_FAULTS
2412 premptyset (&pi
->prrun
.pr_fault
);
2415 if (ioctl (pi
->fd
, PIOCSFAULT
, &pi
->prrun
.pr_fault
))
2417 print_sys_errmsg ("PIOCSFAULT failed", errno
);
2419 if (ioctl (pi
->fd
, PIOCSTRACE
, &pi
->prrun
.pr_trace
))
2421 print_sys_errmsg ("PIOCSTRACE failed", errno
);
2431 do_detach -- detach from an attached-to process
2435 void do_detach (int signal)
2439 Detach from the current attachee.
2441 If signal is non-zero, the attachee is started running again and sent
2442 the specified signal.
2444 If signal is zero and the attachee was not already stopped when we
2445 attached to it, then we make it runnable again when we detach.
2447 Otherwise, we query whether or not to make the attachee runnable
2448 again, since we may simply want to leave it in the state it was in
2451 We report any problems, but do not consider them errors, since we
2452 MUST detach even if some things don't seem to go right. This may not
2453 be the ideal situation. (FIXME).
2460 struct procinfo
*pi
;
2462 pi
= current_procinfo
;
2466 set_proc_siginfo (pi
, signal
);
2468 if (ioctl (pi
->fd
, PIOCSEXIT
, &pi
->saved_exitset
) < 0)
2470 print_sys_errmsg (pi
->pathname
, errno
);
2471 printf_unfiltered ("PIOCSEXIT failed.\n");
2473 if (ioctl (pi
->fd
, PIOCSENTRY
, &pi
->saved_entryset
) < 0)
2475 print_sys_errmsg (pi
->pathname
, errno
);
2476 printf_unfiltered ("PIOCSENTRY failed.\n");
2478 if (ioctl (pi
->fd
, PIOCSTRACE
, &pi
->saved_trace
) < 0)
2480 print_sys_errmsg (pi
->pathname
, errno
);
2481 printf_unfiltered ("PIOCSTRACE failed.\n");
2483 if (ioctl (pi
->fd
, PIOCSHOLD
, &pi
->saved_sighold
) < 0)
2485 print_sys_errmsg (pi
->pathname
, errno
);
2486 printf_unfiltered ("PIOSCHOLD failed.\n");
2488 if (ioctl (pi
->fd
, PIOCSFAULT
, &pi
->saved_fltset
) < 0)
2490 print_sys_errmsg (pi
->pathname
, errno
);
2491 printf_unfiltered ("PIOCSFAULT failed.\n");
2493 if (ioctl (pi
->fd
, PIOCSTATUS
, &pi
->prstatus
) < 0)
2495 print_sys_errmsg (pi
->pathname
, errno
);
2496 printf_unfiltered ("PIOCSTATUS failed.\n");
2500 if (signal
|| (pi
->prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
)))
2502 if (signal
|| !pi
->was_stopped
||
2503 query ("Was stopped when attached, make it runnable again? "))
2505 /* Clear any pending signal if we want to detach without
2508 set_proc_siginfo (pi
, signal
);
2510 /* Clear any fault that might have stopped it. */
2511 if (ioctl (pi
->fd
, PIOCCFAULT
, 0))
2513 print_sys_errmsg (pi
->pathname
, errno
);
2514 printf_unfiltered ("PIOCCFAULT failed.\n");
2517 /* Make it run again when we close it. */
2519 modify_run_on_last_close_flag (pi
->fd
, 1);
2523 close_proc_file (pi
);
2527 /* emulate wait() as much as possible.
2528 Wait for child to do something. Return pid of child, or -1 in case
2529 of error; store status in *OURSTATUS.
2531 Not sure why we can't
2532 just use wait(), but it seems to have problems when applied to a
2533 process being controlled with the /proc interface.
2535 We have a race problem here with no obvious solution. We need to let
2536 the inferior run until it stops on an event of interest, which means
2537 that we need to use the PIOCWSTOP ioctl. However, we cannot use this
2538 ioctl if the process is already stopped on something that is not an
2539 event of interest, or the call will hang indefinitely. Thus we first
2540 use PIOCSTATUS to see if the process is not stopped. If not, then we
2541 use PIOCWSTOP. But during the window between the two, if the process
2542 stops for any reason that is not an event of interest (such as a job
2543 control signal) then gdb will hang. One possible workaround is to set
2544 an alarm to wake up every minute of so and check to see if the process
2545 is still running, and if so, then reissue the PIOCWSTOP. But this is
2546 a real kludge, so has not been implemented. FIXME: investigate
2549 FIXME: Investigate why wait() seems to have problems with programs
2550 being control by /proc routines. */
2553 procfs_wait (pid
, ourstatus
)
2555 struct target_waitstatus
*ourstatus
;
2562 struct procinfo
*pi
;
2564 if (pid
!= -1) /* Non-specific process? */
2567 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
2582 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
2583 if (pi
->pid
== pid
&& pi
->had_event
)
2586 if (!pi
&& !checkerr
)
2589 if (!checkerr
&& !(pi
->prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
)))
2591 if (ioctl (pi
->fd
, PIOCWSTOP
, &pi
->prstatus
) < 0)
2598 if (errno
== ENOENT
)
2600 rtnval
= wait (&statval
);
2601 if (rtnval
!= inferior_pid
)
2603 print_sys_errmsg (pi
->pathname
, errno
);
2604 error ("PIOCWSTOP, wait failed, returned %d", rtnval
);
2610 print_sys_errmsg (pi
->pathname
, errno
);
2611 error ("PIOCSTATUS or PIOCWSTOP failed.");
2615 else if (pi
->prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
))
2618 why
= pi
->prstatus
.pr_why
;
2619 what
= pi
->prstatus
.pr_what
;
2624 statval
= (what
<< 8) | 0177;
2630 int found_handler
= 0;
2632 for (i
= 0; i
< pi
->num_syscall_handlers
; i
++)
2633 if (pi
->syscall_handlers
[i
].syscall_num
== what
)
2636 if (!pi
->syscall_handlers
[i
].func (pi
, what
, why
,
2644 if (why
== PR_SYSENTRY
)
2645 error ("PR_SYSENTRY, unhandled system call %d", what
);
2647 error ("PR_SYSEXIT, unhandled system call %d", what
);
2651 case (short)PR_DEAD
:
2655 /* The inferior process is about to terminate.
2656 pr_what has the process's exit or return value.
2657 A PIOCRUN ioctl must be used to restart the process so it
2658 can finish exiting. */
2660 pi
->prrun
.pr_flags
= PRCFAULT
;
2662 if (ioctl (pi
->fd
, PIOCRUN
, &pi
->prrun
) != 0)
2663 perror_with_name (pi
->pathname
);
2665 if (wait (&dummy
) < 0)
2667 statval
= pi
->prstatus
.pr_what
;
2672 statval
= (SIGSTOP
<< 8) | 0177;
2675 statval
= (what
<< 8) | 0177;
2682 statval
= (SIGTRAP
<< 8) | 0177;
2687 statval
= (SIGTRAP
<< 8) | 0177;
2690 #ifndef FAULTED_USE_SIGINFO
2691 /* Irix, contrary to the documentation, fills in 0 for si_signo.
2692 Solaris fills in si_signo. I'm not sure about others. */
2695 statval
= (SIGILL
<< 8) | 0177;
2699 statval
= (SIGTRAP
<< 8) | 0177;
2704 statval
= (SIGSEGV
<< 8) | 0177;
2709 statval
= (SIGFPE
<< 8) | 0177;
2711 case FLTPAGE
: /* Recoverable page fault */
2712 #endif /* not FAULTED_USE_SIGINFO */
2714 /* Use the signal which the kernel assigns. This is better than
2715 trying to second-guess it from the fault. In fact, I suspect
2716 that FLTACCESS can be either SIGSEGV or SIGBUS. */
2717 statval
= ((pi
->prstatus
.pr_info
.si_signo
) << 8) | 0177;
2722 error ("PIOCWSTOP, unknown why %d, what %d", why
, what
);
2724 /* Stop all the other threads when any of them stops. */
2727 struct procinfo
*procinfo
;
2729 for (procinfo
= procinfo_list
; procinfo
; procinfo
= procinfo
->next
)
2731 if (!procinfo
->had_event
)
2733 /* A bug in Solaris (2.5) causes us to hang when trying to
2734 stop a stopped process. So, we have to check first in
2735 order to avoid the hang. */
2736 if (ioctl (procinfo
->fd
, PIOCSTATUS
, &procinfo
->prstatus
) < 0)
2738 print_sys_errmsg (procinfo
->pathname
, errno
);
2739 error ("PIOCSTATUS failed");
2741 if (!(procinfo
->prstatus
.pr_flags
& PR_STOPPED
))
2742 if (ioctl (procinfo
->fd
, PIOCSTOP
, &procinfo
->prstatus
) < 0)
2744 print_sys_errmsg (procinfo
->pathname
, errno
);
2745 error ("PIOCSTOP failed");
2753 error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
2754 pi
->prstatus
.pr_flags
);
2757 store_waitstatus (ourstatus
, statval
);
2759 if (rtnval
== -1) /* No more children to wait for */
2761 fprintf_unfiltered (gdb_stderr
, "Child process unexpectedly missing.\n");
2762 /* Claim it exited with unknown signal. */
2763 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2764 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
2768 pi
->had_event
= 0; /* Indicate that we've seen this one */
2776 set_proc_siginfo - set a process's current signal info
2780 void set_proc_siginfo (struct procinfo *pip, int signo);
2784 Given a pointer to a process info struct in PIP and a signal number
2785 in SIGNO, set the process's current signal and its associated signal
2786 information. The signal will be delivered to the process immediately
2787 after execution is resumed, even if it is being held. In addition,
2788 this particular delivery will not cause another PR_SIGNALLED stop
2789 even if the signal is being traced.
2791 If we are not delivering the same signal that the prstatus siginfo
2792 struct contains information about, then synthesize a siginfo struct
2793 to match the signal we are doing to deliver, make it of the type
2794 "generated by a user process", and send this synthesized copy. When
2795 used to set the inferior's signal state, this will be required if we
2796 are not currently stopped because of a traced signal, or if we decide
2797 to continue with a different signal.
2799 Note that when continuing the inferior from a stop due to receipt
2800 of a traced signal, we either have set PRCSIG to clear the existing
2801 signal, or we have to call this function to do a PIOCSSIG with either
2802 the existing siginfo struct from pr_info, or one we have synthesized
2803 appropriately for the signal we want to deliver. Otherwise if the
2804 signal is still being traced, the inferior will immediately stop
2807 See siginfo(5) for more details.
2811 set_proc_siginfo (pip
, signo
)
2812 struct procinfo
*pip
;
2815 struct siginfo newsiginfo
;
2816 struct siginfo
*sip
;
2818 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2819 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2820 receives a PIOCSSIG with a signal identical to the current signal,
2821 it messes up the current signal. Work around the kernel bug. */
2822 if (signo
== pip
-> prstatus
.pr_cursig
)
2826 if (signo
== pip
-> prstatus
.pr_info
.si_signo
)
2828 sip
= &pip
-> prstatus
.pr_info
;
2832 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
2834 sip
-> si_signo
= signo
;
2836 sip
-> si_errno
= 0;
2837 sip
-> si_pid
= getpid ();
2838 sip
-> si_uid
= getuid ();
2840 if (ioctl (pip
-> fd
, PIOCSSIG
, sip
) < 0)
2842 print_sys_errmsg (pip
-> pathname
, errno
);
2843 warning ("PIOCSSIG failed");
2847 /* Resume execution of process PID. If STEP is nozero, then
2848 just single step it. If SIGNAL is nonzero, restart it with that
2849 signal activated. */
2852 procfs_resume (pid
, step
, signo
)
2855 enum target_signal signo
;
2858 struct procinfo
*pi
, *procinfo
;
2860 pi
= find_procinfo (pid
== -1 ? inferior_pid
: pid
, 0);
2863 pi
->prrun
.pr_flags
= PRSTRACE
| PRSFAULT
| PRCFAULT
;
2866 /* It should not be necessary. If the user explicitly changes the value,
2867 value_assign calls write_register_bytes, which writes it. */
2868 /* It may not be absolutely necessary to specify the PC value for
2869 restarting, but to be safe we use the value that gdb considers
2870 to be current. One case where this might be necessary is if the
2871 user explicitly changes the PC value that gdb considers to be
2872 current. FIXME: Investigate if this is necessary or not. */
2874 #ifdef PRSVADDR_BROKEN
2875 /* Can't do this under Solaris running on a Sparc, as there seems to be no
2876 place to put nPC. In fact, if you use this, nPC seems to be set to some
2877 random garbage. We have to rely on the fact that PC and nPC have been
2878 written previously via PIOCSREG during a register flush. */
2880 pi
->prrun
.pr_vaddr
= (caddr_t
) *(int *) ®isters
[REGISTER_BYTE (PC_REGNUM
)];
2881 pi
->prrun
.pr_flags
!= PRSVADDR
;
2885 if (signo
== TARGET_SIGNAL_STOP
&& pi
->nopass_next_sigstop
)
2886 /* When attaching to a child process, if we forced it to stop with
2887 a PIOCSTOP, then we will have set the nopass_next_sigstop flag.
2888 Upon resuming the first time after such a stop, we explicitly
2889 inhibit sending it another SIGSTOP, which would be the normal
2890 result of default signal handling. One potential drawback to
2891 this is that we will also ignore any attempt to by the user
2892 to explicitly continue after the attach with a SIGSTOP. Ultimately
2893 this problem should be dealt with by making the routines that
2894 deal with the inferior a little smarter, and possibly even allow
2895 an inferior to continue running at the same time as gdb. (FIXME?) */
2897 else if (signo
== TARGET_SIGNAL_TSTP
2898 && pi
->prstatus
.pr_cursig
== SIGTSTP
2899 && pi
->prstatus
.pr_action
.sa_handler
== SIG_DFL
)
2901 /* We are about to pass the inferior a SIGTSTP whose action is
2902 SIG_DFL. The SIG_DFL action for a SIGTSTP is to stop
2903 (notifying the parent via wait()), and then keep going from the
2904 same place when the parent is ready for you to keep going. So
2905 under the debugger, it should do nothing (as if the program had
2906 been stopped and then later resumed. Under ptrace, this
2907 happens for us, but under /proc, the system obligingly stops
2908 the process, and wait_for_inferior would have no way of
2909 distinguishing that type of stop (which indicates that we
2910 should just start it again), with a stop due to the pr_trace
2911 field of the prrun_t struct.
2913 Note that if the SIGTSTP is being caught, we *do* need to pass it,
2914 because the handler needs to get executed. */
2917 signal_to_pass
= target_signal_to_host (signo
);
2921 set_proc_siginfo (pi
, signal_to_pass
);
2925 pi
->prrun
.pr_flags
|= PRCSIG
;
2927 pi
->nopass_next_sigstop
= 0;
2930 pi
->prrun
.pr_flags
|= PRSTEP
;
2933 /* Don't try to start a process unless it's stopped on an
2934 `event of interest'. Doing so will cause errors. */
2936 if ((pi
->prstatus
.pr_flags
& PR_ISTOP
)
2937 && ioctl (pi
->fd
, PIOCRUN
, &pi
->prrun
) != 0)
2939 perror_with_name (pi
->pathname
);
2945 /* Continue all the other threads that haven't had an event of
2949 for (procinfo
= procinfo_list
; procinfo
; procinfo
= procinfo
->next
)
2951 if (pi
!= procinfo
&& !procinfo
->had_event
)
2953 procinfo
->prrun
.pr_flags
&= PRSTEP
;
2954 procinfo
->prrun
.pr_flags
|= PRCFAULT
| PRCSIG
;
2955 ioctl (procinfo
->fd
, PIOCSTATUS
, &procinfo
->prstatus
);
2957 /* Don't try to start a process unless it's stopped on an
2958 `event of interest'. Doing so will cause errors. */
2960 if ((procinfo
->prstatus
.pr_flags
& PR_ISTOP
)
2961 && ioctl (procinfo
->fd
, PIOCRUN
, &procinfo
->prrun
) < 0)
2963 if (ioctl (procinfo
->fd
, PIOCSTATUS
, &procinfo
->prstatus
) < 0)
2965 fprintf_unfiltered(gdb_stderr
, "PIOCSTATUS failed, errno=%d\n", errno
);
2967 print_sys_errmsg (procinfo
->pathname
, errno
);
2968 error ("PIOCRUN failed");
2970 ioctl (procinfo
->fd
, PIOCSTATUS
, &procinfo
->prstatus
);
2979 procfs_fetch_registers -- fetch current registers from inferior
2983 void procfs_fetch_registers (int regno)
2987 Read the current values of the inferior's registers, both the
2988 general register set and floating point registers (if supported)
2989 and update gdb's idea of their current values.
2994 procfs_fetch_registers (regno
)
2997 struct procinfo
*pi
;
2999 pi
= current_procinfo
;
3001 if (ioctl (pi
->fd
, PIOCGREG
, &pi
->gregset
) != -1)
3003 supply_gregset (&pi
->gregset
);
3005 #if defined (FP0_REGNUM)
3006 if (ioctl (pi
->fd
, PIOCGFPREG
, &pi
->fpregset
) != -1)
3008 supply_fpregset (&pi
->fpregset
);
3017 proc_init_failed - called whenever /proc access initialization
3022 static void proc_init_failed (struct procinfo *pi, char *why)
3026 This function is called whenever initialization of access to a /proc
3027 entry fails. It prints a suitable error message, does some cleanup,
3028 and then invokes the standard error processing routine which dumps
3029 us back into the command loop.
3033 proc_init_failed (pi
, why
)
3034 struct procinfo
*pi
;
3037 print_sys_errmsg (pi
->pathname
, errno
);
3038 kill (pi
->pid
, SIGKILL
);
3039 close_proc_file (pi
);
3048 close_proc_file - close any currently open /proc entry
3052 static void close_proc_file (struct procinfo *pip)
3056 Close any currently open /proc entry and mark the process information
3057 entry as invalid. In order to ensure that we don't try to reuse any
3058 stale information, the pid, fd, and pathnames are explicitly
3059 invalidated, which may be overkill.
3064 close_proc_file (pip
)
3065 struct procinfo
*pip
;
3067 struct procinfo
*procinfo
;
3069 remove_fd (pip
); /* Remove fd from poll/select list */
3073 free (pip
-> pathname
);
3075 /* Unlink pip from the procinfo chain. Note pip might not be on the list. */
3077 if (procinfo_list
== pip
)
3078 procinfo_list
= pip
->next
;
3080 for (procinfo
= procinfo_list
; procinfo
; procinfo
= procinfo
->next
)
3081 if (procinfo
->next
== pip
)
3082 procinfo
->next
= pip
->next
;
3091 open_proc_file - open a /proc entry for a given process id
3095 static int open_proc_file (int pid, struct procinfo *pip, int mode)
3099 Given a process id and a mode, close the existing open /proc
3100 entry (if any) and open one for the new process id, in the
3101 specified mode. Once it is open, then mark the local process
3102 information structure as valid, which guarantees that the pid,
3103 fd, and pathname fields match an open /proc entry. Returns
3104 zero if the open fails, nonzero otherwise.
3106 Note that the pathname is left intact, even when the open fails,
3107 so that callers can use it to construct meaningful error messages
3108 rather than just "file open failed".
3110 Note that for Solaris, the process-id also includes an LWP-id, so we
3111 actually attempt to open that. If we are handed a pid with a 0 LWP-id,
3112 then we will ask the kernel what it is and add it to the pid. Hence,
3113 the pid can be changed by us.
3117 open_proc_file (pid
, pip
, mode
)
3119 struct procinfo
*pip
;
3125 pip
-> had_event
= 0;
3126 pip
-> pathname
= xmalloc (32);
3135 sprintf (pip
-> pathname
, PROC_NAME_FMT
, tmp
);
3136 if ((tmpfd
= open (pip
-> pathname
, mode
)) < 0)
3142 tmp
= (pid
>> 16) & 0xffff; /* Extract thread id */
3145 { /* Don't know thread id yet */
3146 if (ioctl (tmpfd
, PIOCSTATUS
, &pip
-> prstatus
) < 0)
3148 print_sys_errmsg (pip
-> pathname
, errno
);
3150 error ("open_proc_file: PIOCSTATUS failed");
3153 tmp
= pip
-> prstatus
.pr_who
; /* Get thread id from prstatus_t */
3154 pip
-> pid
= (tmp
<< 16) | pid
; /* Update pip */
3157 if ((pip
-> fd
= ioctl (tmpfd
, PIOCOPENLWP
, &tmp
)) < 0)
3163 #ifdef PIOCSET /* New method */
3166 pr_flags
= PR_ASYNC
;
3167 ioctl (pip
-> fd
, PIOCSET
, &pr_flags
);
3171 close (tmpfd
); /* All done with main pid */
3172 #endif /* PIOCOPENLWP */
3178 mappingflags (flags
)
3181 static char asciiflags
[8];
3183 strcpy (asciiflags
, "-------");
3184 #if defined (MA_PHYS)
3185 if (flags
& MA_PHYS
) asciiflags
[0] = 'd';
3187 if (flags
& MA_STACK
) asciiflags
[1] = 's';
3188 if (flags
& MA_BREAK
) asciiflags
[2] = 'b';
3189 if (flags
& MA_SHARED
) asciiflags
[3] = 's';
3190 if (flags
& MA_READ
) asciiflags
[4] = 'r';
3191 if (flags
& MA_WRITE
) asciiflags
[5] = 'w';
3192 if (flags
& MA_EXEC
) asciiflags
[6] = 'x';
3193 return (asciiflags
);
3197 info_proc_flags (pip
, summary
)
3198 struct procinfo
*pip
;
3201 struct trans
*transp
;
3203 printf_filtered ("%-32s", "Process status flags:");
3206 printf_filtered ("\n\n");
3208 for (transp
= pr_flag_table
; transp
-> name
!= NULL
; transp
++)
3210 if (pip
-> prstatus
.pr_flags
& transp
-> value
)
3214 printf_filtered ("%s ", transp
-> name
);
3218 printf_filtered ("\t%-16s %s.\n", transp
-> name
, transp
-> desc
);
3222 printf_filtered ("\n");
3226 info_proc_stop (pip
, summary
)
3227 struct procinfo
*pip
;
3230 struct trans
*transp
;
3234 why
= pip
-> prstatus
.pr_why
;
3235 what
= pip
-> prstatus
.pr_what
;
3237 if (pip
-> prstatus
.pr_flags
& PR_STOPPED
)
3239 printf_filtered ("%-32s", "Reason for stopping:");
3242 printf_filtered ("\n\n");
3244 for (transp
= pr_why_table
; transp
-> name
!= NULL
; transp
++)
3246 if (why
== transp
-> value
)
3250 printf_filtered ("%s ", transp
-> name
);
3254 printf_filtered ("\t%-16s %s.\n",
3255 transp
-> name
, transp
-> desc
);
3261 /* Use the pr_why field to determine what the pr_what field means, and
3262 print more information. */
3267 /* pr_what is unused for this case */
3273 printf_filtered ("%s ", signalname (what
));
3277 printf_filtered ("\t%-16s %s.\n", signalname (what
),
3278 safe_strsignal (what
));
3284 printf_filtered ("%s ", syscallname (what
));
3288 printf_filtered ("\t%-16s %s.\n", syscallname (what
),
3289 "Entered this system call");
3295 printf_filtered ("%s ", syscallname (what
));
3299 printf_filtered ("\t%-16s %s.\n", syscallname (what
),
3300 "Returned from this system call");
3306 printf_filtered ("%s ",
3307 lookupname (faults_table
, what
, "fault"));
3311 printf_filtered ("\t%-16s %s.\n",
3312 lookupname (faults_table
, what
, "fault"),
3313 lookupdesc (faults_table
, what
));
3317 printf_filtered ("\n");
3322 info_proc_siginfo (pip
, summary
)
3323 struct procinfo
*pip
;
3326 struct siginfo
*sip
;
3328 if ((pip
-> prstatus
.pr_flags
& PR_STOPPED
) &&
3329 (pip
-> prstatus
.pr_why
== PR_SIGNALLED
||
3330 pip
-> prstatus
.pr_why
== PR_FAULTED
))
3332 printf_filtered ("%-32s", "Additional signal/fault info:");
3333 sip
= &pip
-> prstatus
.pr_info
;
3336 printf_filtered ("%s ", signalname (sip
-> si_signo
));
3337 if (sip
-> si_errno
> 0)
3339 printf_filtered ("%s ", errnoname (sip
-> si_errno
));
3341 if (sip
-> si_code
<= 0)
3343 printf_filtered ("sent by %s, uid %d ",
3344 target_pid_to_str (sip
-> si_pid
),
3349 printf_filtered ("%s ", sigcodename (sip
));
3350 if ((sip
-> si_signo
== SIGILL
) ||
3351 (sip
-> si_signo
== SIGFPE
) ||
3352 (sip
-> si_signo
== SIGSEGV
) ||
3353 (sip
-> si_signo
== SIGBUS
))
3355 printf_filtered ("addr=%#lx ",
3356 (unsigned long) sip
-> si_addr
);
3358 else if ((sip
-> si_signo
== SIGCHLD
))
3360 printf_filtered ("child %s, status %u ",
3361 target_pid_to_str (sip
-> si_pid
),
3364 else if ((sip
-> si_signo
== SIGPOLL
))
3366 printf_filtered ("band %u ", sip
-> si_band
);
3372 printf_filtered ("\n\n");
3373 printf_filtered ("\t%-16s %s.\n", signalname (sip
-> si_signo
),
3374 safe_strsignal (sip
-> si_signo
));
3375 if (sip
-> si_errno
> 0)
3377 printf_filtered ("\t%-16s %s.\n",
3378 errnoname (sip
-> si_errno
),
3379 safe_strerror (sip
-> si_errno
));
3381 if (sip
-> si_code
<= 0)
3383 printf_filtered ("\t%-16u %s\n", sip
-> si_pid
, /* XXX need target_pid_to_str() */
3384 "PID of process sending signal");
3385 printf_filtered ("\t%-16u %s\n", sip
-> si_uid
,
3386 "UID of process sending signal");
3390 printf_filtered ("\t%-16s %s.\n", sigcodename (sip
),
3392 if ((sip
-> si_signo
== SIGILL
) ||
3393 (sip
-> si_signo
== SIGFPE
))
3395 printf_filtered ("\t%#-16lx %s.\n",
3396 (unsigned long) sip
-> si_addr
,
3397 "Address of faulting instruction");
3399 else if ((sip
-> si_signo
== SIGSEGV
) ||
3400 (sip
-> si_signo
== SIGBUS
))
3402 printf_filtered ("\t%#-16lx %s.\n",
3403 (unsigned long) sip
-> si_addr
,
3404 "Address of faulting memory reference");
3406 else if ((sip
-> si_signo
== SIGCHLD
))
3408 printf_filtered ("\t%-16u %s.\n", sip
-> si_pid
, /* XXX need target_pid_to_str() */
3409 "Child process ID");
3410 printf_filtered ("\t%-16u %s.\n", sip
-> si_status
,
3411 "Child process exit value or signal");
3413 else if ((sip
-> si_signo
== SIGPOLL
))
3415 printf_filtered ("\t%-16u %s.\n", sip
-> si_band
,
3416 "Band event for POLL_{IN,OUT,MSG}");
3420 printf_filtered ("\n");
3425 info_proc_syscalls (pip
, summary
)
3426 struct procinfo
*pip
;
3434 #if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
3435 if (pip
-> prstatus
.pr_flags
& PR_ASLEEP
)
3437 int syscallnum
= pip
-> prstatus
.pr_reg
[R_D0
];
3440 printf_filtered ("%-32s", "Sleeping in system call:");
3441 printf_filtered ("%s", syscallname (syscallnum
));
3445 printf_filtered ("Sleeping in system call '%s'.\n",
3446 syscallname (syscallnum
));
3451 if (ioctl (pip
-> fd
, PIOCGENTRY
, &pip
-> entryset
) < 0)
3453 print_sys_errmsg (pip
-> pathname
, errno
);
3454 error ("PIOCGENTRY failed");
3457 if (ioctl (pip
-> fd
, PIOCGEXIT
, &pip
-> exitset
) < 0)
3459 print_sys_errmsg (pip
-> pathname
, errno
);
3460 error ("PIOCGEXIT failed");
3463 printf_filtered ("System call tracing information:\n\n");
3465 printf_filtered ("\t%-12s %-8s %-8s\n",
3469 for (syscallnum
= 0; syscallnum
< MAX_SYSCALLS
; syscallnum
++)
3472 if (syscall_table
[syscallnum
] != NULL
)
3473 printf_filtered ("\t%-12s ", syscall_table
[syscallnum
]);
3475 printf_filtered ("\t%-12d ", syscallnum
);
3477 printf_filtered ("%-8s ",
3478 prismember (&pip
-> entryset
, syscallnum
)
3480 printf_filtered ("%-8s ",
3481 prismember (&pip
-> exitset
, syscallnum
)
3483 printf_filtered ("\n");
3485 printf_filtered ("\n");
3494 static char locbuf
[32];
3496 name
= strsigno (signo
);
3499 sprintf (locbuf
, "Signal %d", signo
);
3503 sprintf (locbuf
, "%s (%d)", name
, signo
);
3513 static char locbuf
[32];
3515 name
= strerrno (errnum
);
3518 sprintf (locbuf
, "Errno %d", errnum
);
3522 sprintf (locbuf
, "%s (%d)", name
, errnum
);
3528 info_proc_signals (pip
, summary
)
3529 struct procinfo
*pip
;
3536 if (ioctl (pip
-> fd
, PIOCGTRACE
, &pip
-> trace
) < 0)
3538 print_sys_errmsg (pip
-> pathname
, errno
);
3539 error ("PIOCGTRACE failed");
3542 printf_filtered ("Disposition of signals:\n\n");
3543 printf_filtered ("\t%-15s %-8s %-8s %-8s %s\n\n",
3544 "Signal", "Trace", "Hold", "Pending", "Description");
3545 for (signo
= 0; signo
< NSIG
; signo
++)
3548 printf_filtered ("\t%-15s ", signalname (signo
));
3549 printf_filtered ("%-8s ",
3550 prismember (&pip
-> trace
, signo
)
3552 printf_filtered ("%-8s ",
3553 prismember (&pip
-> prstatus
.pr_sighold
, signo
)
3556 #ifdef PROCFS_SIGPEND_OFFSET
3557 /* Alpha OSF/1 numbers the pending signals from 1. */
3558 printf_filtered ("%-8s ",
3559 (signo
? prismember (&pip
-> prstatus
.pr_sigpend
,
3564 printf_filtered ("%-8s ",
3565 prismember (&pip
-> prstatus
.pr_sigpend
, signo
)
3568 printf_filtered (" %s\n", safe_strsignal (signo
));
3570 printf_filtered ("\n");
3575 info_proc_faults (pip
, summary
)
3576 struct procinfo
*pip
;
3579 struct trans
*transp
;
3583 if (ioctl (pip
-> fd
, PIOCGFAULT
, &pip
-> fltset
) < 0)
3585 print_sys_errmsg (pip
-> pathname
, errno
);
3586 error ("PIOCGFAULT failed");
3589 printf_filtered ("Current traced hardware fault set:\n\n");
3590 printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
3592 for (transp
= faults_table
; transp
-> name
!= NULL
; transp
++)
3595 printf_filtered ("\t%-12s ", transp
-> name
);
3596 printf_filtered ("%-8s", prismember (&pip
-> fltset
, transp
-> value
)
3598 printf_filtered ("\n");
3600 printf_filtered ("\n");
3605 info_proc_mappings (pip
, summary
)
3606 struct procinfo
*pip
;
3610 struct prmap
*prmaps
;
3611 struct prmap
*prmap
;
3615 printf_filtered ("Mapped address spaces:\n\n");
3616 #ifdef BFD_HOST_64_BIT
3617 printf_filtered (" %18s %18s %10s %10s %7s\n",
3619 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3626 if (ioctl (pip
-> fd
, PIOCNMAP
, &nmap
) == 0)
3628 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
3629 if (ioctl (pip
-> fd
, PIOCMAP
, prmaps
) == 0)
3631 for (prmap
= prmaps
; prmap
-> pr_size
; ++prmap
)
3633 #ifdef BFD_HOST_64_BIT
3634 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3636 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3638 (unsigned long)prmap
-> pr_vaddr
,
3639 (unsigned long)prmap
-> pr_vaddr
3640 + prmap
-> pr_size
- 1,
3643 mappingflags (prmap
-> pr_mflags
));
3647 printf_filtered ("\n");
3655 info_proc -- implement the "info proc" command
3659 void info_proc (char *args, int from_tty)
3663 Implement gdb's "info proc" command by using the /proc interface
3664 to print status information about any currently running process.
3666 Examples of the use of "info proc" are:
3668 info proc (prints summary info for current inferior)
3669 info proc 123 (prints summary info for process with pid 123)
3670 info proc mappings (prints address mappings)
3671 info proc times (prints process/children times)
3672 info proc id (prints pid, ppid, gid, sid, etc)
3673 FIXME: i proc id not implemented.
3674 info proc status (prints general process state info)
3675 FIXME: i proc status not implemented.
3676 info proc signals (prints info about signal handling)
3677 info proc all (prints all info)
3682 info_proc (args
, from_tty
)
3686 int pid
= inferior_pid
;
3687 struct procinfo
*pip
;
3688 struct cleanup
*old_chain
;
3704 old_chain
= make_cleanup (null_cleanup
, 0);
3706 /* Default to using the current inferior if no pid specified. Note
3707 that inferior_pid may be 0, hence we set okerr. */
3709 pip
= find_procinfo (inferior_pid
, 1);
3713 if ((argv
= buildargv (args
)) == NULL
)
3717 make_cleanup (freeargv
, (char *) argv
);
3719 while (*argv
!= NULL
)
3721 argsize
= strlen (*argv
);
3722 if (argsize
>= 1 && strncmp (*argv
, "all", argsize
) == 0)
3727 else if (argsize
>= 2 && strncmp (*argv
, "faults", argsize
) == 0)
3732 else if (argsize
>= 2 && strncmp (*argv
, "flags", argsize
) == 0)
3737 else if (argsize
>= 1 && strncmp (*argv
, "id", argsize
) == 0)
3742 else if (argsize
>= 1 && strncmp (*argv
, "mappings", argsize
) == 0)
3747 else if (argsize
>= 2 && strncmp (*argv
, "signals", argsize
) == 0)
3752 else if (argsize
>= 2 && strncmp (*argv
, "status", argsize
) == 0)
3757 else if (argsize
>= 2 && strncmp (*argv
, "syscalls", argsize
) == 0)
3762 else if (argsize
>= 1 && strncmp (*argv
, "times", argsize
) == 0)
3767 else if ((pid
= atoi (*argv
)) > 0)
3769 pip
= (struct procinfo
*) xmalloc (sizeof (struct procinfo
));
3770 memset (pip
, 0, sizeof (*pip
));
3773 if (!open_proc_file (pid
, pip
, O_RDONLY
))
3775 perror_with_name (pip
-> pathname
);
3779 make_cleanup (close_proc_file
, pip
);
3781 else if (**argv
!= '\000')
3783 error ("Unrecognized or ambiguous keyword `%s'.", *argv
);
3789 /* If we don't have a valid open process at this point, then we have no
3790 inferior or didn't specify a specific pid. */
3795 No process. Start debugging a program or specify an explicit process ID.");
3797 if (ioctl (pip
-> fd
, PIOCSTATUS
, &(pip
-> prstatus
)) < 0)
3799 print_sys_errmsg (pip
-> pathname
, errno
);
3800 error ("PIOCSTATUS failed");
3804 nlwp
= pip
->prstatus
.pr_nlwp
;
3805 lwps
= alloca ((2 * nlwp
+ 2) * sizeof (id_t
));
3807 if (ioctl (pip
->fd
, PIOCLWPIDS
, lwps
))
3809 print_sys_errmsg (pip
-> pathname
, errno
);
3810 error ("PIOCSTATUS failed");
3812 #else /* PIOCLWPIDS */
3814 lwps
= alloca ((2 * nlwp
+ 2) * sizeof *lwps
);
3816 #endif /* PIOCLWPIDS */
3818 for (; nlwp
> 0; nlwp
--, lwps
++)
3820 pip
= find_procinfo ((*lwps
<< 16) | pid
, 1);
3824 pip
= (struct procinfo
*) xmalloc (sizeof (struct procinfo
));
3825 memset (pip
, 0, sizeof (*pip
));
3826 if (!open_proc_file ((*lwps
<< 16) | pid
, pip
, O_RDONLY
))
3829 make_cleanup (close_proc_file
, pip
);
3831 if (ioctl (pip
-> fd
, PIOCSTATUS
, &(pip
-> prstatus
)) < 0)
3833 print_sys_errmsg (pip
-> pathname
, errno
);
3834 error ("PIOCSTATUS failed");
3838 /* Print verbose information of the requested type(s), or just a summary
3839 of the information for all types. */
3841 printf_filtered ("\nInformation for %s.%d:\n\n", pip
-> pathname
, *lwps
);
3842 if (summary
|| all
|| flags
)
3844 info_proc_flags (pip
, summary
);
3848 info_proc_stop (pip
, summary
);
3850 if (summary
|| all
|| signals
|| faults
)
3852 info_proc_siginfo (pip
, summary
);
3854 if (summary
|| all
|| syscalls
)
3856 info_proc_syscalls (pip
, summary
);
3858 if (summary
|| all
|| mappings
)
3860 info_proc_mappings (pip
, summary
);
3862 if (summary
|| all
|| signals
)
3864 info_proc_signals (pip
, summary
);
3866 if (summary
|| all
|| faults
)
3868 info_proc_faults (pip
, summary
);
3870 printf_filtered ("\n");
3872 /* All done, deal with closing any temporary process info structure,
3873 freeing temporary memory , etc. */
3875 do_cleanups (old_chain
);
3883 modify_inherit_on_fork_flag - Change the inherit-on-fork flag
3887 void modify_inherit_on_fork_flag (fd, flag)
3891 Call this routine to modify the inherit-on-fork flag. This routine is
3892 just a nice wrapper to hide the #ifdefs needed by various systems to
3898 modify_inherit_on_fork_flag (fd
, flag
)
3907 #ifdef PIOCSET /* New method */
3910 retval
= ioctl (fd
, PIOCSET
, &pr_flags
);
3912 retval
= ioctl (fd
, PIOCRESET
, &pr_flags
);
3915 #ifdef PIOCSFORK /* Original method */
3917 retval
= ioctl (fd
, PIOCSFORK
, NULL
);
3919 retval
= ioctl (fd
, PIOCRFORK
, NULL
);
3921 Neither PR_FORK nor PIOCSFORK exist
!!!
3928 print_sys_errmsg ("modify_inherit_on_fork_flag", errno
);
3929 error ("PIOCSFORK or PR_FORK modification failed");
3936 modify_run_on_last_close_flag - Change the run-on-last-close flag
3940 void modify_run_on_last_close_flag (fd, flag)
3944 Call this routine to modify the run-on-last-close flag. This routine
3945 is just a nice wrapper to hide the #ifdefs needed by various systems to
3951 modify_run_on_last_close_flag (fd
, flag
)
3960 #ifdef PIOCSET /* New method */
3963 retval
= ioctl (fd
, PIOCSET
, &pr_flags
);
3965 retval
= ioctl (fd
, PIOCRESET
, &pr_flags
);
3968 #ifdef PIOCSRLC /* Original method */
3970 retval
= ioctl (fd
, PIOCSRLC
, NULL
);
3972 retval
= ioctl (fd
, PIOCRRLC
, NULL
);
3974 Neither PR_RLC nor PIOCSRLC exist
!!!
3981 print_sys_errmsg ("modify_run_on_last_close_flag", errno
);
3982 error ("PIOCSRLC or PR_RLC modification failed");
3989 procfs_clear_syscall_trap -- Deletes the trap for the specified system call.
3993 void procfs_clear_syscall_trap (struct procinfo *, int syscall_num, int errok)
3997 This function function disables traps for the specified system call.
3998 errok is non-zero if errors should be ignored.
4002 procfs_clear_syscall_trap (pi
, syscall_num
, errok
)
4003 struct procinfo
*pi
;
4010 goterr
= ioctl (pi
->fd
, PIOCGENTRY
, &sysset
) < 0;
4012 if (goterr
&& !errok
)
4014 print_sys_errmsg (pi
->pathname
, errno
);
4015 error ("PIOCGENTRY failed");
4020 prdelset (&sysset
, syscall_num
);
4022 if ((ioctl (pi
->fd
, PIOCSENTRY
, &sysset
) < 0) && !errok
)
4024 print_sys_errmsg (pi
->pathname
, errno
);
4025 error ("PIOCSENTRY failed");
4029 goterr
= ioctl (pi
->fd
, PIOCGEXIT
, &sysset
) < 0;
4031 if (goterr
&& !errok
)
4033 procfs_clear_syscall_trap (pi
, syscall_num
, 1);
4034 print_sys_errmsg (pi
->pathname
, errno
);
4035 error ("PIOCGEXIT failed");
4040 praddset (&sysset
, syscall_num
);
4042 if ((ioctl (pi
->fd
, PIOCSEXIT
, &sysset
) < 0) && !errok
)
4044 procfs_clear_syscall_trap (pi
, syscall_num
, 1);
4045 print_sys_errmsg (pi
->pathname
, errno
);
4046 error ("PIOCSEXIT failed");
4050 if (!pi
->syscall_handlers
)
4053 error ("procfs_clear_syscall_trap: syscall_handlers is empty");
4057 /* Remove handler func from the handler list */
4059 for (i
= 0; i
< pi
->num_syscall_handlers
; i
++)
4060 if (pi
->syscall_handlers
[i
].syscall_num
== syscall_num
)
4062 if (i
+ 1 != pi
->num_syscall_handlers
)
4063 { /* Not the last entry.
4064 Move subsequent entries fwd. */
4065 memcpy (&pi
->syscall_handlers
[i
], &pi
->syscall_handlers
[i
+ 1],
4066 (pi
->num_syscall_handlers
- i
- 1)
4067 * sizeof (struct procfs_syscall_handler
));
4070 pi
->syscall_handlers
= xrealloc (pi
->syscall_handlers
,
4071 (pi
->num_syscall_handlers
- 1)
4072 * sizeof (struct procfs_syscall_handler
));
4073 pi
->num_syscall_handlers
--;
4078 error ("procfs_clear_syscall_trap: Couldn't find handler for sys call %d",
4086 procfs_set_syscall_trap -- arrange for a function to be called when the
4087 child executes the specified system call.
4091 void procfs_set_syscall_trap (struct procinfo *, int syscall_num, int flags,
4092 syscall_func_t *function)
4096 This function sets up an entry and/or exit trap for the specified system
4097 call. When the child executes the specified system call, your function
4098 will be called with the call #, a flag that indicates entry or exit, and
4099 pointers to rtnval and statval (which are used by procfs_wait). The
4100 function should return non-zero if something interesting happened, zero
4105 procfs_set_syscall_trap (pi
, syscall_num
, flags
, func
)
4106 struct procinfo
*pi
;
4109 syscall_func_t
*func
;
4113 if (flags
& PROCFS_SYSCALL_ENTRY
)
4115 if (ioctl (pi
->fd
, PIOCGENTRY
, &sysset
) < 0)
4117 print_sys_errmsg (pi
->pathname
, errno
);
4118 error ("PIOCGENTRY failed");
4121 praddset (&sysset
, syscall_num
);
4123 if (ioctl (pi
->fd
, PIOCSENTRY
, &sysset
) < 0)
4125 print_sys_errmsg (pi
->pathname
, errno
);
4126 error ("PIOCSENTRY failed");
4130 if (flags
& PROCFS_SYSCALL_EXIT
)
4132 if (ioctl (pi
->fd
, PIOCGEXIT
, &sysset
) < 0)
4134 procfs_clear_syscall_trap (pi
, syscall_num
, 1);
4135 print_sys_errmsg (pi
->pathname
, errno
);
4136 error ("PIOCGEXIT failed");
4139 praddset (&sysset
, syscall_num
);
4141 if (ioctl (pi
->fd
, PIOCSEXIT
, &sysset
) < 0)
4143 procfs_clear_syscall_trap (pi
, syscall_num
, 1);
4144 print_sys_errmsg (pi
->pathname
, errno
);
4145 error ("PIOCSEXIT failed");
4149 if (!pi
->syscall_handlers
)
4151 pi
->syscall_handlers
= xmalloc (sizeof (struct procfs_syscall_handler
));
4152 pi
->syscall_handlers
[0].syscall_num
= syscall_num
;
4153 pi
->syscall_handlers
[0].func
= func
;
4154 pi
->num_syscall_handlers
= 1;
4160 for (i
= 0; i
< pi
->num_syscall_handlers
; i
++)
4161 if (pi
->syscall_handlers
[i
].syscall_num
== syscall_num
)
4163 pi
->syscall_handlers
[i
].func
= func
;
4167 pi
->syscall_handlers
= xrealloc (pi
->syscall_handlers
, (i
+ 1)
4168 * sizeof (struct procfs_syscall_handler
));
4169 pi
->syscall_handlers
[i
].syscall_num
= syscall_num
;
4170 pi
->syscall_handlers
[i
].func
= func
;
4171 pi
->num_syscall_handlers
++;
4175 #ifdef SYS_lwp_create
4181 procfs_lwp_creation_handler - handle exit from the _lwp_create syscall
4185 int procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
4189 This routine is called both when an inferior process and it's new lwp
4190 are about to finish a _lwp_create() system call. This is the system
4191 call that Solaris uses to create a lightweight process. When the
4192 target process gets this event, we can look at sysarg[2] to find the
4193 new childs lwp ID, and create a procinfo struct from that. After that,
4194 we pretend that we got a SIGTRAP, and return non-zero to tell
4195 procfs_wait to wake up. Subsequently, wait_for_inferior gets woken up,
4196 sees the new process and continues it.
4198 When we see the child exiting from lwp_create, we just contine it,
4199 since everything was handled when the parent trapped.
4202 In effect, we are only paying attention to the parent's completion of
4203 the lwp_create syscall. If we only paid attention to the child
4204 instead, then we wouldn't detect the creation of a suspended thread.
4208 procfs_lwp_creation_handler (pi
, syscall_num
, why
, rtnvalp
, statvalp
)
4209 struct procinfo
*pi
;
4216 struct procinfo
*childpi
;
4218 /* We've just detected the completion of an lwp_create system call. Now we
4219 need to setup a procinfo struct for this thread, and notify the thread
4220 system of the new arrival. */
4222 /* If lwp_create failed, then nothing interesting happened. Continue the
4223 process and go back to sleep. */
4225 if (pi
->prstatus
.pr_reg
[R_PSR
] & PS_FLAG_CARRY
)
4226 { /* _lwp_create failed */
4227 pi
->prrun
.pr_flags
&= PRSTEP
;
4228 pi
->prrun
.pr_flags
|= PRCFAULT
;
4230 if (ioctl (pi
->fd
, PIOCRUN
, &pi
->prrun
) != 0)
4231 perror_with_name (pi
->pathname
);
4236 /* At this point, the new thread is stopped at it's first instruction, and
4237 the parent is stopped at the exit from lwp_create. */
4239 if (pi
->new_child
) /* Child? */
4240 { /* Yes, just continue it */
4241 pi
->prrun
.pr_flags
&= PRSTEP
;
4242 pi
->prrun
.pr_flags
|= PRCFAULT
;
4244 if ((pi
->prstatus
.pr_flags
& PR_ISTOP
)
4245 && ioctl (pi
->fd
, PIOCRUN
, &pi
->prrun
) != 0)
4246 perror_with_name (pi
->pathname
);
4248 pi
->new_child
= 0; /* No longer new */
4253 /* We're the proud parent of a new thread. Setup an exit trap for lwp_create
4254 in the child and continue the parent. */
4256 /* Third arg is pointer to new thread id. */
4257 lwp_id
= read_memory_integer (pi
->prstatus
.pr_sysarg
[2], sizeof (int));
4259 lwp_id
= (lwp_id
<< 16) | PIDGET (pi
->pid
);
4261 childpi
= create_procinfo (lwp_id
);
4263 /* The new process has actually inherited the lwp_create syscall trap from
4264 it's parent, but we still have to call this to register a handler for
4267 procfs_set_syscall_trap (childpi
, SYS_lwp_create
, PROCFS_SYSCALL_EXIT
,
4268 procfs_lwp_creation_handler
);
4270 childpi
->new_child
= 1; /* Flag this as an unseen child process */
4272 *rtnvalp
= lwp_id
; /* the new arrival. */
4273 *statvalp
= (SIGTRAP
<< 8) | 0177;
4277 #endif /* SYS_lwp_create */
4279 /* Fork an inferior process, and start debugging it with /proc. */
4282 procfs_create_inferior (exec_file
, allargs
, env
)
4287 char *shell_file
= getenv ("SHELL");
4289 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4292 /* We will be looking down the PATH to find shell_file. If we
4293 just do this the normal way (via execlp, which operates by
4294 attempting an exec for each element of the PATH until it
4295 finds one which succeeds), then there will be an exec for
4296 each failed attempt, each of which will cause a PR_SYSEXIT
4297 stop, and we won't know how to distinguish the PR_SYSEXIT's
4298 for these failed execs with the ones for successful execs
4299 (whether the exec has succeeded is stored at that time in the
4300 carry bit or some such architecture-specific and
4301 non-ABI-specified place).
4303 So I can't think of anything better than to search the PATH
4304 now. This has several disadvantages: (1) There is a race
4305 condition; if we find a file now and it is deleted before we
4306 exec it, we lose, even if the deletion leaves a valid file
4307 further down in the PATH, (2) there is no way to know exactly
4308 what an executable (in the sense of "capable of being
4309 exec'd") file is. Using access() loses because it may lose
4310 if the caller is the superuser; failing to use it loses if
4311 there are ACLs or some such. */
4315 /* FIXME-maybe: might want "set path" command so user can change what
4316 path is used from within GDB. */
4317 char *path
= getenv ("PATH");
4319 struct stat statbuf
;
4322 path
= "/bin:/usr/bin";
4324 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4325 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4327 p1
= strchr (p
, ':');
4332 strncpy (tryname
, p
, len
);
4333 tryname
[len
] = '\0';
4334 strcat (tryname
, "/");
4335 strcat (tryname
, shell_file
);
4336 if (access (tryname
, X_OK
) < 0)
4338 if (stat (tryname
, &statbuf
) < 0)
4340 if (!S_ISREG (statbuf
.st_mode
))
4341 /* We certainly need to reject directories. I'm not quite
4342 as sure about FIFOs, sockets, etc., but I kind of doubt
4343 that people want to exec() these things. */
4348 /* Not found. This must be an error rather than merely passing
4349 the file to execlp(), because execlp() would try all the
4350 exec()s, causing GDB to get confused. */
4351 error ("Can't find shell %s in PATH", shell_file
);
4353 shell_file
= tryname
;
4356 fork_inferior (exec_file
, allargs
, env
,
4357 proc_set_exec_trap
, procfs_init_inferior
, shell_file
);
4359 /* We are at the first instruction we care about. */
4360 /* Pedal to the metal... */
4362 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
4365 /* Clean up after the inferior dies. */
4368 procfs_mourn_inferior ()
4370 struct procinfo
*pi
;
4371 struct procinfo
*next_pi
;
4373 for (pi
= procinfo_list
; pi
; pi
= next_pi
)
4376 unconditionally_kill_inferior (pi
);
4379 unpush_target (&procfs_ops
);
4380 generic_mourn_inferior ();
4384 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
4388 /* This variable is controlled by modules that sit atop procfs that may layer
4389 their own process structure atop that provided here. sol-thread.c does
4390 this because of the Solaris two-level thread model. */
4392 return !procfs_suppress_run
;
4394 #ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
4396 /* Insert a watchpoint */
4398 procfs_set_watchpoint(pid
, addr
, len
, rw
)
4404 struct procinfo
*pi
;
4407 pi
= find_procinfo (pid
== -1 ? inferior_pid
: pid
, 0);
4408 wpt
.pr_vaddr
= (caddr_t
)addr
;
4410 wpt
.pr_wflags
= ((rw
& 1) ? MA_READ
: 0) | ((rw
& 2) ? MA_WRITE
: 0);
4411 if (ioctl (pi
->fd
, PIOCSWATCH
, &wpt
) < 0)
4415 /* Currently it sometimes happens that the same watchpoint gets
4416 deleted twice - don't die in this case (FIXME please) */
4417 if (errno
== ESRCH
&& len
== 0)
4419 print_sys_errmsg (pi
->pathname
, errno
);
4420 error ("PIOCSWATCH failed");
4426 procfs_stopped_by_watchpoint(pid
)
4429 struct procinfo
*pi
;
4433 pi
= find_procinfo (pid
== -1 ? inferior_pid
: pid
, 0);
4434 if (pi
->prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
))
4436 why
= pi
->prstatus
.pr_why
;
4437 what
= pi
->prstatus
.pr_what
;
4438 if (why
== PR_FAULTED
4439 #if defined (FLTWATCH) && defined (FLTKWATCH)
4440 && (what
== FLTWATCH
|| what
== FLTKWATCH
)
4443 && (what
== FLTWATCH
)
4446 && (what
== FLTKWATCH
)
4456 /* Why is this necessary? Shouldn't dead threads just be removed from the
4460 procfs_thread_alive (pid
)
4466 /* Send a SIGINT to the process group. This acts just like the user typed a
4467 ^C on the controlling terminal.
4469 XXX - This may not be correct for all systems. Some may want to use
4470 killpg() instead of kill (-pgrp). */
4475 extern pid_t inferior_process_group
;
4477 kill (-inferior_process_group
, SIGINT
);
4480 /* Convert a pid to printable form. */
4484 procfs_pid_to_str (pid
)
4487 static char buf
[100];
4489 sprintf (buf
, "Kernel thread %d", TIDGET (pid
));
4495 struct target_ops procfs_ops
= {
4496 "procfs", /* to_shortname */
4497 "Unix /proc child process", /* to_longname */
4498 "Unix /proc child process (started by the \"run\" command).", /* to_doc */
4499 procfs_open
, /* to_open */
4501 procfs_attach
, /* to_attach */
4502 procfs_detach
, /* to_detach */
4503 procfs_resume
, /* to_resume */
4504 procfs_wait
, /* to_wait */
4505 procfs_fetch_registers
, /* to_fetch_registers */
4506 procfs_store_registers
, /* to_store_registers */
4507 procfs_prepare_to_store
, /* to_prepare_to_store */
4508 procfs_xfer_memory
, /* to_xfer_memory */
4509 procfs_files_info
, /* to_files_info */
4510 memory_insert_breakpoint
, /* to_insert_breakpoint */
4511 memory_remove_breakpoint
, /* to_remove_breakpoint */
4512 terminal_init_inferior
, /* to_terminal_init */
4513 terminal_inferior
, /* to_terminal_inferior */
4514 terminal_ours_for_output
, /* to_terminal_ours_for_output */
4515 terminal_ours
, /* to_terminal_ours */
4516 child_terminal_info
, /* to_terminal_info */
4517 procfs_kill_inferior
, /* to_kill */
4519 0, /* to_lookup_symbol */
4520 procfs_create_inferior
, /* to_create_inferior */
4521 procfs_mourn_inferior
, /* to_mourn_inferior */
4522 procfs_can_run
, /* to_can_run */
4523 procfs_notice_signals
, /* to_notice_signals */
4524 procfs_thread_alive
, /* to_thread_alive */
4525 procfs_stop
, /* to_stop */
4526 process_stratum
, /* to_stratum */
4528 1, /* to_has_all_memory */
4529 1, /* to_has_memory */
4530 1, /* to_has_stack */
4531 1, /* to_has_registers */
4532 1, /* to_has_execution */
4534 0, /* sections_end */
4535 OPS_MAGIC
/* to_magic */
4539 _initialize_procfs ()
4541 #ifdef HAVE_OPTIONAL_PROC_FS
4545 /* If we have an optional /proc filesystem (e.g. under OSF/1),
4546 don't add procfs support if we cannot access the running
4548 sprintf (procname
, PROC_NAME_FMT
, getpid ());
4549 if ((fd
= open (procname
, O_RDONLY
)) < 0)
4554 add_target (&procfs_ops
);
4556 add_info ("proc", info_proc
,
4557 "Show process status information using /proc entry.\n\
4558 Specify process id or use current inferior by default.\n\
4559 Specify keywords for detailed information; default is summary.\n\
4560 Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
4561 `status', `syscalls', and `times'.\n\
4562 Unambiguous abbreviations may be used.");
4564 init_syscall_table ();