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>
44 * This module provides the interface between GDB and the
45 * /proc file system, which is used on many versions of Unix
46 * as a means for debuggers to control other processes.
47 * Examples of the systems that use this interface are:
53 * /proc works by immitating a file system: you open a simulated file
54 * that represents the process you wish to interact with, and
55 * perform operations on that "file" in order to examine or change
56 * the state of the other process.
58 * The most important thing to know about /proc and this module
59 * is that there are two very different interfaces to /proc:
60 * One that uses the ioctl system call, and
61 * another that uses read and write system calls.
62 * This module has to support both /proc interfaces. This means
63 * that there are two different ways of doing every basic operation.
65 * In order to keep most of the code simple and clean, I have
66 * defined an interface "layer" which hides all these system calls.
67 * An ifdef (NEW_PROC_API) determines which interface we are using,
68 * and most or all occurrances of this ifdef should be confined to
69 * this interface layer.
73 /* Determine which /proc API we are using:
74 The ioctl API defines PIOCSTATUS, while
75 the read/write (multiple fd) API never does. */
78 #include <sys/types.h>
79 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
82 #include <fcntl.h> /* for O_RDONLY */
83 #include <unistd.h> /* for "X_OK" */
84 #include "gdb_stat.h" /* for struct stat */
86 /* Note: procfs-utils.h must be included after the above system header
87 files, because it redefines various system calls using macros.
88 This may be incompatible with the prototype declarations. */
91 #include "proc-utils.h"
93 /* =================== TARGET_OPS "MODULE" =================== */
96 * This module defines the GDB target vector and its methods.
99 static void procfs_open
PARAMS((char *, int));
100 static void procfs_attach
PARAMS ((char *, int));
101 static void procfs_detach
PARAMS ((char *, int));
102 static void procfs_resume
PARAMS ((int, int, enum target_signal
));
103 static int procfs_can_run
PARAMS ((void));
104 static void procfs_stop
PARAMS ((void));
105 static void procfs_files_info
PARAMS ((struct target_ops
*));
106 static void procfs_fetch_registers
PARAMS ((int));
107 static void procfs_store_registers
PARAMS ((int));
108 static void procfs_notice_signals
PARAMS ((int));
109 static void procfs_prepare_to_store
PARAMS ((void));
110 static void procfs_kill_inferior
PARAMS ((void));
111 static void procfs_mourn_inferior
PARAMS ((void));
112 static void procfs_create_inferior
PARAMS ((char *, char *, char **));
113 static int procfs_wait
PARAMS ((int,
114 struct target_waitstatus
*));
115 static int procfs_xfer_memory
PARAMS ((CORE_ADDR
,
117 struct target_ops
*));
119 static int procfs_thread_alive
PARAMS ((int));
121 void procfs_find_new_threads
PARAMS ((void));
122 char *procfs_pid_to_str
PARAMS ((int));
124 struct target_ops procfs_ops
; /* the target vector */
129 procfs_ops
.to_shortname
= "procfs";
130 procfs_ops
.to_longname
= "Unix /proc child process";
132 "Unix /proc child process (started by the \"run\" command).";
133 procfs_ops
.to_open
= procfs_open
;
134 procfs_ops
.to_can_run
= procfs_can_run
;
135 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
136 procfs_ops
.to_kill
= procfs_kill_inferior
;
137 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
138 procfs_ops
.to_attach
= procfs_attach
;
139 procfs_ops
.to_detach
= procfs_detach
;
140 procfs_ops
.to_wait
= procfs_wait
;
141 procfs_ops
.to_resume
= procfs_resume
;
142 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
143 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
144 procfs_ops
.to_store_registers
= procfs_store_registers
;
145 procfs_ops
.to_xfer_memory
= procfs_xfer_memory
;
146 procfs_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
147 procfs_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
148 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
149 procfs_ops
.to_files_info
= procfs_files_info
;
150 procfs_ops
.to_stop
= procfs_stop
;
152 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
153 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
154 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
155 procfs_ops
.to_terminal_ours
= terminal_ours
;
156 procfs_ops
.to_terminal_info
= child_terminal_info
;
158 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
159 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
160 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
162 procfs_ops
.to_has_all_memory
= 1;
163 procfs_ops
.to_has_memory
= 1;
164 procfs_ops
.to_has_execution
= 1;
165 procfs_ops
.to_has_stack
= 1;
166 procfs_ops
.to_has_registers
= 1;
167 procfs_ops
.to_stratum
= process_stratum
;
168 procfs_ops
.to_has_thread_control
= tc_schedlock
;
169 procfs_ops
.to_magic
= OPS_MAGIC
;
172 /* =================== END, TARGET_OPS "MODULE" =================== */
177 * Put any typedefs, defines etc. here that are required for
178 * the unification of code that handles different versions of /proc.
181 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
183 enum { READ_WATCHFLAG
= WA_READ
,
184 WRITE_WATCHFLAG
= WA_WRITE
,
185 EXEC_WATCHFLAG
= WA_EXEC
,
186 AFTER_WATCHFLAG
= WA_TRAPAFTER
189 #else /* Irix method for watchpoints */
190 enum { READ_WATCHFLAG
= MA_READ
,
191 WRITE_WATCHFLAG
= MA_WRITE
,
192 EXEC_WATCHFLAG
= MA_EXEC
,
193 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
200 /* =================== STRUCT PROCINFO "MODULE" =================== */
202 /* FIXME: this comment will soon be out of date W.R.T. threads. */
204 /* The procinfo struct is a wrapper to hold all the state information
205 concerning a /proc process. There should be exactly one procinfo
206 for each process, and since GDB currently can debug only one
207 process at a time, that means there should be only one procinfo.
208 All of the LWP's of a process can be accessed indirectly thru the
209 single process procinfo.
211 However, against the day when GDB may debug more than one process,
212 this data structure is kept in a list (which for now will hold no
213 more than one member), and many functions will have a pointer to a
214 procinfo as an argument.
216 There will be a separate procinfo structure for use by the (not yet
217 implemented) "info proc" command, so that we can print useful
218 information about any random process without interfering with the
219 inferior's procinfo information. */
222 /* format strings for /proc paths */
223 # ifndef CTL_PROC_NAME_FMT
224 # define MAIN_PROC_NAME_FMT "/proc/%d"
225 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
226 # define AS_PROC_NAME_FMT "/proc/%d/as"
227 # define MAP_PROC_NAME_FMT "/proc/%d/map"
228 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
229 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
231 /* the name of the proc status struct depends on the implementation */
232 typedef pstatus_t gdb_prstatus_t
;
233 typedef lwpstatus_t gdb_lwpstatus_t
;
234 #else /* ! NEW_PROC_API */
235 /* format strings for /proc paths */
236 # ifndef CTL_PROC_NAME_FMT
237 # define MAIN_PROC_NAME_FMT "/proc/%05d"
238 # define CTL_PROC_NAME_FMT "/proc/%05d"
239 # define AS_PROC_NAME_FMT "/proc/%05d"
240 # define MAP_PROC_NAME_FMT "/proc/%05d"
241 # define STATUS_PROC_NAME_FMT "/proc/%05d"
242 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
244 /* the name of the proc status struct depends on the implementation */
245 typedef prstatus_t gdb_prstatus_t
;
246 typedef prstatus_t gdb_lwpstatus_t
;
247 #endif /* NEW_PROC_API */
250 /* These #ifdefs are for sol2.x in particular. sol2.x has
251 both a "gregset_t" and a "prgregset_t", which have
252 similar uses but different layouts. sol2.x gdb tries to
253 use prgregset_t (and prfpregset_t) everywhere. */
255 #ifdef GDB_GREGSET_TYPE
256 typedef GDB_GREGSET_TYPE gdb_gregset_t
;
258 typedef gregset_t gdb_gregset_t
;
261 #ifdef GDB_FPREGSET_TYPE
262 typedef GDB_FPREGSET_TYPE gdb_fpregset_t
;
264 typedef fpregset_t gdb_fpregset_t
;
267 /* Provide default composite pid manipulation macros for systems that
268 don't have threads. */
271 #define PIDGET(PID) (PID)
272 #define TIDGET(PID) (PID)
275 #define MERGEPID(PID, TID) (PID)
278 typedef struct procinfo
{
279 struct procinfo
*next
;
280 int pid
; /* Process ID */
281 int tid
; /* Thread/LWP id */
285 int ignore_next_sigstop
;
287 /* The following four fd fields may be identical, or may contain
288 several different fd's, depending on the version of /proc
289 (old ioctl or new read/write). */
291 int ctl_fd
; /* File descriptor for /proc control file */
293 * The next three file descriptors are actually only needed in the
294 * read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
295 * However, to avoid a bunch of #ifdefs in the code, we will use
296 * them uniformly by (in the case of the ioctl single-file-descriptor
297 * implementation) filling them with copies of the control fd.
299 int status_fd
; /* File descriptor for /proc status file */
300 int as_fd
; /* File descriptor for /proc as file */
302 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
304 fltset_t saved_fltset
; /* Saved traced hardware fault set */
305 sigset_t saved_sigset
; /* Saved traced signal set */
306 sigset_t saved_sighold
; /* Saved held signal set */
307 sysset_t saved_exitset
; /* Saved traced system call exit set */
308 sysset_t saved_entryset
; /* Saved traced system call entry set */
310 gdb_prstatus_t prstatus
; /* Current process status info */
313 gdb_fpregset_t fpregset
; /* Current floating point registers */
316 struct procinfo
*thread_list
;
318 int status_valid
: 1;
320 int fpregs_valid
: 1;
321 int threads_valid
: 1;
324 static char errmsg
[128]; /* shared error msg buffer */
326 /* Function prototypes for procinfo module: */
328 static procinfo
*find_procinfo_or_die
PARAMS ((int pid
, int tid
));
329 static procinfo
*find_procinfo
PARAMS ((int pid
, int tid
));
330 static procinfo
*create_procinfo
PARAMS ((int pid
, int tid
));
331 static void destroy_procinfo
PARAMS ((procinfo
*p
));
332 static void dead_procinfo
PARAMS ((procinfo
*p
,
333 char *msg
, int killp
));
334 static int open_procinfo_files
PARAMS ((procinfo
*p
, int which
));
335 static void close_procinfo_files
PARAMS ((procinfo
*p
));
337 /* The head of the procinfo list: */
338 static procinfo
* procinfo_list
;
341 * Function: find_procinfo
343 * Search the procinfo list.
345 * Returns: pointer to procinfo, or NULL if not found.
349 find_procinfo (pid
, tid
)
355 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
362 /* Don't check threads_valid. If we're updating the
363 thread_list, we want to find whatever threads are already
364 here. This means that in general it is the caller's
365 responsibility to check threads_valid and update before
366 calling find_procinfo, if the caller wants to find a new
369 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
378 * Function: find_procinfo_or_die
380 * Calls find_procinfo, but errors on failure.
384 find_procinfo_or_die (pid
, tid
)
388 procinfo
*pi
= find_procinfo (pid
, tid
);
393 error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",
396 error ("procfs: couldn't find pid %d in procinfo list.", pid
);
402 * Function: open_procinfo_files
404 * Open the file descriptor for the process or LWP.
405 * ifdef NEW_PROC_API, we only open the control file descriptor;
406 * the others are opened lazily as needed.
407 * else (if not NEW_PROC_API), there is only one real
408 * file descriptor, but we keep multiple copies of it so that
409 * the code that uses them does not have to be #ifdef'd.
411 * Return: file descriptor, or zero for failure.
414 enum { FD_CTL
, FD_STATUS
, FD_AS
};
417 open_procinfo_files (pi
, which
)
422 char tmp
[MAX_PROC_NAME_SIZE
];
427 * This function is getting ALMOST long enough to break up into several.
428 * Here is some rationale:
430 * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
431 * There are several file descriptors that may need to be open
432 * for any given process or LWP. The ones we're intereted in are:
433 * - control (ctl) write-only change the state
434 * - status (status) read-only query the state
435 * - address space (as) read/write access memory
436 * - map (map) read-only virtual addr map
437 * Most of these are opened lazily as they are needed.
438 * The pathnames for the 'files' for an LWP look slightly
439 * different from those of a first-class process:
440 * Pathnames for a process (<proc-id>):
441 * /proc/<proc-id>/ctl
442 * /proc/<proc-id>/status
444 * /proc/<proc-id>/map
445 * Pathnames for an LWP (lwp-id):
446 * /proc/<proc-id>/lwp/<lwp-id>/lwpctl
447 * /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
448 * An LWP has no map or address space file descriptor, since
449 * the memory map and address space are shared by all LWPs.
451 * Everyone else (Solaris 2.5, Irix, OSF)
452 * There is only one file descriptor for each process or LWP.
453 * For convenience, we copy the same file descriptor into all
454 * three fields of the procinfo struct (ctl_fd, status_fd, and
455 * as_fd, see NEW_PROC_API above) so that code that uses them
456 * doesn't need any #ifdef's.
461 * Each LWP has an independent file descriptor, but these
462 * are not obtained via the 'open' system call like the rest:
463 * instead, they're obtained thru an ioctl call (PIOCOPENLWP)
464 * to the file descriptor of the parent process.
467 * These do not even have their own independent file descriptor.
468 * All operations are carried out on the file descriptor of the
469 * parent process. Therefore we just call open again for each
470 * thread, getting a new handle for the same 'file'.
475 * In this case, there are several different file descriptors that
476 * we might be asked to open. The control file descriptor will be
477 * opened early, but the others will be opened lazily as they are
481 strcpy (tmp
, pi
->pathname
);
482 switch (which
) { /* which file descriptor to open? */
485 strcat (tmp
, "/lwpctl");
487 strcat (tmp
, "/ctl");
488 fd
= open (tmp
, O_WRONLY
);
495 return 0; /* there is no 'as' file descriptor for an lwp */
497 fd
= open (tmp
, O_RDWR
);
504 strcat (tmp
, "/lwpstatus");
506 strcat (tmp
, "/status");
507 fd
= open (tmp
, O_RDONLY
);
513 return 0; /* unknown file descriptor */
515 #else /* not NEW_PROC_API */
517 * In this case, there is only one file descriptor for each procinfo
518 * (ie. each process or LWP). In fact, only the file descriptor for
519 * the process can actually be opened by an 'open' system call.
520 * The ones for the LWPs have to be obtained thru an IOCTL call
521 * on the process's file descriptor.
523 * For convenience, we copy each procinfo's single file descriptor
524 * into all of the fields occupied by the several file descriptors
525 * of the NEW_PROC_API implementation. That way, the code that uses
526 * them can be written without ifdefs.
530 #ifdef PIOCTSTATUS /* OSF */
531 if ((fd
= open (pi
->pathname
, O_RDWR
)) == 0) /* Only one FD; just open it. */
533 #else /* Sol 2.5, Irix, other? */
534 if (pi
->tid
== 0) /* Master procinfo for the process */
536 fd
= open (pi
->pathname
, O_RDWR
);
540 else /* LWP thread procinfo */
542 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
546 /* Find the procinfo for the entire process. */
547 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
550 /* Now obtain the file descriptor for the LWP. */
551 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) <= 0)
553 #else /* Irix, other? */
554 return 0; /* Don't know how to open threads */
555 #endif /* Sol 2.5 PIOCOPENLWP */
557 #endif /* OSF PIOCTSTATUS */
558 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
559 #endif /* NEW_PROC_API */
561 return 1; /* success */
565 * Function: create_procinfo
567 * Allocate a data structure and link it into the procinfo list.
568 * (First tries to find a pre-existing one (FIXME: why?)
570 * Return: pointer to new procinfo struct.
574 create_procinfo (pid
, tid
)
578 procinfo
*pi
, *parent
;
580 if ((pi
= find_procinfo (pid
, tid
)))
581 return pi
; /* Already exists, nothing to do. */
583 /* find parent before doing malloc, to save having to cleanup */
585 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
587 doesn't exist yet? */
589 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
590 memset (pi
, 0, sizeof (procinfo
));
594 /* Chain into list. */
597 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
598 pi
->next
= procinfo_list
;
604 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
606 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
608 pi
->next
= parent
->thread_list
;
609 parent
->thread_list
= pi
;
615 * Function: close_procinfo_files
617 * Close all file descriptors associated with the procinfo
621 close_procinfo_files (pi
)
629 if (pi
->status_fd
> 0)
630 close (pi
->status_fd
);
632 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
636 * Function: destroy_procinfo
638 * Destructor function. Close, unlink and deallocate the object.
642 destroy_one_procinfo (list
, pi
)
648 /* Step one: unlink the procinfo from its list */
652 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
655 ptr
->next
= pi
->next
;
659 /* Step two: close any open file descriptors */
660 close_procinfo_files (pi
);
662 /* Step three: free the memory. */
667 destroy_procinfo (pi
)
672 if (pi
->tid
!= 0) /* destroy a thread procinfo */
674 tmp
= find_procinfo (pi
->pid
, 0); /* find the parent process */
675 destroy_one_procinfo (&tmp
->thread_list
, pi
);
677 else /* destroy a process procinfo and all its threads */
679 /* First destroy the children, if any; */
680 while (pi
->thread_list
!= NULL
)
681 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
682 /* Then destroy the parent. Genocide!!! */
683 destroy_one_procinfo (&procinfo_list
, pi
);
687 enum { NOKILL
, KILL
};
690 * Function: dead_procinfo
692 * To be called on a non_recoverable error for a procinfo.
693 * Prints error messages, optionally sends a SIGKILL to the process,
694 * then destroys the data structure.
698 dead_procinfo (pi
, msg
, kill_p
)
707 print_sys_errmsg (pi
->pathname
, errno
);
711 sprintf (procfile
, "process %d", pi
->pid
);
712 print_sys_errmsg (procfile
, errno
);
715 kill (pi
->pid
, SIGKILL
);
717 destroy_procinfo (pi
);
721 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
723 /* =================== /proc "MODULE" =================== */
726 * This "module" is the interface layer between the /proc system API
727 * and the gdb target vector functions. This layer consists of
728 * access functions that encapsulate each of the basic operations
729 * that we need to use from the /proc API.
731 * The main motivation for this layer is to hide the fact that
732 * there are two very different implementations of the /proc API.
733 * Rather than have a bunch of #ifdefs all thru the gdb target vector
734 * functions, we do our best to hide them all in here.
737 int proc_get_status
PARAMS ((procinfo
*pi
));
738 long proc_flags
PARAMS ((procinfo
*pi
));
739 int proc_why
PARAMS ((procinfo
*pi
));
740 int proc_what
PARAMS ((procinfo
*pi
));
741 int proc_set_run_on_last_close
PARAMS ((procinfo
*pi
));
742 int proc_unset_run_on_last_close
PARAMS ((procinfo
*pi
));
743 int proc_set_inherit_on_fork
PARAMS ((procinfo
*pi
));
744 int proc_unset_inherit_on_fork
PARAMS ((procinfo
*pi
));
745 int proc_set_async
PARAMS ((procinfo
*pi
));
746 int proc_unset_async
PARAMS ((procinfo
*pi
));
747 int proc_stop_process
PARAMS ((procinfo
*pi
));
748 int proc_trace_signal
PARAMS ((procinfo
*pi
, int signo
));
749 int proc_ignore_signal
PARAMS ((procinfo
*pi
, int signo
));
750 int proc_clear_current_fault
PARAMS ((procinfo
*pi
));
751 int proc_set_current_signal
PARAMS ((procinfo
*pi
, int signo
));
752 int proc_clear_current_signal
PARAMS ((procinfo
*pi
));
753 int proc_set_gregs
PARAMS ((procinfo
*pi
));
754 int proc_set_fpregs
PARAMS ((procinfo
*pi
));
755 int proc_wait_for_stop
PARAMS ((procinfo
*pi
));
756 int proc_run_process
PARAMS ((procinfo
*pi
, int step
, int signo
));
757 int proc_kill
PARAMS ((procinfo
*pi
, int signo
));
758 int proc_parent_pid
PARAMS ((procinfo
*pi
));
759 int proc_get_nthreads
PARAMS ((procinfo
*pi
));
760 int proc_get_current_thread
PARAMS ((procinfo
*pi
));
761 int proc_set_held_signals
PARAMS ((procinfo
*pi
, sigset_t
*sighold
));
762 int proc_set_traced_sysexit
PARAMS ((procinfo
*pi
, sysset_t
*sysset
));
763 int proc_set_traced_sysentry
PARAMS ((procinfo
*pi
, sysset_t
*sysset
));
764 int proc_set_traced_faults
PARAMS ((procinfo
*pi
, fltset_t
*fltset
));
765 int proc_set_traced_signals
PARAMS ((procinfo
*pi
, sigset_t
*sigset
));
767 int proc_update_threads
PARAMS ((procinfo
*pi
));
768 int proc_iterate_over_threads
PARAMS ((procinfo
*pi
,
769 int (*func
) PARAMS ((procinfo
*,
774 gdb_gregset_t
*proc_get_gregs
PARAMS ((procinfo
*pi
));
775 gdb_fpregset_t
*proc_get_fpregs
PARAMS ((procinfo
*pi
));
776 sysset_t
*proc_get_traced_sysexit
PARAMS ((procinfo
*pi
, sysset_t
*save
));
777 sysset_t
*proc_get_traced_sysentry
PARAMS ((procinfo
*pi
, sysset_t
*save
));
778 fltset_t
*proc_get_traced_faults
PARAMS ((procinfo
*pi
, fltset_t
*save
));
779 sigset_t
*proc_get_traced_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
780 sigset_t
*proc_get_held_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
781 sigset_t
*proc_get_pending_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
782 struct sigaction
*proc_get_signal_actions
PARAMS ((procinfo
*pi
,
783 struct sigaction
*save
));
785 void proc_warn
PARAMS ((procinfo
*pi
, char *func
, int line
));
786 void proc_error
PARAMS ((procinfo
*pi
, char *func
, int line
));
789 proc_warn (pi
, func
, line
)
794 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
795 print_sys_errmsg (errmsg
, errno
);
799 proc_error (pi
, func
, line
)
804 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
805 perror_with_name (errmsg
);
809 * Function: proc_get_status
811 * Updates the status struct in the procinfo.
812 * There is a 'valid' flag, to let other functions know when
813 * this function needs to be called (so the status is only
814 * read when it is needed). The status file descriptor is
815 * also only opened when it is needed.
817 * Return: non-zero for success, zero for failure.
824 /* Status file descriptor is opened "lazily" */
825 if (pi
->status_fd
== 0 &&
826 open_procinfo_files (pi
, FD_STATUS
) == 0)
828 pi
->status_valid
= 0;
833 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
834 pi
->status_valid
= 0; /* fail */
837 /* Sigh... I have to read a different data structure,
838 depending on whether this is a main process or an LWP. */
840 pi
->status_valid
= (read (pi
->status_fd
,
841 (char *) &pi
->prstatus
.pr_lwp
,
842 sizeof (lwpstatus_t
))
843 == sizeof (lwpstatus_t
));
846 pi
->status_valid
= (read (pi
->status_fd
,
847 (char *) &pi
->prstatus
,
848 sizeof (gdb_prstatus_t
))
849 == sizeof (gdb_prstatus_t
));
850 #if 0 /*def UNIXWARE*/
851 if (pi
->status_valid
&&
852 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
853 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
854 /* Unixware peculiarity -- read the damn thing again! */
855 pi
->status_valid
= (read (pi
->status_fd
,
856 (char *) &pi
->prstatus
,
857 sizeof (gdb_prstatus_t
))
858 == sizeof (gdb_prstatus_t
));
859 #endif /* UNIXWARE */
862 #else /* ioctl method */
863 #ifdef PIOCTSTATUS /* osf */
864 if (pi
->tid
== 0) /* main process */
866 /* Just read the danged status. Now isn't that simple? */
868 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
875 tid_t pr_error_thread
;
876 struct prstatus status
;
879 thread_status
.pr_count
= 1;
880 thread_status
.status
.pr_tid
= pi
->tid
;
881 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
884 memcpy (&pi
->prstatus
, &thread_status
.status
,
885 sizeof (pi
->prstatus
));
886 pi
->status_valid
= 1;
890 /* Just read the danged status. Now isn't that simple? */
891 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
895 if (pi
->status_valid
)
897 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
900 proc_get_current_thread (pi
));
903 /* The status struct includes general regs, so mark them valid too */
904 pi
->gregs_valid
= pi
->status_valid
;
906 /* In the read/write multiple-fd model,
907 the status struct includes the fp regs too, so mark them valid too */
908 pi
->fpregs_valid
= pi
->status_valid
;
910 return pi
->status_valid
; /* True if success, false if failure. */
914 * Function: proc_flags
916 * returns the process flags (pr_flags field).
923 if (!pi
->status_valid
)
924 if (!proc_get_status (pi
))
925 return 0; /* FIXME: not a good failure value (but what is?) */
929 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
930 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
931 The two sets of flags don't overlap. */
932 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
934 return pi
->prstatus
.pr_lwp
.pr_flags
;
937 return pi
->prstatus
.pr_flags
;
944 * returns the pr_why field (why the process stopped).
951 if (!pi
->status_valid
)
952 if (!proc_get_status (pi
))
953 return 0; /* FIXME: not a good failure value (but what is?) */
956 return pi
->prstatus
.pr_lwp
.pr_why
;
958 return pi
->prstatus
.pr_why
;
963 * Function: proc_what
965 * returns the pr_what field (details of 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_what
;
979 return pi
->prstatus
.pr_what
;
983 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
985 * Function: proc_nsysarg
987 * returns the pr_nsysarg field (number of args to the current syscall).
994 if (!pi
->status_valid
)
995 if (!proc_get_status (pi
))
999 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1001 return pi
->prstatus
.pr_nsysarg
;
1006 * Function: proc_sysargs
1008 * returns the pr_sysarg field (pointer to the arguments of current syscall).
1015 if (!pi
->status_valid
)
1016 if (!proc_get_status (pi
))
1020 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1022 return (long *) &pi
->prstatus
.pr_sysarg
;
1027 * Function: proc_syscall
1029 * returns the pr_syscall field (id of current syscall if we are in one).
1036 if (!pi
->status_valid
)
1037 if (!proc_get_status (pi
))
1041 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1043 return pi
->prstatus
.pr_syscall
;
1046 #endif /* PIOCSSPCACT */
1049 * Function: proc_cursig:
1051 * returns the pr_cursig field (current signal).
1055 proc_cursig (struct procinfo
*pi
)
1057 if (!pi
->status_valid
)
1058 if (!proc_get_status (pi
))
1059 return 0; /* FIXME: not a good failure value (but what is?) */
1062 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1064 return pi
->prstatus
.pr_cursig
;
1069 * Function: proc_modify_flag
1071 * === I appologize for the messiness of this function.
1072 * === This is an area where the different versions of
1073 * === /proc are more inconsistent than usual. MVS
1075 * Set or reset any of the following process flags:
1076 * PR_FORK -- forked child will inherit trace flags
1077 * PR_RLC -- traced process runs when last /proc file closed.
1078 * PR_KLC -- traced process is killed when last /proc file closed.
1079 * PR_ASYNC -- LWP's get to run/stop independently.
1081 * There are three methods for doing this function:
1082 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1084 * 2) Middle: PIOCSET/PIOCRESET
1086 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1089 * Note: Irix does not define PR_ASYNC.
1090 * Note: OSF does not define PR_KLC.
1091 * Note: OSF is the only one that can ONLY use the oldest method.
1094 * pi -- the procinfo
1095 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1096 * mode -- 1 for set, 0 for reset.
1098 * Returns non-zero for success, zero for failure.
1101 enum { FLAG_RESET
, FLAG_SET
};
1104 proc_modify_flag (pi
, flag
, mode
)
1109 long win
= 0; /* default to fail */
1112 * These operations affect the process as a whole, and applying
1113 * them to an individual LWP has the same meaning as applying them
1114 * to the main process. Therefore, if we're ever called with a
1115 * pointer to an LWP's procinfo, let's substitute the process's
1116 * procinfo and avoid opening the LWP's file descriptor
1121 pi
= find_procinfo_or_die (pi
->pid
, 0);
1123 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
1124 /* First normalize the PCUNSET/PCRESET command opcode
1125 (which for no obvious reason has a different definition
1126 from one operating system to the next...) */
1128 #define GDBRESET PCUNSET
1131 #define GDBRESET PCRESET
1136 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC) */
1138 else /* Reset the flag */
1142 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1145 #ifdef PIOCSET /* Irix/Sol5 method */
1146 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
1148 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1150 else /* Reset the flag */
1152 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1156 #ifdef PIOCSRLC /* Oldest method: OSF */
1159 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1161 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1163 else /* Clear run-on-last-close */
1165 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1169 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1171 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1173 else /* Clear inherit-on-fork */
1175 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1179 win
= 0; /* fail -- unknown flag (can't do PR_ASYNC) */
1186 /* The above operation renders the procinfo's cached pstatus obsolete. */
1187 pi
->status_valid
= 0;
1190 warning ("procfs: modify_flag failed to turn %s %s",
1191 flag
== PR_FORK
? "PR_FORK" :
1192 flag
== PR_RLC
? "PR_RLC" :
1194 flag
== PR_ASYNC
? "PR_ASYNC" :
1197 flag
== PR_KLC
? "PR_KLC" :
1200 mode
== FLAG_RESET
? "off" : "on");
1206 * Function: proc_set_run_on_last_close
1208 * Set the run_on_last_close flag.
1209 * Process with all threads will become runnable
1210 * when debugger closes all /proc fds.
1212 * Returns non-zero for success, zero for failure.
1216 proc_set_run_on_last_close (pi
)
1219 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1223 * Function: proc_unset_run_on_last_close
1225 * Reset the run_on_last_close flag.
1226 * Process will NOT become runnable
1227 * when debugger closes its file handles.
1229 * Returns non-zero for success, zero for failure.
1233 proc_unset_run_on_last_close (pi
)
1236 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1241 * Function: proc_set_kill_on_last_close
1243 * Set the kill_on_last_close flag.
1244 * Process with all threads will be killed when debugger
1245 * closes all /proc fds (or debugger exits or dies).
1247 * Returns non-zero for success, zero for failure.
1251 proc_set_kill_on_last_close (pi
)
1254 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1258 * Function: proc_unset_kill_on_last_close
1260 * Reset the kill_on_last_close flag.
1261 * Process will NOT be killed when debugger
1262 * closes its file handles (or exits or dies).
1264 * Returns non-zero for success, zero for failure.
1268 proc_unset_kill_on_last_close (pi
)
1271 return proc_modify_flag (pi
, PR_KLC
, FLAG_RESET
);
1276 * Function: proc_set_inherit_on_fork
1278 * Set inherit_on_fork flag.
1279 * If the process forks a child while we are registered for events
1280 * in the parent, then we will also recieve events from the child.
1282 * Returns non-zero for success, zero for failure.
1286 proc_set_inherit_on_fork (pi
)
1289 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1293 * Function: proc_unset_inherit_on_fork
1295 * Reset inherit_on_fork flag.
1296 * If the process forks a child while we are registered for events
1297 * in the parent, then we will NOT recieve events from the child.
1299 * Returns non-zero for success, zero for failure.
1303 proc_unset_inherit_on_fork (pi
)
1306 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1311 * Function: proc_set_async
1313 * Set PR_ASYNC flag.
1314 * If one LWP stops because of a debug event (signal etc.),
1315 * the remaining LWPs will continue to run.
1317 * Returns non-zero for success, zero for failure.
1324 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1328 * Function: proc_unset_async
1330 * Reset PR_ASYNC flag.
1331 * If one LWP stops because of a debug event (signal etc.),
1332 * then all other LWPs will stop as well.
1334 * Returns non-zero for success, zero for failure.
1338 proc_unset_async (pi
)
1341 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1343 #endif /* PR_ASYNC */
1346 * Function: proc_stop_process
1348 * Request the process/LWP to stop. Does not wait.
1349 * Returns non-zero for success, zero for failure.
1353 proc_stop_process (pi
)
1359 * We might conceivably apply this operation to an LWP, and
1360 * the LWP's ctl file descriptor might not be open.
1363 if (pi
->ctl_fd
== 0 &&
1364 open_procinfo_files (pi
, FD_CTL
) == 0)
1370 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1371 #else /* ioctl method */
1372 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1373 /* Note: the call also reads the prstatus. */
1376 pi
->status_valid
= 1;
1377 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1380 proc_get_current_thread (pi
));
1389 * Function: proc_wait_for_stop
1391 * Wait for the process or LWP to stop (block until it does).
1392 * Returns non-zero for success, zero for failure.
1396 proc_wait_for_stop (pi
)
1402 * We should never have to apply this operation to any procinfo
1403 * except the one for the main process. If that ever changes
1404 * for any reason, then take out the following clause and
1405 * replace it with one that makes sure the ctl_fd is open.
1409 pi
= find_procinfo_or_die (pi
->pid
, 0);
1414 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1415 /* We been runnin' and we stopped -- need to update status. */
1416 pi
->status_valid
= 0;
1418 #else /* ioctl method */
1419 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1420 /* Above call also refreshes the prstatus. */
1423 pi
->status_valid
= 1;
1424 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1427 proc_get_current_thread (pi
));
1435 * Function: proc_run_process
1437 * Make the process or LWP runnable.
1438 * Options (not all are implemented):
1440 * - clear current fault
1441 * - clear current signal
1442 * - abort the current system call
1443 * - stop as soon as finished with system call
1444 * - (ioctl): set traced signal set
1445 * - (ioctl): set held signal set
1446 * - (ioctl): set traced fault set
1447 * - (ioctl): set start pc (vaddr)
1448 * Always clear the current fault.
1449 * Clear the current signal if 'signo' is zero.
1452 * pi the process or LWP to operate on.
1453 * step if true, set the process or LWP to trap after one instr.
1454 * signo if zero, clear the current signal if any.
1455 * if non-zero, set the current signal to this one.
1457 * Returns non-zero for success, zero for failure.
1461 proc_run_process (pi
, step
, signo
)
1470 * We will probably have to apply this operation to individual threads,
1471 * so make sure the control file descriptor is open.
1474 if (pi
->ctl_fd
== 0 &&
1475 open_procinfo_files (pi
, FD_CTL
) == 0)
1480 runflags
= PRCFAULT
; /* always clear current fault */
1485 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals */
1486 proc_set_current_signal (pi
, signo
);
1494 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1496 #else /* ioctl method */
1500 memset (&prrun
, 0, sizeof (prrun
));
1501 prrun
.pr_flags
= runflags
;
1502 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1510 * Function: proc_set_traced_signals
1512 * Register to trace signals in the process or LWP.
1513 * Returns non-zero for success, zero for failure.
1517 proc_set_traced_signals (pi
, sigset
)
1524 * We should never have to apply this operation to any procinfo
1525 * except the one for the main process. If that ever changes
1526 * for any reason, then take out the following clause and
1527 * replace it with one that makes sure the ctl_fd is open.
1531 pi
= find_procinfo_or_die (pi
->pid
, 0);
1537 /* Use char array to avoid alignment issues. */
1538 char sigset
[sizeof (sigset_t
)];
1542 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
1544 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1546 #else /* ioctl method */
1547 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1549 /* The above operation renders the procinfo's cached pstatus obsolete. */
1550 pi
->status_valid
= 0;
1553 warning ("procfs: set_traced_signals failed");
1558 * Function: proc_set_traced_faults
1560 * Register to trace hardware faults in the process or LWP.
1561 * Returns non-zero for success, zero for failure.
1565 proc_set_traced_faults (pi
, fltset
)
1572 * We should never have to apply this operation to any procinfo
1573 * except the one for the main process. If that ever changes
1574 * for any reason, then take out the following clause and
1575 * replace it with one that makes sure the ctl_fd is open.
1579 pi
= find_procinfo_or_die (pi
->pid
, 0);
1585 /* Use char array to avoid alignment issues. */
1586 char fltset
[sizeof (fltset_t
)];
1590 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1592 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1594 #else /* ioctl method */
1595 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1597 /* The above operation renders the procinfo's cached pstatus obsolete. */
1598 pi
->status_valid
= 0;
1604 * Function: proc_set_traced_sysentry
1606 * Register to trace entry to system calls in the process or LWP.
1607 * Returns non-zero for success, zero for failure.
1611 proc_set_traced_sysentry (pi
, sysset
)
1618 * We should never have to apply this operation to any procinfo
1619 * except the one for the main process. If that ever changes
1620 * for any reason, then take out the following clause and
1621 * replace it with one that makes sure the ctl_fd is open.
1625 pi
= find_procinfo_or_die (pi
->pid
, 0);
1631 /* Use char array to avoid alignment issues. */
1632 char sysset
[sizeof (sysset_t
)];
1636 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1638 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1640 #else /* ioctl method */
1641 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1643 /* The above operation renders the procinfo's cached pstatus obsolete. */
1644 pi
->status_valid
= 0;
1650 * Function: proc_set_traced_sysexit
1652 * Register to trace exit from system calls in the process or LWP.
1653 * Returns non-zero for success, zero for failure.
1657 proc_set_traced_sysexit (pi
, sysset
)
1664 * We should never have to apply this operation to any procinfo
1665 * except the one for the main process. If that ever changes
1666 * for any reason, then take out the following clause and
1667 * replace it with one that makes sure the ctl_fd is open.
1671 pi
= find_procinfo_or_die (pi
->pid
, 0);
1677 /* Use char array to avoid alignment issues. */
1678 char sysset
[sizeof (sysset_t
)];
1682 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1684 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1686 #else /* ioctl method */
1687 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1689 /* The above operation renders the procinfo's cached pstatus obsolete. */
1690 pi
->status_valid
= 0;
1696 * Function: proc_set_held_signals
1698 * Specify the set of blocked / held signals in the process or LWP.
1699 * Returns non-zero for success, zero for failure.
1703 proc_set_held_signals (pi
, sighold
)
1710 * We should never have to apply this operation to any procinfo
1711 * except the one for the main process. If that ever changes
1712 * for any reason, then take out the following clause and
1713 * replace it with one that makes sure the ctl_fd is open.
1717 pi
= find_procinfo_or_die (pi
->pid
, 0);
1723 /* Use char array to avoid alignment issues. */
1724 char hold
[sizeof (sigset_t
)];
1728 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1729 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1732 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1734 /* The above operation renders the procinfo's cached pstatus obsolete. */
1735 pi
->status_valid
= 0;
1741 * Function: proc_get_pending_signals
1743 * returns the set of signals that are pending in the process or LWP.
1744 * Will also copy the sigset if 'save' is non-zero.
1748 proc_get_pending_signals (pi
, save
)
1752 sigset_t
*ret
= NULL
;
1755 * We should never have to apply this operation to any procinfo
1756 * except the one for the main process. If that ever changes
1757 * for any reason, then take out the following clause and
1758 * replace it with one that makes sure the ctl_fd is open.
1762 pi
= find_procinfo_or_die (pi
->pid
, 0);
1764 if (!pi
->status_valid
)
1765 if (!proc_get_status (pi
))
1769 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
1771 ret
= &pi
->prstatus
.pr_sigpend
;
1774 memcpy (save
, ret
, sizeof (sigset_t
));
1780 * Function: proc_get_signal_actions
1782 * returns the set of signal actions.
1783 * Will also copy the sigactionset if 'save' is non-zero.
1787 proc_get_signal_actions (pi
, save
)
1789 struct sigaction
*save
;
1791 struct sigaction
*ret
= NULL
;
1794 * We should never have to apply this operation to any procinfo
1795 * except the one for the main process. If that ever changes
1796 * for any reason, then take out the following clause and
1797 * replace it with one that makes sure the ctl_fd is open.
1801 pi
= find_procinfo_or_die (pi
->pid
, 0);
1803 if (!pi
->status_valid
)
1804 if (!proc_get_status (pi
))
1808 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
1810 ret
= &pi
->prstatus
.pr_action
;
1813 memcpy (save
, ret
, sizeof (struct sigaction
));
1819 * Function: proc_get_held_signals
1821 * returns the set of signals that are held / blocked.
1822 * Will also copy the sigset if 'save' is non-zero.
1826 proc_get_held_signals (pi
, save
)
1830 sigset_t
*ret
= NULL
;
1833 * We should never have to apply this operation to any procinfo
1834 * except the one for the main process. If that ever changes
1835 * for any reason, then take out the following clause and
1836 * replace it with one that makes sure the ctl_fd is open.
1840 pi
= find_procinfo_or_die (pi
->pid
, 0);
1843 if (!pi
->status_valid
)
1844 if (!proc_get_status (pi
))
1848 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1850 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1851 #endif /* UNIXWARE */
1852 #else /* not NEW_PROC_API */
1854 static sigset_t sigheld
;
1856 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1859 #endif /* NEW_PROC_API */
1861 memcpy (save
, ret
, sizeof (sigset_t
));
1867 * Function: proc_get_traced_signals
1869 * returns the set of signals that are traced / debugged.
1870 * Will also copy the sigset if 'save' is non-zero.
1874 proc_get_traced_signals (pi
, save
)
1878 sigset_t
*ret
= NULL
;
1881 * We should never have to apply this operation to any procinfo
1882 * except the one for the main process. If that ever changes
1883 * for any reason, then take out the following clause and
1884 * replace it with one that makes sure the ctl_fd is open.
1888 pi
= find_procinfo_or_die (pi
->pid
, 0);
1891 if (!pi
->status_valid
)
1892 if (!proc_get_status (pi
))
1895 ret
= &pi
->prstatus
.pr_sigtrace
;
1898 static sigset_t sigtrace
;
1900 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
1905 memcpy (save
, ret
, sizeof (sigset_t
));
1911 * Function: proc_trace_signal
1913 * Add 'signo' to the set of signals that are traced.
1914 * Returns non-zero for success, zero for failure.
1918 proc_trace_signal (pi
, signo
)
1925 * We should never have to apply this operation to any procinfo
1926 * except the one for the main process. If that ever changes
1927 * for any reason, then take out the following clause and
1928 * replace it with one that makes sure the ctl_fd is open.
1932 pi
= find_procinfo_or_die (pi
->pid
, 0);
1936 if (proc_get_traced_signals (pi
, &temp
))
1938 praddset (&temp
, signo
);
1939 return proc_set_traced_signals (pi
, &temp
);
1943 return 0; /* failure */
1947 * Function: proc_ignore_signal
1949 * Remove 'signo' from the set of signals that are traced.
1950 * Returns non-zero for success, zero for failure.
1954 proc_ignore_signal (pi
, signo
)
1961 * We should never have to apply this operation to any procinfo
1962 * except the one for the main process. If that ever changes
1963 * for any reason, then take out the following clause and
1964 * replace it with one that makes sure the ctl_fd is open.
1968 pi
= find_procinfo_or_die (pi
->pid
, 0);
1972 if (proc_get_traced_signals (pi
, &temp
))
1974 prdelset (&temp
, signo
);
1975 return proc_set_traced_signals (pi
, &temp
);
1979 return 0; /* failure */
1983 * Function: proc_get_traced_faults
1985 * returns the set of hardware faults that are traced /debugged.
1986 * Will also copy the faultset if 'save' is non-zero.
1990 proc_get_traced_faults (pi
, save
)
1994 fltset_t
*ret
= NULL
;
1997 * We should never have to apply this operation to any procinfo
1998 * except the one for the main process. If that ever changes
1999 * for any reason, then take out the following clause and
2000 * replace it with one that makes sure the ctl_fd is open.
2004 pi
= find_procinfo_or_die (pi
->pid
, 0);
2007 if (!pi
->status_valid
)
2008 if (!proc_get_status (pi
))
2011 ret
= &pi
->prstatus
.pr_flttrace
;
2014 static fltset_t flttrace
;
2016 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
2021 memcpy (save
, ret
, sizeof (fltset_t
));
2027 * Function: proc_get_traced_sysentry
2029 * returns the set of syscalls that are traced /debugged on entry.
2030 * Will also copy the syscall set if 'save' is non-zero.
2034 proc_get_traced_sysentry (pi
, save
)
2038 sysset_t
*ret
= NULL
;
2041 * We should never have to apply this operation to any procinfo
2042 * except the one for the main process. If that ever changes
2043 * for any reason, then take out the following clause and
2044 * replace it with one that makes sure the ctl_fd is open.
2048 pi
= find_procinfo_or_die (pi
->pid
, 0);
2051 if (!pi
->status_valid
)
2052 if (!proc_get_status (pi
))
2055 ret
= &pi
->prstatus
.pr_sysentry
;
2058 static sysset_t sysentry
;
2060 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
2065 memcpy (save
, ret
, sizeof (sysset_t
));
2071 * Function: proc_get_traced_sysexit
2073 * returns the set of syscalls that are traced /debugged on exit.
2074 * Will also copy the syscall set if 'save' is non-zero.
2078 proc_get_traced_sysexit (pi
, save
)
2082 sysset_t
* ret
= NULL
;
2085 * We should never have to apply this operation to any procinfo
2086 * except the one for the main process. If that ever changes
2087 * for any reason, then take out the following clause and
2088 * replace it with one that makes sure the ctl_fd is open.
2092 pi
= find_procinfo_or_die (pi
->pid
, 0);
2095 if (!pi
->status_valid
)
2096 if (!proc_get_status (pi
))
2099 ret
= &pi
->prstatus
.pr_sysexit
;
2102 static sysset_t sysexit
;
2104 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2109 memcpy (save
, ret
, sizeof (sysset_t
));
2115 * Function: proc_clear_current_fault
2117 * The current fault (if any) is cleared; the associated signal
2118 * will not be sent to the process or LWP when it resumes.
2119 * Returns non-zero for success, zero for failure.
2123 proc_clear_current_fault (pi
)
2129 * We should never have to apply this operation to any procinfo
2130 * except the one for the main process. If that ever changes
2131 * for any reason, then take out the following clause and
2132 * replace it with one that makes sure the ctl_fd is open.
2136 pi
= find_procinfo_or_die (pi
->pid
, 0);
2140 long cmd
= PCCFAULT
;
2141 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2144 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2151 * Function: proc_set_current_signal
2153 * Set the "current signal" that will be delivered next to the process.
2154 * NOTE: semantics are different from those of KILL.
2155 * This signal will be delivered to the process or LWP
2156 * immediately when it is resumed (even if the signal is held/blocked);
2157 * it will NOT immediately cause another event of interest, and will NOT
2158 * first trap back to the debugger.
2160 * Returns non-zero for success, zero for failure.
2164 proc_set_current_signal (pi
, signo
)
2171 /* Use char array to avoid alignment issues. */
2172 char sinfo
[sizeof (struct siginfo
)];
2174 struct siginfo
*mysinfo
;
2177 * We should never have to apply this operation to any procinfo
2178 * except the one for the main process. If that ever changes
2179 * for any reason, then take out the following clause and
2180 * replace it with one that makes sure the ctl_fd is open.
2184 pi
= find_procinfo_or_die (pi
->pid
, 0);
2186 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2187 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2188 * receives a PIOCSSIG with a signal identical to the current signal,
2189 * it messes up the current signal. Work around the kernel bug.
2192 signo
== proc_cursig (pi
))
2193 return 1; /* I assume this is a success? */
2196 /* The pointer is just a type alias. */
2197 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2198 mysinfo
->si_signo
= signo
;
2199 mysinfo
->si_code
= 0;
2200 mysinfo
->si_pid
= getpid (); /* ?why? */
2201 mysinfo
->si_uid
= getuid (); /* ?why? */
2205 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2207 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2214 * Function: proc_clear_current_signal
2216 * The current signal (if any) is cleared, and
2217 * is not sent to the process or LWP when it resumes.
2218 * Returns non-zero for success, zero for failure.
2222 proc_clear_current_signal (pi
)
2228 * We should never have to apply this operation to any procinfo
2229 * except the one for the main process. If that ever changes
2230 * for any reason, then take out the following clause and
2231 * replace it with one that makes sure the ctl_fd is open.
2235 pi
= find_procinfo_or_die (pi
->pid
, 0);
2241 /* Use char array to avoid alignment issues. */
2242 char sinfo
[sizeof (struct siginfo
)];
2244 struct siginfo
*mysinfo
;
2247 /* The pointer is just a type alias. */
2248 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2249 mysinfo
->si_signo
= 0;
2250 mysinfo
->si_code
= 0;
2251 mysinfo
->si_errno
= 0;
2252 mysinfo
->si_pid
= getpid (); /* ?why? */
2253 mysinfo
->si_uid
= getuid (); /* ?why? */
2255 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2258 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2265 * Function: proc_get_gregs
2267 * Get the general registers for the process or LWP.
2268 * Returns non-zero for success, zero for failure.
2275 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2276 if (!proc_get_status (pi
))
2280 * OK, sorry about the ifdef's.
2281 * There's three cases instead of two, because
2282 * in this instance Unixware and Solaris/RW differ.
2286 #ifdef UNIXWARE /* ugh, a true architecture dependency */
2287 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2288 #else /* not Unixware */
2289 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2290 #endif /* Unixware */
2291 #else /* not NEW_PROC_API */
2292 return &pi
->prstatus
.pr_reg
;
2293 #endif /* NEW_PROC_API */
2297 * Function: proc_get_fpregs
2299 * Get the floating point registers for the process or LWP.
2300 * Returns non-zero for success, zero for failure.
2304 proc_get_fpregs (pi
)
2308 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2309 if (!proc_get_status (pi
))
2312 #ifdef UNIXWARE /* a true architecture dependency */
2313 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2315 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2316 #endif /* Unixware */
2318 #else /* not NEW_PROC_API */
2319 if (pi
->fpregs_valid
)
2320 return &pi
->fpregset
; /* already got 'em */
2323 if (pi
->ctl_fd
== 0 &&
2324 open_procinfo_files (pi
, FD_CTL
) == 0)
2333 tid_t pr_error_thread
;
2334 tfpregset_t thread_1
;
2337 thread_fpregs
.pr_count
= 1;
2338 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2341 ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2343 pi
->fpregs_valid
= 1;
2344 return &pi
->fpregset
; /* got 'em now! */
2346 else if (pi
->tid
!= 0 &&
2347 ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2349 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2350 sizeof (pi
->fpregset
));
2351 pi
->fpregs_valid
= 1;
2352 return &pi
->fpregset
; /* got 'em now! */
2359 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2361 pi
->fpregs_valid
= 1;
2362 return &pi
->fpregset
; /* got 'em now! */
2375 * Function: proc_set_gregs
2377 * Write the general registers back to the process or LWP.
2378 * Returns non-zero for success, zero for failure.
2385 gdb_gregset_t
*gregs
;
2388 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2389 return 0; /* get_regs has already warned */
2391 if (pi
->ctl_fd
== 0 &&
2392 open_procinfo_files (pi
, FD_CTL
) == 0)
2401 /* Use char array to avoid alignment issues. */
2402 char gregs
[sizeof (gdb_gregset_t
)];
2406 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2407 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2409 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2413 /* Policy: writing the regs invalidates our cache. */
2414 pi
->gregs_valid
= 0;
2419 * Function: proc_set_fpregs
2421 * Modify the floating point register set of the process or LWP.
2422 * Returns non-zero for success, zero for failure.
2426 proc_set_fpregs (pi
)
2429 gdb_fpregset_t
*fpregs
;
2432 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
2433 return 0; /* get_fpregs has already warned */
2435 if (pi
->ctl_fd
== 0 &&
2436 open_procinfo_files (pi
, FD_CTL
) == 0)
2445 /* Use char array to avoid alignment issues. */
2446 char fpregs
[sizeof (gdb_fpregset_t
)];
2450 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2451 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2455 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2460 tid_t pr_error_thread
;
2461 tfpregset_t thread_1
;
2464 thread_fpregs
.pr_count
= 1;
2465 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2466 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2468 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2471 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2472 #endif /* osf PIOCTSFPREG */
2473 #endif /* NEW_PROC_API */
2476 /* Policy: writing the regs invalidates our cache. */
2477 pi
->fpregs_valid
= 0;
2482 * Function: proc_kill
2484 * Send a signal to the proc or lwp with the semantics of "kill()".
2485 * Returns non-zero for success, zero for failure.
2489 proc_kill (pi
, signo
)
2496 * We might conceivably apply this operation to an LWP, and
2497 * the LWP's ctl file descriptor might not be open.
2500 if (pi
->ctl_fd
== 0 &&
2501 open_procinfo_files (pi
, FD_CTL
) == 0)
2512 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2513 #else /* ioctl method */
2514 /* FIXME: do I need the Alpha OSF fixups present in
2515 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2516 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2524 * Function: proc_parent_pid
2526 * Find the pid of the process that started this one.
2527 * Returns the parent process pid, or zero.
2531 proc_parent_pid (pi
)
2535 * We should never have to apply this operation to any procinfo
2536 * except the one for the main process. If that ever changes
2537 * for any reason, then take out the following clause and
2538 * replace it with one that makes sure the ctl_fd is open.
2542 pi
= find_procinfo_or_die (pi
->pid
, 0);
2544 if (!pi
->status_valid
)
2545 if (!proc_get_status (pi
))
2548 return pi
->prstatus
.pr_ppid
;
2553 * Function: proc_set_watchpoint
2558 proc_set_watchpoint (pi
, addr
, len
, wflags
)
2564 #if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
2567 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
2568 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
2573 char watch
[sizeof (prwatch_t
)];
2577 pwatch
= (prwatch_t
*) &arg
.watch
;
2578 pwatch
->pr_vaddr
= addr
;
2579 pwatch
->pr_size
= len
;
2580 pwatch
->pr_wflags
= wflags
;
2581 #if defined(NEW_PROC_API) && defined (PCWATCH)
2583 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2585 #if defined (PIOCSWATCH)
2586 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, pwatch
) >= 0);
2588 return 0; /* Fail */
2596 * Function: proc_iterate_over_mappings
2598 * Given a pointer to a function, call that function once for every
2599 * mapped address space in the process. The callback function
2600 * receives an open file descriptor for the file corresponding to
2601 * that mapped address space (if there is one), and the base address
2602 * of the mapped space. Quit when the callback function returns a
2603 * nonzero value, or at teh end of the mappings.
2605 * Returns: the first non-zero return value of the callback function,
2609 /* FIXME: it's probably a waste to cache this FD.
2610 It doesn't get called that often... and if I open it
2611 every time, I don't need to lseek it. */
2613 proc_iterate_over_mappings (func
)
2614 int (*func
) PARAMS ((int, CORE_ADDR
));
2618 #ifndef NEW_PROC_API /* avoid compiler warning */
2623 char pathname
[MAX_PROC_NAME_SIZE
];
2628 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
2632 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
2633 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
2634 proc_error (pi
, "proc_iterate_over_mappings (open)", __LINE__
);
2636 /* Make sure it gets closed again. */
2637 make_cleanup ((make_cleanup_func
) close
, (void *) map_fd
);
2639 /* Allocate space for mapping (lifetime only for this function). */
2640 map
= alloca (sizeof (struct prmap
));
2642 /* Now read the mappings from the file,
2643 open a file descriptor for those that have a name,
2644 and call the callback function. */
2645 while (read (map_fd
,
2647 sizeof (struct prmap
)) == sizeof (struct prmap
))
2649 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
2651 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
2654 if (map
->pr_mapname
[0] == 0)
2656 fd
= -1; /* no map file */
2660 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
2661 /* Note: caller's responsibility to close this fd! */
2662 fd
= open (name
, O_RDONLY
);
2663 /* Note: we don't test the above call for failure;
2664 we just pass the FD on as given. Sometimes there is
2665 no file, so the ioctl may return failure, but that's
2669 /* Stop looping if the callback returns non-zero. */
2670 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
)) != 0)
2674 /* Get the number of mapping entries. */
2675 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmaps
) < 0)
2676 proc_error (pi
, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__
);
2678 /* Allocate space for mappings (lifetime only this function). */
2679 map
= (struct prmap
*) alloca ((nmaps
+ 1) * sizeof (struct prmap
));
2681 /* Read in all the mappings. */
2682 if (ioctl (pi
->ctl_fd
, PIOCMAP
, map
) < 0)
2683 proc_error (pi
, "proc_iterate_over_mappings (PIOCMAP)", __LINE__
);
2685 /* Now loop through the mappings, open an fd for each, and
2686 call the callback function. */
2688 i
< nmaps
&& map
[i
].pr_size
!= 0;
2691 /* Note: caller's responsibility to close this fd! */
2692 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
[i
].pr_vaddr
);
2693 /* Note: we don't test the above call for failure;
2694 we just pass the FD on as given. Sometimes there is
2695 no file, so the ioctl may return failure, but that's
2698 /* Stop looping if the callback returns non-zero. */
2699 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
[i
].pr_vaddr
)) != 0)
2707 #ifdef TM_I386SOL2_H /* Is it hokey to use this? */
2709 #include <sys/sysi86.h>
2712 * Function: proc_get_LDT_entry
2718 * The 'key' is actually the value of the lower 16 bits of
2719 * the GS register for the LWP that we're interested in.
2721 * Return: matching ssh struct (LDT entry).
2725 proc_get_LDT_entry (pi
, key
)
2729 static struct ssd
*ldt_entry
= NULL
;
2731 char pathname
[MAX_PROC_NAME_SIZE
];
2732 struct cleanup
*old_chain
= NULL
;
2735 /* Allocate space for one LDT entry.
2736 This alloc must persist, because we return a pointer to it. */
2737 if (ldt_entry
== NULL
)
2738 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2740 /* Open the file descriptor for the LDT table. */
2741 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2742 if ((fd
= open (pathname
, O_RDONLY
)) < 0)
2744 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2747 /* Make sure it gets closed again! */
2748 old_chain
= make_cleanup ((make_cleanup_func
) close
, (void *) fd
);
2750 /* Now 'read' thru the table, find a match and return it. */
2751 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2753 if (ldt_entry
->sel
== 0 &&
2754 ldt_entry
->bo
== 0 &&
2755 ldt_entry
->acc1
== 0 &&
2756 ldt_entry
->acc2
== 0)
2757 break; /* end of table */
2758 /* If key matches, return this entry. */
2759 if (ldt_entry
->sel
== key
)
2762 /* Loop ended, match not found. */
2766 static int nalloc
= 0;
2768 /* Get the number of LDT entries. */
2769 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2771 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2775 /* Allocate space for the number of LDT entries. */
2776 /* This alloc has to persist, 'cause we return a pointer to it. */
2779 ldt_entry
= (struct ssd
*)
2780 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2784 /* Read the whole table in one gulp. */
2785 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2787 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2791 /* Search the table and return the (first) entry matching 'key'. */
2792 for (i
= 0; i
< nldt
; i
++)
2793 if (ldt_entry
[i
].sel
== key
)
2794 return &ldt_entry
[i
];
2796 /* Loop ended, match not found. */
2801 #endif /* TM_I386SOL2_H */
2803 /* =============== END, non-thread part of /proc "MODULE" =============== */
2805 /* =================== Thread "MODULE" =================== */
2807 /* NOTE: you'll see more ifdefs and duplication of functions here,
2808 since there is a different way to do threads on every OS. */
2811 * Function: proc_get_nthreads
2813 * Return the number of threads for the process
2816 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2821 proc_get_nthreads (pi
)
2826 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2827 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2833 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2835 * Solaris and Unixware version
2838 proc_get_nthreads (pi
)
2841 if (!pi
->status_valid
)
2842 if (!proc_get_status (pi
))
2846 * NEW_PROC_API: only works for the process procinfo,
2847 * because the LWP procinfos do not get prstatus filled in.
2850 if (pi
->tid
!= 0) /* find the parent process procinfo */
2851 pi
= find_procinfo_or_die (pi
->pid
, 0);
2853 return pi
->prstatus
.pr_nlwp
;
2861 proc_get_nthreads (pi
)
2870 * Function: proc_get_current_thread (LWP version)
2872 * Return the ID of the thread that had an event of interest.
2873 * (ie. the one that hit a breakpoint or other traced event).
2874 * All other things being equal, this should be the ID of a
2875 * thread that is currently executing.
2878 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2880 * Solaris and Unixware version
2883 proc_get_current_thread (pi
)
2887 * Note: this should be applied to the root procinfo for the process,
2888 * not to the procinfo for an LWP. If applied to the procinfo for
2889 * an LWP, it will simply return that LWP's ID. In that case,
2890 * find the parent process procinfo.
2894 pi
= find_procinfo_or_die (pi
->pid
, 0);
2896 if (!pi
->status_valid
)
2897 if (!proc_get_status (pi
))
2901 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2903 return pi
->prstatus
.pr_who
;
2908 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2913 proc_get_current_thread (pi
)
2916 #if 0 /* FIXME: not ready for prime time? */
2917 return pi
->prstatus
.pr_tid
;
2928 proc_get_current_thread (pi
)
2938 * Function: proc_update_threads
2940 * Discover the IDs of all the threads within the process, and
2941 * create a procinfo for each of them (chained to the parent).
2943 * This unfortunately requires a different method on every OS.
2945 * Return: non-zero for success, zero for failure.
2949 proc_delete_dead_threads (parent
, thread
, ignore
)
2954 if (thread
&& parent
) /* sanity */
2956 thread
->status_valid
= 0;
2957 if (!proc_get_status (thread
))
2958 destroy_one_procinfo (&parent
->thread_list
, thread
);
2960 return 0; /* keep iterating */
2963 #if defined (PIOCLSTATUS)
2965 * Solaris 2.5 (ioctl) version
2968 proc_update_threads (pi
)
2971 gdb_prstatus_t
*prstatus
;
2972 struct cleanup
*old_chain
= NULL
;
2977 * We should never have to apply this operation to any procinfo
2978 * except the one for the main process. If that ever changes
2979 * for any reason, then take out the following clause and
2980 * replace it with one that makes sure the ctl_fd is open.
2984 pi
= find_procinfo_or_die (pi
->pid
, 0);
2986 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2988 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2989 return 1; /* Process is not multi-threaded; nothing to do. */
2991 if ((prstatus
= (gdb_prstatus_t
*)
2992 malloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1))) == 0)
2993 perror_with_name ("procfs: malloc failed in update_threads");
2995 old_chain
= make_cleanup (free
, prstatus
);
2996 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2997 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2999 /* Skip element zero, which represents the process as a whole. */
3000 for (i
= 1; i
< nlwp
+ 1; i
++)
3002 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
3003 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3005 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
3006 thread
->status_valid
= 1;
3008 pi
->threads_valid
= 1;
3009 do_cleanups (old_chain
);
3015 * Unixware and Solaris 6 (and later) version
3018 proc_update_threads (pi
)
3021 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3022 struct dirent
*direntry
;
3023 struct cleanup
*old_chain
= NULL
;
3029 * We should never have to apply this operation to any procinfo
3030 * except the one for the main process. If that ever changes
3031 * for any reason, then take out the following clause and
3032 * replace it with one that makes sure the ctl_fd is open.
3036 pi
= find_procinfo_or_die (pi
->pid
, 0);
3038 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3043 * Note: this brute-force method is the only way I know of
3044 * to accomplish this task on Unixware. This method will
3045 * also work on Solaris 2.6 and 2.7. There is a much simpler
3046 * and more elegant way to do this on Solaris, but the margins
3047 * of this manuscript are too small to write it here... ;-)
3050 strcpy (pathname
, pi
->pathname
);
3051 strcat (pathname
, "/lwp");
3052 if ((dirp
= opendir (pathname
)) == NULL
)
3053 proc_error (pi
, "update_threads, opendir", __LINE__
);
3055 old_chain
= make_cleanup ((make_cleanup_func
) closedir
, dirp
);
3056 while ((direntry
= readdir (dirp
)) != NULL
)
3057 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3059 lwpid
= atoi (&direntry
->d_name
[0]);
3060 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3061 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3063 pi
->threads_valid
= 1;
3064 do_cleanups (old_chain
);
3073 proc_update_threads (pi
)
3080 * We should never have to apply this operation to any procinfo
3081 * except the one for the main process. If that ever changes
3082 * for any reason, then take out the following clause and
3083 * replace it with one that makes sure the ctl_fd is open.
3087 pi
= find_procinfo_or_die (pi
->pid
, 0);
3089 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3091 nthreads
= proc_get_nthreads (pi
);
3093 return 0; /* nothing to do for 1 or fewer threads */
3095 if ((threads
= malloc (nthreads
* sizeof (tid_t
))) == NULL
)
3096 proc_error (pi
, "update_threads, malloc", __LINE__
);
3098 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3099 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3101 for (i
= 0; i
< nthreads
; i
++)
3103 if (!find_procinfo (pi
->pid
, threads
[i
]))
3104 if (!create_procinfo (pi
->pid
, threads
[i
]))
3105 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3107 pi
->threads_valid
= 1;
3115 proc_update_threads (pi
)
3120 #endif /* OSF PIOCTLIST */
3121 #endif /* NEW_PROC_API */
3122 #endif /* SOL 2.5 PIOCLSTATUS */
3125 * Function: proc_iterate_over_threads
3128 * Given a pointer to a function, call that function once
3129 * for each lwp in the procinfo list, until the function
3130 * returns non-zero, in which event return the value
3131 * returned by the function.
3133 * Note: this function does NOT call update_threads.
3134 * If you want to discover new threads first, you must
3135 * call that function explicitly. This function just makes
3136 * a quick pass over the currently-known procinfos.
3139 * pi - parent process procinfo
3140 * func - per-thread function
3141 * ptr - opaque parameter for function.
3144 * First non-zero return value from the callee, or zero.
3148 proc_iterate_over_threads (pi
, func
, ptr
)
3150 int (*func
) PARAMS ((procinfo
*, procinfo
*, void *));
3153 procinfo
*thread
, *next
;
3157 * We should never have to apply this operation to any procinfo
3158 * except the one for the main process. If that ever changes
3159 * for any reason, then take out the following clause and
3160 * replace it with one that makes sure the ctl_fd is open.
3164 pi
= find_procinfo_or_die (pi
->pid
, 0);
3166 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3168 next
= thread
->next
; /* in case thread is destroyed */
3169 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3176 /* =================== END, Thread "MODULE" =================== */
3178 /* =================== END, /proc "MODULE" =================== */
3180 /* =================== GDB "MODULE" =================== */
3183 * Here are all of the gdb target vector functions and their friends.
3186 static int do_attach
PARAMS ((int pid
));
3187 static void do_detach
PARAMS ((int signo
));
3188 static int register_gdb_signals
PARAMS ((procinfo
*, sigset_t
*));
3191 * Function: procfs_debug_inferior
3193 * Sets up the inferior to be debugged.
3194 * Registers to trace signals, hardware faults, and syscalls.
3195 * Note: does not set RLC flag: caller may want to customize that.
3197 * Returns: zero for success (note! unlike most functions in this module)
3198 * On failure, returns the LINE NUMBER where it failed!
3202 procfs_debug_inferior (pi
)
3205 fltset_t traced_faults
;
3206 sigset_t traced_signals
;
3207 sysset_t traced_syscall_entries
;
3208 sysset_t traced_syscall_exits
;
3210 #ifdef PROCFS_DONT_TRACE_FAULTS
3211 /* On some systems (OSF), we don't trace hardware faults.
3212 Apparently it's enough that we catch them as signals.
3213 Wonder why we don't just do that in general? */
3214 premptyset (&traced_faults
); /* don't trace faults. */
3216 /* Register to trace hardware faults in the child. */
3217 prfillset (&traced_faults
); /* trace all faults... */
3218 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3220 if (!proc_set_traced_faults (pi
, &traced_faults
))
3223 /* Register to trace selected signals in the child. */
3224 premptyset (&traced_signals
);
3225 if (!register_gdb_signals (pi
, &traced_signals
))
3228 /* Register to trace the 'exit' system call (on entry). */
3229 premptyset (&traced_syscall_entries
);
3230 praddset (&traced_syscall_entries
, SYS_exit
);
3232 praddset (&traced_syscall_entries
, SYS_lwpexit
); /* And _lwp_exit... */
3235 praddset (&traced_syscall_entries
, SYS_lwp_exit
);
3238 if (!proc_set_traced_sysentry (pi
, &traced_syscall_entries
))
3241 #ifdef PRFS_STOPEXEC /* defined on OSF */
3242 /* OSF method for tracing exec syscalls. Quoting:
3243 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3244 exits from exec system calls because of the user level loader. */
3245 /* FIXME: make nice and maybe move into an access function. */
3249 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3252 prfs_flags
|= PRFS_STOPEXEC
;
3254 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3257 #else /* not PRFS_STOPEXEC */
3258 /* Everyone else's (except OSF) method for tracing exec syscalls */
3260 Not all systems with /proc have all the exec* syscalls with the same
3261 names. On the SGI, for example, there is no SYS_exec, but there
3262 *is* a SYS_execv. So, we try to account for that. */
3264 premptyset (&traced_syscall_exits
);
3266 praddset (&traced_syscall_exits
, SYS_exec
);
3269 praddset (&traced_syscall_exits
, SYS_execve
);
3272 praddset (&traced_syscall_exits
, SYS_execv
);
3275 #ifdef SYS_lwpcreate
3276 praddset (&traced_syscall_exits
, SYS_lwpcreate
);
3277 praddset (&traced_syscall_exits
, SYS_lwpexit
);
3280 #ifdef SYS_lwp_create /* FIXME: once only, please */
3281 praddset (&traced_syscall_exits
, SYS_lwp_create
);
3282 praddset (&traced_syscall_exits
, SYS_lwp_exit
);
3286 if (!proc_set_traced_sysexit (pi
, &traced_syscall_exits
))
3289 #endif /* PRFS_STOPEXEC */
3294 procfs_attach (args
, from_tty
)
3302 error_no_arg ("process-id to attach");
3305 if (pid
== getpid ())
3306 error ("Attaching GDB to itself is not a good idea...");
3310 exec_file
= get_exec_file (0);
3313 printf_filtered ("Attaching to program `%s', %s\n",
3314 exec_file
, target_pid_to_str (pid
));
3316 printf_filtered ("Attaching to %s\n", target_pid_to_str (pid
));
3320 inferior_pid
= do_attach (pid
);
3321 push_target (&procfs_ops
);
3325 procfs_detach (args
, from_tty
)
3334 exec_file
= get_exec_file (0);
3337 printf_filtered ("Detaching from program: %s %s\n",
3338 exec_file
, target_pid_to_str (inferior_pid
));
3342 signo
= atoi (args
);
3346 unpush_target (&procfs_ops
); /* Pop out of handling an inferior */
3356 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
3357 perror ("procfs: out of memory in 'attach'");
3359 if (!open_procinfo_files (pi
, FD_CTL
))
3361 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3362 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3364 dead_procinfo (pi
, errmsg
, NOKILL
);
3367 /* Stop the process (if it isn't already stopped). */
3368 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3370 pi
->was_stopped
= 1;
3371 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3375 pi
->was_stopped
= 0;
3376 /* Set the process to run again when we close it. */
3377 if (!proc_set_run_on_last_close (pi
))
3378 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3380 /* Now stop the process. */
3381 if (!proc_stop_process (pi
))
3382 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3383 pi
->ignore_next_sigstop
= 1;
3385 /* Save some of the /proc state to be restored if we detach. */
3386 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3387 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3388 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3389 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3390 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
3391 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3393 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
3394 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3396 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3397 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3399 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3400 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3402 /* Let GDB know that the inferior was attached. */
3404 return MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3413 /* Find procinfo for the main process */
3414 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0); /* FIXME: threads */
3416 if (!proc_set_current_signal (pi
, signo
))
3417 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3419 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3420 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3422 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3423 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3425 if (!proc_set_traced_sysentry (pi
, &pi
->saved_entryset
))
3426 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3428 if (!proc_set_traced_sysexit (pi
, &pi
->saved_exitset
))
3429 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3431 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3432 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3434 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3435 if (signo
|| !(pi
->was_stopped
) ||
3436 query ("Was stopped when attached, make it runnable again? "))
3438 /* Clear any pending signal. */
3439 if (!proc_clear_current_fault (pi
))
3440 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3442 if (!proc_set_run_on_last_close (pi
))
3443 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3447 destroy_procinfo (pi
);
3453 * Since the /proc interface cannot give us individual registers,
3454 * we pay no attention to the (regno) argument, and just fetch them all.
3455 * This results in the possibility that we will do unnecessarily many
3456 * fetches, since we may be called repeatedly for individual registers.
3457 * So we cache the results, and mark the cache invalid when the process
3461 /* These could go in a header file, but the many and various
3462 definitions of gregset_t would make it tricky and ugly. Several
3463 different native operating systems (notably Solaris and Linux) have
3464 various different definitions for gregset_t and fpregset_t. We
3465 have been kludging around this problem for a while, it would be
3466 nice if someday we came up with a prettier way of handling it
3469 extern void fill_gregset (gdb_gregset_t
*, int);
3470 extern void fill_fpregset (gdb_fpregset_t
*, int);
3471 extern void supply_gregset (gdb_gregset_t
*);
3472 extern void supply_fpregset (gdb_fpregset_t
*);
3475 procfs_fetch_registers (regno
)
3478 gdb_fpregset_t
*fpregs
;
3479 gdb_gregset_t
*gregs
;
3484 pid
= PIDGET (inferior_pid
);
3485 tid
= TIDGET (inferior_pid
);
3487 /* First look up procinfo for the main process. */
3488 pi
= find_procinfo_or_die (pid
, 0);
3490 /* If the event thread is not the same as GDB's requested thread
3491 (ie. inferior_pid), then look up procinfo for the requested
3494 (tid
!= proc_get_current_thread (pi
)))
3495 pi
= find_procinfo_or_die (pid
, tid
);
3498 error ("procfs: fetch_registers failed to find procinfo for %s",
3499 target_pid_to_str (inferior_pid
));
3501 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3502 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3504 supply_gregset (gregs
);
3506 #if defined (FP0_REGNUM) /* need floating point? */
3507 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3508 regno
== PC_REGNUM
||
3509 (NPC_REGNUM
>= 0 && regno
== NPC_REGNUM
) ||
3510 regno
== FP_REGNUM
||
3512 return; /* not a floating point register */
3514 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3515 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3517 supply_fpregset (fpregs
);
3521 /* Get ready to modify the registers array. On machines which store
3522 individual registers, this doesn't need to do anything. On
3523 machines which store all the registers in one fell swoop, such as
3524 /proc, this makes sure that registers contains all the registers
3525 from the program being debugged. */
3528 procfs_prepare_to_store ()
3530 #ifdef CHILD_PREPARE_TO_STORE
3531 CHILD_PREPARE_TO_STORE ();
3538 * Since the /proc interface will not read individual registers,
3539 * we will cache these requests until the process is resumed, and
3540 * only then write them back to the inferior process.
3542 * FIXME: is that a really bad idea? Have to think about cases
3543 * where writing one register might affect the value of others, etc.
3547 procfs_store_registers (regno
)
3550 gdb_fpregset_t
*fpregs
;
3551 gdb_gregset_t
*gregs
;
3556 pid
= PIDGET (inferior_pid
);
3557 tid
= TIDGET (inferior_pid
);
3559 /* First find procinfo for main process */
3560 pi
= find_procinfo_or_die (pid
, 0);
3562 /* If current lwp for process is not the same as requested thread
3563 (ie. inferior_pid), then find procinfo for the requested thread. */
3566 (tid
!= proc_get_current_thread (pi
)))
3567 pi
= find_procinfo_or_die (pid
, tid
);
3570 error ("procfs: store_registers: failed to find procinfo for %s",
3571 target_pid_to_str (inferior_pid
));
3573 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3574 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3576 fill_gregset (gregs
, regno
);
3577 if (!proc_set_gregs (pi
))
3578 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3580 #if defined (FP0_REGNUM) /* need floating point? */
3581 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3582 regno
== PC_REGNUM
||
3583 (NPC_REGNUM
>= 0 && regno
== NPC_REGNUM
) ||
3584 regno
== FP_REGNUM
||
3586 return; /* not a floating point register */
3588 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3589 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3591 fill_fpregset (fpregs
, regno
);
3592 if (!proc_set_fpregs (pi
))
3593 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3598 * Function: target_wait
3600 * Retrieve the next stop event from the child process.
3601 * If child has not stopped yet, wait for it to stop.
3602 * Translate /proc eventcodes (or possibly wait eventcodes)
3603 * into gdb internal event codes.
3605 * Return: id of process (and possibly thread) that incurred the event.
3606 * event codes are returned thru a pointer parameter.
3610 procfs_wait (pid
, status
)
3612 struct target_waitstatus
*status
;
3614 /* First cut: loosely based on original version 2.1 */
3618 int why
, what
, flags
;
3627 /* Find procinfo for main process */
3628 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
3631 /* We must assume that the status is stale now... */
3632 pi
->status_valid
= 0;
3633 pi
->gregs_valid
= 0;
3634 pi
->fpregs_valid
= 0;
3636 #if 0 /* just try this out... */
3637 flags
= proc_flags (pi
);
3638 why
= proc_why (pi
);
3639 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3640 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3642 /* If child is not stopped, wait for it to stop. */
3643 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3644 !proc_wait_for_stop (pi
))
3646 /* wait_for_stop failed: has the child terminated? */
3647 if (errno
== ENOENT
)
3649 /* /proc file not found; presumably child has terminated. */
3650 retval
= wait (&wstat
); /* "wait" for the child's exit */
3652 if (retval
!= PIDGET (inferior_pid
)) /* wrong child? */
3653 error ("procfs: couldn't stop process %d: wait returned %d\n",
3654 inferior_pid
, retval
);
3655 /* FIXME: might I not just use waitpid?
3656 Or try find_procinfo to see if I know about this child? */
3660 /* Unknown error from wait_for_stop. */
3661 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3666 /* This long block is reached if either:
3667 a) the child was already stopped, or
3668 b) we successfully waited for the child with wait_for_stop.
3669 This block will analyze the /proc status, and translate it
3670 into a waitstatus for GDB.
3672 If we actually had to call wait because the /proc file
3673 is gone (child terminated), then we skip this block,
3674 because we already have a waitstatus. */
3676 flags
= proc_flags (pi
);
3677 why
= proc_why (pi
);
3678 what
= proc_what (pi
);
3680 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3683 /* If it's running async (for single_thread control),
3684 set it back to normal again. */
3685 if (flags
& PR_ASYNC
)
3686 if (!proc_unset_async (pi
))
3687 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3691 proc_prettyprint_why (why
, what
, 1);
3693 /* The 'pid' we will return to GDB is composed of
3694 the process ID plus the lwp ID. */
3695 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3699 wstat
= (what
<< 8) | 0177;
3709 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3710 printf_filtered ("[%s exited]\n",
3711 target_pid_to_str (retval
));
3712 delete_thread (retval
);
3713 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3715 #endif /* _lwp_exit */
3718 /* Handle SYS_exit call only */
3719 /* Stopped at entry to SYS_exit.
3720 Make it runnable, resume it, then use
3721 the wait system call to get its exit code.
3722 Proc_run_process always clears the current
3724 Then return its exit status. */
3725 pi
->status_valid
= 0;
3727 /* FIXME: what we should do is return
3728 TARGET_WAITKIND_SPURIOUS. */
3729 if (!proc_run_process (pi
, 0, 0))
3730 proc_error (pi
, "target_wait, run_process", __LINE__
);
3733 /* Don't call wait: simulate waiting for exit,
3734 return a "success" exit code. Bogus: what if
3735 it returns something else? */
3737 retval
= inferior_pid
; /* ? ? ? */
3741 int temp
= wait (&wstat
);
3743 /* FIXME: shouldn't I make sure I get the right
3744 event from the right process? If (for
3745 instance) I have killed an earlier inferior
3746 process but failed to clean up after it
3747 somehow, I could get its termination event
3750 /* If wait returns -1, that's what we return to GDB. */
3756 printf_filtered ("procfs: trapped on entry to ");
3757 proc_prettyprint_syscall (proc_what (pi
), 0);
3758 printf_filtered ("\n");
3761 long i
, nsysargs
, *sysargs
;
3763 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3764 (sysargs
= proc_sysargs (pi
)) != NULL
)
3766 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3767 for (i
= 0; i
< nsysargs
; i
++)
3768 printf_filtered ("#%ld: 0x%08lx\n",
3776 /* How to exit gracefully, returning "unknown event" */
3777 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3778 return inferior_pid
;
3782 /* How to keep going without returning to wfi: */
3783 target_resume (pid
, 0, TARGET_SIGNAL_0
);
3800 /* Hopefully this is our own "fork-child" execing
3801 the real child. Hoax this event into a trap, and
3802 GDB will see the child about to execute its start
3804 wstat
= (SIGTRAP
<< 8) | 0177;
3806 #ifdef SYS_lwp_create
3807 case SYS_lwp_create
:
3809 #ifdef SYS_lwpcreate
3812 #if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
3814 * This syscall is somewhat like fork/exec.
3815 * We will get the event twice: once for the parent LWP,
3816 * and once for the child. We should already know about
3817 * the parent LWP, but the child will be new to us. So,
3818 * whenever we get this event, if it represents a new
3819 * thread, simply add the thread to the list.
3822 /* If not in procinfo list, add it. */
3823 temp
= proc_get_current_thread (pi
);
3824 if (!find_procinfo (pi
->pid
, temp
))
3825 create_procinfo (pi
->pid
, temp
);
3827 temp
= MERGEPID (pi
->pid
, temp
);
3828 /* If not in GDB's thread list, add it. */
3829 if (!in_thread_list (temp
))
3831 printf_filtered ("[New %s]\n", target_pid_to_str (temp
));
3834 /* Return to WFI, but tell it to immediately resume. */
3835 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3836 return inferior_pid
;
3837 #endif /* _lwp_create */
3845 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3846 printf_filtered ("[%s exited]\n",
3847 target_pid_to_str (retval
));
3848 delete_thread (retval
);
3849 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3851 #endif /* _lwp_exit */
3855 /* Nothing to do here for now. The old procfs
3856 seemed to use this event to handle threads on
3857 older (non-LWP) systems, where I'm assuming that
3858 threads were actually separate processes. Irix,
3859 maybe? Anyway, low priority for now. */
3863 /* FIXME: do we need to handle this? Investigate. */
3867 /* FIXME: see above. */
3870 printf_filtered ("procfs: trapped on exit from ");
3871 proc_prettyprint_syscall (proc_what (pi
), 0);
3872 printf_filtered ("\n");
3875 long i
, nsysargs
, *sysargs
;
3877 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3878 (sysargs
= proc_sysargs (pi
)) != NULL
)
3880 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3881 for (i
= 0; i
< nsysargs
; i
++)
3882 printf_filtered ("#%ld: 0x%08lx\n",
3887 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3888 return inferior_pid
;
3893 wstat
= (SIGSTOP
<< 8) | 0177;
3898 printf_filtered ("Retry #%d:\n", retry
);
3899 pi
->status_valid
= 0;
3904 /* If not in procinfo list, add it. */
3905 temp
= proc_get_current_thread (pi
);
3906 if (!find_procinfo (pi
->pid
, temp
))
3907 create_procinfo (pi
->pid
, temp
);
3909 /* If not in GDB's thread list, add it. */
3910 temp
= MERGEPID (pi
->pid
, temp
);
3911 if (!in_thread_list (temp
))
3913 printf_filtered ("[New %s]\n",
3914 target_pid_to_str (temp
));
3918 status
->kind
= TARGET_WAITKIND_STOPPED
;
3919 status
->value
.sig
= 0;
3924 wstat
= (what
<< 8) | 0177;
3927 switch (what
) { /* FIXME: FAULTED_USE_SIGINFO */
3930 wstat
= (SIGTRAP
<< 8) | 0177;
3935 wstat
= (SIGTRAP
<< 8) | 0177;
3938 /* FIXME: use si_signo where possible. */
3940 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
3943 wstat
= (SIGILL
<< 8) | 0177;
3946 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
3949 wstat
= (SIGTRAP
<< 8) | 0177;
3953 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
3956 wstat
= (SIGSEGV
<< 8) | 0177;
3960 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
3963 wstat
= (SIGFPE
<< 8) | 0177;
3965 case FLTPAGE
: /* Recoverable page fault */
3966 default: /* FIXME: use si_signo if possible for fault */
3968 printf_filtered ("procfs:%d -- ", __LINE__
);
3969 printf_filtered ("child stopped for unknown reason:\n");
3970 proc_prettyprint_why (why
, what
, 1);
3971 error ("... giving up...");
3974 break; /* case PR_FAULTED: */
3975 default: /* switch (why) unmatched */
3976 printf_filtered ("procfs:%d -- ", __LINE__
);
3977 printf_filtered ("child stopped for unknown reason:\n");
3978 proc_prettyprint_why (why
, what
, 1);
3979 error ("... giving up...");
3983 * Got this far without error:
3984 * If retval isn't in the threads database, add it.
3987 retval
!= inferior_pid
&&
3988 !in_thread_list (retval
))
3991 * We have a new thread.
3992 * We need to add it both to GDB's list and to our own.
3993 * If we don't create a procinfo, resume may be unhappy
3996 printf_filtered ("[New %s]\n", target_pid_to_str (retval
));
3997 add_thread (retval
);
3998 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
3999 create_procinfo (PIDGET (retval
), TIDGET (retval
));
4001 /* In addition, it's possible that this is the first
4002 * new thread we've seen, in which case we may not
4003 * have created entries for inferior_pid yet.
4005 if (TIDGET (inferior_pid
) != 0)
4007 if (!in_thread_list (inferior_pid
))
4008 add_thread (inferior_pid
);
4009 if (find_procinfo (PIDGET (inferior_pid
),
4010 TIDGET (inferior_pid
)) == NULL
)
4011 create_procinfo (PIDGET (inferior_pid
),
4012 TIDGET (inferior_pid
));
4016 else /* flags do not indicate STOPPED */
4018 /* surely this can't happen... */
4019 printf_filtered ("procfs:%d -- process not stopped.\n",
4021 proc_prettyprint_flags (flags
, 1);
4022 error ("procfs: ...giving up...");
4027 store_waitstatus (status
, wstat
);
4034 procfs_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
4039 struct target_ops
*target
; /* ignored */
4044 /* Find procinfo for main process */
4045 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4046 if (pi
->as_fd
== 0 &&
4047 open_procinfo_files (pi
, FD_AS
) == 0)
4049 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4053 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4058 PROCFS_NOTE ("write memory: ");
4060 PROCFS_NOTE ("write memory: \n");
4062 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4066 PROCFS_NOTE ("read memory: \n");
4067 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4078 * Function: invalidate_cache
4080 * Called by target_resume before making child runnable.
4081 * Mark cached registers and status's invalid.
4082 * If there are "dirty" caches that need to be written back
4083 * to the child process, do that.
4085 * File descriptors are also cached.
4086 * As they are a limited resource, we cannot hold onto them indefinitely.
4087 * However, as they are expensive to open, we don't want to throw them
4088 * away indescriminately either. As a compromise, we will keep the
4089 * file descriptors for the parent process, but discard any file
4090 * descriptors we may have accumulated for the threads.
4093 * As this function is called by iterate_over_threads, it always
4094 * returns zero (so that iterate_over_threads will keep iterating).
4099 invalidate_cache (parent
, pi
, ptr
)
4105 * About to run the child; invalidate caches and do any other cleanup.
4109 if (pi
->gregs_dirty
)
4110 if (parent
== NULL
||
4111 proc_get_current_thread (parent
) != pi
->tid
)
4112 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4113 proc_warn (pi
, "target_resume, set_gregs",
4116 if (pi
->fpregs_dirty
)
4117 if (parent
== NULL
||
4118 proc_get_current_thread (parent
) != pi
->tid
)
4119 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4120 proc_warn (pi
, "target_resume, set_fpregs",
4127 /* The presence of a parent indicates that this is an LWP.
4128 Close any file descriptors that it might have open.
4129 We don't do this to the master (parent) procinfo. */
4131 close_procinfo_files (pi
);
4133 pi
->gregs_valid
= 0;
4134 pi
->fpregs_valid
= 0;
4136 pi
->gregs_dirty
= 0;
4137 pi
->fpregs_dirty
= 0;
4139 pi
->status_valid
= 0;
4140 pi
->threads_valid
= 0;
4147 * Function: make_signal_thread_runnable
4149 * A callback function for iterate_over_threads.
4150 * Find the asynchronous signal thread, and make it runnable.
4151 * See if that helps matters any.
4155 make_signal_thread_runnable (process
, pi
, ptr
)
4161 if (proc_flags (pi
) & PR_ASLWP
)
4163 if (!proc_run_process (pi
, 0, -1))
4164 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4173 * Function: target_resume
4175 * Make the child process runnable. Normally we will then call
4176 * procfs_wait and wait for it to stop again (unles gdb is async).
4179 * step: if true, then arrange for the child to stop again
4180 * after executing a single instruction.
4181 * signo: if zero, then cancel any pending signal.
4182 * If non-zero, then arrange for the indicated signal
4183 * to be delivered to the child when it runs.
4184 * pid: if -1, then allow any child thread to run.
4185 * if non-zero, then allow only the indicated thread to run.
4186 ******* (not implemented yet)
4190 procfs_resume (pid
, step
, signo
)
4193 enum target_signal signo
;
4195 procinfo
*pi
, *thread
;
4199 prrun.prflags |= PRSVADDR;
4200 prrun.pr_vaddr = $PC; set resume address
4201 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4202 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4203 prrun.prflags |= PRCFAULT; clear current fault.
4205 PRSTRACE and PRSFAULT can be done by other means
4206 (proc_trace_signals, proc_trace_faults)
4207 PRSVADDR is unnecessary.
4208 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4209 This basically leaves PRSTEP and PRCSIG.
4210 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4211 So basically PR_STEP is the sole argument that must be passed
4212 to proc_run_process (for use in the prrun struct by ioctl). */
4214 /* Find procinfo for main process */
4215 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4217 /* First cut: ignore pid argument */
4220 /* Convert signal to host numbering. */
4222 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4225 native_signo
= target_signal_to_host (signo
);
4227 pi
->ignore_next_sigstop
= 0;
4229 /* Running the process voids all cached registers and status. */
4230 /* Void the threads' caches first */
4231 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4232 /* Void the process procinfo's caches. */
4233 invalidate_cache (NULL
, pi
, NULL
);
4237 /* Resume a specific thread, presumably suppressing the others. */
4238 thread
= find_procinfo (PIDGET (pid
), TIDGET (pid
));
4240 warning ("procfs: resume can't find thread %d -- resuming all.",
4244 if (thread
->tid
!= 0)
4246 /* We're to resume a specific thread, and not the others.
4247 * Set the child process's PR_ASYNC flag.
4250 if (!proc_set_async (pi
))
4251 proc_error (pi
, "target_resume, set_async", __LINE__
);
4254 proc_iterate_over_threads (pi
,
4255 make_signal_thread_runnable
,
4258 pi
= thread
; /* substitute the thread's procinfo for run */
4263 if (!proc_run_process (pi
, step
, native_signo
))
4266 warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
4268 proc_error (pi
, "target_resume", __LINE__
);
4273 * Function: register_gdb_signals
4275 * Traverse the list of signals that GDB knows about
4276 * (see "handle" command), and arrange for the target
4277 * to be stopped or not, according to these settings.
4279 * Returns non-zero for success, zero for failure.
4283 register_gdb_signals (pi
, signals
)
4289 for (signo
= 0; signo
< NSIG
; signo
++)
4290 if (signal_stop_state (target_signal_from_host (signo
)) == 0 &&
4291 signal_print_state (target_signal_from_host (signo
)) == 0 &&
4292 signal_pass_state (target_signal_from_host (signo
)) == 1)
4293 prdelset (signals
, signo
);
4295 praddset (signals
, signo
);
4297 return proc_set_traced_signals (pi
, signals
);
4301 * Function: target_notice_signals
4303 * Set up to trace signals in the child process.
4307 procfs_notice_signals (pid
)
4311 procinfo
*pi
= find_procinfo_or_die (PIDGET (pid
), 0);
4313 if (proc_get_traced_signals (pi
, &signals
) &&
4314 register_gdb_signals (pi
, &signals
))
4317 proc_error (pi
, "notice_signals", __LINE__
);
4321 * Function: target_files_info
4323 * Print status information about the child process.
4327 procfs_files_info (ignore
)
4328 struct target_ops
*ignore
;
4330 printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
4331 attach_flag
? "attached": "child",
4332 target_pid_to_str (inferior_pid
));
4336 * Function: target_open
4338 * A dummy: you don't open procfs.
4342 procfs_open (args
, from_tty
)
4346 error ("Use the \"run\" command to start a Unix child process.");
4350 * Function: target_can_run
4352 * This tells GDB that this target vector can be invoked
4353 * for "run" or "attach".
4356 int procfs_suppress_run
= 0; /* Non-zero if procfs should pretend not to
4357 be a runnable target. Used by targets
4358 that can sit atop procfs, such as solaris
4365 /* This variable is controlled by modules that sit atop procfs that
4366 may layer their own process structure atop that provided here.
4367 sol-thread.c does this because of the Solaris two-level thread
4370 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
4372 return !procfs_suppress_run
;
4376 * Function: target_stop
4378 * Stop the child process asynchronously, as when the
4379 * gdb user types control-c or presses a "stop" button.
4381 * Works by sending kill(SIGINT) to the child's process group.
4387 extern pid_t inferior_process_group
;
4389 kill (-inferior_process_group
, SIGINT
);
4393 * Function: unconditionally_kill_inferior
4395 * Make it die. Wait for it to die. Clean up after it.
4396 * Note: this should only be applied to the real process,
4397 * not to an LWP, because of the check for parent-process.
4398 * If we need this to work for an LWP, it needs some more logic.
4402 unconditionally_kill_inferior (pi
)
4407 parent_pid
= proc_parent_pid (pi
);
4408 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4409 /* FIXME: use access functions */
4410 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4411 before the PIOCKILL, otherwise it might generate a corrupted core
4412 file for the inferior. */
4413 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4415 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4418 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4419 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4420 to kill the inferior, otherwise it might remain stopped with a
4422 We do not check the result of the PIOCSSIG, the inferior might have
4425 struct siginfo newsiginfo
;
4427 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4428 newsiginfo
.si_signo
= SIGKILL
;
4429 newsiginfo
.si_code
= 0;
4430 newsiginfo
.si_errno
= 0;
4431 newsiginfo
.si_pid
= getpid ();
4432 newsiginfo
.si_uid
= getuid ();
4433 /* FIXME: use proc_set_current_signal */
4434 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4436 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4437 if (!proc_kill (pi
, SIGKILL
))
4438 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4439 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4440 destroy_procinfo (pi
);
4442 /* If pi is GDB's child, wait for it to die. */
4443 if (parent_pid
== getpid ())
4444 /* FIXME: should we use waitpid to make sure we get the right event?
4445 Should we check the returned event? */
4450 ret
= waitpid (pi
->pid
, &status
, 0);
4458 * Function: target_kill_inferior
4460 * We're done debugging it, and we want it to go away.
4461 * Then we want GDB to forget all about it.
4465 procfs_kill_inferior ()
4467 if (inferior_pid
!= 0) /* ? */
4469 /* Find procinfo for main process */
4470 procinfo
*pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4473 unconditionally_kill_inferior (pi
);
4474 target_mourn_inferior ();
4479 * Function: target_mourn_inferior
4481 * Forget we ever debugged this thing!
4485 procfs_mourn_inferior ()
4489 if (inferior_pid
!= 0)
4491 /* Find procinfo for main process */
4492 pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4494 destroy_procinfo (pi
);
4496 unpush_target (&procfs_ops
);
4497 generic_mourn_inferior ();
4501 * Function: init_inferior
4503 * When GDB forks to create a runnable inferior process,
4504 * this function is called on the parent side of the fork.
4505 * It's job is to do whatever is necessary to make the child
4506 * ready to be debugged, and then wait for the child to synchronize.
4510 procfs_init_inferior (pid
)
4517 /* This routine called on the parent side (GDB side)
4518 after GDB forks the inferior. */
4520 push_target (&procfs_ops
);
4522 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4523 perror ("procfs: out of memory in 'init_inferior'");
4525 if (!open_procinfo_files (pi
, FD_CTL
))
4526 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4530 open_procinfo_files // done
4533 procfs_notice_signals
4540 /* If not stopped yet, wait for it to stop. */
4541 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4542 !(proc_wait_for_stop (pi
)))
4543 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4545 /* Save some of the /proc state to be restored if we detach. */
4546 /* FIXME: Why? In case another debugger was debugging it?
4547 We're it's parent, for Ghu's sake! */
4548 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4549 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4550 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4551 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4552 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4553 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4554 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
4555 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4556 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
4557 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4559 /* Register to trace selected signals in the child. */
4560 prfillset (&signals
);
4561 if (!register_gdb_signals (pi
, &signals
))
4562 proc_error (pi
, "init_inferior, register_signals", __LINE__
);
4564 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4565 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4567 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4568 and possibly even turning ON kill-on-last-close at this point. But
4569 I can't make that change without careful testing which I don't have
4570 time to do right now... */
4571 /* Turn on run-on-last-close flag so that the child
4572 will die if GDB goes away for some reason. */
4573 if (!proc_set_run_on_last_close (pi
))
4574 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4576 /* The 'process ID' we return to GDB is composed of
4577 the actual process ID plus the lwp ID. */
4578 inferior_pid
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
4580 #ifdef START_INFERIOR_TRAPS_EXPECTED
4581 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4583 /* One trap to exec the shell, one to exec the program being debugged. */
4584 startup_inferior (2);
4585 #endif /* START_INFERIOR_TRAPS_EXPECTED */
4589 * Function: set_exec_trap
4591 * When GDB forks to create a new process, this function is called
4592 * on the child side of the fork before GDB exec's the user program.
4593 * Its job is to make the child minimally debuggable, so that the
4594 * parent GDB process can connect to the child and take over.
4595 * This function should do only the minimum to make that possible,
4596 * and to synchronize with the parent process. The parent process
4597 * should take care of the details.
4601 procfs_set_exec_trap ()
4603 /* This routine called on the child side (inferior side)
4604 after GDB forks the inferior. It must use only local variables,
4605 because it may be sharing data space with its parent. */
4610 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4611 perror_with_name ("procfs: create_procinfo failed in child.");
4613 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4615 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4616 gdb_flush (gdb_stderr
);
4617 /* no need to call "dead_procinfo", because we're going to exit. */
4621 #ifdef PRFS_STOPEXEC /* defined on OSF */
4622 /* OSF method for tracing exec syscalls. Quoting:
4623 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4624 exits from exec system calls because of the user level loader. */
4625 /* FIXME: make nice and maybe move into an access function. */
4629 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4631 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4632 gdb_flush (gdb_stderr
);
4635 prfs_flags
|= PRFS_STOPEXEC
;
4637 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4639 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4640 gdb_flush (gdb_stderr
);
4644 #else /* not PRFS_STOPEXEC */
4645 /* Everyone else's (except OSF) method for tracing exec syscalls */
4647 Not all systems with /proc have all the exec* syscalls with the same
4648 names. On the SGI, for example, there is no SYS_exec, but there
4649 *is* a SYS_execv. So, we try to account for that. */
4651 premptyset (&exitset
);
4653 praddset (&exitset
, SYS_exec
);
4656 praddset (&exitset
, SYS_execve
);
4659 praddset (&exitset
, SYS_execv
);
4662 if (!proc_set_traced_sysexit (pi
, &exitset
))
4664 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4665 gdb_flush (gdb_stderr
);
4668 #endif /* PRFS_STOPEXEC */
4670 /* FIXME: should this be done in the parent instead? */
4671 /* Turn off inherit on fork flag so that all grand-children
4672 of gdb start with tracing flags cleared. */
4673 if (!proc_unset_inherit_on_fork (pi
))
4674 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4676 /* Turn off run on last close flag, so that the child process
4677 cannot run away just because we close our handle on it.
4678 We want it to wait for the parent to attach. */
4679 if (!proc_unset_run_on_last_close (pi
))
4680 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4682 /* FIXME: No need to destroy the procinfo --
4683 we have our own address space, and we're about to do an exec! */
4684 /*destroy_procinfo (pi);*/
4688 * Function: create_inferior
4690 * This function is called BEFORE gdb forks the inferior process.
4691 * Its only real responsibility is to set things up for the fork,
4692 * and tell GDB which two functions to call after the fork (one
4693 * for the parent, and one for the child).
4695 * This function does a complicated search for a unix shell program,
4696 * which it then uses to parse arguments and environment variables
4697 * to be sent to the child. I wonder whether this code could not
4698 * be abstracted out and shared with other unix targets such as
4703 procfs_create_inferior (exec_file
, allargs
, env
)
4708 char *shell_file
= getenv ("SHELL");
4710 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4713 /* We will be looking down the PATH to find shell_file. If we
4714 just do this the normal way (via execlp, which operates by
4715 attempting an exec for each element of the PATH until it
4716 finds one which succeeds), then there will be an exec for
4717 each failed attempt, each of which will cause a PR_SYSEXIT
4718 stop, and we won't know how to distinguish the PR_SYSEXIT's
4719 for these failed execs with the ones for successful execs
4720 (whether the exec has succeeded is stored at that time in the
4721 carry bit or some such architecture-specific and
4722 non-ABI-specified place).
4724 So I can't think of anything better than to search the PATH
4725 now. This has several disadvantages: (1) There is a race
4726 condition; if we find a file now and it is deleted before we
4727 exec it, we lose, even if the deletion leaves a valid file
4728 further down in the PATH, (2) there is no way to know exactly
4729 what an executable (in the sense of "capable of being
4730 exec'd") file is. Using access() loses because it may lose
4731 if the caller is the superuser; failing to use it loses if
4732 there are ACLs or some such. */
4736 /* FIXME-maybe: might want "set path" command so user can change what
4737 path is used from within GDB. */
4738 char *path
= getenv ("PATH");
4740 struct stat statbuf
;
4743 path
= "/bin:/usr/bin";
4745 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4746 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4748 p1
= strchr (p
, ':');
4753 strncpy (tryname
, p
, len
);
4754 tryname
[len
] = '\0';
4755 strcat (tryname
, "/");
4756 strcat (tryname
, shell_file
);
4757 if (access (tryname
, X_OK
) < 0)
4759 if (stat (tryname
, &statbuf
) < 0)
4761 if (!S_ISREG (statbuf
.st_mode
))
4762 /* We certainly need to reject directories. I'm not quite
4763 as sure about FIFOs, sockets, etc., but I kind of doubt
4764 that people want to exec() these things. */
4769 /* Not found. This must be an error rather than merely passing
4770 the file to execlp(), because execlp() would try all the
4771 exec()s, causing GDB to get confused. */
4772 error ("procfs:%d -- Can't find shell %s in PATH",
4773 __LINE__
, shell_file
);
4775 shell_file
= tryname
;
4778 fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4779 procfs_init_inferior
, NULL
, shell_file
);
4781 /* We are at the first instruction we care about. */
4782 /* Pedal to the metal... */
4784 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
4788 * Function: notice_thread
4790 * Callback for find_new_threads.
4791 * Calls "add_thread".
4795 procfs_notice_thread (pi
, thread
, ptr
)
4800 int gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4802 if (!in_thread_list (gdb_threadid
))
4803 add_thread (gdb_threadid
);
4809 * Function: target_find_new_threads
4811 * Query all the threads that the target knows about,
4812 * and give them back to GDB to add to its list.
4816 procfs_find_new_threads ()
4820 /* Find procinfo for main process */
4821 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4822 proc_update_threads (pi
);
4823 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4827 * Function: target_thread_alive
4829 * Return true if the thread is still 'alive'.
4831 * This guy doesn't really seem to be doing his job.
4832 * Got to investigate how to tell when a thread is really gone.
4836 procfs_thread_alive (pid
)
4842 proc
= PIDGET (pid
);
4843 thread
= TIDGET (pid
);
4844 /* If I don't know it, it ain't alive! */
4845 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4848 /* If I can't get its status, it ain't alive!
4849 What's more, I need to forget about it! */
4850 if (!proc_get_status (pi
))
4852 destroy_procinfo (pi
);
4855 /* I couldn't have got its status if it weren't alive, so it's alive. */
4860 * Function: target_pid_to_str
4862 * Return a string to be used to identify the thread in
4863 * the "info threads" display.
4867 procfs_pid_to_str (pid
)
4870 static char buf
[80];
4874 proc
= PIDGET (pid
);
4875 thread
= TIDGET (pid
);
4876 pi
= find_procinfo (proc
, thread
);
4879 sprintf (buf
, "Process %d", proc
);
4881 sprintf (buf
, "LWP %d", thread
);
4886 * Function: procfs_set_watchpoint
4887 * Insert a watchpoint
4891 procfs_set_watchpoint (pid
, addr
, len
, rwflag
, after
)
4902 pi
= find_procinfo_or_die (pid
== -1 ?
4903 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4905 /* Translate from GDB's flags to /proc's */
4906 if (len
> 0) /* len == 0 means delete watchpoint */
4908 switch (rwflag
) { /* FIXME: need an enum! */
4909 case hw_write
: /* default watchpoint (write) */
4910 pflags
= WRITE_WATCHFLAG
;
4912 case hw_read
: /* read watchpoint */
4913 pflags
= READ_WATCHFLAG
;
4915 case hw_access
: /* access watchpoint */
4916 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
4918 case hw_execute
: /* execution HW breakpoint */
4919 pflags
= EXEC_WATCHFLAG
;
4921 default: /* Something weird. Return error. */
4924 if (after
) /* Stop after r/w access is completed. */
4925 pflags
|= AFTER_WATCHFLAG
;
4928 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
4930 if (errno
== E2BIG
) /* Typical error for no resources */
4931 return -1; /* fail */
4932 /* GDB may try to remove the same watchpoint twice.
4933 If a remove request returns no match, don't error. */
4934 if (errno
== ESRCH
&& len
== 0)
4935 return 0; /* ignore */
4936 proc_error (pi
, "set_watchpoint", __LINE__
);
4943 * Function: stopped_by_watchpoint
4945 * Returns non-zero if process is stopped on a hardware watchpoint fault,
4946 * else returns zero.
4950 procfs_stopped_by_watchpoint (pid
)
4955 pi
= find_procinfo_or_die (pid
== -1 ?
4956 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4957 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
4959 if (proc_why (pi
) == PR_FAULTED
)
4962 if (proc_what (pi
) == FLTWATCH
)
4966 if (proc_what (pi
) == FLTKWATCH
)
4974 #ifdef TM_I386SOL2_H
4976 * Function: procfs_find_LDT_entry
4979 * int pid; // The GDB-style pid-plus-LWP.
4982 * pointer to the corresponding LDT entry.
4986 procfs_find_LDT_entry (pid
)
4989 gdb_gregset_t
*gregs
;
4993 /* Find procinfo for the lwp. */
4994 if ((pi
= find_procinfo (PIDGET (pid
), TIDGET (pid
))) == NULL
)
4996 warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
5000 /* get its general registers. */
5001 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
5003 warning ("procfs_find_LDT_entry: could not read gregs for %d.",
5007 /* Now extract the GS register's lower 16 bits. */
5008 key
= (*gregs
)[GS
] & 0xffff;
5010 /* Find the matching entry and return it. */
5011 return proc_get_LDT_entry (pi
, key
);
5013 #endif /* TM_I386SOL2_H */
5018 info_proc_cmd (args
, from_tty
)
5022 struct cleanup
*old_chain
;
5023 procinfo
*process
= NULL
;
5024 procinfo
*thread
= NULL
;
5030 old_chain
= make_cleanup (null_cleanup
, 0);
5033 if ((argv
= buildargv (args
)) == NULL
)
5036 make_cleanup ((make_cleanup_func
) freeargv
, argv
);
5038 while (argv
!= NULL
&& *argv
!= NULL
)
5040 if (isdigit (argv
[0][0]))
5042 pid
= strtoul (argv
[0], &tmp
, 10);
5044 tid
= strtoul (++tmp
, NULL
, 10);
5046 else if (argv
[0][0] == '/')
5048 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5057 pid
= PIDGET (inferior_pid
);
5059 error ("No current process: you must name one.");
5062 /* Have pid, will travel.
5063 First see if it's a process we're already debugging. */
5064 process
= find_procinfo (pid
, 0);
5065 if (process
== NULL
)
5067 /* No. So open a procinfo for it, but
5068 remember to close it again when finished. */
5069 process
= create_procinfo (pid
, 0);
5070 make_cleanup ((make_cleanup_func
) destroy_procinfo
, process
);
5071 if (!open_procinfo_files (process
, FD_CTL
))
5072 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5076 thread
= create_procinfo (pid
, tid
);
5080 printf_filtered ("process %d flags:\n", process
->pid
);
5081 proc_prettyprint_flags (proc_flags (process
), 1);
5082 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5083 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5084 if (proc_get_nthreads (process
) > 1)
5085 printf_filtered ("Process has %d threads.\n",
5086 proc_get_nthreads (process
));
5090 printf_filtered ("thread %d flags:\n", thread
->tid
);
5091 proc_prettyprint_flags (proc_flags (thread
), 1);
5092 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5093 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5096 do_cleanups (old_chain
);
5100 proc_trace_syscalls (args
, from_tty
, entry_or_exit
, mode
)
5110 if (inferior_pid
<= 0)
5111 error ("you must be debugging a process to use this command.");
5113 if (args
== NULL
|| args
[0] == 0)
5114 error_no_arg ("system call to trace");
5116 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
5117 if (isdigit (args
[0]))
5119 syscallnum
= atoi (args
);
5120 if (entry_or_exit
== PR_SYSENTRY
)
5121 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5123 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5126 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5128 if (mode
== FLAG_SET
)
5129 praddset (sysset
, syscallnum
);
5131 prdelset (sysset
, syscallnum
);
5133 if (entry_or_exit
== PR_SYSENTRY
)
5135 if (!proc_set_traced_sysentry (pi
, sysset
))
5136 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5140 if (!proc_set_traced_sysexit (pi
, sysset
))
5141 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5147 proc_trace_sysentry_cmd (args
, from_tty
)
5151 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5155 proc_trace_sysexit_cmd (args
, from_tty
)
5159 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5163 proc_untrace_sysentry_cmd (args
, from_tty
)
5167 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5171 proc_untrace_sysexit_cmd (args
, from_tty
)
5175 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5180 _initialize_procfs ()
5183 add_target (&procfs_ops
);
5184 add_info ("proc", info_proc_cmd
,
5185 "Show /proc process information about any running process.\
5186 Default is the process being debugged.");
5187 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5188 "Give a trace of entries into the syscall.");
5189 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5190 "Give a trace of exits from the syscall.");
5191 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5192 "Cancel a trace of entries into the syscall.");
5193 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5194 "Cancel a trace of exits from the syscall.");
5197 /* =================== END, GDB "MODULE" =================== */
5201 /* miscelaneous stubs: */
5202 /* The following satisfy a few random symbols mostly created by */
5203 /* the solaris threads implementation, which I will chase down */
5207 * Return a pid for which we guarantee
5208 * we will be able to find a 'live' procinfo.
5212 procfs_first_available ()
5215 return procinfo_list
->pid
;