1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 Copyright 1999 Free Software Foundation, Inc.
3 Written by Michael Snyder at Cygnus Solutions.
4 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software Foundation,
20 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "gdbthread.h"
29 #if defined (NEW_PROC_API)
30 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
33 #include <sys/procfs.h>
34 #include <sys/fault.h>
35 #include <sys/syscall.h>
36 #include <sys/errno.h>
41 #include "proc-utils.h"
46 * This module provides the interface between GDB and the
47 * /proc file system, which is used on many versions of Unix
48 * as a means for debuggers to control other processes.
49 * Examples of the systems that use this interface are:
55 * /proc works by immitating a file system: you open a simulated file
56 * that represents the process you wish to interact with, and
57 * perform operations on that "file" in order to examine or change
58 * the state of the other process.
60 * The most important thing to know about /proc and this module
61 * is that there are two very different interfaces to /proc:
62 * One that uses the ioctl system call, and
63 * another that uses read and write system calls.
64 * This module has to support both /proc interfaces. This means
65 * that there are two different ways of doing every basic operation.
67 * In order to keep most of the code simple and clean, I have
68 * defined an interface "layer" which hides all these system calls.
69 * An ifdef (NEW_PROC_API) determines which interface we are using,
70 * and most or all occurrances of this ifdef should be confined to
71 * this interface layer.
75 /* Determine which /proc API we are using:
76 The ioctl API defines PIOCSTATUS, while
77 the read/write (multiple fd) API never does. */
80 #include <sys/types.h>
81 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
84 #include <fcntl.h> /* for O_RDONLY */
85 #include <unistd.h> /* for "X_OK" */
86 #include "gdb_stat.h" /* for struct stat */
88 /* =================== TARGET_OPS "MODULE" =================== */
91 * This module defines the GDB target vector and its methods.
94 static void procfs_open
PARAMS((char *, int));
95 static void procfs_attach
PARAMS ((char *, int));
96 static void procfs_detach
PARAMS ((char *, int));
97 static void procfs_resume
PARAMS ((int, int, enum target_signal
));
98 static int procfs_can_run
PARAMS ((void));
99 static void procfs_stop
PARAMS ((void));
100 static void procfs_files_info
PARAMS ((struct target_ops
*));
101 static void procfs_fetch_registers
PARAMS ((int));
102 static void procfs_store_registers
PARAMS ((int));
103 static void procfs_notice_signals
PARAMS ((int));
104 static void procfs_prepare_to_store
PARAMS ((void));
105 static void procfs_kill_inferior
PARAMS ((void));
106 static void procfs_mourn_inferior
PARAMS ((void));
107 static void procfs_create_inferior
PARAMS ((char *, char *, char **));
108 static int procfs_wait
PARAMS ((int,
109 struct target_waitstatus
*));
110 static int procfs_xfer_memory
PARAMS ((CORE_ADDR
,
112 struct target_ops
*));
114 static int procfs_thread_alive
PARAMS ((int));
116 void procfs_find_new_threads
PARAMS ((void));
117 char *procfs_pid_to_str
PARAMS ((int));
119 struct target_ops procfs_ops
; /* the target vector */
124 procfs_ops
.to_shortname
= "procfs";
125 procfs_ops
.to_longname
= "Unix /proc child process";
127 "Unix /proc child process (started by the \"run\" command).";
128 procfs_ops
.to_open
= procfs_open
;
129 procfs_ops
.to_can_run
= procfs_can_run
;
130 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
131 procfs_ops
.to_kill
= procfs_kill_inferior
;
132 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
133 procfs_ops
.to_attach
= procfs_attach
;
134 procfs_ops
.to_detach
= procfs_detach
;
135 procfs_ops
.to_wait
= procfs_wait
;
136 procfs_ops
.to_resume
= procfs_resume
;
137 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
138 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
139 procfs_ops
.to_store_registers
= procfs_store_registers
;
140 procfs_ops
.to_xfer_memory
= procfs_xfer_memory
;
141 procfs_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
142 procfs_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
143 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
144 procfs_ops
.to_files_info
= procfs_files_info
;
145 procfs_ops
.to_stop
= procfs_stop
;
147 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
148 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
149 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
150 procfs_ops
.to_terminal_ours
= terminal_ours
;
151 procfs_ops
.to_terminal_info
= child_terminal_info
;
153 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
154 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
155 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
157 procfs_ops
.to_has_execution
= 1;
158 procfs_ops
.to_has_stack
= 1;
159 procfs_ops
.to_has_registers
= 1;
160 procfs_ops
.to_stratum
= process_stratum
;
161 procfs_ops
.to_has_thread_control
= tc_schedlock
;
162 procfs_ops
.to_magic
= OPS_MAGIC
;
165 /* =================== END, TARGET_OPS "MODULE" =================== */
168 * Temporary debugging code:
170 * These macros allow me to trace the system calls that we make
171 * to control the child process. This is quite handy for comparing
172 * with the older version of procfs.
177 extern int write_with_trace
PARAMS ((int, void *, size_t, char *, int));
178 extern off_t lseek_with_trace
PARAMS ((int, off_t
, int, char *, int));
179 #define write(X,Y,Z) write_with_trace (X, Y, Z, __FILE__, __LINE__)
180 #define lseek(X,Y,Z) lseek_with_trace (X, Y, Z, __FILE__, __LINE__)
182 extern int ioctl_with_trace
PARAMS ((int, long, void *, char *, int));
183 #define ioctl(X,Y,Z) ioctl_with_trace (X, Y, Z, __FILE__, __LINE__)
185 #define open(X,Y) open_with_trace (X, Y, __FILE__, __LINE__)
186 #define close(X) close_with_trace (X, __FILE__, __LINE__)
187 #define wait(X) wait_with_trace (X, __FILE__, __LINE__)
188 #define PROCFS_NOTE(X) procfs_note (X, __FILE__, __LINE__)
189 #define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T) \
190 proc_prettyfprint_status (X, Y, Z, T)
192 #define PROCFS_NOTE(X)
193 #define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T)
200 * Put any typedefs, defines etc. here that are required for
201 * the unification of code that handles different versions of /proc.
204 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
206 enum { READ_WATCHFLAG
= WA_READ
,
207 WRITE_WATCHFLAG
= WA_WRITE
,
208 EXEC_WATCHFLAG
= WA_EXEC
,
209 AFTER_WATCHFLAG
= WA_TRAPAFTER
212 #else /* Irix method for watchpoints */
213 enum { READ_WATCHFLAG
= MA_READ
,
214 WRITE_WATCHFLAG
= MA_WRITE
,
215 EXEC_WATCHFLAG
= MA_EXEC
,
216 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
223 /* =================== STRUCT PROCINFO "MODULE" =================== */
225 /* FIXME: this comment will soon be out of date W.R.T. threads. */
227 /* The procinfo struct is a wrapper to hold all the state information
228 concerning a /proc process. There should be exactly one procinfo
229 for each process, and since GDB currently can debug only one
230 process at a time, that means there should be only one procinfo.
231 All of the LWP's of a process can be accessed indirectly thru the
232 single process procinfo.
234 However, against the day when GDB may debug more than one process,
235 this data structure is kept in a list (which for now will hold no
236 more than one member), and many functions will have a pointer to a
237 procinfo as an argument.
239 There will be a separate procinfo structure for use by the (not yet
240 implemented) "info proc" command, so that we can print useful
241 information about any random process without interfering with the
242 inferior's procinfo information. */
245 /* format strings for /proc paths */
246 # ifndef CTL_PROC_NAME_FMT
247 # define MAIN_PROC_NAME_FMT "/proc/%d"
248 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
249 # define AS_PROC_NAME_FMT "/proc/%d/as"
250 # define MAP_PROC_NAME_FMT "/proc/%d/map"
251 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
252 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
254 /* the name of the proc status struct depends on the implementation */
255 typedef pstatus_t gdb_prstatus_t
;
256 typedef lwpstatus_t gdb_lwpstatus_t
;
257 #else /* ! NEW_PROC_API */
258 /* format strings for /proc paths */
259 # ifndef CTL_PROC_NAME_FMT
260 # define MAIN_PROC_NAME_FMT "/proc/%05d"
261 # define CTL_PROC_NAME_FMT "/proc/%05d"
262 # define AS_PROC_NAME_FMT "/proc/%05d"
263 # define MAP_PROC_NAME_FMT "/proc/%05d"
264 # define STATUS_PROC_NAME_FMT "/proc/%05d"
265 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
267 /* the name of the proc status struct depends on the implementation */
268 typedef prstatus_t gdb_prstatus_t
;
269 typedef prstatus_t gdb_lwpstatus_t
;
270 #endif /* NEW_PROC_API */
273 /* These #ifdefs are for sol2.x in particular. sol2.x has
274 both a "gregset_t" and a "prgregset_t", which have
275 similar uses but different layouts. sol2.x gdb tries to
276 use prgregset_t (and prfpregset_t) everywhere. */
278 #ifdef GDB_GREGSET_TYPE
279 typedef GDB_GREGSET_TYPE gdb_gregset_t
;
281 typedef gregset_t gdb_gregset_t
;
284 #ifdef GDB_FPREGSET_TYPE
285 typedef GDB_FPREGSET_TYPE gdb_fpregset_t
;
287 typedef fpregset_t gdb_fpregset_t
;
290 /* Provide default composite pid manipulation macros for systems that
291 don't have threads. */
294 #define PIDGET(PID) (PID)
295 #define TIDGET(PID) (PID)
296 #define MERGEPID(PID, TID) (PID)
299 typedef struct procinfo
{
300 struct procinfo
*next
;
301 int pid
; /* Process ID */
302 int tid
; /* Thread/LWP id */
306 int ignore_next_sigstop
;
308 /* The following four fd fields may be identical, or may contain
309 several different fd's, depending on the version of /proc
310 (old ioctl or new read/write). */
312 int ctl_fd
; /* File descriptor for /proc control file */
314 * The next three file descriptors are actually only needed in the
315 * read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
316 * However, to avoid a bunch of #ifdefs in the code, we will use
317 * them uniformly by (in the case of the ioctl single-file-descriptor
318 * implementation) filling them with copies of the control fd.
320 int status_fd
; /* File descriptor for /proc status file */
321 int as_fd
; /* File descriptor for /proc as file */
323 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
325 fltset_t saved_fltset
; /* Saved traced hardware fault set */
326 sigset_t saved_sigset
; /* Saved traced signal set */
327 sigset_t saved_sighold
; /* Saved held signal set */
328 sysset_t saved_exitset
; /* Saved traced system call exit set */
329 sysset_t saved_entryset
; /* Saved traced system call entry set */
331 gdb_prstatus_t prstatus
; /* Current process status info */
334 gdb_fpregset_t fpregset
; /* Current floating point registers */
337 struct procinfo
*thread_list
;
339 int status_valid
: 1;
341 int fpregs_valid
: 1;
342 int threads_valid
: 1;
345 static char errmsg
[128]; /* shared error msg buffer */
347 /* Function prototypes for procinfo module: */
349 static procinfo
*find_procinfo_or_die
PARAMS ((int pid
, int tid
));
350 static procinfo
*find_procinfo
PARAMS ((int pid
, int tid
));
351 static procinfo
*create_procinfo
PARAMS ((int pid
, int tid
));
352 static void destroy_procinfo
PARAMS ((procinfo
*p
));
353 static void dead_procinfo
PARAMS ((procinfo
*p
,
354 char *msg
, int killp
));
355 static int open_procinfo_files
PARAMS ((procinfo
*p
, int which
));
356 static void close_procinfo_files
PARAMS ((procinfo
*p
));
358 /* The head of the procinfo list: */
359 static procinfo
* procinfo_list
;
362 * Function: find_procinfo
364 * Search the procinfo list.
366 * Returns: pointer to procinfo, or NULL if not found.
370 find_procinfo (pid
, tid
)
376 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
383 /* Don't check threads_valid. If we're updating the
384 thread_list, we want to find whatever threads are already
385 here. This means that in general it is the caller's
386 responsibility to check threads_valid and update before
387 calling find_procinfo, if the caller wants to find a new
390 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
399 * Function: find_procinfo_or_die
401 * Calls find_procinfo, but errors on failure.
405 find_procinfo_or_die (pid
, tid
)
409 procinfo
*pi
= find_procinfo (pid
, tid
);
414 error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",
417 error ("procfs: couldn't find pid %d in procinfo list.", pid
);
423 * Function: open_procinfo_files
425 * Open the file descriptor for the process or LWP.
426 * ifdef NEW_PROC_API, we only open the control file descriptor;
427 * the others are opened lazily as needed.
428 * else (if not NEW_PROC_API), there is only one real
429 * file descriptor, but we keep multiple copies of it so that
430 * the code that uses them does not have to be #ifdef'd.
432 * Return: file descriptor, or zero for failure.
435 enum { FD_CTL
, FD_STATUS
, FD_AS
};
438 open_procinfo_files (pi
, which
)
443 char tmp
[MAX_PROC_NAME_SIZE
];
448 * This function is getting ALMOST long enough to break up into several.
449 * Here is some rationale:
451 * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
452 * There are several file descriptors that may need to be open
453 * for any given process or LWP. The ones we're intereted in are:
454 * - control (ctl) write-only change the state
455 * - status (status) read-only query the state
456 * - address space (as) read/write access memory
457 * - map (map) read-only virtual addr map
458 * Most of these are opened lazily as they are needed.
459 * The pathnames for the 'files' for an LWP look slightly
460 * different from those of a first-class process:
461 * Pathnames for a process (<proc-id>):
462 * /proc/<proc-id>/ctl
463 * /proc/<proc-id>/status
465 * /proc/<proc-id>/map
466 * Pathnames for an LWP (lwp-id):
467 * /proc/<proc-id>/lwp/<lwp-id>/lwpctl
468 * /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
469 * An LWP has no map or address space file descriptor, since
470 * the memory map and address space are shared by all LWPs.
472 * Everyone else (Solaris 2.5, Irix, OSF)
473 * There is only one file descriptor for each process or LWP.
474 * For convenience, we copy the same file descriptor into all
475 * three fields of the procinfo struct (ctl_fd, status_fd, and
476 * as_fd, see NEW_PROC_API above) so that code that uses them
477 * doesn't need any #ifdef's.
482 * Each LWP has an independent file descriptor, but these
483 * are not obtained via the 'open' system call like the rest:
484 * instead, they're obtained thru an ioctl call (PIOCOPENLWP)
485 * to the file descriptor of the parent process.
488 * These do not even have their own independent file descriptor.
489 * All operations are carried out on the file descriptor of the
490 * parent process. Therefore we just call open again for each
491 * thread, getting a new handle for the same 'file'.
496 * In this case, there are several different file descriptors that
497 * we might be asked to open. The control file descriptor will be
498 * opened early, but the others will be opened lazily as they are
502 strcpy (tmp
, pi
->pathname
);
503 switch (which
) { /* which file descriptor to open? */
506 strcat (tmp
, "/lwpctl");
508 strcat (tmp
, "/ctl");
509 fd
= open (tmp
, O_WRONLY
);
516 return 0; /* there is no 'as' file descriptor for an lwp */
518 fd
= open (tmp
, O_RDWR
);
525 strcat (tmp
, "/lwpstatus");
527 strcat (tmp
, "/status");
528 fd
= open (tmp
, O_RDONLY
);
534 return 0; /* unknown file descriptor */
536 #else /* not NEW_PROC_API */
538 * In this case, there is only one file descriptor for each procinfo
539 * (ie. each process or LWP). In fact, only the file descriptor for
540 * the process can actually be opened by an 'open' system call.
541 * The ones for the LWPs have to be obtained thru an IOCTL call
542 * on the process's file descriptor.
544 * For convenience, we copy each procinfo's single file descriptor
545 * into all of the fields occupied by the several file descriptors
546 * of the NEW_PROC_API implementation. That way, the code that uses
547 * them can be written without ifdefs.
551 #ifdef PIOCTSTATUS /* OSF */
552 if ((fd
= open (pi
->pathname
, O_RDWR
)) == 0) /* Only one FD; just open it. */
554 #else /* Sol 2.5, Irix, other? */
555 if (pi
->tid
== 0) /* Master procinfo for the process */
557 fd
= open (pi
->pathname
, O_RDWR
);
561 else /* LWP thread procinfo */
563 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
567 /* Find the procinfo for the entire process. */
568 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
571 /* Now obtain the file descriptor for the LWP. */
572 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) <= 0)
574 #else /* Irix, other? */
575 return 0; /* Don't know how to open threads */
576 #endif /* Sol 2.5 PIOCOPENLWP */
578 #endif /* OSF PIOCTSTATUS */
579 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
580 #endif /* NEW_PROC_API */
582 return 1; /* success */
586 * Function: create_procinfo
588 * Allocate a data structure and link it into the procinfo list.
589 * (First tries to find a pre-existing one (FIXME: why???)
591 * Return: pointer to new procinfo struct.
595 create_procinfo (pid
, tid
)
599 procinfo
*pi
, *parent
;
601 if ((pi
= find_procinfo (pid
, tid
)))
602 return pi
; /* Already exists, nothing to do. */
604 /* find parent before doing malloc, to save having to cleanup */
606 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
608 doesn't exist yet? */
610 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
611 memset (pi
, 0, sizeof (procinfo
));
615 /* Chain into list. */
618 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
619 pi
->next
= procinfo_list
;
625 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
627 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
629 pi
->next
= parent
->thread_list
;
630 parent
->thread_list
= pi
;
636 * Function: close_procinfo_files
638 * Close all file descriptors associated with the procinfo
642 close_procinfo_files (pi
)
650 if (pi
->status_fd
> 0)
651 close (pi
->status_fd
);
653 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
657 * Function: destroy_procinfo
659 * Destructor function. Close, unlink and deallocate the object.
663 destroy_one_procinfo (list
, pi
)
669 /* Step one: unlink the procinfo from its list */
673 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
676 ptr
->next
= pi
->next
;
680 /* Step two: close any open file descriptors */
681 close_procinfo_files (pi
);
683 /* Step three: free the memory. */
688 destroy_procinfo (pi
)
693 if (pi
->tid
!= 0) /* destroy a thread procinfo */
695 tmp
= find_procinfo (pi
->pid
, 0); /* find the parent process */
696 destroy_one_procinfo (&tmp
->thread_list
, pi
);
698 else /* destroy a process procinfo and all its threads */
700 /* First destroy the children, if any; */
701 while (pi
->thread_list
!= NULL
)
702 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
703 /* Then destroy the parent. Genocide!!! */
704 destroy_one_procinfo (&procinfo_list
, pi
);
708 enum { NOKILL
, KILL
};
711 * Function: dead_procinfo
713 * To be called on a non_recoverable error for a procinfo.
714 * Prints error messages, optionally sends a SIGKILL to the process,
715 * then destroys the data structure.
719 dead_procinfo (pi
, msg
, kill_p
)
728 print_sys_errmsg (pi
->pathname
, errno
);
732 sprintf (procfile
, "process %d", pi
->pid
);
733 print_sys_errmsg (procfile
, errno
);
736 kill (pi
->pid
, SIGKILL
);
738 destroy_procinfo (pi
);
742 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
744 /* =================== /proc "MODULE" =================== */
747 * This "module" is the interface layer between the /proc system API
748 * and the gdb target vector functions. This layer consists of
749 * access functions that encapsulate each of the basic operations
750 * that we need to use from the /proc API.
752 * The main motivation for this layer is to hide the fact that
753 * there are two very different implementations of the /proc API.
754 * Rather than have a bunch of #ifdefs all thru the gdb target vector
755 * functions, we do our best to hide them all in here.
758 int proc_get_status
PARAMS ((procinfo
*pi
));
759 long proc_flags
PARAMS ((procinfo
*pi
));
760 int proc_why
PARAMS ((procinfo
*pi
));
761 int proc_what
PARAMS ((procinfo
*pi
));
762 int proc_set_run_on_last_close
PARAMS ((procinfo
*pi
));
763 int proc_unset_run_on_last_close
PARAMS ((procinfo
*pi
));
764 int proc_set_inherit_on_fork
PARAMS ((procinfo
*pi
));
765 int proc_unset_inherit_on_fork
PARAMS ((procinfo
*pi
));
766 int proc_set_async
PARAMS ((procinfo
*pi
));
767 int proc_unset_async
PARAMS ((procinfo
*pi
));
768 int proc_stop_process
PARAMS ((procinfo
*pi
));
769 int proc_trace_signal
PARAMS ((procinfo
*pi
, int signo
));
770 int proc_ignore_signal
PARAMS ((procinfo
*pi
, int signo
));
771 int proc_clear_current_fault
PARAMS ((procinfo
*pi
));
772 int proc_set_current_signal
PARAMS ((procinfo
*pi
, int signo
));
773 int proc_clear_current_signal
PARAMS ((procinfo
*pi
));
774 int proc_set_gregs
PARAMS ((procinfo
*pi
));
775 int proc_set_fpregs
PARAMS ((procinfo
*pi
));
776 int proc_wait_for_stop
PARAMS ((procinfo
*pi
));
777 int proc_run_process
PARAMS ((procinfo
*pi
, int step
, int signo
));
778 int proc_kill
PARAMS ((procinfo
*pi
, int signo
));
779 int proc_parent_pid
PARAMS ((procinfo
*pi
));
780 int proc_get_nthreads
PARAMS ((procinfo
*pi
));
781 int proc_get_current_thread
PARAMS ((procinfo
*pi
));
782 int proc_set_held_signals
PARAMS ((procinfo
*pi
, sigset_t
*sighold
));
783 int proc_set_traced_sysexit
PARAMS ((procinfo
*pi
, sysset_t
*sysset
));
784 int proc_set_traced_sysentry
PARAMS ((procinfo
*pi
, sysset_t
*sysset
));
785 int proc_set_traced_faults
PARAMS ((procinfo
*pi
, fltset_t
*fltset
));
786 int proc_set_traced_signals
PARAMS ((procinfo
*pi
, sigset_t
*sigset
));
788 int proc_update_threads
PARAMS ((procinfo
*pi
));
789 int proc_iterate_over_threads
PARAMS ((procinfo
*pi
,
790 int (*func
) PARAMS ((procinfo
*,
795 gdb_gregset_t
*proc_get_gregs
PARAMS ((procinfo
*pi
));
796 gdb_fpregset_t
*proc_get_fpregs
PARAMS ((procinfo
*pi
));
797 sysset_t
*proc_get_traced_sysexit
PARAMS ((procinfo
*pi
, sysset_t
*save
));
798 sysset_t
*proc_get_traced_sysentry
PARAMS ((procinfo
*pi
, sysset_t
*save
));
799 fltset_t
*proc_get_traced_faults
PARAMS ((procinfo
*pi
, fltset_t
*save
));
800 sigset_t
*proc_get_traced_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
801 sigset_t
*proc_get_held_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
802 sigset_t
*proc_get_pending_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
803 struct sigaction
*proc_get_signal_actions
PARAMS ((procinfo
*pi
,
804 struct sigaction
*save
));
806 void proc_warn
PARAMS ((procinfo
*pi
, char *func
, int line
));
807 void proc_error
PARAMS ((procinfo
*pi
, char *func
, int line
));
810 proc_warn (pi
, func
, line
)
815 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
816 print_sys_errmsg (errmsg
, errno
);
820 proc_error (pi
, func
, line
)
825 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
826 perror_with_name (errmsg
);
830 * Function: proc_get_status
832 * Updates the status struct in the procinfo.
833 * There is a 'valid' flag, to let other functions know when
834 * this function needs to be called (so the status is only
835 * read when it is needed). The status file descriptor is
836 * also only opened when it is needed.
838 * Return: non-zero for success, zero for failure.
845 /* Status file descriptor is opened "lazily" */
846 if (pi
->status_fd
== 0 &&
847 open_procinfo_files (pi
, FD_STATUS
) == 0)
849 pi
->status_valid
= 0;
854 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
855 pi
->status_valid
= 0; /* fail */
858 /* Sigh... I have to read a different data structure,
859 depending on whether this is a main process or an LWP. */
861 pi
->status_valid
= (read (pi
->status_fd
,
862 (char *) &pi
->prstatus
.pr_lwp
,
863 sizeof (lwpstatus_t
))
864 == sizeof (lwpstatus_t
));
867 pi
->status_valid
= (read (pi
->status_fd
,
868 (char *) &pi
->prstatus
,
869 sizeof (gdb_prstatus_t
))
870 == sizeof (gdb_prstatus_t
));
871 #if 0 /*def UNIXWARE*/
872 if (pi
->status_valid
&&
873 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
874 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
875 /* Unixware peculiarity -- read the damn thing again! */
876 pi
->status_valid
= (read (pi
->status_fd
,
877 (char *) &pi
->prstatus
,
878 sizeof (gdb_prstatus_t
))
879 == sizeof (gdb_prstatus_t
));
880 #endif /* UNIXWARE */
883 #else /* ioctl method */
884 #ifdef PIOCTSTATUS /* osf */
885 if (pi
->tid
== 0) /* main process */
887 /* Just read the danged status. Now isn't that simple? */
889 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
896 tid_t pr_error_thread
;
897 struct prstatus status
;
900 thread_status
.pr_count
= 1;
901 thread_status
.status
.pr_tid
= pi
->tid
;
902 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
905 memcpy (&pi
->prstatus
, &thread_status
.status
,
906 sizeof (pi
->prstatus
));
907 pi
->status_valid
= 1;
911 /* Just read the danged status. Now isn't that simple? */
912 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
916 if (pi
->status_valid
)
918 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
921 proc_get_current_thread (pi
));
924 /* The status struct includes general regs, so mark them valid too */
925 pi
->gregs_valid
= pi
->status_valid
;
927 /* In the read/write multiple-fd model,
928 the status struct includes the fp regs too, so mark them valid too */
929 pi
->fpregs_valid
= pi
->status_valid
;
931 return pi
->status_valid
; /* True if success, false if failure. */
935 * Function: proc_flags
937 * returns the process flags (pr_flags field).
944 if (!pi
->status_valid
)
945 if (!proc_get_status (pi
))
946 return 0; /* FIXME: not a good failure value (but what is?) */
950 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
951 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
952 The two sets of flags don't overlap. */
953 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
955 return pi
->prstatus
.pr_lwp
.pr_flags
;
958 return pi
->prstatus
.pr_flags
;
965 * returns the pr_why field (why the process stopped).
972 if (!pi
->status_valid
)
973 if (!proc_get_status (pi
))
974 return 0; /* FIXME: not a good failure value (but what is?) */
977 return pi
->prstatus
.pr_lwp
.pr_why
;
979 return pi
->prstatus
.pr_why
;
984 * Function: proc_what
986 * returns the pr_what field (details of why the process stopped).
993 if (!pi
->status_valid
)
994 if (!proc_get_status (pi
))
995 return 0; /* FIXME: not a good failure value (but what is?) */
998 return pi
->prstatus
.pr_lwp
.pr_what
;
1000 return pi
->prstatus
.pr_what
;
1004 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1006 * Function: proc_nsysarg
1008 * returns the pr_nsysarg field (number of args to the current syscall).
1015 if (!pi
->status_valid
)
1016 if (!proc_get_status (pi
))
1020 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1022 return pi
->prstatus
.pr_nsysarg
;
1027 * Function: proc_sysargs
1029 * returns the pr_sysarg field (pointer to the arguments of current syscall).
1036 if (!pi
->status_valid
)
1037 if (!proc_get_status (pi
))
1041 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1043 return (long *) &pi
->prstatus
.pr_sysarg
;
1048 * Function: proc_syscall
1050 * returns the pr_syscall field (id of current syscall if we are in one).
1057 if (!pi
->status_valid
)
1058 if (!proc_get_status (pi
))
1062 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1064 return pi
->prstatus
.pr_syscall
;
1067 #endif /* PIOCSSPCACT */
1070 * Function: proc_cursig:
1072 * returns the pr_cursig field (current signal).
1076 proc_cursig (struct procinfo
*pi
)
1078 if (!pi
->status_valid
)
1079 if (!proc_get_status (pi
))
1080 return 0; /* FIXME: not a good failure value (but what is?) */
1083 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1085 return pi
->prstatus
.pr_cursig
;
1090 * Function: proc_modify_flag
1092 * === I appologize for the messiness of this function.
1093 * === This is an area where the different versions of
1094 * === /proc are more inconsistent than usual. MVS
1096 * Set or reset any of the following process flags:
1097 * PR_FORK -- forked child will inherit trace flags
1098 * PR_RLC -- traced process runs when last /proc file closed.
1099 * PR_KLC -- traced process is killed when last /proc file closed.
1100 * PR_ASYNC -- LWP's get to run/stop independently.
1102 * There are three methods for doing this function:
1103 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1105 * 2) Middle: PIOCSET/PIOCRESET
1107 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1110 * Note: Irix does not define PR_ASYNC.
1111 * Note: OSF does not define PR_KLC.
1112 * Note: OSF is the only one that can ONLY use the oldest method.
1115 * pi -- the procinfo
1116 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1117 * mode -- 1 for set, 0 for reset.
1119 * Returns non-zero for success, zero for failure.
1122 enum { FLAG_RESET
, FLAG_SET
};
1125 proc_modify_flag (pi
, flag
, mode
)
1130 long win
= 0; /* default to fail */
1133 * These operations affect the process as a whole, and applying
1134 * them to an individual LWP has the same meaning as applying them
1135 * to the main process. Therefore, if we're ever called with a
1136 * pointer to an LWP's procinfo, let's substitute the process's
1137 * procinfo and avoid opening the LWP's file descriptor
1142 pi
= find_procinfo_or_die (pi
->pid
, 0);
1144 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
1145 /* First normalize the PCUNSET/PCRESET command opcode
1146 (which for no obvious reason has a different definition
1147 from one operating system to the next...) */
1149 #define GDBRESET PCUNSET
1152 #define GDBRESET PCRESET
1157 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC) */
1159 else /* Reset the flag */
1163 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1166 #ifdef PIOCSET /* Irix/Sol5 method */
1167 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
1169 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1171 else /* Reset the flag */
1173 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1177 #ifdef PIOCSRLC /* Oldest method: OSF */
1180 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1182 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1184 else /* Clear run-on-last-close */
1186 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1190 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1192 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1194 else /* Clear inherit-on-fork */
1196 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1200 win
= 0; /* fail -- unknown flag (can't do PR_ASYNC) */
1207 /* The above operation renders the procinfo's cached pstatus obsolete. */
1208 pi
->status_valid
= 0;
1211 warning ("procfs: modify_flag failed to turn %s %s",
1212 flag
== PR_FORK
? "PR_FORK" :
1213 flag
== PR_RLC
? "PR_RLC" :
1215 flag
== PR_ASYNC
? "PR_ASYNC" :
1218 flag
== PR_KLC
? "PR_KLC" :
1221 mode
== FLAG_RESET
? "off" : "on");
1227 * Function: proc_set_run_on_last_close
1229 * Set the run_on_last_close flag.
1230 * Process with all threads will become runnable
1231 * when debugger closes all /proc fds.
1233 * Returns non-zero for success, zero for failure.
1237 proc_set_run_on_last_close (pi
)
1240 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1244 * Function: proc_unset_run_on_last_close
1246 * Reset the run_on_last_close flag.
1247 * Process will NOT become runnable
1248 * when debugger closes its file handles.
1250 * Returns non-zero for success, zero for failure.
1254 proc_unset_run_on_last_close (pi
)
1257 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1262 * Function: proc_set_kill_on_last_close
1264 * Set the kill_on_last_close flag.
1265 * Process with all threads will be killed when debugger
1266 * closes all /proc fds (or debugger exits or dies).
1268 * Returns non-zero for success, zero for failure.
1272 proc_set_kill_on_last_close (pi
)
1275 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1279 * Function: proc_unset_kill_on_last_close
1281 * Reset the kill_on_last_close flag.
1282 * Process will NOT be killed when debugger
1283 * closes its file handles (or exits or dies).
1285 * Returns non-zero for success, zero for failure.
1289 proc_unset_kill_on_last_close (pi
)
1292 return proc_modify_flag (pi
, PR_KLC
, FLAG_RESET
);
1297 * Function: proc_set_inherit_on_fork
1299 * Set inherit_on_fork flag.
1300 * If the process forks a child while we are registered for events
1301 * in the parent, then we will also recieve events from the child.
1303 * Returns non-zero for success, zero for failure.
1307 proc_set_inherit_on_fork (pi
)
1310 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1314 * Function: proc_unset_inherit_on_fork
1316 * Reset inherit_on_fork flag.
1317 * If the process forks a child while we are registered for events
1318 * in the parent, then we will NOT recieve events from the child.
1320 * Returns non-zero for success, zero for failure.
1324 proc_unset_inherit_on_fork (pi
)
1327 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1332 * Function: proc_set_async
1334 * Set PR_ASYNC flag.
1335 * If one LWP stops because of a debug event (signal etc.),
1336 * the remaining LWPs will continue to run.
1338 * Returns non-zero for success, zero for failure.
1345 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1349 * Function: proc_unset_async
1351 * Reset PR_ASYNC flag.
1352 * If one LWP stops because of a debug event (signal etc.),
1353 * then all other LWPs will stop as well.
1355 * Returns non-zero for success, zero for failure.
1359 proc_unset_async (pi
)
1362 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1364 #endif /* PR_ASYNC */
1367 * Function: proc_stop_process
1369 * Request the process/LWP to stop. Does not wait.
1370 * Returns non-zero for success, zero for failure.
1374 proc_stop_process (pi
)
1380 * We might conceivably apply this operation to an LWP, and
1381 * the LWP's ctl file descriptor might not be open.
1384 if (pi
->ctl_fd
== 0 &&
1385 open_procinfo_files (pi
, FD_CTL
) == 0)
1391 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1392 #else /* ioctl method */
1393 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1394 /* Note: the call also reads the prstatus. */
1397 pi
->status_valid
= 1;
1398 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1401 proc_get_current_thread (pi
));
1410 * Function: proc_wait_for_stop
1412 * Wait for the process or LWP to stop (block until it does).
1413 * Returns non-zero for success, zero for failure.
1417 proc_wait_for_stop (pi
)
1423 * We should never have to apply this operation to any procinfo
1424 * except the one for the main process. If that ever changes
1425 * for any reason, then take out the following clause and
1426 * replace it with one that makes sure the ctl_fd is open.
1430 pi
= find_procinfo_or_die (pi
->pid
, 0);
1435 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1436 /* We been runnin' and we stopped -- need to update status. */
1437 pi
->status_valid
= 0;
1439 #else /* ioctl method */
1440 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1441 /* Above call also refreshes the prstatus. */
1444 pi
->status_valid
= 1;
1445 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1448 proc_get_current_thread (pi
));
1456 * Function: proc_run_process
1458 * Make the process or LWP runnable.
1459 * Options (not all are implemented):
1461 * - clear current fault
1462 * - clear current signal
1463 * - abort the current system call
1464 * - stop as soon as finished with system call
1465 * - (ioctl): set traced signal set
1466 * - (ioctl): set held signal set
1467 * - (ioctl): set traced fault set
1468 * - (ioctl): set start pc (vaddr)
1469 * Always clear the current fault.
1470 * Clear the current signal if 'signo' is zero.
1473 * pi the process or LWP to operate on.
1474 * step if true, set the process or LWP to trap after one instr.
1475 * signo if zero, clear the current signal if any.
1476 * if non-zero, set the current signal to this one.
1478 * Returns non-zero for success, zero for failure.
1482 proc_run_process (pi
, step
, signo
)
1491 * We will probably have to apply this operation to individual threads,
1492 * so make sure the control file descriptor is open.
1495 if (pi
->ctl_fd
== 0 &&
1496 open_procinfo_files (pi
, FD_CTL
) == 0)
1501 runflags
= PRCFAULT
; /* always clear current fault */
1506 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals */
1507 proc_set_current_signal (pi
, signo
);
1515 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1517 #else /* ioctl method */
1521 memset (&prrun
, 0, sizeof (prrun
));
1522 prrun
.pr_flags
= runflags
;
1523 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1531 * Function: proc_set_traced_signals
1533 * Register to trace signals in the process or LWP.
1534 * Returns non-zero for success, zero for failure.
1538 proc_set_traced_signals (pi
, sigset
)
1545 * We should never have to apply this operation to any procinfo
1546 * except the one for the main process. If that ever changes
1547 * for any reason, then take out the following clause and
1548 * replace it with one that makes sure the ctl_fd is open.
1552 pi
= find_procinfo_or_die (pi
->pid
, 0);
1558 /* Use char array to avoid alignment issues. */
1559 char sigset
[sizeof (sigset_t
)];
1563 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
1565 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1567 #else /* ioctl method */
1568 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1570 /* The above operation renders the procinfo's cached pstatus obsolete. */
1571 pi
->status_valid
= 0;
1574 warning ("procfs: set_traced_signals failed");
1579 * Function: proc_set_traced_faults
1581 * Register to trace hardware faults in the process or LWP.
1582 * Returns non-zero for success, zero for failure.
1586 proc_set_traced_faults (pi
, fltset
)
1593 * We should never have to apply this operation to any procinfo
1594 * except the one for the main process. If that ever changes
1595 * for any reason, then take out the following clause and
1596 * replace it with one that makes sure the ctl_fd is open.
1600 pi
= find_procinfo_or_die (pi
->pid
, 0);
1606 /* Use char array to avoid alignment issues. */
1607 char fltset
[sizeof (fltset_t
)];
1611 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1613 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1615 #else /* ioctl method */
1616 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1618 /* The above operation renders the procinfo's cached pstatus obsolete. */
1619 pi
->status_valid
= 0;
1625 * Function: proc_set_traced_sysentry
1627 * Register to trace entry to system calls in the process or LWP.
1628 * Returns non-zero for success, zero for failure.
1632 proc_set_traced_sysentry (pi
, sysset
)
1639 * We should never have to apply this operation to any procinfo
1640 * except the one for the main process. If that ever changes
1641 * for any reason, then take out the following clause and
1642 * replace it with one that makes sure the ctl_fd is open.
1646 pi
= find_procinfo_or_die (pi
->pid
, 0);
1652 /* Use char array to avoid alignment issues. */
1653 char sysset
[sizeof (sysset_t
)];
1657 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1659 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1661 #else /* ioctl method */
1662 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1664 /* The above operation renders the procinfo's cached pstatus obsolete. */
1665 pi
->status_valid
= 0;
1671 * Function: proc_set_traced_sysexit
1673 * Register to trace exit from system calls in the process or LWP.
1674 * Returns non-zero for success, zero for failure.
1678 proc_set_traced_sysexit (pi
, sysset
)
1685 * We should never have to apply this operation to any procinfo
1686 * except the one for the main process. If that ever changes
1687 * for any reason, then take out the following clause and
1688 * replace it with one that makes sure the ctl_fd is open.
1692 pi
= find_procinfo_or_die (pi
->pid
, 0);
1698 /* Use char array to avoid alignment issues. */
1699 char sysset
[sizeof (sysset_t
)];
1703 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1705 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1707 #else /* ioctl method */
1708 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1710 /* The above operation renders the procinfo's cached pstatus obsolete. */
1711 pi
->status_valid
= 0;
1717 * Function: proc_set_held_signals
1719 * Specify the set of blocked / held signals in the process or LWP.
1720 * Returns non-zero for success, zero for failure.
1724 proc_set_held_signals (pi
, sighold
)
1731 * We should never have to apply this operation to any procinfo
1732 * except the one for the main process. If that ever changes
1733 * for any reason, then take out the following clause and
1734 * replace it with one that makes sure the ctl_fd is open.
1738 pi
= find_procinfo_or_die (pi
->pid
, 0);
1744 /* Use char array to avoid alignment issues. */
1745 char hold
[sizeof (sigset_t
)];
1749 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1750 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1753 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1755 /* The above operation renders the procinfo's cached pstatus obsolete. */
1756 pi
->status_valid
= 0;
1762 * Function: proc_get_pending_signals
1764 * returns the set of signals that are pending in the process or LWP.
1765 * Will also copy the sigset if 'save' is non-zero.
1769 proc_get_pending_signals (pi
, save
)
1773 sigset_t
*ret
= NULL
;
1776 * We should never have to apply this operation to any procinfo
1777 * except the one for the main process. If that ever changes
1778 * for any reason, then take out the following clause and
1779 * replace it with one that makes sure the ctl_fd is open.
1783 pi
= find_procinfo_or_die (pi
->pid
, 0);
1785 if (!pi
->status_valid
)
1786 if (!proc_get_status (pi
))
1790 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
1792 ret
= &pi
->prstatus
.pr_sigpend
;
1795 memcpy (save
, ret
, sizeof (sigset_t
));
1801 * Function: proc_get_signal_actions
1803 * returns the set of signal actions.
1804 * Will also copy the sigactionset if 'save' is non-zero.
1808 proc_get_signal_actions (pi
, save
)
1810 struct sigaction
*save
;
1812 struct sigaction
*ret
= NULL
;
1815 * We should never have to apply this operation to any procinfo
1816 * except the one for the main process. If that ever changes
1817 * for any reason, then take out the following clause and
1818 * replace it with one that makes sure the ctl_fd is open.
1822 pi
= find_procinfo_or_die (pi
->pid
, 0);
1824 if (!pi
->status_valid
)
1825 if (!proc_get_status (pi
))
1829 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
1831 ret
= &pi
->prstatus
.pr_action
;
1834 memcpy (save
, ret
, sizeof (struct sigaction
));
1840 * Function: proc_get_held_signals
1842 * returns the set of signals that are held / blocked.
1843 * Will also copy the sigset if 'save' is non-zero.
1847 proc_get_held_signals (pi
, save
)
1851 sigset_t
*ret
= NULL
;
1854 * We should never have to apply this operation to any procinfo
1855 * except the one for the main process. If that ever changes
1856 * for any reason, then take out the following clause and
1857 * replace it with one that makes sure the ctl_fd is open.
1861 pi
= find_procinfo_or_die (pi
->pid
, 0);
1864 if (!pi
->status_valid
)
1865 if (!proc_get_status (pi
))
1869 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1871 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1872 #endif /* UNIXWARE */
1873 #else /* not NEW_PROC_API */
1875 static sigset_t sigheld
;
1877 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1880 #endif /* NEW_PROC_API */
1882 memcpy (save
, ret
, sizeof (sigset_t
));
1888 * Function: proc_get_traced_signals
1890 * returns the set of signals that are traced / debugged.
1891 * Will also copy the sigset if 'save' is non-zero.
1895 proc_get_traced_signals (pi
, save
)
1899 sigset_t
*ret
= NULL
;
1902 * We should never have to apply this operation to any procinfo
1903 * except the one for the main process. If that ever changes
1904 * for any reason, then take out the following clause and
1905 * replace it with one that makes sure the ctl_fd is open.
1909 pi
= find_procinfo_or_die (pi
->pid
, 0);
1912 if (!pi
->status_valid
)
1913 if (!proc_get_status (pi
))
1916 ret
= &pi
->prstatus
.pr_sigtrace
;
1919 static sigset_t sigtrace
;
1921 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
1926 memcpy (save
, ret
, sizeof (sigset_t
));
1932 * Function: proc_trace_signal
1934 * Add 'signo' to the set of signals that are traced.
1935 * Returns non-zero for success, zero for failure.
1939 proc_trace_signal (pi
, signo
)
1946 * We should never have to apply this operation to any procinfo
1947 * except the one for the main process. If that ever changes
1948 * for any reason, then take out the following clause and
1949 * replace it with one that makes sure the ctl_fd is open.
1953 pi
= find_procinfo_or_die (pi
->pid
, 0);
1957 if (proc_get_traced_signals (pi
, &temp
))
1959 praddset (&temp
, signo
);
1960 return proc_set_traced_signals (pi
, &temp
);
1964 return 0; /* failure */
1968 * Function: proc_ignore_signal
1970 * Remove 'signo' from the set of signals that are traced.
1971 * Returns non-zero for success, zero for failure.
1975 proc_ignore_signal (pi
, signo
)
1982 * We should never have to apply this operation to any procinfo
1983 * except the one for the main process. If that ever changes
1984 * for any reason, then take out the following clause and
1985 * replace it with one that makes sure the ctl_fd is open.
1989 pi
= find_procinfo_or_die (pi
->pid
, 0);
1993 if (proc_get_traced_signals (pi
, &temp
))
1995 prdelset (&temp
, signo
);
1996 return proc_set_traced_signals (pi
, &temp
);
2000 return 0; /* failure */
2004 * Function: proc_get_traced_faults
2006 * returns the set of hardware faults that are traced /debugged.
2007 * Will also copy the faultset if 'save' is non-zero.
2011 proc_get_traced_faults (pi
, save
)
2015 fltset_t
*ret
= NULL
;
2018 * We should never have to apply this operation to any procinfo
2019 * except the one for the main process. If that ever changes
2020 * for any reason, then take out the following clause and
2021 * replace it with one that makes sure the ctl_fd is open.
2025 pi
= find_procinfo_or_die (pi
->pid
, 0);
2028 if (!pi
->status_valid
)
2029 if (!proc_get_status (pi
))
2032 ret
= &pi
->prstatus
.pr_flttrace
;
2035 static fltset_t flttrace
;
2037 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
2042 memcpy (save
, ret
, sizeof (fltset_t
));
2048 * Function: proc_get_traced_sysentry
2050 * returns the set of syscalls that are traced /debugged on entry.
2051 * Will also copy the syscall set if 'save' is non-zero.
2055 proc_get_traced_sysentry (pi
, save
)
2059 sysset_t
*ret
= NULL
;
2062 * We should never have to apply this operation to any procinfo
2063 * except the one for the main process. If that ever changes
2064 * for any reason, then take out the following clause and
2065 * replace it with one that makes sure the ctl_fd is open.
2069 pi
= find_procinfo_or_die (pi
->pid
, 0);
2072 if (!pi
->status_valid
)
2073 if (!proc_get_status (pi
))
2076 ret
= &pi
->prstatus
.pr_sysentry
;
2079 static sysset_t sysentry
;
2081 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
2086 memcpy (save
, ret
, sizeof (sysset_t
));
2092 * Function: proc_get_traced_sysexit
2094 * returns the set of syscalls that are traced /debugged on exit.
2095 * Will also copy the syscall set if 'save' is non-zero.
2099 proc_get_traced_sysexit (pi
, save
)
2103 sysset_t
* ret
= NULL
;
2106 * We should never have to apply this operation to any procinfo
2107 * except the one for the main process. If that ever changes
2108 * for any reason, then take out the following clause and
2109 * replace it with one that makes sure the ctl_fd is open.
2113 pi
= find_procinfo_or_die (pi
->pid
, 0);
2116 if (!pi
->status_valid
)
2117 if (!proc_get_status (pi
))
2120 ret
= &pi
->prstatus
.pr_sysexit
;
2123 static sysset_t sysexit
;
2125 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2130 memcpy (save
, ret
, sizeof (sysset_t
));
2136 * Function: proc_clear_current_fault
2138 * The current fault (if any) is cleared; the associated signal
2139 * will not be sent to the process or LWP when it resumes.
2140 * Returns non-zero for success, zero for failure.
2144 proc_clear_current_fault (pi
)
2150 * We should never have to apply this operation to any procinfo
2151 * except the one for the main process. If that ever changes
2152 * for any reason, then take out the following clause and
2153 * replace it with one that makes sure the ctl_fd is open.
2157 pi
= find_procinfo_or_die (pi
->pid
, 0);
2162 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2165 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2172 * Function: proc_set_current_signal
2174 * Set the "current signal" that will be delivered next to the process.
2175 * NOTE: semantics are different from those of KILL.
2176 * This signal will be delivered to the process or LWP
2177 * immediately when it is resumed (even if the signal is held/blocked);
2178 * it will NOT immediately cause another event of interest, and will NOT
2179 * first trap back to the debugger.
2181 * Returns non-zero for success, zero for failure.
2185 proc_set_current_signal (pi
, signo
)
2192 /* Use char array to avoid alignment issues. */
2193 char sinfo
[sizeof (struct siginfo
)];
2195 struct siginfo
*mysinfo
;
2198 * We should never have to apply this operation to any procinfo
2199 * except the one for the main process. If that ever changes
2200 * for any reason, then take out the following clause and
2201 * replace it with one that makes sure the ctl_fd is open.
2205 pi
= find_procinfo_or_die (pi
->pid
, 0);
2207 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2208 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2209 * receives a PIOCSSIG with a signal identical to the current signal,
2210 * it messes up the current signal. Work around the kernel bug.
2213 signo
== proc_cursig (pi
))
2214 return 1; /* I assume this is a success? */
2217 /* The pointer is just a type alias. */
2218 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2219 mysinfo
->si_signo
= signo
;
2220 mysinfo
->si_code
= 0;
2221 mysinfo
->si_pid
= getpid (); /* ?why? */
2222 mysinfo
->si_uid
= getuid (); /* ?why? */
2226 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2228 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2235 * Function: proc_clear_current_signal
2237 * The current signal (if any) is cleared, and
2238 * is not sent to the process or LWP when it resumes.
2239 * Returns non-zero for success, zero for failure.
2243 proc_clear_current_signal (pi
)
2249 * We should never have to apply this operation to any procinfo
2250 * except the one for the main process. If that ever changes
2251 * for any reason, then take out the following clause and
2252 * replace it with one that makes sure the ctl_fd is open.
2256 pi
= find_procinfo_or_die (pi
->pid
, 0);
2262 /* Use char array to avoid alignment issues. */
2263 char sinfo
[sizeof (struct siginfo
)];
2265 struct siginfo
*mysinfo
;
2268 /* The pointer is just a type alias. */
2269 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2270 mysinfo
->si_signo
= 0;
2271 mysinfo
->si_code
= 0;
2272 mysinfo
->si_errno
= 0;
2273 mysinfo
->si_pid
= getpid (); /* ?why? */
2274 mysinfo
->si_uid
= getuid (); /* ?why? */
2276 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2279 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2286 * Function: proc_get_gregs
2288 * Get the general registers for the process or LWP.
2289 * Returns non-zero for success, zero for failure.
2296 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2297 if (!proc_get_status (pi
))
2301 * OK, sorry about the ifdef's.
2302 * There's three cases instead of two, because
2303 * in this instance Unixware and Solaris/RW differ.
2307 #ifdef UNIXWARE /* ugh, a true architecture dependency */
2308 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2309 #else /* not Unixware */
2310 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2311 #endif /* Unixware */
2312 #else /* not NEW_PROC_API */
2313 return &pi
->prstatus
.pr_reg
;
2314 #endif /* NEW_PROC_API */
2318 * Function: proc_get_fpregs
2320 * Get the floating point registers for the process or LWP.
2321 * Returns non-zero for success, zero for failure.
2325 proc_get_fpregs (pi
)
2329 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2330 if (!proc_get_status (pi
))
2333 #ifdef UNIXWARE /* a true architecture dependency */
2334 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2336 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2337 #endif /* Unixware */
2339 #else /* not NEW_PROC_API */
2340 if (pi
->fpregs_valid
)
2341 return &pi
->fpregset
; /* already got 'em */
2344 if (pi
->ctl_fd
== 0 &&
2345 open_procinfo_files (pi
, FD_CTL
) == 0)
2354 tid_t pr_error_thread
;
2355 tfpregset_t thread_1
;
2358 thread_fpregs
.pr_count
= 1;
2359 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2362 ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2364 pi
->fpregs_valid
= 1;
2365 return &pi
->fpregset
; /* got 'em now! */
2367 else if (pi
->tid
!= 0 &&
2368 ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2370 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2371 sizeof (pi
->fpregset
));
2372 pi
->fpregs_valid
= 1;
2373 return &pi
->fpregset
; /* got 'em now! */
2380 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2382 pi
->fpregs_valid
= 1;
2383 return &pi
->fpregset
; /* got 'em now! */
2396 * Function: proc_set_gregs
2398 * Write the general registers back to the process or LWP.
2399 * Returns non-zero for success, zero for failure.
2406 gdb_gregset_t
*gregs
;
2409 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2410 return 0; /* get_regs has already warned */
2412 if (pi
->ctl_fd
== 0 &&
2413 open_procinfo_files (pi
, FD_CTL
) == 0)
2422 /* Use char array to avoid alignment issues. */
2423 char gregs
[sizeof (gdb_gregset_t
)];
2427 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2428 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2430 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2434 /* Policy: writing the regs invalidates our cache. */
2435 pi
->gregs_valid
= 0;
2440 * Function: proc_set_fpregs
2442 * Modify the floating point register set of the process or LWP.
2443 * Returns non-zero for success, zero for failure.
2447 proc_set_fpregs (pi
)
2450 gdb_fpregset_t
*fpregs
;
2453 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
2454 return 0; /* get_fpregs has already warned */
2456 if (pi
->ctl_fd
== 0 &&
2457 open_procinfo_files (pi
, FD_CTL
) == 0)
2466 /* Use char array to avoid alignment issues. */
2467 char fpregs
[sizeof (gdb_fpregset_t
)];
2471 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2472 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2476 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2481 tid_t pr_error_thread
;
2482 tfpregset_t thread_1
;
2485 thread_fpregs
.pr_count
= 1;
2486 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2487 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2489 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2492 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2493 #endif /* osf PIOCTSFPREG */
2494 #endif /* NEW_PROC_API */
2497 /* Policy: writing the regs invalidates our cache. */
2498 pi
->fpregs_valid
= 0;
2503 * Function: proc_kill
2505 * Send a signal to the proc or lwp with the semantics of "kill()".
2506 * Returns non-zero for success, zero for failure.
2510 proc_kill (pi
, signo
)
2517 * We might conceivably apply this operation to an LWP, and
2518 * the LWP's ctl file descriptor might not be open.
2521 if (pi
->ctl_fd
== 0 &&
2522 open_procinfo_files (pi
, FD_CTL
) == 0)
2533 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2534 #else /* ioctl method */
2535 /* FIXME: do I need the Alpha OSF fixups present in
2536 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2537 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2545 * Function: proc_parent_pid
2547 * Find the pid of the process that started this one.
2548 * Returns the parent process pid, or zero.
2552 proc_parent_pid (pi
)
2556 * We should never have to apply this operation to any procinfo
2557 * except the one for the main process. If that ever changes
2558 * for any reason, then take out the following clause and
2559 * replace it with one that makes sure the ctl_fd is open.
2563 pi
= find_procinfo_or_die (pi
->pid
, 0);
2565 if (!pi
->status_valid
)
2566 if (!proc_get_status (pi
))
2569 return pi
->prstatus
.pr_ppid
;
2574 * Function: proc_set_watchpoint
2579 proc_set_watchpoint (pi
, addr
, len
, wflags
)
2585 #if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
2588 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
2589 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
2594 char watch
[sizeof (prwatch_t
)];
2598 pwatch
= (prwatch_t
*) &arg
.watch
;
2599 pwatch
->pr_vaddr
= addr
;
2600 pwatch
->pr_size
= len
;
2601 pwatch
->pr_wflags
= wflags
;
2602 #if defined(NEW_PROC_API) && defined (PCWATCH)
2604 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2606 #if defined (PIOCSWATCH)
2607 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, pwatch
) >= 0);
2609 return 0; /* Fail */
2617 * Function: proc_iterate_over_mappings
2619 * Given a pointer to a function, call that function once for every
2620 * mapped address space in the process. The callback function
2621 * receives an open file descriptor for the file corresponding to
2622 * that mapped address space (if there is one), and the base address
2623 * of the mapped space. Quit when the callback function returns a
2624 * nonzero value, or at teh end of the mappings.
2626 * Returns: the first non-zero return value of the callback function,
2630 /* FIXME: it's probably a waste to cache this FD.
2631 It doesn't get called that often... and if I open it
2632 every time, I don't need to lseek it. */
2634 proc_iterate_over_mappings (func
)
2635 int (*func
) PARAMS ((int, CORE_ADDR
));
2639 #ifndef NEW_PROC_API /* avoid compiler warning */
2644 char pathname
[MAX_PROC_NAME_SIZE
];
2649 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
2653 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
2654 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
2655 proc_error (pi
, "proc_iterate_over_mappings (open)", __LINE__
);
2657 /* Make sure it gets closed again. */
2658 make_cleanup ((make_cleanup_func
) close
, (void *) map_fd
);
2660 /* Allocate space for mapping (lifetime only for this function). */
2661 map
= alloca (sizeof (struct prmap
));
2663 /* Now read the mappings from the file,
2664 open a file descriptor for those that have a name,
2665 and call the callback function. */
2666 while (read (map_fd
,
2668 sizeof (struct prmap
)) == sizeof (struct prmap
))
2670 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
2672 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
2675 if (map
->pr_mapname
[0] == 0)
2677 fd
= -1; /* no map file */
2681 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
2682 /* Note: caller's responsibility to close this fd! */
2683 fd
= open (name
, O_RDONLY
);
2684 /* Note: we don't test the above call for failure;
2685 we just pass the FD on as given. Sometimes there is
2686 no file, so the ioctl may return failure, but that's
2690 /* Stop looping if the callback returns non-zero. */
2691 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
)) != 0)
2695 /* Get the number of mapping entries. */
2696 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmaps
) < 0)
2697 proc_error (pi
, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__
);
2699 /* Allocate space for mappings (lifetime only this function). */
2700 map
= (struct prmap
*) alloca ((nmaps
+ 1) * sizeof (struct prmap
));
2702 /* Read in all the mappings. */
2703 if (ioctl (pi
->ctl_fd
, PIOCMAP
, map
) < 0)
2704 proc_error (pi
, "proc_iterate_over_mappings (PIOCMAP)", __LINE__
);
2706 /* Now loop through the mappings, open an fd for each, and
2707 call the callback function. */
2709 i
< nmaps
&& map
[i
].pr_size
!= 0;
2712 /* Note: caller's responsibility to close this fd! */
2713 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
[i
].pr_vaddr
);
2714 /* Note: we don't test the above call for failure;
2715 we just pass the FD on as given. Sometimes there is
2716 no file, so the ioctl may return failure, but that's
2719 /* Stop looping if the callback returns non-zero. */
2720 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
[i
].pr_vaddr
)) != 0)
2728 #ifdef TM_I386SOL2_H /* Is it hokey to use this? */
2730 #include <sys/sysi86.h>
2733 * Function: proc_get_LDT_entry
2739 * The 'key' is actually the value of the lower 16 bits of
2740 * the GS register for the LWP that we're interested in.
2742 * Return: matching ssh struct (LDT entry).
2746 proc_get_LDT_entry (pi
, key
)
2750 static struct ssd
*ldt_entry
= NULL
;
2752 char pathname
[MAX_PROC_NAME_SIZE
];
2753 struct cleanup
*old_chain
= NULL
;
2756 /* Allocate space for one LDT entry.
2757 This alloc must persist, because we return a pointer to it. */
2758 if (ldt_entry
== NULL
)
2759 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2761 /* Open the file descriptor for the LDT table. */
2762 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2763 if ((fd
= open (pathname
, O_RDONLY
)) < 0)
2765 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2768 /* Make sure it gets closed again! */
2769 old_chain
= make_cleanup ((make_cleanup_func
) close
, (void *) fd
);
2771 /* Now 'read' thru the table, find a match and return it. */
2772 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2774 if (ldt_entry
->sel
== 0 &&
2775 ldt_entry
->bo
== 0 &&
2776 ldt_entry
->acc1
== 0 &&
2777 ldt_entry
->acc2
== 0)
2778 break; /* end of table */
2779 /* If key matches, return this entry. */
2780 if (ldt_entry
->sel
== key
)
2783 /* Loop ended, match not found. */
2787 static int nalloc
= 0;
2789 /* Get the number of LDT entries. */
2790 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2792 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2796 /* Allocate space for the number of LDT entries. */
2797 /* This alloc has to persist, 'cause we return a pointer to it. */
2800 ldt_entry
= (struct ssd
*)
2801 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2805 /* Read the whole table in one gulp. */
2806 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2808 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2812 /* Search the table and return the (first) entry matching 'key'. */
2813 for (i
= 0; i
< nldt
; i
++)
2814 if (ldt_entry
[i
].sel
== key
)
2815 return &ldt_entry
[i
];
2817 /* Loop ended, match not found. */
2822 #endif /* TM_I386SOL2_H */
2824 /* =============== END, non-thread part of /proc "MODULE" =============== */
2826 /* =================== Thread "MODULE" =================== */
2828 /* NOTE: you'll see more ifdefs and duplication of functions here,
2829 since there is a different way to do threads on every OS. */
2832 * Function: proc_get_nthreads
2834 * Return the number of threads for the process
2837 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2842 proc_get_nthreads (pi
)
2847 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2848 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2854 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2856 * Solaris and Unixware version
2859 proc_get_nthreads (pi
)
2862 if (!pi
->status_valid
)
2863 if (!proc_get_status (pi
))
2867 * NEW_PROC_API: only works for the process procinfo,
2868 * because the LWP procinfos do not get prstatus filled in.
2871 if (pi
->tid
!= 0) /* find the parent process procinfo */
2872 pi
= find_procinfo_or_die (pi
->pid
, 0);
2874 return pi
->prstatus
.pr_nlwp
;
2882 proc_get_nthreads (pi
)
2891 * Function: proc_get_current_thread (LWP version)
2893 * Return the ID of the thread that had an event of interest.
2894 * (ie. the one that hit a breakpoint or other traced event).
2895 * All other things being equal, this should be the ID of a
2896 * thread that is currently executing.
2899 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2901 * Solaris and Unixware version
2904 proc_get_current_thread (pi
)
2908 * Note: this should be applied to the root procinfo for the process,
2909 * not to the procinfo for an LWP. If applied to the procinfo for
2910 * an LWP, it will simply return that LWP's ID. In that case,
2911 * find the parent process procinfo.
2915 pi
= find_procinfo_or_die (pi
->pid
, 0);
2917 if (!pi
->status_valid
)
2918 if (!proc_get_status (pi
))
2922 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2924 return pi
->prstatus
.pr_who
;
2929 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2934 proc_get_current_thread (pi
)
2937 #if 0 /* FIXME: not ready for prime time? */
2938 return pi
->prstatus
.pr_tid
;
2949 proc_get_current_thread (pi
)
2959 * Function: proc_update_threads
2961 * Discover the IDs of all the threads within the process, and
2962 * create a procinfo for each of them (chained to the parent).
2964 * This unfortunately requires a different method on every OS.
2966 * Return: non-zero for success, zero for failure.
2970 proc_delete_dead_threads (parent
, thread
, ignore
)
2975 if (thread
&& parent
) /* sanity */
2977 thread
->status_valid
= 0;
2978 if (!proc_get_status (thread
))
2979 destroy_one_procinfo (&parent
->thread_list
, thread
);
2981 return 0; /* keep iterating */
2984 #if defined (PIOCLSTATUS)
2986 * Solaris 2.5 (ioctl) version
2989 proc_update_threads (pi
)
2992 gdb_prstatus_t
*prstatus
;
2993 struct cleanup
*old_chain
= NULL
;
2998 * We should never have to apply this operation to any procinfo
2999 * except the one for the main process. If that ever changes
3000 * for any reason, then take out the following clause and
3001 * replace it with one that makes sure the ctl_fd is open.
3005 pi
= find_procinfo_or_die (pi
->pid
, 0);
3007 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3009 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
3010 return 1; /* Process is not multi-threaded; nothing to do. */
3012 if ((prstatus
= (gdb_prstatus_t
*)
3013 malloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1))) == 0)
3014 perror_with_name ("procfs: malloc failed in update_threads");
3016 old_chain
= make_cleanup (free
, prstatus
);
3017 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
3018 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
3020 /* Skip element zero, which represents the process as a whole. */
3021 for (i
= 1; i
< nlwp
+ 1; i
++)
3023 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
3024 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3026 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
3027 thread
->status_valid
= 1;
3029 pi
->threads_valid
= 1;
3030 do_cleanups (old_chain
);
3036 * Unixware and Solaris 6 (and later) version
3039 proc_update_threads (pi
)
3042 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3043 struct dirent
*direntry
;
3044 struct cleanup
*old_chain
= NULL
;
3050 * We should never have to apply this operation to any procinfo
3051 * except the one for the main process. If that ever changes
3052 * for any reason, then take out the following clause and
3053 * replace it with one that makes sure the ctl_fd is open.
3057 pi
= find_procinfo_or_die (pi
->pid
, 0);
3059 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3064 * Note: this brute-force method is the only way I know of
3065 * to accomplish this task on Unixware. This method will
3066 * also work on Solaris 2.6 and 2.7. There is a much simpler
3067 * and more elegant way to do this on Solaris, but the margins
3068 * of this manuscript are too small to write it here... ;-)
3071 strcpy (pathname
, pi
->pathname
);
3072 strcat (pathname
, "/lwp");
3073 if ((dirp
= opendir (pathname
)) == NULL
)
3074 proc_error (pi
, "update_threads, opendir", __LINE__
);
3076 old_chain
= make_cleanup ((make_cleanup_func
) closedir
, dirp
);
3077 while ((direntry
= readdir (dirp
)) != NULL
)
3078 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3080 lwpid
= atoi (&direntry
->d_name
[0]);
3081 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3082 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3084 pi
->threads_valid
= 1;
3085 do_cleanups (old_chain
);
3094 proc_update_threads (pi
)
3101 * We should never have to apply this operation to any procinfo
3102 * except the one for the main process. If that ever changes
3103 * for any reason, then take out the following clause and
3104 * replace it with one that makes sure the ctl_fd is open.
3108 pi
= find_procinfo_or_die (pi
->pid
, 0);
3110 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3112 nthreads
= proc_get_nthreads (pi
);
3114 return 0; /* nothing to do for 1 or fewer threads */
3116 if ((threads
= malloc (nthreads
* sizeof (tid_t
))) == NULL
)
3117 proc_error (pi
, "update_threads, malloc", __LINE__
);
3119 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3120 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3122 for (i
= 0; i
< nthreads
; i
++)
3124 if (!find_procinfo (pi
->pid
, threads
[i
]))
3125 if (!create_procinfo (pi
->pid
, threads
[i
]))
3126 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3128 pi
->threads_valid
= 1;
3136 proc_update_threads (pi
)
3141 #endif /* OSF PIOCTLIST */
3142 #endif /* NEW_PROC_API */
3143 #endif /* SOL 2.5 PIOCLSTATUS */
3146 * Function: proc_iterate_over_threads
3149 * Given a pointer to a function, call that function once
3150 * for each lwp in the procinfo list, until the function
3151 * returns non-zero, in which event return the value
3152 * returned by the function.
3154 * Note: this function does NOT call update_threads.
3155 * If you want to discover new threads first, you must
3156 * call that function explicitly. This function just makes
3157 * a quick pass over the currently-known procinfos.
3160 * pi - parent process procinfo
3161 * func - per-thread function
3162 * ptr - opaque parameter for function.
3165 * First non-zero return value from the callee, or zero.
3169 proc_iterate_over_threads (pi
, func
, ptr
)
3171 int (*func
) PARAMS ((procinfo
*, procinfo
*, void *));
3174 procinfo
*thread
, *next
;
3178 * We should never have to apply this operation to any procinfo
3179 * except the one for the main process. If that ever changes
3180 * for any reason, then take out the following clause and
3181 * replace it with one that makes sure the ctl_fd is open.
3185 pi
= find_procinfo_or_die (pi
->pid
, 0);
3187 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3189 next
= thread
->next
; /* in case thread is destroyed */
3190 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3197 /* =================== END, Thread "MODULE" =================== */
3199 /* =================== END, /proc "MODULE" =================== */
3201 /* =================== GDB "MODULE" =================== */
3204 * Here are all of the gdb target vector functions and their friends.
3207 static int do_attach
PARAMS ((int pid
));
3208 static void do_detach
PARAMS ((int signo
));
3209 static int register_gdb_signals
PARAMS ((procinfo
*, sigset_t
*));
3212 * Function: procfs_debug_inferior
3214 * Sets up the inferior to be debugged.
3215 * Registers to trace signals, hardware faults, and syscalls.
3216 * Note: does not set RLC flag: caller may want to customize that.
3218 * Returns: zero for success (note! unlike most functions in this module)
3219 * On failure, returns the LINE NUMBER where it failed!
3223 procfs_debug_inferior (pi
)
3226 fltset_t traced_faults
;
3227 sigset_t traced_signals
;
3228 sysset_t traced_syscall_entries
;
3229 sysset_t traced_syscall_exits
;
3231 #ifdef PROCFS_DONT_TRACE_FAULTS
3232 /* On some systems (OSF), we don't trace hardware faults.
3233 Apparently it's enough that we catch them as signals.
3234 Wonder why we don't just do that in general? */
3235 premptyset (&traced_faults
); /* don't trace faults. */
3237 /* Register to trace hardware faults in the child. */
3238 prfillset (&traced_faults
); /* trace all faults... */
3239 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3241 if (!proc_set_traced_faults (pi
, &traced_faults
))
3244 /* Register to trace selected signals in the child. */
3245 premptyset (&traced_signals
);
3246 if (!register_gdb_signals (pi
, &traced_signals
))
3249 /* Register to trace the 'exit' system call (on entry). */
3250 premptyset (&traced_syscall_entries
);
3251 praddset (&traced_syscall_entries
, SYS_exit
);
3253 praddset (&traced_syscall_entries
, SYS_lwpexit
); /* And _lwp_exit... */
3256 praddset (&traced_syscall_entries
, SYS_lwp_exit
);
3259 if (!proc_set_traced_sysentry (pi
, &traced_syscall_entries
))
3262 #ifdef PRFS_STOPEXEC /* defined on OSF */
3263 /* OSF method for tracing exec syscalls. Quoting:
3264 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3265 exits from exec system calls because of the user level loader. */
3266 /* FIXME: make nice and maybe move into an access function. */
3270 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3273 prfs_flags
|= PRFS_STOPEXEC
;
3275 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3278 #else /* not PRFS_STOPEXEC */
3279 /* Everyone else's (except OSF) method for tracing exec syscalls */
3281 Not all systems with /proc have all the exec* syscalls with the same
3282 names. On the SGI, for example, there is no SYS_exec, but there
3283 *is* a SYS_execv. So, we try to account for that. */
3285 premptyset (&traced_syscall_exits
);
3287 praddset (&traced_syscall_exits
, SYS_exec
);
3290 praddset (&traced_syscall_exits
, SYS_execve
);
3293 praddset (&traced_syscall_exits
, SYS_execv
);
3296 #ifdef SYS_lwpcreate
3297 praddset (&traced_syscall_exits
, SYS_lwpcreate
);
3298 praddset (&traced_syscall_exits
, SYS_lwpexit
);
3301 #ifdef SYS_lwp_create /* FIXME: once only, please */
3302 praddset (&traced_syscall_exits
, SYS_lwp_create
);
3303 praddset (&traced_syscall_exits
, SYS_lwp_exit
);
3307 if (!proc_set_traced_sysexit (pi
, &traced_syscall_exits
))
3310 #endif /* PRFS_STOPEXEC */
3315 procfs_attach (args
, from_tty
)
3323 error_no_arg ("process-id to attach");
3326 if (pid
== getpid ())
3327 error ("Attaching GDB to itself is not a good idea...");
3331 exec_file
= get_exec_file (0);
3334 printf_filtered ("Attaching to program `%s', %s\n",
3335 exec_file
, target_pid_to_str (pid
));
3337 printf_filtered ("Attaching to %s\n", target_pid_to_str (pid
));
3341 inferior_pid
= do_attach (pid
);
3342 push_target (&procfs_ops
);
3346 procfs_detach (args
, from_tty
)
3355 exec_file
= get_exec_file (0);
3358 printf_filtered ("Detaching from program: %s %s\n",
3359 exec_file
, target_pid_to_str (inferior_pid
));
3363 signo
= atoi (args
);
3367 unpush_target (&procfs_ops
); /* Pop out of handling an inferior */
3377 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
3378 perror ("procfs: out of memory in 'attach'");
3380 if (!open_procinfo_files (pi
, FD_CTL
))
3382 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3383 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3385 dead_procinfo (pi
, errmsg
, NOKILL
);
3388 /* Stop the process (if it isn't already stopped). */
3389 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3391 pi
->was_stopped
= 1;
3392 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3396 pi
->was_stopped
= 0;
3397 /* Set the process to run again when we close it. */
3398 if (!proc_set_run_on_last_close (pi
))
3399 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3401 /* Now stop the process. */
3402 if (!proc_stop_process (pi
))
3403 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3404 pi
->ignore_next_sigstop
= 1;
3406 /* Save some of the /proc state to be restored if we detach. */
3407 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3408 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3409 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3410 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3411 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
3412 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3414 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
3415 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3417 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3418 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3420 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3421 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3423 /* Let GDB know that the inferior was attached. */
3425 return MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3434 /* Find procinfo for the main process */
3435 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0); /* FIXME: threads */
3437 if (!proc_set_current_signal (pi
, signo
))
3438 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3440 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3441 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3443 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3444 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3446 if (!proc_set_traced_sysentry (pi
, &pi
->saved_entryset
))
3447 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3449 if (!proc_set_traced_sysexit (pi
, &pi
->saved_exitset
))
3450 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3452 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3453 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3455 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3456 if (signo
|| !(pi
->was_stopped
) ||
3457 query ("Was stopped when attached, make it runnable again? "))
3459 /* Clear any pending signal. */
3460 if (!proc_clear_current_fault (pi
))
3461 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3463 if (!proc_set_run_on_last_close (pi
))
3464 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3468 destroy_procinfo (pi
);
3474 * Since the /proc interface cannot give us individual registers,
3475 * we pay no attention to the (regno) argument, and just fetch them all.
3476 * This results in the possibility that we will do unnecessarily many
3477 * fetches, since we may be called repeatedly for individual registers.
3478 * So we cache the results, and mark the cache invalid when the process
3483 procfs_fetch_registers (regno
)
3486 gdb_fpregset_t
*fpregs
;
3487 gdb_gregset_t
*gregs
;
3492 pid
= PIDGET (inferior_pid
);
3493 tid
= TIDGET (inferior_pid
);
3495 /* First look up procinfo for the main process. */
3496 pi
= find_procinfo_or_die (pid
, 0);
3498 /* If the event thread is not the same as GDB's requested thread
3499 (ie. inferior_pid), then look up procinfo for the requested
3502 (tid
!= proc_get_current_thread (pi
)))
3503 pi
= find_procinfo_or_die (pid
, tid
);
3506 error ("procfs: fetch_registers failed to find procinfo for %s",
3507 target_pid_to_str (inferior_pid
));
3509 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3510 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3512 supply_gregset (gregs
);
3514 #if defined (FP0_REGNUM) /* need floating point? */
3515 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3516 regno
== PC_REGNUM
||
3518 regno
== NPC_REGNUM
||
3520 regno
== FP_REGNUM
||
3522 return; /* not a floating point register */
3524 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3525 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3527 supply_fpregset (fpregs
);
3531 /* Get ready to modify the registers array. On machines which store
3532 individual registers, this doesn't need to do anything. On
3533 machines which store all the registers in one fell swoop, such as
3534 /proc, this makes sure that registers contains all the registers
3535 from the program being debugged. */
3538 procfs_prepare_to_store ()
3540 #ifdef CHILD_PREPARE_TO_STORE
3541 CHILD_PREPARE_TO_STORE ();
3548 * Since the /proc interface will not read individual registers,
3549 * we will cache these requests until the process is resumed, and
3550 * only then write them back to the inferior process.
3552 * FIXME: is that a really bad idea? Have to think about cases
3553 * where writing one register might affect the value of others, etc.
3557 procfs_store_registers (regno
)
3560 gdb_fpregset_t
*fpregs
;
3561 gdb_gregset_t
*gregs
;
3566 pid
= PIDGET (inferior_pid
);
3567 tid
= TIDGET (inferior_pid
);
3569 /* First find procinfo for main process */
3570 pi
= find_procinfo_or_die (pid
, 0);
3572 /* If current lwp for process is not the same as requested thread
3573 (ie. inferior_pid), then find procinfo for the requested thread. */
3576 (tid
!= proc_get_current_thread (pi
)))
3577 pi
= find_procinfo_or_die (pid
, tid
);
3580 error ("procfs: store_registers: failed to find procinfo for %s",
3581 target_pid_to_str (inferior_pid
));
3583 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3584 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3586 fill_gregset (gregs
, regno
);
3587 if (!proc_set_gregs (pi
))
3588 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3590 #if defined (FP0_REGNUM) /* need floating point? */
3591 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3592 regno
== PC_REGNUM
||
3594 regno
== NPC_REGNUM
||
3596 regno
== FP_REGNUM
||
3598 return; /* not a floating point register */
3600 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3601 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3603 fill_fpregset (fpregs
, regno
);
3604 if (!proc_set_fpregs (pi
))
3605 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3610 * Function: target_wait
3612 * Retrieve the next stop event from the child process.
3613 * If child has not stopped yet, wait for it to stop.
3614 * Translate /proc eventcodes (or possibly wait eventcodes)
3615 * into gdb internal event codes.
3617 * Return: id of process (and possibly thread) that incurred the event.
3618 * event codes are returned thru a pointer parameter.
3622 procfs_wait (pid
, status
)
3624 struct target_waitstatus
*status
;
3626 /* First cut: loosely based on original version 2.1 */
3630 int why
, what
, flags
;
3639 /* Find procinfo for main process */
3640 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
3643 /* We must assume that the status is stale now... */
3644 pi
->status_valid
= 0;
3645 pi
->gregs_valid
= 0;
3646 pi
->fpregs_valid
= 0;
3648 #if 0 /* just try this out... */
3649 flags
= proc_flags (pi
);
3650 why
= proc_why (pi
);
3651 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3652 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3654 /* If child is not stopped, wait for it to stop. */
3655 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3656 !proc_wait_for_stop (pi
))
3658 /* wait_for_stop failed: has the child terminated? */
3659 if (errno
== ENOENT
)
3661 /* /proc file not found; presumably child has terminated. */
3662 retval
= wait (&wstat
); /* "wait" for the child's exit */
3664 if (retval
!= PIDGET (inferior_pid
)) /* wrong child? */
3665 error ("procfs: couldn't stop process %d: wait returned %d\n",
3666 inferior_pid
, retval
);
3667 /* FIXME: might I not just use waitpid?
3668 Or try find_procinfo to see if I know about this child? */
3672 /* Unknown error from wait_for_stop. */
3673 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3678 /* This long block is reached if either:
3679 a) the child was already stopped, or
3680 b) we successfully waited for the child with wait_for_stop.
3681 This block will analyze the /proc status, and translate it
3682 into a waitstatus for GDB.
3684 If we actually had to call wait because the /proc file
3685 is gone (child terminated), then we skip this block,
3686 because we already have a waitstatus. */
3688 flags
= proc_flags (pi
);
3689 why
= proc_why (pi
);
3690 what
= proc_what (pi
);
3692 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3695 /* If it's running async (for single_thread control),
3696 set it back to normal again. */
3697 if (flags
& PR_ASYNC
)
3698 if (!proc_unset_async (pi
))
3699 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3703 proc_prettyprint_why (why
, what
, 1);
3705 /* The 'pid' we will return to GDB is composed of
3706 the process ID plus the lwp ID. */
3707 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3711 wstat
= (what
<< 8) | 0177;
3721 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3722 printf_filtered ("[%s exited]\n",
3723 target_pid_to_str (retval
));
3724 delete_thread (retval
);
3725 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3727 #endif /* _lwp_exit */
3730 /* Handle SYS_exit call only */
3731 /* Stopped at entry to SYS_exit.
3732 Make it runnable, resume it, then use
3733 the wait system call to get its exit code.
3734 Proc_run_process always clears the current
3736 Then return its exit status. */
3737 pi
->status_valid
= 0;
3739 /* FIXME: what we should do is return
3740 TARGET_WAITKIND_SPURIOUS. */
3741 if (!proc_run_process (pi
, 0, 0))
3742 proc_error (pi
, "target_wait, run_process", __LINE__
);
3745 /* Don't call wait: simulate waiting for exit,
3746 return a "success" exit code. Bogus: what if
3747 it returns something else? */
3749 retval
= inferior_pid
; /* ??? */
3753 int temp
= wait (&wstat
);
3755 /* FIXME: shouldn't I make sure I get the right
3756 event from the right process? If (for
3757 instance) I have killed an earlier inferior
3758 process but failed to clean up after it
3759 somehow, I could get its termination event
3762 /* If wait returns -1, that's what we return to GDB. */
3768 printf_filtered ("procfs: trapped on entry to ");
3769 proc_prettyprint_syscall (proc_what (pi
), 0);
3770 printf_filtered ("\n");
3773 long i
, nsysargs
, *sysargs
;
3775 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3776 (sysargs
= proc_sysargs (pi
)) != NULL
)
3778 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3779 for (i
= 0; i
< nsysargs
; i
++)
3780 printf_filtered ("#%ld: 0x%08x\n",
3788 /* How to exit gracefully, returning "unknown event" */
3789 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3790 return inferior_pid
;
3794 /* How to keep going without returning to wfi: */
3795 target_resume (pid
, 0, TARGET_SIGNAL_0
);
3812 /* Hopefully this is our own "fork-child" execing
3813 the real child. Hoax this event into a trap, and
3814 GDB will see the child about to execute its start
3816 wstat
= (SIGTRAP
<< 8) | 0177;
3818 #ifdef SYS_lwp_create
3819 case SYS_lwp_create
:
3821 #ifdef SYS_lwpcreate
3824 #if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
3826 * This syscall is somewhat like fork/exec.
3827 * We will get the event twice: once for the parent LWP,
3828 * and once for the child. We should already know about
3829 * the parent LWP, but the child will be new to us. So,
3830 * whenever we get this event, if it represents a new
3831 * thread, simply add the thread to the list.
3834 /* If not in procinfo list, add it. */
3835 temp
= proc_get_current_thread (pi
);
3836 if (!find_procinfo (pi
->pid
, temp
))
3837 create_procinfo (pi
->pid
, temp
);
3839 temp
= MERGEPID (pi
->pid
, temp
);
3840 /* If not in GDB's thread list, add it. */
3841 if (!in_thread_list (temp
))
3843 printf_filtered ("[New %s]\n", target_pid_to_str (temp
));
3846 /* Return to WFI, but tell it to immediately resume. */
3847 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3848 return inferior_pid
;
3849 #endif /* _lwp_create */
3857 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3858 printf_filtered ("[%s exited]\n",
3859 target_pid_to_str (retval
));
3860 delete_thread (retval
);
3861 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3863 #endif /* _lwp_exit */
3867 /* Nothing to do here for now. The old procfs
3868 seemed to use this event to handle threads on
3869 older (non-LWP) systems, where I'm assuming that
3870 threads were actually separate processes. Irix,
3871 maybe? Anyway, low priority for now. */
3875 /* FIXME: do we need to handle this? Investigate. */
3879 /* FIXME: see above. */
3882 printf_filtered ("procfs: trapped on exit from ");
3883 proc_prettyprint_syscall (proc_what (pi
), 0);
3884 printf_filtered ("\n");
3887 long i
, nsysargs
, *sysargs
;
3889 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3890 (sysargs
= proc_sysargs (pi
)) != NULL
)
3892 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3893 for (i
= 0; i
< nsysargs
; i
++)
3894 printf_filtered ("#%ld: 0x%08x\n",
3899 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3900 return inferior_pid
;
3905 wstat
= (SIGSTOP
<< 8) | 0177;
3910 printf_filtered ("Retry #%d:\n", retry
);
3911 pi
->status_valid
= 0;
3916 /* If not in procinfo list, add it. */
3917 temp
= proc_get_current_thread (pi
);
3918 if (!find_procinfo (pi
->pid
, temp
))
3919 create_procinfo (pi
->pid
, temp
);
3921 /* If not in GDB's thread list, add it. */
3922 temp
= MERGEPID (pi
->pid
, temp
);
3923 if (!in_thread_list (temp
))
3925 printf_filtered ("[New %s]\n",
3926 target_pid_to_str (temp
));
3930 status
->kind
= TARGET_WAITKIND_STOPPED
;
3931 status
->value
.sig
= 0;
3936 wstat
= (what
<< 8) | 0177;
3939 switch (what
) { /* FIXME: FAULTED_USE_SIGINFO */
3942 wstat
= (SIGTRAP
<< 8) | 0177;
3947 wstat
= (SIGTRAP
<< 8) | 0177;
3950 /* FIXME: use si_signo where possible. */
3952 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
3955 wstat
= (SIGILL
<< 8) | 0177;
3958 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
3961 wstat
= (SIGTRAP
<< 8) | 0177;
3965 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
3968 wstat
= (SIGSEGV
<< 8) | 0177;
3972 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
3975 wstat
= (SIGFPE
<< 8) | 0177;
3977 case FLTPAGE
: /* Recoverable page fault */
3978 default: /* FIXME: use si_signo if possible for fault */
3980 printf_filtered ("procfs:%d -- ", __LINE__
);
3981 printf_filtered ("child stopped for unknown reason:\n");
3982 proc_prettyprint_why (why
, what
, 1);
3983 error ("... giving up...");
3986 break; /* case PR_FAULTED: */
3987 default: /* switch (why) unmatched */
3988 printf_filtered ("procfs:%d -- ", __LINE__
);
3989 printf_filtered ("child stopped for unknown reason:\n");
3990 proc_prettyprint_why (why
, what
, 1);
3991 error ("... giving up...");
3995 * Got this far without error:
3996 * If retval isn't in the threads database, add it.
3999 retval
!= inferior_pid
&&
4000 !in_thread_list (retval
))
4003 * We have a new thread.
4004 * We need to add it both to GDB's list and to our own.
4005 * If we don't create a procinfo, resume may be unhappy
4008 printf_filtered ("[New %s]\n", target_pid_to_str (retval
));
4009 add_thread (retval
);
4010 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
4011 create_procinfo (PIDGET (retval
), TIDGET (retval
));
4013 /* In addition, it's possible that this is the first
4014 * new thread we've seen, in which case we may not
4015 * have created entries for inferior_pid yet.
4017 if (TIDGET (inferior_pid
) != 0)
4019 if (!in_thread_list (inferior_pid
))
4020 add_thread (inferior_pid
);
4021 if (find_procinfo (PIDGET (inferior_pid
),
4022 TIDGET (inferior_pid
)) == NULL
)
4023 create_procinfo (PIDGET (inferior_pid
),
4024 TIDGET (inferior_pid
));
4028 else /* flags do not indicate STOPPED */
4030 /* surely this can't happen... */
4031 printf_filtered ("procfs:%d -- process not stopped.\n",
4033 proc_prettyprint_flags (flags
, 1);
4034 error ("procfs: ...giving up...");
4039 store_waitstatus (status
, wstat
);
4046 procfs_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
4051 struct target_ops
*target
; /* ignored */
4056 /* Find procinfo for main process */
4057 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4058 if (pi
->as_fd
== 0 &&
4059 open_procinfo_files (pi
, FD_AS
) == 0)
4061 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4065 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4070 PROCFS_NOTE ("write memory: ");
4072 PROCFS_NOTE ("write memory: \n");
4074 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4078 PROCFS_NOTE ("read memory: \n");
4079 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4090 * Function: invalidate_cache
4092 * Called by target_resume before making child runnable.
4093 * Mark cached registers and status's invalid.
4094 * If there are "dirty" caches that need to be written back
4095 * to the child process, do that.
4097 * File descriptors are also cached.
4098 * As they are a limited resource, we cannot hold onto them indefinitely.
4099 * However, as they are expensive to open, we don't want to throw them
4100 * away indescriminately either. As a compromise, we will keep the
4101 * file descriptors for the parent process, but discard any file
4102 * descriptors we may have accumulated for the threads.
4105 * As this function is called by iterate_over_threads, it always
4106 * returns zero (so that iterate_over_threads will keep iterating).
4111 invalidate_cache (parent
, pi
, ptr
)
4117 * About to run the child; invalidate caches and do any other cleanup.
4121 if (pi
->gregs_dirty
)
4122 if (parent
== NULL
||
4123 proc_get_current_thread (parent
) != pi
->tid
)
4124 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4125 proc_warn (pi
, "target_resume, set_gregs",
4128 if (pi
->fpregs_dirty
)
4129 if (parent
== NULL
||
4130 proc_get_current_thread (parent
) != pi
->tid
)
4131 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4132 proc_warn (pi
, "target_resume, set_fpregs",
4139 /* The presence of a parent indicates that this is an LWP.
4140 Close any file descriptors that it might have open.
4141 We don't do this to the master (parent) procinfo. */
4143 close_procinfo_files (pi
);
4145 pi
->gregs_valid
= 0;
4146 pi
->fpregs_valid
= 0;
4148 pi
->gregs_dirty
= 0;
4149 pi
->fpregs_dirty
= 0;
4151 pi
->status_valid
= 0;
4152 pi
->threads_valid
= 0;
4159 * Function: make_signal_thread_runnable
4161 * A callback function for iterate_over_threads.
4162 * Find the asynchronous signal thread, and make it runnable.
4163 * See if that helps matters any.
4167 make_signal_thread_runnable (process
, pi
, ptr
)
4173 if (proc_flags (pi
) & PR_ASLWP
)
4175 if (!proc_run_process (pi
, 0, -1))
4176 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4185 * Function: target_resume
4187 * Make the child process runnable. Normally we will then call
4188 * procfs_wait and wait for it to stop again (unles gdb is async).
4191 * step: if true, then arrange for the child to stop again
4192 * after executing a single instruction.
4193 * signo: if zero, then cancel any pending signal.
4194 * If non-zero, then arrange for the indicated signal
4195 * to be delivered to the child when it runs.
4196 * pid: if -1, then allow any child thread to run.
4197 * if non-zero, then allow only the indicated thread to run.
4198 ******* (not implemented yet)
4202 procfs_resume (pid
, step
, signo
)
4205 enum target_signal signo
;
4207 procinfo
*pi
, *thread
;
4211 prrun.prflags |= PRSVADDR;
4212 prrun.pr_vaddr = $PC; set resume address
4213 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4214 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4215 prrun.prflags |= PRCFAULT; clear current fault.
4217 PRSTRACE and PRSFAULT can be done by other means
4218 (proc_trace_signals, proc_trace_faults)
4219 PRSVADDR is unnecessary.
4220 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4221 This basically leaves PRSTEP and PRCSIG.
4222 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4223 So basically PR_STEP is the sole argument that must be passed
4224 to proc_run_process (for use in the prrun struct by ioctl). */
4226 /* Find procinfo for main process */
4227 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4229 /* First cut: ignore pid argument */
4232 /* Convert signal to host numbering. */
4234 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4237 native_signo
= target_signal_to_host (signo
);
4239 pi
->ignore_next_sigstop
= 0;
4241 /* Running the process voids all cached registers and status. */
4242 /* Void the threads' caches first */
4243 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4244 /* Void the process procinfo's caches. */
4245 invalidate_cache (NULL
, pi
, NULL
);
4249 /* Resume a specific thread, presumably suppressing the others. */
4250 thread
= find_procinfo (PIDGET (pid
), TIDGET (pid
));
4252 warning ("procfs: resume can't find thread %d -- resuming all.",
4256 if (thread
->tid
!= 0)
4258 /* We're to resume a specific thread, and not the others.
4259 * Set the child process's PR_ASYNC flag.
4262 if (!proc_set_async (pi
))
4263 proc_error (pi
, "target_resume, set_async", __LINE__
);
4266 proc_iterate_over_threads (pi
,
4267 make_signal_thread_runnable
,
4270 pi
= thread
; /* substitute the thread's procinfo for run */
4275 if (!proc_run_process (pi
, step
, native_signo
))
4278 warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
4280 proc_error (pi
, "target_resume", __LINE__
);
4285 * Function: register_gdb_signals
4287 * Traverse the list of signals that GDB knows about
4288 * (see "handle" command), and arrange for the target
4289 * to be stopped or not, according to these settings.
4291 * Returns non-zero for success, zero for failure.
4295 register_gdb_signals (pi
, signals
)
4301 for (signo
= 0; signo
< NSIG
; signo
++)
4302 if (signal_stop_state (target_signal_from_host (signo
)) == 0 &&
4303 signal_print_state (target_signal_from_host (signo
)) == 0 &&
4304 signal_pass_state (target_signal_from_host (signo
)) == 1)
4305 prdelset (signals
, signo
);
4307 praddset (signals
, signo
);
4309 return proc_set_traced_signals (pi
, signals
);
4313 * Function: target_notice_signals
4315 * Set up to trace signals in the child process.
4319 procfs_notice_signals (pid
)
4323 procinfo
*pi
= find_procinfo_or_die (PIDGET (pid
), 0);
4325 if (proc_get_traced_signals (pi
, &signals
) &&
4326 register_gdb_signals (pi
, &signals
))
4329 proc_error (pi
, "notice_signals", __LINE__
);
4333 * Function: target_files_info
4335 * Print status information about the child process.
4339 procfs_files_info (ignore
)
4340 struct target_ops
*ignore
;
4342 printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
4343 attach_flag
? "attached": "child",
4344 target_pid_to_str (inferior_pid
));
4348 * Function: target_open
4350 * A dummy: you don't open procfs.
4354 procfs_open (args
, from_tty
)
4358 error ("Use the \"run\" command to start a Unix child process.");
4362 * Function: target_can_run
4364 * This tells GDB that this target vector can be invoked
4365 * for "run" or "attach".
4368 int procfs_suppress_run
= 0; /* Non-zero if procfs should pretend not to
4369 be a runnable target. Used by targets
4370 that can sit atop procfs, such as solaris
4377 /* This variable is controlled by modules that sit atop procfs that
4378 may layer their own process structure atop that provided here.
4379 sol-thread.c does this because of the Solaris two-level thread
4382 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
4384 return !procfs_suppress_run
;
4388 * Function: target_stop
4390 * Stop the child process asynchronously, as when the
4391 * gdb user types control-c or presses a "stop" button.
4393 * Works by sending kill(SIGINT) to the child's process group.
4399 extern pid_t inferior_process_group
;
4401 kill (-inferior_process_group
, SIGINT
);
4405 * Function: unconditionally_kill_inferior
4407 * Make it die. Wait for it to die. Clean up after it.
4408 * Note: this should only be applied to the real process,
4409 * not to an LWP, because of the check for parent-process.
4410 * If we need this to work for an LWP, it needs some more logic.
4414 unconditionally_kill_inferior (pi
)
4419 parent_pid
= proc_parent_pid (pi
);
4420 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4421 /* FIXME: use access functions */
4422 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4423 before the PIOCKILL, otherwise it might generate a corrupted core
4424 file for the inferior. */
4425 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4427 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4430 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4431 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4432 to kill the inferior, otherwise it might remain stopped with a
4434 We do not check the result of the PIOCSSIG, the inferior might have
4437 struct siginfo newsiginfo
;
4439 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4440 newsiginfo
.si_signo
= SIGKILL
;
4441 newsiginfo
.si_code
= 0;
4442 newsiginfo
.si_errno
= 0;
4443 newsiginfo
.si_pid
= getpid ();
4444 newsiginfo
.si_uid
= getuid ();
4445 /* FIXME: use proc_set_current_signal */
4446 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4448 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4449 if (!proc_kill (pi
, SIGKILL
))
4450 proc_warn (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4451 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4452 destroy_procinfo (pi
);
4454 /* If pi is GDB's child, wait for it to die. */
4455 if (parent_pid
== getpid ())
4456 /* FIXME: should we use waitpid to make sure we get the right event?
4457 Should we check the returned event? */
4462 ret
= waitpid (pi
->pid
, &status
, 0);
4470 * Function: target_kill_inferior
4472 * We're done debugging it, and we want it to go away.
4473 * Then we want GDB to forget all about it.
4477 procfs_kill_inferior ()
4479 if (inferior_pid
!= 0) /* ? */
4481 /* Find procinfo for main process */
4482 procinfo
*pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4485 unconditionally_kill_inferior (pi
);
4486 target_mourn_inferior ();
4491 * Function: target_mourn_inferior
4493 * Forget we ever debugged this thing!
4497 procfs_mourn_inferior ()
4501 if (inferior_pid
!= 0)
4503 /* Find procinfo for main process */
4504 pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4506 destroy_procinfo (pi
);
4508 unpush_target (&procfs_ops
);
4509 generic_mourn_inferior ();
4513 * Function: init_inferior
4515 * When GDB forks to create a runnable inferior process,
4516 * this function is called on the parent side of the fork.
4517 * It's job is to do whatever is necessary to make the child
4518 * ready to be debugged, and then wait for the child to synchronize.
4522 procfs_init_inferior (pid
)
4529 /* This routine called on the parent side (GDB side)
4530 after GDB forks the inferior. */
4532 push_target (&procfs_ops
);
4534 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4535 perror ("procfs: out of memory in 'init_inferior'");
4537 if (!open_procinfo_files (pi
, FD_CTL
))
4538 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4542 open_procinfo_files // done
4545 procfs_notice_signals
4552 /* If not stopped yet, wait for it to stop. */
4553 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4554 !(proc_wait_for_stop (pi
)))
4555 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4557 /* Save some of the /proc state to be restored if we detach. */
4558 /* FIXME: Why? In case another debugger was debugging it?
4559 We're it's parent, for Ghu's sake! */
4560 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4561 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4562 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4563 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4564 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4565 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4566 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
4567 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4568 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
4569 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4571 /* Register to trace selected signals in the child. */
4572 prfillset (&signals
);
4573 if (!register_gdb_signals (pi
, &signals
))
4574 proc_error (pi
, "init_inferior, register_signals", __LINE__
);
4576 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4577 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4579 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4580 and possibly even turning ON kill-on-last-close at this point. But
4581 I can't make that change without careful testing which I don't have
4582 time to do right now... */
4583 /* Turn on run-on-last-close flag so that the child
4584 will die if GDB goes away for some reason. */
4585 if (!proc_set_run_on_last_close (pi
))
4586 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4588 /* The 'process ID' we return to GDB is composed of
4589 the actual process ID plus the lwp ID. */
4590 inferior_pid
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
4592 #ifdef START_INFERIOR_TRAPS_EXPECTED
4593 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4595 /* One trap to exec the shell, one to exec the program being debugged. */
4596 startup_inferior (2);
4597 #endif /* START_INFERIOR_TRAPS_EXPECTED */
4601 * Function: set_exec_trap
4603 * When GDB forks to create a new process, this function is called
4604 * on the child side of the fork before GDB exec's the user program.
4605 * Its job is to make the child minimally debuggable, so that the
4606 * parent GDB process can connect to the child and take over.
4607 * This function should do only the minimum to make that possible,
4608 * and to synchronize with the parent process. The parent process
4609 * should take care of the details.
4613 procfs_set_exec_trap ()
4615 /* This routine called on the child side (inferior side)
4616 after GDB forks the inferior. It must use only local variables,
4617 because it may be sharing data space with its parent. */
4622 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4623 perror_with_name ("procfs: create_procinfo failed in child.");
4625 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4627 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4628 gdb_flush (gdb_stderr
);
4629 /* no need to call "dead_procinfo", because we're going to exit. */
4633 #ifdef PRFS_STOPEXEC /* defined on OSF */
4634 /* OSF method for tracing exec syscalls. Quoting:
4635 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4636 exits from exec system calls because of the user level loader. */
4637 /* FIXME: make nice and maybe move into an access function. */
4641 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4643 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4644 gdb_flush (gdb_stderr
);
4647 prfs_flags
|= PRFS_STOPEXEC
;
4649 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4651 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4652 gdb_flush (gdb_stderr
);
4656 #else /* not PRFS_STOPEXEC */
4657 /* Everyone else's (except OSF) method for tracing exec syscalls */
4659 Not all systems with /proc have all the exec* syscalls with the same
4660 names. On the SGI, for example, there is no SYS_exec, but there
4661 *is* a SYS_execv. So, we try to account for that. */
4663 premptyset (&exitset
);
4665 praddset (&exitset
, SYS_exec
);
4668 praddset (&exitset
, SYS_execve
);
4671 praddset (&exitset
, SYS_execv
);
4674 if (!proc_set_traced_sysexit (pi
, &exitset
))
4676 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4677 gdb_flush (gdb_stderr
);
4680 #endif /* PRFS_STOPEXEC */
4682 /* FIXME: should this be done in the parent instead? */
4683 /* Turn off inherit on fork flag so that all grand-children
4684 of gdb start with tracing flags cleared. */
4685 if (!proc_unset_inherit_on_fork (pi
))
4686 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4688 /* Turn off run on last close flag, so that the child process
4689 cannot run away just because we close our handle on it.
4690 We want it to wait for the parent to attach. */
4691 if (!proc_unset_run_on_last_close (pi
))
4692 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4694 /* FIXME: No need to destroy the procinfo --
4695 we have our own address space, and we're about to do an exec! */
4696 /*destroy_procinfo (pi);*/
4700 * Function: create_inferior
4702 * This function is called BEFORE gdb forks the inferior process.
4703 * Its only real responsibility is to set things up for the fork,
4704 * and tell GDB which two functions to call after the fork (one
4705 * for the parent, and one for the child).
4707 * This function does a complicated search for a unix shell program,
4708 * which it then uses to parse arguments and environment variables
4709 * to be sent to the child. I wonder whether this code could not
4710 * be abstracted out and shared with other unix targets such as
4715 procfs_create_inferior (exec_file
, allargs
, env
)
4720 char *shell_file
= getenv ("SHELL");
4722 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4725 /* We will be looking down the PATH to find shell_file. If we
4726 just do this the normal way (via execlp, which operates by
4727 attempting an exec for each element of the PATH until it
4728 finds one which succeeds), then there will be an exec for
4729 each failed attempt, each of which will cause a PR_SYSEXIT
4730 stop, and we won't know how to distinguish the PR_SYSEXIT's
4731 for these failed execs with the ones for successful execs
4732 (whether the exec has succeeded is stored at that time in the
4733 carry bit or some such architecture-specific and
4734 non-ABI-specified place).
4736 So I can't think of anything better than to search the PATH
4737 now. This has several disadvantages: (1) There is a race
4738 condition; if we find a file now and it is deleted before we
4739 exec it, we lose, even if the deletion leaves a valid file
4740 further down in the PATH, (2) there is no way to know exactly
4741 what an executable (in the sense of "capable of being
4742 exec'd") file is. Using access() loses because it may lose
4743 if the caller is the superuser; failing to use it loses if
4744 there are ACLs or some such. */
4748 /* FIXME-maybe: might want "set path" command so user can change what
4749 path is used from within GDB. */
4750 char *path
= getenv ("PATH");
4752 struct stat statbuf
;
4755 path
= "/bin:/usr/bin";
4757 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4758 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4760 p1
= strchr (p
, ':');
4765 strncpy (tryname
, p
, len
);
4766 tryname
[len
] = '\0';
4767 strcat (tryname
, "/");
4768 strcat (tryname
, shell_file
);
4769 if (access (tryname
, X_OK
) < 0)
4771 if (stat (tryname
, &statbuf
) < 0)
4773 if (!S_ISREG (statbuf
.st_mode
))
4774 /* We certainly need to reject directories. I'm not quite
4775 as sure about FIFOs, sockets, etc., but I kind of doubt
4776 that people want to exec() these things. */
4781 /* Not found. This must be an error rather than merely passing
4782 the file to execlp(), because execlp() would try all the
4783 exec()s, causing GDB to get confused. */
4784 error ("procfs:%d -- Can't find shell %s in PATH",
4785 __LINE__
, shell_file
);
4787 shell_file
= tryname
;
4790 fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4791 procfs_init_inferior
, NULL
, shell_file
);
4793 /* We are at the first instruction we care about. */
4794 /* Pedal to the metal... */
4796 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
4800 * Function: notice_thread
4802 * Callback for find_new_threads.
4803 * Calls "add_thread".
4807 procfs_notice_thread (pi
, thread
, ptr
)
4812 int gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4814 if (!in_thread_list (gdb_threadid
))
4815 add_thread (gdb_threadid
);
4821 * Function: target_find_new_threads
4823 * Query all the threads that the target knows about,
4824 * and give them back to GDB to add to its list.
4828 procfs_find_new_threads ()
4832 /* Find procinfo for main process */
4833 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4834 proc_update_threads (pi
);
4835 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4839 * Function: target_thread_alive
4841 * Return true if the thread is still 'alive'.
4843 * This guy doesn't really seem to be doing his job.
4844 * Got to investigate how to tell when a thread is really gone.
4848 procfs_thread_alive (pid
)
4854 proc
= PIDGET (pid
);
4855 thread
= TIDGET (pid
);
4856 /* If I don't know it, it ain't alive! */
4857 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4860 /* If I can't get its status, it ain't alive!
4861 What's more, I need to forget about it! */
4862 if (!proc_get_status (pi
))
4864 destroy_procinfo (pi
);
4867 /* I couldn't have got its status if it weren't alive, so it's alive. */
4872 * Function: target_pid_to_str
4874 * Return a string to be used to identify the thread in
4875 * the "info threads" display.
4879 procfs_pid_to_str (pid
)
4882 static char buf
[80];
4886 proc
= PIDGET (pid
);
4887 thread
= TIDGET (pid
);
4888 pi
= find_procinfo (proc
, thread
);
4891 sprintf (buf
, "Process %d", proc
);
4893 sprintf (buf
, "LWP %d", thread
);
4898 * Function: procfs_set_watchpoint
4899 * Insert a watchpoint
4903 procfs_set_watchpoint (pid
, addr
, len
, rwflag
, after
)
4914 pi
= find_procinfo_or_die (pid
== -1 ?
4915 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4917 /* Translate from GDB's flags to /proc's */
4918 if (len
> 0) /* len == 0 means delete watchpoint */
4920 switch (rwflag
) { /* FIXME: need an enum! */
4921 case hw_write
: /* default watchpoint (write) */
4922 pflags
= WRITE_WATCHFLAG
;
4924 case hw_read
: /* read watchpoint */
4925 pflags
= READ_WATCHFLAG
;
4927 case hw_access
: /* access watchpoint */
4928 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
4930 case hw_execute
: /* execution HW breakpoint */
4931 pflags
= EXEC_WATCHFLAG
;
4933 default: /* Something weird. Return error. */
4936 if (after
) /* Stop after r/w access is completed. */
4937 pflags
|= AFTER_WATCHFLAG
;
4940 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
4942 if (errno
== E2BIG
) /* Typical error for no resources */
4943 return -1; /* fail */
4944 /* GDB may try to remove the same watchpoint twice.
4945 If a remove request returns no match, don't error. */
4946 if (errno
== ESRCH
&& len
== 0)
4947 return 0; /* ignore */
4948 proc_error (pi
, "set_watchpoint", __LINE__
);
4955 * Function: stopped_by_watchpoint
4957 * Returns non-zero if process is stopped on a hardware watchpoint fault,
4958 * else returns zero.
4962 procfs_stopped_by_watchpoint (pid
)
4967 pi
= find_procinfo_or_die (pid
== -1 ?
4968 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4969 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
4971 if (proc_why (pi
) == PR_FAULTED
)
4974 if (proc_what (pi
) == FLTWATCH
)
4978 if (proc_what (pi
) == FLTKWATCH
)
4986 #ifdef TM_I386SOL2_H
4988 * Function: procfs_find_LDT_entry
4991 * int pid; // The GDB-style pid-plus-LWP.
4994 * pointer to the corresponding LDT entry.
4998 procfs_find_LDT_entry (pid
)
5001 gdb_gregset_t
*gregs
;
5005 /* Find procinfo for the lwp. */
5006 if ((pi
= find_procinfo (PIDGET (pid
), TIDGET (pid
))) == NULL
)
5008 warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
5012 /* get its general registers. */
5013 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
5015 warning ("procfs_find_LDT_entry: could not read gregs for %d.",
5019 /* Now extract the GS register's lower 16 bits. */
5020 key
= (*gregs
)[GS
] & 0xffff;
5022 /* Find the matching entry and return it. */
5023 return proc_get_LDT_entry (pi
, key
);
5025 #endif /* TM_I386SOL2_H */
5030 info_proc_cmd (args
, from_tty
)
5034 struct cleanup
*old_chain
;
5035 procinfo
*process
= NULL
;
5036 procinfo
*thread
= NULL
;
5042 old_chain
= make_cleanup (null_cleanup
, 0);
5045 if ((argv
= buildargv (args
)) == NULL
)
5048 make_cleanup ((make_cleanup_func
) freeargv
, argv
);
5050 while (argv
!= NULL
&& *argv
!= NULL
)
5052 if (isdigit (argv
[0][0]))
5054 pid
= strtoul (argv
[0], &tmp
, 10);
5056 tid
= strtoul (++tmp
, NULL
, 10);
5058 else if (argv
[0][0] == '/')
5060 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5069 pid
= PIDGET (inferior_pid
);
5071 error ("No current process: you must name one.");
5074 /* Have pid, will travel.
5075 First see if it's a process we're already debugging. */
5076 process
= find_procinfo (pid
, 0);
5077 if (process
== NULL
)
5079 /* No. So open a procinfo for it, but
5080 remember to close it again when finished. */
5081 process
= create_procinfo (pid
, 0);
5082 make_cleanup ((make_cleanup_func
) destroy_procinfo
, process
);
5083 if (!open_procinfo_files (process
, FD_CTL
))
5084 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5088 thread
= create_procinfo (pid
, tid
);
5092 printf_filtered ("process %d flags:\n", process
->pid
);
5093 proc_prettyprint_flags (proc_flags (process
), 1);
5094 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5095 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5096 if (proc_get_nthreads (process
) > 1)
5097 printf_filtered ("Process has %d threads.\n",
5098 proc_get_nthreads (process
));
5102 printf_filtered ("thread %d flags:\n", thread
->tid
);
5103 proc_prettyprint_flags (proc_flags (thread
), 1);
5104 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5105 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5108 do_cleanups (old_chain
);
5112 proc_trace_syscalls (args
, from_tty
, entry_or_exit
, mode
)
5122 if (inferior_pid
<= 0)
5123 error ("you must be debugging a process to use this command.");
5125 if (args
== NULL
|| args
[0] == 0)
5126 error_no_arg ("system call to trace");
5128 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
5129 if (isdigit (args
[0]))
5131 syscallnum
= atoi (args
);
5132 if (entry_or_exit
== PR_SYSENTRY
)
5133 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5135 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5138 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5140 if (mode
== FLAG_SET
)
5141 praddset (sysset
, syscallnum
);
5143 prdelset (sysset
, syscallnum
);
5145 if (entry_or_exit
== PR_SYSENTRY
)
5147 if (!proc_set_traced_sysentry (pi
, sysset
))
5148 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5152 if (!proc_set_traced_sysexit (pi
, sysset
))
5153 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5159 proc_trace_sysentry_cmd (args
, from_tty
)
5163 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5167 proc_trace_sysexit_cmd (args
, from_tty
)
5171 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5175 proc_untrace_sysentry_cmd (args
, from_tty
)
5179 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5183 proc_untrace_sysexit_cmd (args
, from_tty
)
5187 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5192 mapping_test (fd
, core_addr
)
5194 CORE_ADDR core_addr
;
5196 printf ("File descriptor %d, base address 0x%08x\n", fd
, core_addr
);
5203 test_mapping_cmd (args
, from_tty
)
5208 ret
= proc_iterate_over_mappings (mapping_test
);
5209 printf ("iterate_over_mappings returned %d.\n", ret
);
5213 _initialize_procfs ()
5216 add_target (&procfs_ops
);
5217 add_info ("proc", info_proc_cmd
,
5218 "Show /proc process information about any running process.\
5219 Default is the process being debugged.");
5220 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5221 "Give a trace of entries into the syscall.");
5222 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5223 "Give a trace of exits from the syscall.");
5224 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5225 "Cancel a trace of entries into the syscall.");
5226 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5227 "Cancel a trace of exits from the syscall.");
5229 add_com ("test-mapping", no_class
, test_mapping_cmd
,
5230 "test iterate-over-mappings");
5233 /* =================== END, GDB "MODULE" =================== */
5237 /* miscelaneous stubs: */
5238 /* The following satisfy a few random symbols mostly created by */
5239 /* the solaris threads implementation, which I will chase down */
5243 * Return a pid for which we guarantee
5244 * we will be able to find a 'live' procinfo.
5248 procfs_first_available ()
5251 return procinfo_list
->pid
;
5257 procfs_get_pid_fd (pid
)
5262 if (pid
== -1 && inferior_pid
!= 0)
5263 pi
= find_procinfo (PIDGET (inferior_pid
), 0);
5265 pi
= find_procinfo (PIDGET (pid
), 0);