1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 Copyright (C) 1991 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support.
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., 675 Mass Ave, Cambridge, MA 02139, 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.
38 #ifdef USE_PROC_FS /* Entire file goes away if not using /proc */
41 #include <sys/procfs.h>
51 #define PROC_NAME_FMT "/proc/%d"
54 extern void EXFUN(supply_gregset
, (gregset_t
*gregsetp
));
55 extern void EXFUN(fill_gregset
, (gregset_t
*gresetp
, int regno
));
57 #if defined (FP0_REGNUM)
58 extern void EXFUN(supply_fpregset
, (fpregset_t
*fpregsetp
));
59 extern void EXFUN(fill_fpregset
, (fpregset_t
*fpresetp
, int regno
));
62 #if 1 /* FIXME: Gross and ugly hack to resolve coredep.c global */
63 CORE_ADDR kernel_u_addr
;
66 /* All access to the inferior, either one started by gdb or one that has
67 been attached to, is controlled by an instance of a procinfo structure,
68 defined below. Since gdb currently only handles one inferior at a time,
69 the procinfo structure is statically allocated and only one exists at
73 int valid
; /* Nonzero if pid, fd, & pathname are valid */
74 int pid
; /* Process ID of inferior */
75 int fd
; /* File descriptor for /proc entry */
76 char *pathname
; /* Pathname to /proc entry */
77 int was_stopped
; /* Nonzero if was stopped prior to attach */
78 prrun_t prrun
; /* Control state when it is run */
79 prstatus_t prstatus
; /* Current process status info */
80 gregset_t gregset
; /* General register set */
81 fpregset_t fpregset
; /* Floating point register set */
82 fltset_t fltset
; /* Current traced hardware fault set */
83 sigset_t trace
; /* Current traced signal set */
84 sysset_t exitset
; /* Current traced system call exit set */
85 sysset_t entryset
; /* Current traced system call entry set */
88 /* Forward declarations of static functions so we don't have to worry
89 about ordering within this file. The EXFUN macro may be slightly
90 misleading. Should probably be called DCLFUN instead, or something
91 more intuitive, since it can be used for both static and external
94 static void EXFUN(proc_init_failed
, (char *why
));
95 static int EXFUN(open_proc_file
, (int pid
));
96 static void EXFUN(close_proc_file
, (void));
97 static void EXFUN(unconditionally_kill_inferior
, (void));
103 ptrace -- override library version to force errors for /proc version
107 int ptrace (int request, int pid, int arg3, int arg4)
111 When gdb is configured to use /proc, it should not be calling
112 or otherwise attempting to use ptrace. In order to catch errors
113 where use of /proc is configured, but some routine is still calling
114 ptrace, we provide a local version of a function with that name
115 that does nothing but issue an error message.
119 DEFUN(ptrace
, (request
, pid
, arg3
, arg4
),
125 error ("internal error - there is a call to ptrace() somewhere");
133 kill_inferior_fast -- kill inferior while gdb is exiting
137 void kill_inferior_fast (void)
141 This is used when GDB is exiting. It gives less chance of error.
145 Don't attempt to kill attached inferiors since we may be called
146 when gdb is in the process of aborting, and killing the attached
147 inferior may be very anti-social. This is particularly true if we
148 were attached just so we could use the /proc facilities to get
149 detailed information about it's status.
154 DEFUN_VOID(kill_inferior_fast
)
156 if (inferior_pid
!= 0 && !attach_flag
)
158 unconditionally_kill_inferior ();
166 kill_inferior - kill any currently inferior
170 void kill_inferior (void)
174 Kill any current inferior.
178 Kills even attached inferiors. Presumably the user has already
179 been prompted that the inferior is an attached one rather than
180 one started by gdb. (FIXME?)
185 DEFUN_VOID(kill_inferior
)
187 if (inferior_pid
!= 0)
189 unconditionally_kill_inferior ();
190 target_mourn_inferior ();
198 unconditionally_kill_inferior - terminate the inferior
202 static void unconditionally_kill_inferior (void)
206 Kill the current inferior. Should not be called until it
207 is at least tested that there is an inferior.
211 A possibly useful enhancement would be to first try sending
212 the inferior a terminate signal, politely asking it to commit
213 suicide, before we murder it.
218 DEFUN_VOID(unconditionally_kill_inferior
)
223 (void) ioctl (pi
.fd
, PIOCKILL
, &signo
);
232 child_xfer_memory -- copy data to or from inferior memory space
236 int child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
237 int dowrite, struct target_ops target)
241 Copy LEN bytes to/from inferior's memory starting at MEMADDR
242 from/to debugger memory starting at MYADDR. Copy from inferior
243 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
245 Returns the length copied, which is either the LEN argument or
246 zero. This xfer function does not do partial moves, since child_ops
247 doesn't allow memory operations to cross below us in the target stack
252 The /proc interface makes this an almost trivial task.
257 DEFUN(child_xfer_memory
, (memaddr
, myaddr
, len
, dowrite
, target
),
258 CORE_ADDR memaddr AND
262 struct target_ops target
/* ignored */)
266 if (lseek (pi
.fd
, (off_t
) memaddr
, 0) == (off_t
) memaddr
)
270 nbytes
= write (pi
.fd
, myaddr
, len
);
274 nbytes
= read (pi
.fd
, myaddr
, len
);
288 store_inferior_registers -- copy register values back to inferior
292 void store_inferior_registers (int regno)
296 Store our current register values back into the inferior. If
297 REGNO is -1 then store all the register, otherwise store just
298 the value specified by REGNO.
302 If we are storing only a single register, we first have to get all
303 the current values from the process, overwrite the desired register
304 in the gregset with the one we want from gdb's registers, and then
305 send the whole set back to the process. For writing all the
306 registers, all we have to do is generate the gregset and send it to
309 Also note that the process has to be stopped on an event of interest
310 for this to work, which basically means that it has to have been
311 run under the control of one of the other /proc ioctl calls and not
312 ptrace. Since we don't use ptrace anyway, we don't worry about this
313 fine point, but it is worth noting for future reference.
315 Gdb is confused about what this function is supposed to return.
316 Some versions return a value, others return nothing. Some are
317 declared to return a value and actually return nothing. Gdb ignores
318 anything returned. (FIXME)
323 DEFUN(store_inferior_registers
, (regno
),
328 (void) ioctl (pi
.fd
, PIOCGREG
, &pi
.gregset
);
330 fill_gregset (&pi
.gregset
, regno
);
331 (void) ioctl (pi
.fd
, PIOCSREG
, &pi
.gregset
);
333 #if defined (FP0_REGNUM)
335 /* Now repeat everything using the floating point register set, if the
336 target has floating point hardware. Since we ignore the returned value,
337 we'll never know whether it worked or not anyway. */
341 (void) ioctl (pi
.fd
, PIOCGFPREG
, &pi
.fpregset
);
343 fill_fpregset (&pi
.fpregset
, regno
);
344 (void) ioctl (pi
.fd
, PIOCSFPREG
, &pi
.fpregset
);
346 #endif /* FP0_REGNUM */
354 inferior_proc_init - initialize access to a /proc entry
358 void inferior_proc_init (int pid)
362 When gdb starts an inferior, this function is called in the parent
363 process immediately after the fork. It waits for the child to stop
364 on the return from the exec system call (the child itself takes care
365 of ensuring that this is set up), then sets up the set of signals
366 and faults that are to be traced.
370 If proc_init_failed ever gets called, control returns to the command
371 processing loop via the standard error handling code.
375 DEFUN(inferior_proc_init
, (int pid
),
378 if (!open_proc_file (pid
))
380 proc_init_failed ("can't open process file");
384 (void) memset (&pi
.prrun
, 0, sizeof (pi
.prrun
));
385 prfillset (&pi
.prrun
.pr_trace
);
386 prfillset (&pi
.prrun
.pr_fault
);
387 prdelset (&pi
.prrun
.pr_fault
, FLTPAGE
);
388 if (ioctl (pi
.fd
, PIOCWSTOP
, &pi
.prstatus
) < 0)
390 proc_init_failed ("PIOCWSTOP failed");
392 else if (ioctl (pi
.fd
, PIOCSTRACE
, &pi
.prrun
.pr_trace
) < 0)
394 proc_init_failed ("PIOCSTRACE failed");
396 else if (ioctl (pi
.fd
, PIOCSFAULT
, &pi
.prrun
.pr_fault
) < 0)
398 proc_init_failed ("PIOCSFAULT failed");
407 proc_set_exec_trap -- arrange for exec'd child to halt at startup
411 void proc_set_exec_trap (void)
415 This function is called in the child process when starting up
416 an inferior, prior to doing the exec of the actual inferior.
417 It sets the child process's exitset to make exit from the exec
418 system call an event of interest to stop on, and then simply
419 returns. The child does the exec, the system call returns, and
420 the child stops at the first instruction, ready for the gdb
421 parent process to take control of it.
425 We need to use all local variables since the child may be sharing
426 it's data space with the parent, if vfork was used rather than
431 DEFUN_VOID(proc_set_exec_trap
)
434 auto char procname
[32];
437 (void) sprintf (procname
, PROC_NAME_FMT
, getpid ());
438 if ((fd
= open (procname
, O_RDWR
)) < 0)
444 premptyset (&exitset
);
445 praddset (&exitset
, SYS_exec
);
446 praddset (&exitset
, SYS_execve
);
447 if (ioctl (fd
, PIOCSEXIT
, &exitset
) < 0)
462 attach -- attach to an already existing process
470 Attach to an already existing process with the specified process
471 id. If the process is not already stopped, query whether to
476 The option of stopping at attach time is specific to the /proc
477 versions of gdb. Versions using ptrace force the attachee
486 if (!open_proc_file (pid
))
488 perror_with_name (pi
.pathname
);
492 /* Get current status of process and if it is not already stopped,
493 then stop it. Remember whether or not it was stopped when we first
496 if (ioctl (pi
.fd
, PIOCSTATUS
, &pi
.prstatus
) < 0)
498 print_sys_errmsg (pi
.pathname
, errno
);
500 error ("PIOCSTATUS failed");
502 if (pi
.prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
))
509 if (query ("Process is currently running, stop it? "))
511 if (ioctl (pi
.fd
, PIOCSTOP
, &pi
.prstatus
) < 0)
513 print_sys_errmsg (pi
.pathname
, errno
);
515 error ("PIOCSTOP failed");
520 /* Remember some things about the inferior that we will, or might, change
521 so that we can restore them when we detach. */
523 (void) ioctl (pi
.fd
, PIOCGTRACE
, &pi
.trace
);
524 (void) ioctl (pi
.fd
, PIOCGFAULT
, &pi
.fltset
);
525 (void) ioctl (pi
.fd
, PIOCGENTRY
, &pi
.entryset
);
526 (void) ioctl (pi
.fd
, PIOCGEXIT
, &pi
.exitset
);
528 /* Set up trace and fault sets, as gdb expects them. */
530 (void) memset (&pi
.prrun
, 0, sizeof (pi
.prrun
));
531 prfillset (&pi
.prrun
.pr_trace
);
532 prfillset (&pi
.prrun
.pr_fault
);
533 prdelset (&pi
.prrun
.pr_fault
, FLTPAGE
);
534 if (ioctl (pi
.fd
, PIOCSFAULT
, &pi
.prrun
.pr_fault
))
536 print_sys_errmsg ("PIOCSFAULT failed");
538 if (ioctl (pi
.fd
, PIOCSTRACE
, &pi
.prrun
.pr_trace
))
540 print_sys_errmsg ("PIOCSTRACE failed");
550 detach -- detach from an attached-to process
554 void detach (int signal)
558 Detach from the current attachee.
560 If signal is non-zero, the attachee is started running again and sent
561 the specified signal.
563 If signal is zero and the attachee was not already stopped when we
564 attached to it, then we make it runnable again when we detach.
566 Otherwise, we query whether or not to make the attachee runnable
567 again, since we may simply want to leave it in the state it was in
570 We report any problems, but do not consider them errors, since we
571 MUST detach even if some things don't seem to go right. This may not
572 be the ideal situation. (FIXME).
576 DEFUN(detach
, (signal
),
581 struct siginfo siginfo
;
582 siginfo
.si_signo
= signal
;
584 siginfo
.si_errno
= 0;
585 if (ioctl (pi
.fd
, PIOCSSIG
, &siginfo
) < 0)
587 print_sys_errmsg (pi
.pathname
, errno
);
588 printf ("PIOCSSIG failed.\n");
591 if (ioctl (pi
.fd
, PIOCSEXIT
, &pi
.exitset
) < 0)
593 print_sys_errmsg (pi
.pathname
, errno
);
594 printf ("PIOCSEXIT failed.\n");
596 if (ioctl (pi
.fd
, PIOCSENTRY
, &pi
.entryset
) < 0)
598 print_sys_errmsg (pi
.pathname
, errno
);
599 printf ("PIOCSENTRY failed.\n");
601 if (ioctl (pi
.fd
, PIOCSTRACE
, &pi
.trace
) < 0)
603 print_sys_errmsg (pi
.pathname
, errno
);
604 printf ("PIOCSTRACE failed.\n");
606 if (ioctl (pi
.fd
, PIOCSFAULT
, &pi
.fltset
) < 0)
608 print_sys_errmsg (pi
.pathname
, errno
);
609 printf ("PIOCSFAULT failed.\n");
611 if (ioctl (pi
.fd
, PIOCSTATUS
, &pi
.prstatus
) < 0)
613 print_sys_errmsg (pi
.pathname
, errno
);
614 printf ("PIOCSTATUS failed.\n");
618 if (signal
|| (pi
.prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
)))
620 if (signal
|| !pi
.was_stopped
||
621 query ("Was stopped when attached, make it runnable again? "))
623 (void) memset (&pi
.prrun
, 0, sizeof (pi
.prrun
));
624 pi
.prrun
.pr_flags
= PRCFAULT
;
625 if (ioctl (pi
.fd
, PIOCRUN
, &pi
.prrun
))
627 print_sys_errmsg (pi
.pathname
, errno
);
628 printf ("PIOCRUN failed.\n");
641 proc_wait -- emulate wait() as much as possible
645 int proc_wait (int *statloc)
649 Try to emulate wait() as much as possible. Not sure why we can't
650 just use wait(), but it seems to have problems when applied to a
651 process being controlled with the /proc interface.
655 We have a race problem here with no obvious solution. We need to let
656 the inferior run until it stops on an event of interest, which means
657 that we need to use the PIOCWSTOP ioctl. However, we cannot use this
658 ioctl if the process is already stopped on something that is not an
659 event of interest, or the call will hang indefinitely. Thus we first
660 use PIOCSTATUS to see if the process is not stopped. If not, then we
661 use PIOCWSTOP. But during the window between the two, if the process
662 stops for any reason that is not an event of interest (such as a job
663 control signal) then gdb will hang. One possible workaround is to set
664 an alarm to wake up every minute of so and check to see if the process
665 is still running, and if so, then reissue the PIOCWSTOP. But this is
666 a real kludge, so has not been implemented. FIXME: investigate
669 FIXME: Investigate why wait() seems to have problems with programs
670 being control by /proc routines.
675 DEFUN(proc_wait
, (statloc
),
684 if (ioctl (pi
.fd
, PIOCSTATUS
, &pi
.prstatus
) < 0)
688 else if (!(pi
.prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
)))
690 if (ioctl (pi
.fd
, PIOCWSTOP
, &pi
.prstatus
) < 0)
699 rtnval
= wait (&statval
);
700 if (rtnval
!= inferior_pid
)
702 error ("PIOCWSTOP, wait failed, returned %d", rtnval
);
708 print_sys_errmsg (pi
.pathname
, errno
);
709 error ("PIOCSTATUS or PIOCWSTOP failed.");
713 else if (pi
.prstatus
.pr_flags
& (PR_STOPPED
| PR_ISTOP
))
715 rtnval
= pi
.prstatus
.pr_pid
;
716 why
= pi
.prstatus
.pr_why
;
717 what
= pi
.prstatus
.pr_what
;
718 if (why
== PR_SIGNALLED
)
720 statval
= (what
<< 8) | 0177;
722 else if ((why
== PR_SYSEXIT
) &&
723 (what
== SYS_exec
|| what
== SYS_execve
))
725 statval
= (SIGTRAP
<< 8) | 0177;
727 else if (why
== PR_REQUESTED
)
729 statval
= (SIGSTOP
<< 8) | 0177;
731 else if (why
== PR_JOBCONTROL
)
733 statval
= (what
<< 8) | 0177;
735 else if (why
== PR_FAULTED
)
741 statval
= (SIGILL
<< 8) | 0177;
745 statval
= (SIGTRAP
<< 8) | 0177;
750 statval
= (SIGSEGV
<< 8) | 0177;
755 statval
= (SIGFPE
<< 8) | 0177;
757 case FLTPAGE
: /* Recoverable page fault */
760 error ("PIOCWSTOP, unknown why %d, what %d", why
, what
);
767 error ("PIOCWSTOP, unknown why %d, what %d", why
, what
);
773 error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
774 pi
.prstatus
.pr_flags
);
788 child_resume -- resume execution of the inferior process
792 void child_resume (int step, int signal)
796 Resume execution of the inferior process. If STEP is nozero, then
797 just single step it. If SIGNAL is nonzero, restart it with that
802 It may not be absolutely necessary to specify the PC value for
803 restarting, but to be safe we use the value that gdb considers
804 to be current. One case where this might be necessary is if the
805 user explicitly changes the PC value that gdb considers to be
806 current. FIXME: Investigate if this is necessary or not.
810 DEFUN(child_resume
, (step
, signal
),
815 pi
.prrun
.pr_flags
= PRSVADDR
| PRSTRACE
| PRSFAULT
| PRCFAULT
;
816 pi
.prrun
.pr_vaddr
= (caddr_t
) *(int *) ®isters
[REGISTER_BYTE (PC_REGNUM
)];
819 if (signal
!= pi
.prstatus
.pr_cursig
)
821 struct siginfo siginfo
;
822 siginfo
.si_signo
= signal
;
824 siginfo
.si_errno
= 0;
825 (void) ioctl (pi
.fd
, PIOCSSIG
, &siginfo
);
830 pi
.prrun
.pr_flags
|= PRCSIG
;
834 pi
.prrun
.pr_flags
|= PRSTEP
;
836 if (ioctl (pi
.fd
, PIOCRUN
, &pi
.prrun
) != 0)
838 perror_with_name (pi
.pathname
);
847 fetch_inferior_registers -- fetch current registers from inferior
851 void fetch_inferior_registers (void)
855 Read the current values of the inferior's registers, both the
856 general register set and floating point registers (if supported)
857 and update gdb's idea of their current values.
862 DEFUN_VOID(fetch_inferior_registers
)
864 if (ioctl (pi
.fd
, PIOCGREG
, &pi
.gregset
) != -1)
866 supply_gregset (&pi
.gregset
);
868 #if defined (FP0_REGNUM)
869 if (ioctl (pi
.fd
, PIOCGFPREG
, &pi
.fpregset
) != -1)
871 supply_fpregset (&pi
.fpregset
);
876 #endif /* ATTACH_DETACH */
882 proc_init_failed - called whenever /proc access initialization fails
886 static void proc_init_failed (char *why)
890 This function is called whenever initialization of access to a /proc
891 entry fails. It prints a suitable error message, does some cleanup,
892 and then invokes the standard error processing routine which dumps
893 us back into the command loop.
897 DEFUN(proc_init_failed
, (why
),
900 print_sys_errmsg (pi
.pathname
, errno
);
901 (void) kill (pi
.pid
, SIGKILL
);
911 close_proc_file - close any currently open /proc entry
915 static void close_proc_file (void)
919 Close any currently open /proc entry and mark the process information
920 entry as invalid. In order to ensure that we don't try to reuse any
921 stale information, the pid, fd, and pathnames are explicitly
922 invalidated, which may be overkill.
927 DEFUN_VOID(close_proc_file
)
932 (void) close (pi
.fd
);
947 open_proc_file - open a /proc entry for a given process id
951 static int open_proc_file (pid)
955 Given a process id, close the existing open /proc entry (if any)
956 and open one for the new process id. Once it is open, then
957 mark the local process information structure as valid, which
958 guarantees that the pid, fd, and pathname fields match an open
959 /proc entry. Returns zero if the open fails, nonzero otherwise.
961 Note that the pathname is left intact, even when the open fails,
962 so that callers can use it to construct meaningful error messages
963 rather than just "file open failed".
967 DEFUN(open_proc_file
, (pid
),
973 (void) close (pi
.fd
);
975 if (pi
.pathname
== NULL
)
977 pi
.pathname
= xmalloc (32);
979 sprintf (pi
.pathname
, PROC_NAME_FMT
, pid
);
980 if ((pi
.fd
= open (pi
.pathname
, O_RDWR
)) >= 0)
988 #endif /* USE_PROC_FS */