1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 Copyright 1999-2000 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 "gdb_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. */
90 #include "proc-utils.h"
92 /* Prototypes for supply_gregset etc. */
95 /* =================== TARGET_OPS "MODULE" =================== */
98 * This module defines the GDB target vector and its methods.
101 static void procfs_open (char *, int);
102 static void procfs_attach (char *, int);
103 static void procfs_detach (char *, int);
104 static void procfs_resume (int, int, enum target_signal
);
105 static int procfs_can_run (void);
106 static void procfs_stop (void);
107 static void procfs_files_info (struct target_ops
*);
108 static void procfs_fetch_registers (int);
109 static void procfs_store_registers (int);
110 static void procfs_notice_signals (int);
111 static void procfs_prepare_to_store (void);
112 static void procfs_kill_inferior (void);
113 static void procfs_mourn_inferior (void);
114 static void procfs_create_inferior (char *, char *, char **);
115 static int procfs_wait (int, struct target_waitstatus
*);
116 static int procfs_xfer_memory (CORE_ADDR
,
117 char *, int, int, struct target_ops
*);
119 static int procfs_thread_alive (int);
121 void procfs_find_new_threads (void);
122 char *procfs_pid_to_str (int);
124 struct target_ops procfs_ops
; /* the target vector */
127 init_procfs_ops (void)
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 */
249 /* Provide default composite pid manipulation macros for systems that
250 don't have threads. */
253 #define PIDGET(PID) (PID)
254 #define TIDGET(PID) (PID)
257 #define MERGEPID(PID, TID) (PID)
260 typedef struct procinfo
{
261 struct procinfo
*next
;
262 int pid
; /* Process ID */
263 int tid
; /* Thread/LWP id */
267 int ignore_next_sigstop
;
269 /* The following four fd fields may be identical, or may contain
270 several different fd's, depending on the version of /proc
271 (old ioctl or new read/write). */
273 int ctl_fd
; /* File descriptor for /proc control file */
275 * The next three file descriptors are actually only needed in the
276 * read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
277 * However, to avoid a bunch of #ifdefs in the code, we will use
278 * them uniformly by (in the case of the ioctl single-file-descriptor
279 * implementation) filling them with copies of the control fd.
281 int status_fd
; /* File descriptor for /proc status file */
282 int as_fd
; /* File descriptor for /proc as file */
284 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
286 fltset_t saved_fltset
; /* Saved traced hardware fault set */
287 sigset_t saved_sigset
; /* Saved traced signal set */
288 sigset_t saved_sighold
; /* Saved held signal set */
289 sysset_t saved_exitset
; /* Saved traced system call exit set */
290 sysset_t saved_entryset
; /* Saved traced system call entry set */
292 gdb_prstatus_t prstatus
; /* Current process status info */
295 gdb_fpregset_t fpregset
; /* Current floating point registers */
298 struct procinfo
*thread_list
;
300 int status_valid
: 1;
302 int fpregs_valid
: 1;
303 int threads_valid
: 1;
306 static char errmsg
[128]; /* shared error msg buffer */
308 /* Function prototypes for procinfo module: */
310 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
311 static procinfo
*find_procinfo (int pid
, int tid
);
312 static procinfo
*create_procinfo (int pid
, int tid
);
313 static void destroy_procinfo (procinfo
* p
);
314 static void do_destroy_procinfo_cleanup (void *);
315 static void dead_procinfo (procinfo
* p
, char *msg
, int killp
);
316 static int open_procinfo_files (procinfo
* p
, int which
);
317 static void close_procinfo_files (procinfo
* p
);
319 /* The head of the procinfo list: */
320 static procinfo
* procinfo_list
;
323 * Function: find_procinfo
325 * Search the procinfo list.
327 * Returns: pointer to procinfo, or NULL if not found.
331 find_procinfo (int pid
, int tid
)
335 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
342 /* Don't check threads_valid. If we're updating the
343 thread_list, we want to find whatever threads are already
344 here. This means that in general it is the caller's
345 responsibility to check threads_valid and update before
346 calling find_procinfo, if the caller wants to find a new
349 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
358 * Function: find_procinfo_or_die
360 * Calls find_procinfo, but errors on failure.
364 find_procinfo_or_die (int pid
, int tid
)
366 procinfo
*pi
= find_procinfo (pid
, tid
);
371 error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",
374 error ("procfs: couldn't find pid %d in procinfo list.", pid
);
380 * Function: open_procinfo_files
382 * Open the file descriptor for the process or LWP.
383 * ifdef NEW_PROC_API, we only open the control file descriptor;
384 * the others are opened lazily as needed.
385 * else (if not NEW_PROC_API), there is only one real
386 * file descriptor, but we keep multiple copies of it so that
387 * the code that uses them does not have to be #ifdef'd.
389 * Return: file descriptor, or zero for failure.
392 enum { FD_CTL
, FD_STATUS
, FD_AS
};
395 open_procinfo_files (procinfo
*pi
, int which
)
398 char tmp
[MAX_PROC_NAME_SIZE
];
403 * This function is getting ALMOST long enough to break up into several.
404 * Here is some rationale:
406 * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
407 * There are several file descriptors that may need to be open
408 * for any given process or LWP. The ones we're intereted in are:
409 * - control (ctl) write-only change the state
410 * - status (status) read-only query the state
411 * - address space (as) read/write access memory
412 * - map (map) read-only virtual addr map
413 * Most of these are opened lazily as they are needed.
414 * The pathnames for the 'files' for an LWP look slightly
415 * different from those of a first-class process:
416 * Pathnames for a process (<proc-id>):
417 * /proc/<proc-id>/ctl
418 * /proc/<proc-id>/status
420 * /proc/<proc-id>/map
421 * Pathnames for an LWP (lwp-id):
422 * /proc/<proc-id>/lwp/<lwp-id>/lwpctl
423 * /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
424 * An LWP has no map or address space file descriptor, since
425 * the memory map and address space are shared by all LWPs.
427 * Everyone else (Solaris 2.5, Irix, OSF)
428 * There is only one file descriptor for each process or LWP.
429 * For convenience, we copy the same file descriptor into all
430 * three fields of the procinfo struct (ctl_fd, status_fd, and
431 * as_fd, see NEW_PROC_API above) so that code that uses them
432 * doesn't need any #ifdef's.
437 * Each LWP has an independent file descriptor, but these
438 * are not obtained via the 'open' system call like the rest:
439 * instead, they're obtained thru an ioctl call (PIOCOPENLWP)
440 * to the file descriptor of the parent process.
443 * These do not even have their own independent file descriptor.
444 * All operations are carried out on the file descriptor of the
445 * parent process. Therefore we just call open again for each
446 * thread, getting a new handle for the same 'file'.
451 * In this case, there are several different file descriptors that
452 * we might be asked to open. The control file descriptor will be
453 * opened early, but the others will be opened lazily as they are
457 strcpy (tmp
, pi
->pathname
);
458 switch (which
) { /* which file descriptor to open? */
461 strcat (tmp
, "/lwpctl");
463 strcat (tmp
, "/ctl");
464 fd
= open (tmp
, O_WRONLY
);
471 return 0; /* there is no 'as' file descriptor for an lwp */
473 fd
= open (tmp
, O_RDWR
);
480 strcat (tmp
, "/lwpstatus");
482 strcat (tmp
, "/status");
483 fd
= open (tmp
, O_RDONLY
);
489 return 0; /* unknown file descriptor */
491 #else /* not NEW_PROC_API */
493 * In this case, there is only one file descriptor for each procinfo
494 * (ie. each process or LWP). In fact, only the file descriptor for
495 * the process can actually be opened by an 'open' system call.
496 * The ones for the LWPs have to be obtained thru an IOCTL call
497 * on the process's file descriptor.
499 * For convenience, we copy each procinfo's single file descriptor
500 * into all of the fields occupied by the several file descriptors
501 * of the NEW_PROC_API implementation. That way, the code that uses
502 * them can be written without ifdefs.
506 #ifdef PIOCTSTATUS /* OSF */
507 if ((fd
= open (pi
->pathname
, O_RDWR
)) == 0) /* Only one FD; just open it. */
509 #else /* Sol 2.5, Irix, other? */
510 if (pi
->tid
== 0) /* Master procinfo for the process */
512 fd
= open (pi
->pathname
, O_RDWR
);
516 else /* LWP thread procinfo */
518 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
522 /* Find the procinfo for the entire process. */
523 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
526 /* Now obtain the file descriptor for the LWP. */
527 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) <= 0)
529 #else /* Irix, other? */
530 return 0; /* Don't know how to open threads */
531 #endif /* Sol 2.5 PIOCOPENLWP */
533 #endif /* OSF PIOCTSTATUS */
534 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
535 #endif /* NEW_PROC_API */
537 return 1; /* success */
541 * Function: create_procinfo
543 * Allocate a data structure and link it into the procinfo list.
544 * (First tries to find a pre-existing one (FIXME: why?)
546 * Return: pointer to new procinfo struct.
550 create_procinfo (int pid
, int tid
)
552 procinfo
*pi
, *parent
;
554 if ((pi
= find_procinfo (pid
, tid
)))
555 return pi
; /* Already exists, nothing to do. */
557 /* find parent before doing malloc, to save having to cleanup */
559 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
561 doesn't exist yet? */
563 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
564 memset (pi
, 0, sizeof (procinfo
));
568 /* Chain into list. */
571 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
572 pi
->next
= procinfo_list
;
578 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
580 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
582 pi
->next
= parent
->thread_list
;
583 parent
->thread_list
= pi
;
589 * Function: close_procinfo_files
591 * Close all file descriptors associated with the procinfo
595 close_procinfo_files (procinfo
*pi
)
602 if (pi
->status_fd
> 0)
603 close (pi
->status_fd
);
605 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
609 * Function: destroy_procinfo
611 * Destructor function. Close, unlink and deallocate the object.
615 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
619 /* Step one: unlink the procinfo from its list */
623 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
626 ptr
->next
= pi
->next
;
630 /* Step two: close any open file descriptors */
631 close_procinfo_files (pi
);
633 /* Step three: free the memory. */
638 destroy_procinfo (procinfo
*pi
)
642 if (pi
->tid
!= 0) /* destroy a thread procinfo */
644 tmp
= find_procinfo (pi
->pid
, 0); /* find the parent process */
645 destroy_one_procinfo (&tmp
->thread_list
, pi
);
647 else /* destroy a process procinfo and all its threads */
649 /* First destroy the children, if any; */
650 while (pi
->thread_list
!= NULL
)
651 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
652 /* Then destroy the parent. Genocide!!! */
653 destroy_one_procinfo (&procinfo_list
, pi
);
658 do_destroy_procinfo_cleanup (void *pi
)
660 destroy_procinfo (pi
);
663 enum { NOKILL
, KILL
};
666 * Function: dead_procinfo
668 * To be called on a non_recoverable error for a procinfo.
669 * Prints error messages, optionally sends a SIGKILL to the process,
670 * then destroys the data structure.
674 dead_procinfo (procinfo
*pi
, char *msg
, int kill_p
)
680 print_sys_errmsg (pi
->pathname
, errno
);
684 sprintf (procfile
, "process %d", pi
->pid
);
685 print_sys_errmsg (procfile
, errno
);
688 kill (pi
->pid
, SIGKILL
);
690 destroy_procinfo (pi
);
694 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
696 /* =================== /proc "MODULE" =================== */
699 * This "module" is the interface layer between the /proc system API
700 * and the gdb target vector functions. This layer consists of
701 * access functions that encapsulate each of the basic operations
702 * that we need to use from the /proc API.
704 * The main motivation for this layer is to hide the fact that
705 * there are two very different implementations of the /proc API.
706 * Rather than have a bunch of #ifdefs all thru the gdb target vector
707 * functions, we do our best to hide them all in here.
710 int proc_get_status (procinfo
* pi
);
711 long proc_flags (procinfo
* pi
);
712 int proc_why (procinfo
* pi
);
713 int proc_what (procinfo
* pi
);
714 int proc_set_run_on_last_close (procinfo
* pi
);
715 int proc_unset_run_on_last_close (procinfo
* pi
);
716 int proc_set_inherit_on_fork (procinfo
* pi
);
717 int proc_unset_inherit_on_fork (procinfo
* pi
);
718 int proc_set_async (procinfo
* pi
);
719 int proc_unset_async (procinfo
* pi
);
720 int proc_stop_process (procinfo
* pi
);
721 int proc_trace_signal (procinfo
* pi
, int signo
);
722 int proc_ignore_signal (procinfo
* pi
, int signo
);
723 int proc_clear_current_fault (procinfo
* pi
);
724 int proc_set_current_signal (procinfo
* pi
, int signo
);
725 int proc_clear_current_signal (procinfo
* pi
);
726 int proc_set_gregs (procinfo
* pi
);
727 int proc_set_fpregs (procinfo
* pi
);
728 int proc_wait_for_stop (procinfo
* pi
);
729 int proc_run_process (procinfo
* pi
, int step
, int signo
);
730 int proc_kill (procinfo
* pi
, int signo
);
731 int proc_parent_pid (procinfo
* pi
);
732 int proc_get_nthreads (procinfo
* pi
);
733 int proc_get_current_thread (procinfo
* pi
);
734 int proc_set_held_signals (procinfo
* pi
, sigset_t
* sighold
);
735 int proc_set_traced_sysexit (procinfo
* pi
, sysset_t
* sysset
);
736 int proc_set_traced_sysentry (procinfo
* pi
, sysset_t
* sysset
);
737 int proc_set_traced_faults (procinfo
* pi
, fltset_t
* fltset
);
738 int proc_set_traced_signals (procinfo
* pi
, sigset_t
* sigset
);
740 int proc_update_threads (procinfo
* pi
);
741 int proc_iterate_over_threads (procinfo
* pi
,
742 int (*func
) (procinfo
*, procinfo
*, void *),
745 gdb_gregset_t
*proc_get_gregs (procinfo
* pi
);
746 gdb_fpregset_t
*proc_get_fpregs (procinfo
* pi
);
747 sysset_t
*proc_get_traced_sysexit (procinfo
* pi
, sysset_t
* save
);
748 sysset_t
*proc_get_traced_sysentry (procinfo
* pi
, sysset_t
* save
);
749 fltset_t
*proc_get_traced_faults (procinfo
* pi
, fltset_t
* save
);
750 sigset_t
*proc_get_traced_signals (procinfo
* pi
, sigset_t
* save
);
751 sigset_t
*proc_get_held_signals (procinfo
* pi
, sigset_t
* save
);
752 sigset_t
*proc_get_pending_signals (procinfo
* pi
, sigset_t
* save
);
753 struct sigaction
*proc_get_signal_actions (procinfo
* pi
,
754 struct sigaction
*save
);
756 void proc_warn (procinfo
* pi
, char *func
, int line
);
757 void proc_error (procinfo
* pi
, char *func
, int line
);
760 proc_warn (procinfo
*pi
, char *func
, int line
)
762 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
763 print_sys_errmsg (errmsg
, errno
);
767 proc_error (procinfo
*pi
, char *func
, int line
)
769 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
770 perror_with_name (errmsg
);
774 * Function: proc_get_status
776 * Updates the status struct in the procinfo.
777 * There is a 'valid' flag, to let other functions know when
778 * this function needs to be called (so the status is only
779 * read when it is needed). The status file descriptor is
780 * also only opened when it is needed.
782 * Return: non-zero for success, zero for failure.
786 proc_get_status (procinfo
*pi
)
788 /* Status file descriptor is opened "lazily" */
789 if (pi
->status_fd
== 0 &&
790 open_procinfo_files (pi
, FD_STATUS
) == 0)
792 pi
->status_valid
= 0;
797 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
798 pi
->status_valid
= 0; /* fail */
801 /* Sigh... I have to read a different data structure,
802 depending on whether this is a main process or an LWP. */
804 pi
->status_valid
= (read (pi
->status_fd
,
805 (char *) &pi
->prstatus
.pr_lwp
,
806 sizeof (lwpstatus_t
))
807 == sizeof (lwpstatus_t
));
810 pi
->status_valid
= (read (pi
->status_fd
,
811 (char *) &pi
->prstatus
,
812 sizeof (gdb_prstatus_t
))
813 == sizeof (gdb_prstatus_t
));
814 #if 0 /*def UNIXWARE*/
815 if (pi
->status_valid
&&
816 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
817 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
818 /* Unixware peculiarity -- read the damn thing again! */
819 pi
->status_valid
= (read (pi
->status_fd
,
820 (char *) &pi
->prstatus
,
821 sizeof (gdb_prstatus_t
))
822 == sizeof (gdb_prstatus_t
));
823 #endif /* UNIXWARE */
826 #else /* ioctl method */
827 #ifdef PIOCTSTATUS /* osf */
828 if (pi
->tid
== 0) /* main process */
830 /* Just read the danged status. Now isn't that simple? */
832 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
839 tid_t pr_error_thread
;
840 struct prstatus status
;
843 thread_status
.pr_count
= 1;
844 thread_status
.status
.pr_tid
= pi
->tid
;
845 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
848 memcpy (&pi
->prstatus
, &thread_status
.status
,
849 sizeof (pi
->prstatus
));
850 pi
->status_valid
= 1;
854 /* Just read the danged status. Now isn't that simple? */
855 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
859 if (pi
->status_valid
)
861 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
864 proc_get_current_thread (pi
));
867 /* The status struct includes general regs, so mark them valid too */
868 pi
->gregs_valid
= pi
->status_valid
;
870 /* In the read/write multiple-fd model,
871 the status struct includes the fp regs too, so mark them valid too */
872 pi
->fpregs_valid
= pi
->status_valid
;
874 return pi
->status_valid
; /* True if success, false if failure. */
878 * Function: proc_flags
880 * returns the process flags (pr_flags field).
884 proc_flags (procinfo
*pi
)
886 if (!pi
->status_valid
)
887 if (!proc_get_status (pi
))
888 return 0; /* FIXME: not a good failure value (but what is?) */
892 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
893 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
894 The two sets of flags don't overlap. */
895 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
897 return pi
->prstatus
.pr_lwp
.pr_flags
;
900 return pi
->prstatus
.pr_flags
;
907 * returns the pr_why field (why the process stopped).
911 proc_why (procinfo
*pi
)
913 if (!pi
->status_valid
)
914 if (!proc_get_status (pi
))
915 return 0; /* FIXME: not a good failure value (but what is?) */
918 return pi
->prstatus
.pr_lwp
.pr_why
;
920 return pi
->prstatus
.pr_why
;
925 * Function: proc_what
927 * returns the pr_what field (details of why the process stopped).
931 proc_what (procinfo
*pi
)
933 if (!pi
->status_valid
)
934 if (!proc_get_status (pi
))
935 return 0; /* FIXME: not a good failure value (but what is?) */
938 return pi
->prstatus
.pr_lwp
.pr_what
;
940 return pi
->prstatus
.pr_what
;
944 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
946 * Function: proc_nsysarg
948 * returns the pr_nsysarg field (number of args to the current syscall).
952 proc_nsysarg (procinfo
*pi
)
954 if (!pi
->status_valid
)
955 if (!proc_get_status (pi
))
959 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
961 return pi
->prstatus
.pr_nsysarg
;
966 * Function: proc_sysargs
968 * returns the pr_sysarg field (pointer to the arguments of current syscall).
972 proc_sysargs (procinfo
*pi
)
974 if (!pi
->status_valid
)
975 if (!proc_get_status (pi
))
979 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
981 return (long *) &pi
->prstatus
.pr_sysarg
;
986 * Function: proc_syscall
988 * returns the pr_syscall field (id of current syscall if we are in one).
992 proc_syscall (procinfo
*pi
)
994 if (!pi
->status_valid
)
995 if (!proc_get_status (pi
))
999 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1001 return pi
->prstatus
.pr_syscall
;
1004 #endif /* PIOCSSPCACT */
1007 * Function: proc_cursig:
1009 * returns the pr_cursig field (current signal).
1013 proc_cursig (struct procinfo
*pi
)
1015 if (!pi
->status_valid
)
1016 if (!proc_get_status (pi
))
1017 return 0; /* FIXME: not a good failure value (but what is?) */
1020 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1022 return pi
->prstatus
.pr_cursig
;
1027 * Function: proc_modify_flag
1029 * === I appologize for the messiness of this function.
1030 * === This is an area where the different versions of
1031 * === /proc are more inconsistent than usual. MVS
1033 * Set or reset any of the following process flags:
1034 * PR_FORK -- forked child will inherit trace flags
1035 * PR_RLC -- traced process runs when last /proc file closed.
1036 * PR_KLC -- traced process is killed when last /proc file closed.
1037 * PR_ASYNC -- LWP's get to run/stop independently.
1039 * There are three methods for doing this function:
1040 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1042 * 2) Middle: PIOCSET/PIOCRESET
1044 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1047 * Note: Irix does not define PR_ASYNC.
1048 * Note: OSF does not define PR_KLC.
1049 * Note: OSF is the only one that can ONLY use the oldest method.
1052 * pi -- the procinfo
1053 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1054 * mode -- 1 for set, 0 for reset.
1056 * Returns non-zero for success, zero for failure.
1059 enum { FLAG_RESET
, FLAG_SET
};
1062 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
1064 long win
= 0; /* default to fail */
1067 * These operations affect the process as a whole, and applying
1068 * them to an individual LWP has the same meaning as applying them
1069 * to the main process. Therefore, if we're ever called with a
1070 * pointer to an LWP's procinfo, let's substitute the process's
1071 * procinfo and avoid opening the LWP's file descriptor
1076 pi
= find_procinfo_or_die (pi
->pid
, 0);
1078 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
1079 /* First normalize the PCUNSET/PCRESET command opcode
1080 (which for no obvious reason has a different definition
1081 from one operating system to the next...) */
1083 #define GDBRESET PCUNSET
1086 #define GDBRESET PCRESET
1091 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC) */
1093 else /* Reset the flag */
1097 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1100 #ifdef PIOCSET /* Irix/Sol5 method */
1101 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
1103 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1105 else /* Reset the flag */
1107 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1111 #ifdef PIOCSRLC /* Oldest method: OSF */
1114 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1116 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1118 else /* Clear run-on-last-close */
1120 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1124 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1126 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1128 else /* Clear inherit-on-fork */
1130 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1134 win
= 0; /* fail -- unknown flag (can't do PR_ASYNC) */
1141 /* The above operation renders the procinfo's cached pstatus obsolete. */
1142 pi
->status_valid
= 0;
1145 warning ("procfs: modify_flag failed to turn %s %s",
1146 flag
== PR_FORK
? "PR_FORK" :
1147 flag
== PR_RLC
? "PR_RLC" :
1149 flag
== PR_ASYNC
? "PR_ASYNC" :
1152 flag
== PR_KLC
? "PR_KLC" :
1155 mode
== FLAG_RESET
? "off" : "on");
1161 * Function: proc_set_run_on_last_close
1163 * Set the run_on_last_close flag.
1164 * Process with all threads will become runnable
1165 * when debugger closes all /proc fds.
1167 * Returns non-zero for success, zero for failure.
1171 proc_set_run_on_last_close (procinfo
*pi
)
1173 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1177 * Function: proc_unset_run_on_last_close
1179 * Reset the run_on_last_close flag.
1180 * Process will NOT become runnable
1181 * when debugger closes its file handles.
1183 * Returns non-zero for success, zero for failure.
1187 proc_unset_run_on_last_close (procinfo
*pi
)
1189 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1194 * Function: proc_set_kill_on_last_close
1196 * Set the kill_on_last_close flag.
1197 * Process with all threads will be killed when debugger
1198 * closes all /proc fds (or debugger exits or dies).
1200 * Returns non-zero for success, zero for failure.
1204 proc_set_kill_on_last_close (procinfo
*pi
)
1206 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1210 * Function: proc_unset_kill_on_last_close
1212 * Reset the kill_on_last_close flag.
1213 * Process will NOT be killed when debugger
1214 * closes its file handles (or exits or dies).
1216 * Returns non-zero for success, zero for failure.
1220 proc_unset_kill_on_last_close (procinfo
*pi
)
1222 return proc_modify_flag (pi
, PR_KLC
, FLAG_RESET
);
1227 * Function: proc_set_inherit_on_fork
1229 * Set inherit_on_fork flag.
1230 * If the process forks a child while we are registered for events
1231 * in the parent, then we will also recieve events from the child.
1233 * Returns non-zero for success, zero for failure.
1237 proc_set_inherit_on_fork (procinfo
*pi
)
1239 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1243 * Function: proc_unset_inherit_on_fork
1245 * Reset inherit_on_fork flag.
1246 * If the process forks a child while we are registered for events
1247 * in the parent, then we will NOT recieve events from the child.
1249 * Returns non-zero for success, zero for failure.
1253 proc_unset_inherit_on_fork (procinfo
*pi
)
1255 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1260 * Function: proc_set_async
1262 * Set PR_ASYNC flag.
1263 * If one LWP stops because of a debug event (signal etc.),
1264 * the remaining LWPs will continue to run.
1266 * Returns non-zero for success, zero for failure.
1270 proc_set_async (procinfo
*pi
)
1272 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1276 * Function: proc_unset_async
1278 * Reset PR_ASYNC flag.
1279 * If one LWP stops because of a debug event (signal etc.),
1280 * then all other LWPs will stop as well.
1282 * Returns non-zero for success, zero for failure.
1286 proc_unset_async (procinfo
*pi
)
1288 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1290 #endif /* PR_ASYNC */
1293 * Function: proc_stop_process
1295 * Request the process/LWP to stop. Does not wait.
1296 * Returns non-zero for success, zero for failure.
1300 proc_stop_process (procinfo
*pi
)
1305 * We might conceivably apply this operation to an LWP, and
1306 * the LWP's ctl file descriptor might not be open.
1309 if (pi
->ctl_fd
== 0 &&
1310 open_procinfo_files (pi
, FD_CTL
) == 0)
1316 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1317 #else /* ioctl method */
1318 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1319 /* Note: the call also reads the prstatus. */
1322 pi
->status_valid
= 1;
1323 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1326 proc_get_current_thread (pi
));
1335 * Function: proc_wait_for_stop
1337 * Wait for the process or LWP to stop (block until it does).
1338 * Returns non-zero for success, zero for failure.
1342 proc_wait_for_stop (procinfo
*pi
)
1347 * We should never have to apply this operation to any procinfo
1348 * except the one for the main process. If that ever changes
1349 * for any reason, then take out the following clause and
1350 * replace it with one that makes sure the ctl_fd is open.
1354 pi
= find_procinfo_or_die (pi
->pid
, 0);
1359 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1360 /* We been runnin' and we stopped -- need to update status. */
1361 pi
->status_valid
= 0;
1363 #else /* ioctl method */
1364 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1365 /* Above call also refreshes the prstatus. */
1368 pi
->status_valid
= 1;
1369 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1372 proc_get_current_thread (pi
));
1380 * Function: proc_run_process
1382 * Make the process or LWP runnable.
1383 * Options (not all are implemented):
1385 * - clear current fault
1386 * - clear current signal
1387 * - abort the current system call
1388 * - stop as soon as finished with system call
1389 * - (ioctl): set traced signal set
1390 * - (ioctl): set held signal set
1391 * - (ioctl): set traced fault set
1392 * - (ioctl): set start pc (vaddr)
1393 * Always clear the current fault.
1394 * Clear the current signal if 'signo' is zero.
1397 * pi the process or LWP to operate on.
1398 * step if true, set the process or LWP to trap after one instr.
1399 * signo if zero, clear the current signal if any.
1400 * if non-zero, set the current signal to this one.
1402 * Returns non-zero for success, zero for failure.
1406 proc_run_process (procinfo
*pi
, int step
, int signo
)
1412 * We will probably have to apply this operation to individual threads,
1413 * so make sure the control file descriptor is open.
1416 if (pi
->ctl_fd
== 0 &&
1417 open_procinfo_files (pi
, FD_CTL
) == 0)
1422 runflags
= PRCFAULT
; /* always clear current fault */
1427 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals */
1428 proc_set_current_signal (pi
, signo
);
1436 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1438 #else /* ioctl method */
1442 memset (&prrun
, 0, sizeof (prrun
));
1443 prrun
.pr_flags
= runflags
;
1444 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1452 * Function: proc_set_traced_signals
1454 * Register to trace signals in the process or LWP.
1455 * Returns non-zero for success, zero for failure.
1459 proc_set_traced_signals (procinfo
*pi
, sigset_t
*sigset
)
1464 * We should never have to apply this operation to any procinfo
1465 * except the one for the main process. If that ever changes
1466 * for any reason, then take out the following clause and
1467 * replace it with one that makes sure the ctl_fd is open.
1471 pi
= find_procinfo_or_die (pi
->pid
, 0);
1477 /* Use char array to avoid alignment issues. */
1478 char sigset
[sizeof (sigset_t
)];
1482 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
1484 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1486 #else /* ioctl method */
1487 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1489 /* The above operation renders the procinfo's cached pstatus obsolete. */
1490 pi
->status_valid
= 0;
1493 warning ("procfs: set_traced_signals failed");
1498 * Function: proc_set_traced_faults
1500 * Register to trace hardware faults in the process or LWP.
1501 * Returns non-zero for success, zero for failure.
1505 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1510 * We should never have to apply this operation to any procinfo
1511 * except the one for the main process. If that ever changes
1512 * for any reason, then take out the following clause and
1513 * replace it with one that makes sure the ctl_fd is open.
1517 pi
= find_procinfo_or_die (pi
->pid
, 0);
1523 /* Use char array to avoid alignment issues. */
1524 char fltset
[sizeof (fltset_t
)];
1528 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1530 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1532 #else /* ioctl method */
1533 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1535 /* The above operation renders the procinfo's cached pstatus obsolete. */
1536 pi
->status_valid
= 0;
1542 * Function: proc_set_traced_sysentry
1544 * Register to trace entry to system calls in the process or LWP.
1545 * Returns non-zero for success, zero for failure.
1549 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1554 * We should never have to apply this operation to any procinfo
1555 * except the one for the main process. If that ever changes
1556 * for any reason, then take out the following clause and
1557 * replace it with one that makes sure the ctl_fd is open.
1561 pi
= find_procinfo_or_die (pi
->pid
, 0);
1567 /* Use char array to avoid alignment issues. */
1568 char sysset
[sizeof (sysset_t
)];
1572 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1574 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1576 #else /* ioctl method */
1577 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1579 /* The above operation renders the procinfo's cached pstatus obsolete. */
1580 pi
->status_valid
= 0;
1586 * Function: proc_set_traced_sysexit
1588 * Register to trace exit from system calls in the process or LWP.
1589 * Returns non-zero for success, zero for failure.
1593 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1598 * We should never have to apply this operation to any procinfo
1599 * except the one for the main process. If that ever changes
1600 * for any reason, then take out the following clause and
1601 * replace it with one that makes sure the ctl_fd is open.
1605 pi
= find_procinfo_or_die (pi
->pid
, 0);
1611 /* Use char array to avoid alignment issues. */
1612 char sysset
[sizeof (sysset_t
)];
1616 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1618 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1620 #else /* ioctl method */
1621 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1623 /* The above operation renders the procinfo's cached pstatus obsolete. */
1624 pi
->status_valid
= 0;
1630 * Function: proc_set_held_signals
1632 * Specify the set of blocked / held signals in the process or LWP.
1633 * Returns non-zero for success, zero for failure.
1637 proc_set_held_signals (procinfo
*pi
, sigset_t
*sighold
)
1642 * We should never have to apply this operation to any procinfo
1643 * except the one for the main process. If that ever changes
1644 * for any reason, then take out the following clause and
1645 * replace it with one that makes sure the ctl_fd is open.
1649 pi
= find_procinfo_or_die (pi
->pid
, 0);
1655 /* Use char array to avoid alignment issues. */
1656 char hold
[sizeof (sigset_t
)];
1660 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1661 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1664 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1666 /* The above operation renders the procinfo's cached pstatus obsolete. */
1667 pi
->status_valid
= 0;
1673 * Function: proc_get_pending_signals
1675 * returns the set of signals that are pending in the process or LWP.
1676 * Will also copy the sigset if 'save' is non-zero.
1680 proc_get_pending_signals (procinfo
*pi
, sigset_t
*save
)
1682 sigset_t
*ret
= NULL
;
1685 * We should never have to apply this operation to any procinfo
1686 * except the one for the main process. If that ever changes
1687 * for any reason, then take out the following clause and
1688 * replace it with one that makes sure the ctl_fd is open.
1692 pi
= find_procinfo_or_die (pi
->pid
, 0);
1694 if (!pi
->status_valid
)
1695 if (!proc_get_status (pi
))
1699 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
1701 ret
= &pi
->prstatus
.pr_sigpend
;
1704 memcpy (save
, ret
, sizeof (sigset_t
));
1710 * Function: proc_get_signal_actions
1712 * returns the set of signal actions.
1713 * Will also copy the sigactionset if 'save' is non-zero.
1717 proc_get_signal_actions (procinfo
*pi
, struct sigaction
*save
)
1719 struct sigaction
*ret
= NULL
;
1722 * We should never have to apply this operation to any procinfo
1723 * except the one for the main process. If that ever changes
1724 * for any reason, then take out the following clause and
1725 * replace it with one that makes sure the ctl_fd is open.
1729 pi
= find_procinfo_or_die (pi
->pid
, 0);
1731 if (!pi
->status_valid
)
1732 if (!proc_get_status (pi
))
1736 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
1738 ret
= &pi
->prstatus
.pr_action
;
1741 memcpy (save
, ret
, sizeof (struct sigaction
));
1747 * Function: proc_get_held_signals
1749 * returns the set of signals that are held / blocked.
1750 * Will also copy the sigset if 'save' is non-zero.
1754 proc_get_held_signals (procinfo
*pi
, sigset_t
*save
)
1756 sigset_t
*ret
= NULL
;
1759 * We should never have to apply this operation to any procinfo
1760 * except the one for the main process. If that ever changes
1761 * for any reason, then take out the following clause and
1762 * replace it with one that makes sure the ctl_fd is open.
1766 pi
= find_procinfo_or_die (pi
->pid
, 0);
1769 if (!pi
->status_valid
)
1770 if (!proc_get_status (pi
))
1774 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1776 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1777 #endif /* UNIXWARE */
1778 #else /* not NEW_PROC_API */
1780 static sigset_t sigheld
;
1782 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1785 #endif /* NEW_PROC_API */
1787 memcpy (save
, ret
, sizeof (sigset_t
));
1793 * Function: proc_get_traced_signals
1795 * returns the set of signals that are traced / debugged.
1796 * Will also copy the sigset if 'save' is non-zero.
1800 proc_get_traced_signals (procinfo
*pi
, sigset_t
*save
)
1802 sigset_t
*ret
= NULL
;
1805 * We should never have to apply this operation to any procinfo
1806 * except the one for the main process. If that ever changes
1807 * for any reason, then take out the following clause and
1808 * replace it with one that makes sure the ctl_fd is open.
1812 pi
= find_procinfo_or_die (pi
->pid
, 0);
1815 if (!pi
->status_valid
)
1816 if (!proc_get_status (pi
))
1819 ret
= &pi
->prstatus
.pr_sigtrace
;
1822 static sigset_t sigtrace
;
1824 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
1829 memcpy (save
, ret
, sizeof (sigset_t
));
1835 * Function: proc_trace_signal
1837 * Add 'signo' to the set of signals that are traced.
1838 * Returns non-zero for success, zero for failure.
1842 proc_trace_signal (procinfo
*pi
, int signo
)
1847 * We should never have to apply this operation to any procinfo
1848 * except the one for the main process. If that ever changes
1849 * for any reason, then take out the following clause and
1850 * replace it with one that makes sure the ctl_fd is open.
1854 pi
= find_procinfo_or_die (pi
->pid
, 0);
1858 if (proc_get_traced_signals (pi
, &temp
))
1860 praddset (&temp
, signo
);
1861 return proc_set_traced_signals (pi
, &temp
);
1865 return 0; /* failure */
1869 * Function: proc_ignore_signal
1871 * Remove 'signo' from the set of signals that are traced.
1872 * Returns non-zero for success, zero for failure.
1876 proc_ignore_signal (procinfo
*pi
, int signo
)
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);
1892 if (proc_get_traced_signals (pi
, &temp
))
1894 prdelset (&temp
, signo
);
1895 return proc_set_traced_signals (pi
, &temp
);
1899 return 0; /* failure */
1903 * Function: proc_get_traced_faults
1905 * returns the set of hardware faults that are traced /debugged.
1906 * Will also copy the faultset if 'save' is non-zero.
1910 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
1912 fltset_t
*ret
= NULL
;
1915 * We should never have to apply this operation to any procinfo
1916 * except the one for the main process. If that ever changes
1917 * for any reason, then take out the following clause and
1918 * replace it with one that makes sure the ctl_fd is open.
1922 pi
= find_procinfo_or_die (pi
->pid
, 0);
1925 if (!pi
->status_valid
)
1926 if (!proc_get_status (pi
))
1929 ret
= &pi
->prstatus
.pr_flttrace
;
1932 static fltset_t flttrace
;
1934 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
1939 memcpy (save
, ret
, sizeof (fltset_t
));
1945 * Function: proc_get_traced_sysentry
1947 * returns the set of syscalls that are traced /debugged on entry.
1948 * Will also copy the syscall set if 'save' is non-zero.
1952 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
1954 sysset_t
*ret
= NULL
;
1957 * We should never have to apply this operation to any procinfo
1958 * except the one for the main process. If that ever changes
1959 * for any reason, then take out the following clause and
1960 * replace it with one that makes sure the ctl_fd is open.
1964 pi
= find_procinfo_or_die (pi
->pid
, 0);
1967 if (!pi
->status_valid
)
1968 if (!proc_get_status (pi
))
1971 ret
= &pi
->prstatus
.pr_sysentry
;
1974 static sysset_t sysentry
;
1976 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
1981 memcpy (save
, ret
, sizeof (sysset_t
));
1987 * Function: proc_get_traced_sysexit
1989 * returns the set of syscalls that are traced /debugged on exit.
1990 * Will also copy the syscall set if 'save' is non-zero.
1994 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
1996 sysset_t
* ret
= NULL
;
1999 * We should never have to apply this operation to any procinfo
2000 * except the one for the main process. If that ever changes
2001 * for any reason, then take out the following clause and
2002 * replace it with one that makes sure the ctl_fd is open.
2006 pi
= find_procinfo_or_die (pi
->pid
, 0);
2009 if (!pi
->status_valid
)
2010 if (!proc_get_status (pi
))
2013 ret
= &pi
->prstatus
.pr_sysexit
;
2016 static sysset_t sysexit
;
2018 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2023 memcpy (save
, ret
, sizeof (sysset_t
));
2029 * Function: proc_clear_current_fault
2031 * The current fault (if any) is cleared; the associated signal
2032 * will not be sent to the process or LWP when it resumes.
2033 * Returns non-zero for success, zero for failure.
2037 proc_clear_current_fault (procinfo
*pi
)
2042 * We should never have to apply this operation to any procinfo
2043 * except the one for the main process. If that ever changes
2044 * for any reason, then take out the following clause and
2045 * replace it with one that makes sure the ctl_fd is open.
2049 pi
= find_procinfo_or_die (pi
->pid
, 0);
2053 long cmd
= PCCFAULT
;
2054 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2057 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2064 * Function: proc_set_current_signal
2066 * Set the "current signal" that will be delivered next to the process.
2067 * NOTE: semantics are different from those of KILL.
2068 * This signal will be delivered to the process or LWP
2069 * immediately when it is resumed (even if the signal is held/blocked);
2070 * it will NOT immediately cause another event of interest, and will NOT
2071 * first trap back to the debugger.
2073 * Returns non-zero for success, zero for failure.
2077 proc_set_current_signal (procinfo
*pi
, int signo
)
2082 /* Use char array to avoid alignment issues. */
2083 char sinfo
[sizeof (struct siginfo
)];
2085 struct siginfo
*mysinfo
;
2088 * We should never have to apply this operation to any procinfo
2089 * except the one for the main process. If that ever changes
2090 * for any reason, then take out the following clause and
2091 * replace it with one that makes sure the ctl_fd is open.
2095 pi
= find_procinfo_or_die (pi
->pid
, 0);
2097 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2098 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2099 * receives a PIOCSSIG with a signal identical to the current signal,
2100 * it messes up the current signal. Work around the kernel bug.
2103 signo
== proc_cursig (pi
))
2104 return 1; /* I assume this is a success? */
2107 /* The pointer is just a type alias. */
2108 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2109 mysinfo
->si_signo
= signo
;
2110 mysinfo
->si_code
= 0;
2111 mysinfo
->si_pid
= getpid (); /* ?why? */
2112 mysinfo
->si_uid
= getuid (); /* ?why? */
2116 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2118 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2125 * Function: proc_clear_current_signal
2127 * The current signal (if any) is cleared, and
2128 * is not sent to the process or LWP when it resumes.
2129 * Returns non-zero for success, zero for failure.
2133 proc_clear_current_signal (procinfo
*pi
)
2138 * We should never have to apply this operation to any procinfo
2139 * except the one for the main process. If that ever changes
2140 * for any reason, then take out the following clause and
2141 * replace it with one that makes sure the ctl_fd is open.
2145 pi
= find_procinfo_or_die (pi
->pid
, 0);
2151 /* Use char array to avoid alignment issues. */
2152 char sinfo
[sizeof (struct siginfo
)];
2154 struct siginfo
*mysinfo
;
2157 /* The pointer is just a type alias. */
2158 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2159 mysinfo
->si_signo
= 0;
2160 mysinfo
->si_code
= 0;
2161 mysinfo
->si_errno
= 0;
2162 mysinfo
->si_pid
= getpid (); /* ?why? */
2163 mysinfo
->si_uid
= getuid (); /* ?why? */
2165 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2168 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2175 * Function: proc_get_gregs
2177 * Get the general registers for the process or LWP.
2178 * Returns non-zero for success, zero for failure.
2182 proc_get_gregs (procinfo
*pi
)
2184 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2185 if (!proc_get_status (pi
))
2189 * OK, sorry about the ifdef's.
2190 * There's three cases instead of two, because
2191 * in this instance Unixware and Solaris/RW differ.
2195 #ifdef UNIXWARE /* ugh, a true architecture dependency */
2196 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2197 #else /* not Unixware */
2198 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2199 #endif /* Unixware */
2200 #else /* not NEW_PROC_API */
2201 return &pi
->prstatus
.pr_reg
;
2202 #endif /* NEW_PROC_API */
2206 * Function: proc_get_fpregs
2208 * Get the floating point registers for the process or LWP.
2209 * Returns non-zero for success, zero for failure.
2213 proc_get_fpregs (procinfo
*pi
)
2216 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2217 if (!proc_get_status (pi
))
2220 #ifdef UNIXWARE /* a true architecture dependency */
2221 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2223 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2224 #endif /* Unixware */
2226 #else /* not NEW_PROC_API */
2227 if (pi
->fpregs_valid
)
2228 return &pi
->fpregset
; /* already got 'em */
2231 if (pi
->ctl_fd
== 0 &&
2232 open_procinfo_files (pi
, FD_CTL
) == 0)
2241 tid_t pr_error_thread
;
2242 tfpregset_t thread_1
;
2245 thread_fpregs
.pr_count
= 1;
2246 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2249 ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2251 pi
->fpregs_valid
= 1;
2252 return &pi
->fpregset
; /* got 'em now! */
2254 else if (pi
->tid
!= 0 &&
2255 ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2257 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2258 sizeof (pi
->fpregset
));
2259 pi
->fpregs_valid
= 1;
2260 return &pi
->fpregset
; /* got 'em now! */
2267 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2269 pi
->fpregs_valid
= 1;
2270 return &pi
->fpregset
; /* got 'em now! */
2283 * Function: proc_set_gregs
2285 * Write the general registers back to the process or LWP.
2286 * Returns non-zero for success, zero for failure.
2290 proc_set_gregs (procinfo
*pi
)
2292 gdb_gregset_t
*gregs
;
2295 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2296 return 0; /* get_regs has already warned */
2298 if (pi
->ctl_fd
== 0 &&
2299 open_procinfo_files (pi
, FD_CTL
) == 0)
2308 /* Use char array to avoid alignment issues. */
2309 char gregs
[sizeof (gdb_gregset_t
)];
2313 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2314 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2316 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2320 /* Policy: writing the regs invalidates our cache. */
2321 pi
->gregs_valid
= 0;
2326 * Function: proc_set_fpregs
2328 * Modify the floating point register set of the process or LWP.
2329 * Returns non-zero for success, zero for failure.
2333 proc_set_fpregs (procinfo
*pi
)
2335 gdb_fpregset_t
*fpregs
;
2338 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
2339 return 0; /* get_fpregs has already warned */
2341 if (pi
->ctl_fd
== 0 &&
2342 open_procinfo_files (pi
, FD_CTL
) == 0)
2351 /* Use char array to avoid alignment issues. */
2352 char fpregs
[sizeof (gdb_fpregset_t
)];
2356 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2357 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2361 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2366 tid_t pr_error_thread
;
2367 tfpregset_t thread_1
;
2370 thread_fpregs
.pr_count
= 1;
2371 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2372 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2374 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2377 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2378 #endif /* osf PIOCTSFPREG */
2379 #endif /* NEW_PROC_API */
2382 /* Policy: writing the regs invalidates our cache. */
2383 pi
->fpregs_valid
= 0;
2388 * Function: proc_kill
2390 * Send a signal to the proc or lwp with the semantics of "kill()".
2391 * Returns non-zero for success, zero for failure.
2395 proc_kill (procinfo
*pi
, int signo
)
2400 * We might conceivably apply this operation to an LWP, and
2401 * the LWP's ctl file descriptor might not be open.
2404 if (pi
->ctl_fd
== 0 &&
2405 open_procinfo_files (pi
, FD_CTL
) == 0)
2416 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2417 #else /* ioctl method */
2418 /* FIXME: do I need the Alpha OSF fixups present in
2419 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2420 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2428 * Function: proc_parent_pid
2430 * Find the pid of the process that started this one.
2431 * Returns the parent process pid, or zero.
2435 proc_parent_pid (procinfo
*pi
)
2438 * We should never have to apply this operation to any procinfo
2439 * except the one for the main process. If that ever changes
2440 * for any reason, then take out the following clause and
2441 * replace it with one that makes sure the ctl_fd is open.
2445 pi
= find_procinfo_or_die (pi
->pid
, 0);
2447 if (!pi
->status_valid
)
2448 if (!proc_get_status (pi
))
2451 return pi
->prstatus
.pr_ppid
;
2456 * Function: proc_set_watchpoint
2461 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
2463 #if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
2466 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
2467 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
2472 char watch
[sizeof (prwatch_t
)];
2476 pwatch
= (prwatch_t
*) &arg
.watch
;
2477 pwatch
->pr_vaddr
= address_to_host_pointer (addr
);
2478 pwatch
->pr_size
= len
;
2479 pwatch
->pr_wflags
= wflags
;
2480 #if defined(NEW_PROC_API) && defined (PCWATCH)
2482 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2484 #if defined (PIOCSWATCH)
2485 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, pwatch
) >= 0);
2487 return 0; /* Fail */
2495 * Function: proc_iterate_over_mappings
2497 * Given a pointer to a function, call that function once for every
2498 * mapped address space in the process. The callback function
2499 * receives an open file descriptor for the file corresponding to
2500 * that mapped address space (if there is one), and the base address
2501 * of the mapped space. Quit when the callback function returns a
2502 * nonzero value, or at teh end of the mappings.
2504 * Returns: the first non-zero return value of the callback function,
2508 /* FIXME: it's probably a waste to cache this FD.
2509 It doesn't get called that often... and if I open it
2510 every time, I don't need to lseek it. */
2512 proc_iterate_over_mappings (int (*func
) (int, CORE_ADDR
))
2516 #ifndef NEW_PROC_API /* avoid compiler warning */
2521 char pathname
[MAX_PROC_NAME_SIZE
];
2526 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
2530 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
2531 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
2532 proc_error (pi
, "proc_iterate_over_mappings (open)", __LINE__
);
2534 /* Make sure it gets closed again. */
2535 make_cleanup_close (map_fd
);
2537 /* Allocate space for mapping (lifetime only for this function). */
2538 map
= alloca (sizeof (struct prmap
));
2540 /* Now read the mappings from the file,
2541 open a file descriptor for those that have a name,
2542 and call the callback function. */
2543 while (read (map_fd
,
2545 sizeof (struct prmap
)) == sizeof (struct prmap
))
2547 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
2549 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
2552 if (map
->pr_mapname
[0] == 0)
2554 fd
= -1; /* no map file */
2558 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
2559 /* Note: caller's responsibility to close this fd! */
2560 fd
= open (name
, O_RDONLY
);
2561 /* Note: we don't test the above call for failure;
2562 we just pass the FD on as given. Sometimes there is
2563 no file, so the ioctl may return failure, but that's
2567 /* Stop looping if the callback returns non-zero. */
2568 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
)) != 0)
2572 /* Get the number of mapping entries. */
2573 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmaps
) < 0)
2574 proc_error (pi
, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__
);
2576 /* Allocate space for mappings (lifetime only this function). */
2577 map
= (struct prmap
*) alloca ((nmaps
+ 1) * sizeof (struct prmap
));
2579 /* Read in all the mappings. */
2580 if (ioctl (pi
->ctl_fd
, PIOCMAP
, map
) < 0)
2581 proc_error (pi
, "proc_iterate_over_mappings (PIOCMAP)", __LINE__
);
2583 /* Now loop through the mappings, open an fd for each, and
2584 call the callback function. */
2586 i
< nmaps
&& map
[i
].pr_size
!= 0;
2589 /* Note: caller's responsibility to close this fd! */
2590 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
[i
].pr_vaddr
);
2591 /* Note: we don't test the above call for failure;
2592 we just pass the FD on as given. Sometimes there is
2593 no file, so the ioctl may return failure, but that's
2596 /* Stop looping if the callback returns non-zero. */
2597 funcstat
= (*func
) (fd
, host_pointer_to_address (map
[i
].pr_vaddr
));
2606 #ifdef TM_I386SOL2_H /* Is it hokey to use this? */
2608 #include <sys/sysi86.h>
2611 * Function: proc_get_LDT_entry
2617 * The 'key' is actually the value of the lower 16 bits of
2618 * the GS register for the LWP that we're interested in.
2620 * Return: matching ssh struct (LDT entry).
2624 proc_get_LDT_entry (procinfo
*pi
, int key
)
2626 static struct ssd
*ldt_entry
= NULL
;
2628 char pathname
[MAX_PROC_NAME_SIZE
];
2629 struct cleanup
*old_chain
= NULL
;
2632 /* Allocate space for one LDT entry.
2633 This alloc must persist, because we return a pointer to it. */
2634 if (ldt_entry
== NULL
)
2635 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2637 /* Open the file descriptor for the LDT table. */
2638 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2639 if ((fd
= open (pathname
, O_RDONLY
)) < 0)
2641 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2644 /* Make sure it gets closed again! */
2645 old_chain
= make_cleanup_close (fd
);
2647 /* Now 'read' thru the table, find a match and return it. */
2648 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2650 if (ldt_entry
->sel
== 0 &&
2651 ldt_entry
->bo
== 0 &&
2652 ldt_entry
->acc1
== 0 &&
2653 ldt_entry
->acc2
== 0)
2654 break; /* end of table */
2655 /* If key matches, return this entry. */
2656 if (ldt_entry
->sel
== key
)
2659 /* Loop ended, match not found. */
2663 static int nalloc
= 0;
2665 /* Get the number of LDT entries. */
2666 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2668 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2672 /* Allocate space for the number of LDT entries. */
2673 /* This alloc has to persist, 'cause we return a pointer to it. */
2676 ldt_entry
= (struct ssd
*)
2677 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2681 /* Read the whole table in one gulp. */
2682 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2684 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2688 /* Search the table and return the (first) entry matching 'key'. */
2689 for (i
= 0; i
< nldt
; i
++)
2690 if (ldt_entry
[i
].sel
== key
)
2691 return &ldt_entry
[i
];
2693 /* Loop ended, match not found. */
2698 #endif /* TM_I386SOL2_H */
2700 /* =============== END, non-thread part of /proc "MODULE" =============== */
2702 /* =================== Thread "MODULE" =================== */
2704 /* NOTE: you'll see more ifdefs and duplication of functions here,
2705 since there is a different way to do threads on every OS. */
2708 * Function: proc_get_nthreads
2710 * Return the number of threads for the process
2713 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2718 proc_get_nthreads (procinfo
*pi
)
2722 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2723 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2729 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2731 * Solaris and Unixware version
2734 proc_get_nthreads (procinfo
*pi
)
2736 if (!pi
->status_valid
)
2737 if (!proc_get_status (pi
))
2741 * NEW_PROC_API: only works for the process procinfo,
2742 * because the LWP procinfos do not get prstatus filled in.
2745 if (pi
->tid
!= 0) /* find the parent process procinfo */
2746 pi
= find_procinfo_or_die (pi
->pid
, 0);
2748 return pi
->prstatus
.pr_nlwp
;
2756 proc_get_nthreads (procinfo
*pi
)
2764 * Function: proc_get_current_thread (LWP version)
2766 * Return the ID of the thread that had an event of interest.
2767 * (ie. the one that hit a breakpoint or other traced event).
2768 * All other things being equal, this should be the ID of a
2769 * thread that is currently executing.
2772 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2774 * Solaris and Unixware version
2777 proc_get_current_thread (procinfo
*pi
)
2780 * Note: this should be applied to the root procinfo for the process,
2781 * not to the procinfo for an LWP. If applied to the procinfo for
2782 * an LWP, it will simply return that LWP's ID. In that case,
2783 * find the parent process procinfo.
2787 pi
= find_procinfo_or_die (pi
->pid
, 0);
2789 if (!pi
->status_valid
)
2790 if (!proc_get_status (pi
))
2794 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2796 return pi
->prstatus
.pr_who
;
2801 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2806 proc_get_current_thread (procinfo
*pi
)
2808 #if 0 /* FIXME: not ready for prime time? */
2809 return pi
->prstatus
.pr_tid
;
2820 proc_get_current_thread (procinfo
*pi
)
2829 * Function: proc_update_threads
2831 * Discover the IDs of all the threads within the process, and
2832 * create a procinfo for each of them (chained to the parent).
2834 * This unfortunately requires a different method on every OS.
2836 * Return: non-zero for success, zero for failure.
2840 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
2842 if (thread
&& parent
) /* sanity */
2844 thread
->status_valid
= 0;
2845 if (!proc_get_status (thread
))
2846 destroy_one_procinfo (&parent
->thread_list
, thread
);
2848 return 0; /* keep iterating */
2851 #if defined (PIOCLSTATUS)
2853 * Solaris 2.5 (ioctl) version
2856 proc_update_threads (procinfo
*pi
)
2858 gdb_prstatus_t
*prstatus
;
2859 struct cleanup
*old_chain
= NULL
;
2864 * We should never have to apply this operation to any procinfo
2865 * except the one for the main process. If that ever changes
2866 * for any reason, then take out the following clause and
2867 * replace it with one that makes sure the ctl_fd is open.
2871 pi
= find_procinfo_or_die (pi
->pid
, 0);
2873 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2875 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2876 return 1; /* Process is not multi-threaded; nothing to do. */
2878 if ((prstatus
= (gdb_prstatus_t
*)
2879 malloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1))) == 0)
2880 perror_with_name ("procfs: malloc failed in update_threads");
2882 old_chain
= make_cleanup (xfree
, prstatus
);
2883 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2884 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2886 /* Skip element zero, which represents the process as a whole. */
2887 for (i
= 1; i
< nlwp
+ 1; i
++)
2889 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
2890 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2892 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
2893 thread
->status_valid
= 1;
2895 pi
->threads_valid
= 1;
2896 do_cleanups (old_chain
);
2902 * Unixware and Solaris 6 (and later) version
2905 do_closedir_cleanup (void *dir
)
2911 proc_update_threads (procinfo
*pi
)
2913 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
2914 struct dirent
*direntry
;
2915 struct cleanup
*old_chain
= NULL
;
2921 * We should never have to apply this operation to any procinfo
2922 * except the one for the main process. If that ever changes
2923 * for any reason, then take out the following clause and
2924 * replace it with one that makes sure the ctl_fd is open.
2928 pi
= find_procinfo_or_die (pi
->pid
, 0);
2930 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2935 * Note: this brute-force method is the only way I know of
2936 * to accomplish this task on Unixware. This method will
2937 * also work on Solaris 2.6 and 2.7. There is a much simpler
2938 * and more elegant way to do this on Solaris, but the margins
2939 * of this manuscript are too small to write it here... ;-)
2942 strcpy (pathname
, pi
->pathname
);
2943 strcat (pathname
, "/lwp");
2944 if ((dirp
= opendir (pathname
)) == NULL
)
2945 proc_error (pi
, "update_threads, opendir", __LINE__
);
2947 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
2948 while ((direntry
= readdir (dirp
)) != NULL
)
2949 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
2951 lwpid
= atoi (&direntry
->d_name
[0]);
2952 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
2953 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2955 pi
->threads_valid
= 1;
2956 do_cleanups (old_chain
);
2965 proc_update_threads (procinfo
*pi
)
2971 * We should never have to apply this operation to any procinfo
2972 * except the one for the main process. If that ever changes
2973 * for any reason, then take out the following clause and
2974 * replace it with one that makes sure the ctl_fd is open.
2978 pi
= find_procinfo_or_die (pi
->pid
, 0);
2980 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2982 nthreads
= proc_get_nthreads (pi
);
2984 return 0; /* nothing to do for 1 or fewer threads */
2986 if ((threads
= malloc (nthreads
* sizeof (tid_t
))) == NULL
)
2987 proc_error (pi
, "update_threads, malloc", __LINE__
);
2989 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
2990 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
2992 for (i
= 0; i
< nthreads
; i
++)
2994 if (!find_procinfo (pi
->pid
, threads
[i
]))
2995 if (!create_procinfo (pi
->pid
, threads
[i
]))
2996 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2998 pi
->threads_valid
= 1;
3006 proc_update_threads (procinfo
*pi
)
3010 #endif /* OSF PIOCTLIST */
3011 #endif /* NEW_PROC_API */
3012 #endif /* SOL 2.5 PIOCLSTATUS */
3015 * Function: proc_iterate_over_threads
3018 * Given a pointer to a function, call that function once
3019 * for each lwp in the procinfo list, until the function
3020 * returns non-zero, in which event return the value
3021 * returned by the function.
3023 * Note: this function does NOT call update_threads.
3024 * If you want to discover new threads first, you must
3025 * call that function explicitly. This function just makes
3026 * a quick pass over the currently-known procinfos.
3029 * pi - parent process procinfo
3030 * func - per-thread function
3031 * ptr - opaque parameter for function.
3034 * First non-zero return value from the callee, or zero.
3038 proc_iterate_over_threads (procinfo
*pi
,
3039 int (*func
) (procinfo
*, procinfo
*, void *),
3042 procinfo
*thread
, *next
;
3046 * We should never have to apply this operation to any procinfo
3047 * except the one for the main process. If that ever changes
3048 * for any reason, then take out the following clause and
3049 * replace it with one that makes sure the ctl_fd is open.
3053 pi
= find_procinfo_or_die (pi
->pid
, 0);
3055 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3057 next
= thread
->next
; /* in case thread is destroyed */
3058 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3065 /* =================== END, Thread "MODULE" =================== */
3067 /* =================== END, /proc "MODULE" =================== */
3069 /* =================== GDB "MODULE" =================== */
3072 * Here are all of the gdb target vector functions and their friends.
3075 static int do_attach (int pid
);
3076 static void do_detach (int signo
);
3077 static int register_gdb_signals (procinfo
*, sigset_t
*);
3080 * Function: procfs_debug_inferior
3082 * Sets up the inferior to be debugged.
3083 * Registers to trace signals, hardware faults, and syscalls.
3084 * Note: does not set RLC flag: caller may want to customize that.
3086 * Returns: zero for success (note! unlike most functions in this module)
3087 * On failure, returns the LINE NUMBER where it failed!
3091 procfs_debug_inferior (procinfo
*pi
)
3093 fltset_t traced_faults
;
3094 sigset_t traced_signals
;
3095 sysset_t traced_syscall_entries
;
3096 sysset_t traced_syscall_exits
;
3098 #ifdef PROCFS_DONT_TRACE_FAULTS
3099 /* On some systems (OSF), we don't trace hardware faults.
3100 Apparently it's enough that we catch them as signals.
3101 Wonder why we don't just do that in general? */
3102 premptyset (&traced_faults
); /* don't trace faults. */
3104 /* Register to trace hardware faults in the child. */
3105 prfillset (&traced_faults
); /* trace all faults... */
3106 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3108 if (!proc_set_traced_faults (pi
, &traced_faults
))
3111 /* Register to trace selected signals in the child. */
3112 premptyset (&traced_signals
);
3113 if (!register_gdb_signals (pi
, &traced_signals
))
3116 /* Register to trace the 'exit' system call (on entry). */
3117 premptyset (&traced_syscall_entries
);
3118 praddset (&traced_syscall_entries
, SYS_exit
);
3120 praddset (&traced_syscall_entries
, SYS_lwpexit
); /* And _lwp_exit... */
3123 praddset (&traced_syscall_entries
, SYS_lwp_exit
);
3126 if (!proc_set_traced_sysentry (pi
, &traced_syscall_entries
))
3129 #ifdef PRFS_STOPEXEC /* defined on OSF */
3130 /* OSF method for tracing exec syscalls. Quoting:
3131 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3132 exits from exec system calls because of the user level loader. */
3133 /* FIXME: make nice and maybe move into an access function. */
3137 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3140 prfs_flags
|= PRFS_STOPEXEC
;
3142 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3145 #else /* not PRFS_STOPEXEC */
3146 /* Everyone else's (except OSF) method for tracing exec syscalls */
3148 Not all systems with /proc have all the exec* syscalls with the same
3149 names. On the SGI, for example, there is no SYS_exec, but there
3150 *is* a SYS_execv. So, we try to account for that. */
3152 premptyset (&traced_syscall_exits
);
3154 praddset (&traced_syscall_exits
, SYS_exec
);
3157 praddset (&traced_syscall_exits
, SYS_execve
);
3160 praddset (&traced_syscall_exits
, SYS_execv
);
3163 #ifdef SYS_lwpcreate
3164 praddset (&traced_syscall_exits
, SYS_lwpcreate
);
3165 praddset (&traced_syscall_exits
, SYS_lwpexit
);
3168 #ifdef SYS_lwp_create /* FIXME: once only, please */
3169 praddset (&traced_syscall_exits
, SYS_lwp_create
);
3170 praddset (&traced_syscall_exits
, SYS_lwp_exit
);
3174 if (!proc_set_traced_sysexit (pi
, &traced_syscall_exits
))
3177 #endif /* PRFS_STOPEXEC */
3182 procfs_attach (char *args
, int from_tty
)
3188 error_no_arg ("process-id to attach");
3191 if (pid
== getpid ())
3192 error ("Attaching GDB to itself is not a good idea...");
3196 exec_file
= get_exec_file (0);
3199 printf_filtered ("Attaching to program `%s', %s\n",
3200 exec_file
, target_pid_to_str (pid
));
3202 printf_filtered ("Attaching to %s\n", target_pid_to_str (pid
));
3206 inferior_pid
= do_attach (pid
);
3207 push_target (&procfs_ops
);
3211 procfs_detach (char *args
, int from_tty
)
3218 exec_file
= get_exec_file (0);
3221 printf_filtered ("Detaching from program: %s %s\n",
3222 exec_file
, target_pid_to_str (inferior_pid
));
3226 signo
= atoi (args
);
3230 unpush_target (&procfs_ops
); /* Pop out of handling an inferior */
3239 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
3240 perror ("procfs: out of memory in 'attach'");
3242 if (!open_procinfo_files (pi
, FD_CTL
))
3244 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3245 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3247 dead_procinfo (pi
, errmsg
, NOKILL
);
3250 /* Stop the process (if it isn't already stopped). */
3251 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3253 pi
->was_stopped
= 1;
3254 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3258 pi
->was_stopped
= 0;
3259 /* Set the process to run again when we close it. */
3260 if (!proc_set_run_on_last_close (pi
))
3261 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3263 /* Now stop the process. */
3264 if (!proc_stop_process (pi
))
3265 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3266 pi
->ignore_next_sigstop
= 1;
3268 /* Save some of the /proc state to be restored if we detach. */
3269 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3270 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3271 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3272 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3273 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
3274 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3276 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
3277 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3279 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3280 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3282 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3283 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3285 /* Let GDB know that the inferior was attached. */
3287 return MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3291 do_detach (int signo
)
3295 /* Find procinfo for the main process */
3296 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0); /* FIXME: threads */
3298 if (!proc_set_current_signal (pi
, signo
))
3299 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3301 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3302 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3304 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3305 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3307 if (!proc_set_traced_sysentry (pi
, &pi
->saved_entryset
))
3308 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3310 if (!proc_set_traced_sysexit (pi
, &pi
->saved_exitset
))
3311 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3313 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3314 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3316 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3317 if (signo
|| !(pi
->was_stopped
) ||
3318 query ("Was stopped when attached, make it runnable again? "))
3320 /* Clear any pending signal. */
3321 if (!proc_clear_current_fault (pi
))
3322 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3324 if (!proc_set_run_on_last_close (pi
))
3325 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3329 destroy_procinfo (pi
);
3335 * Since the /proc interface cannot give us individual registers,
3336 * we pay no attention to the (regno) argument, and just fetch them all.
3337 * This results in the possibility that we will do unnecessarily many
3338 * fetches, since we may be called repeatedly for individual registers.
3339 * So we cache the results, and mark the cache invalid when the process
3344 procfs_fetch_registers (int regno
)
3346 gdb_fpregset_t
*fpregs
;
3347 gdb_gregset_t
*gregs
;
3352 pid
= PIDGET (inferior_pid
);
3353 tid
= TIDGET (inferior_pid
);
3355 /* First look up procinfo for the main process. */
3356 pi
= find_procinfo_or_die (pid
, 0);
3358 /* If the event thread is not the same as GDB's requested thread
3359 (ie. inferior_pid), then look up procinfo for the requested
3362 (tid
!= proc_get_current_thread (pi
)))
3363 pi
= find_procinfo_or_die (pid
, tid
);
3366 error ("procfs: fetch_registers failed to find procinfo for %s",
3367 target_pid_to_str (inferior_pid
));
3369 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3370 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3372 supply_gregset (gregs
);
3374 if (FP0_REGNUM
>= 0) /* need floating point? */
3376 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3377 regno
== PC_REGNUM
||
3378 (NPC_REGNUM
>= 0 && regno
== NPC_REGNUM
) ||
3379 regno
== FP_REGNUM
||
3381 return; /* not a floating point register */
3383 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3384 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3386 supply_fpregset (fpregs
);
3390 /* Get ready to modify the registers array. On machines which store
3391 individual registers, this doesn't need to do anything. On
3392 machines which store all the registers in one fell swoop, such as
3393 /proc, this makes sure that registers contains all the registers
3394 from the program being debugged. */
3397 procfs_prepare_to_store (void)
3399 #ifdef CHILD_PREPARE_TO_STORE
3400 CHILD_PREPARE_TO_STORE ();
3407 * Since the /proc interface will not read individual registers,
3408 * we will cache these requests until the process is resumed, and
3409 * only then write them back to the inferior process.
3411 * FIXME: is that a really bad idea? Have to think about cases
3412 * where writing one register might affect the value of others, etc.
3416 procfs_store_registers (int regno
)
3418 gdb_fpregset_t
*fpregs
;
3419 gdb_gregset_t
*gregs
;
3424 pid
= PIDGET (inferior_pid
);
3425 tid
= TIDGET (inferior_pid
);
3427 /* First find procinfo for main process */
3428 pi
= find_procinfo_or_die (pid
, 0);
3430 /* If current lwp for process is not the same as requested thread
3431 (ie. inferior_pid), then find procinfo for the requested thread. */
3434 (tid
!= proc_get_current_thread (pi
)))
3435 pi
= find_procinfo_or_die (pid
, tid
);
3438 error ("procfs: store_registers: failed to find procinfo for %s",
3439 target_pid_to_str (inferior_pid
));
3441 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3442 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3444 fill_gregset (gregs
, regno
);
3445 if (!proc_set_gregs (pi
))
3446 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3448 if (FP0_REGNUM
>= 0) /* need floating point? */
3450 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3451 regno
== PC_REGNUM
||
3452 (NPC_REGNUM
>= 0 && regno
== NPC_REGNUM
) ||
3453 regno
== FP_REGNUM
||
3455 return; /* not a floating point register */
3457 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3458 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3460 fill_fpregset (fpregs
, regno
);
3461 if (!proc_set_fpregs (pi
))
3462 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3467 * Function: target_wait
3469 * Retrieve the next stop event from the child process.
3470 * If child has not stopped yet, wait for it to stop.
3471 * Translate /proc eventcodes (or possibly wait eventcodes)
3472 * into gdb internal event codes.
3474 * Return: id of process (and possibly thread) that incurred the event.
3475 * event codes are returned thru a pointer parameter.
3479 procfs_wait (int pid
, struct target_waitstatus
*status
)
3481 /* First cut: loosely based on original version 2.1 */
3485 int why
, what
, flags
;
3494 /* Find procinfo for main process */
3495 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
3498 /* We must assume that the status is stale now... */
3499 pi
->status_valid
= 0;
3500 pi
->gregs_valid
= 0;
3501 pi
->fpregs_valid
= 0;
3503 #if 0 /* just try this out... */
3504 flags
= proc_flags (pi
);
3505 why
= proc_why (pi
);
3506 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3507 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3509 /* If child is not stopped, wait for it to stop. */
3510 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3511 !proc_wait_for_stop (pi
))
3513 /* wait_for_stop failed: has the child terminated? */
3514 if (errno
== ENOENT
)
3516 /* /proc file not found; presumably child has terminated. */
3517 retval
= wait (&wstat
); /* "wait" for the child's exit */
3519 if (retval
!= PIDGET (inferior_pid
)) /* wrong child? */
3520 error ("procfs: couldn't stop process %d: wait returned %d\n",
3521 inferior_pid
, retval
);
3522 /* FIXME: might I not just use waitpid?
3523 Or try find_procinfo to see if I know about this child? */
3527 /* Unknown error from wait_for_stop. */
3528 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3533 /* This long block is reached if either:
3534 a) the child was already stopped, or
3535 b) we successfully waited for the child with wait_for_stop.
3536 This block will analyze the /proc status, and translate it
3537 into a waitstatus for GDB.
3539 If we actually had to call wait because the /proc file
3540 is gone (child terminated), then we skip this block,
3541 because we already have a waitstatus. */
3543 flags
= proc_flags (pi
);
3544 why
= proc_why (pi
);
3545 what
= proc_what (pi
);
3547 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3550 /* If it's running async (for single_thread control),
3551 set it back to normal again. */
3552 if (flags
& PR_ASYNC
)
3553 if (!proc_unset_async (pi
))
3554 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3558 proc_prettyprint_why (why
, what
, 1);
3560 /* The 'pid' we will return to GDB is composed of
3561 the process ID plus the lwp ID. */
3562 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3566 wstat
= (what
<< 8) | 0177;
3576 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3577 printf_filtered ("[%s exited]\n",
3578 target_pid_to_str (retval
));
3579 delete_thread (retval
);
3580 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3582 #endif /* _lwp_exit */
3585 /* Handle SYS_exit call only */
3586 /* Stopped at entry to SYS_exit.
3587 Make it runnable, resume it, then use
3588 the wait system call to get its exit code.
3589 Proc_run_process always clears the current
3591 Then return its exit status. */
3592 pi
->status_valid
= 0;
3594 /* FIXME: what we should do is return
3595 TARGET_WAITKIND_SPURIOUS. */
3596 if (!proc_run_process (pi
, 0, 0))
3597 proc_error (pi
, "target_wait, run_process", __LINE__
);
3600 /* Don't call wait: simulate waiting for exit,
3601 return a "success" exit code. Bogus: what if
3602 it returns something else? */
3604 retval
= inferior_pid
; /* ? ? ? */
3608 int temp
= wait (&wstat
);
3610 /* FIXME: shouldn't I make sure I get the right
3611 event from the right process? If (for
3612 instance) I have killed an earlier inferior
3613 process but failed to clean up after it
3614 somehow, I could get its termination event
3617 /* If wait returns -1, that's what we return to GDB. */
3623 printf_filtered ("procfs: trapped on entry to ");
3624 proc_prettyprint_syscall (proc_what (pi
), 0);
3625 printf_filtered ("\n");
3628 long i
, nsysargs
, *sysargs
;
3630 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3631 (sysargs
= proc_sysargs (pi
)) != NULL
)
3633 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3634 for (i
= 0; i
< nsysargs
; i
++)
3635 printf_filtered ("#%ld: 0x%08lx\n",
3643 /* How to exit gracefully, returning "unknown event" */
3644 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3645 return inferior_pid
;
3649 /* How to keep going without returning to wfi: */
3650 target_resume (pid
, 0, TARGET_SIGNAL_0
);
3667 /* Hopefully this is our own "fork-child" execing
3668 the real child. Hoax this event into a trap, and
3669 GDB will see the child about to execute its start
3671 wstat
= (SIGTRAP
<< 8) | 0177;
3673 #ifdef SYS_lwp_create
3674 case SYS_lwp_create
:
3676 #ifdef SYS_lwpcreate
3679 #if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
3681 * This syscall is somewhat like fork/exec.
3682 * We will get the event twice: once for the parent LWP,
3683 * and once for the child. We should already know about
3684 * the parent LWP, but the child will be new to us. So,
3685 * whenever we get this event, if it represents a new
3686 * thread, simply add the thread to the list.
3689 /* If not in procinfo list, add it. */
3690 temp
= proc_get_current_thread (pi
);
3691 if (!find_procinfo (pi
->pid
, temp
))
3692 create_procinfo (pi
->pid
, temp
);
3694 temp
= MERGEPID (pi
->pid
, temp
);
3695 /* If not in GDB's thread list, add it. */
3696 if (!in_thread_list (temp
))
3698 printf_filtered ("[New %s]\n", target_pid_to_str (temp
));
3701 /* Return to WFI, but tell it to immediately resume. */
3702 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3703 return inferior_pid
;
3704 #endif /* _lwp_create */
3712 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3713 printf_filtered ("[%s exited]\n",
3714 target_pid_to_str (retval
));
3715 delete_thread (retval
);
3716 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3718 #endif /* _lwp_exit */
3722 /* Nothing to do here for now. The old procfs
3723 seemed to use this event to handle threads on
3724 older (non-LWP) systems, where I'm assuming that
3725 threads were actually separate processes. Irix,
3726 maybe? Anyway, low priority for now. */
3730 /* FIXME: do we need to handle this? Investigate. */
3734 /* FIXME: see above. */
3737 printf_filtered ("procfs: trapped on exit from ");
3738 proc_prettyprint_syscall (proc_what (pi
), 0);
3739 printf_filtered ("\n");
3742 long i
, nsysargs
, *sysargs
;
3744 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3745 (sysargs
= proc_sysargs (pi
)) != NULL
)
3747 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3748 for (i
= 0; i
< nsysargs
; i
++)
3749 printf_filtered ("#%ld: 0x%08lx\n",
3754 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3755 return inferior_pid
;
3760 wstat
= (SIGSTOP
<< 8) | 0177;
3765 printf_filtered ("Retry #%d:\n", retry
);
3766 pi
->status_valid
= 0;
3771 /* If not in procinfo list, add it. */
3772 temp
= proc_get_current_thread (pi
);
3773 if (!find_procinfo (pi
->pid
, temp
))
3774 create_procinfo (pi
->pid
, temp
);
3776 /* If not in GDB's thread list, add it. */
3777 temp
= MERGEPID (pi
->pid
, temp
);
3778 if (!in_thread_list (temp
))
3780 printf_filtered ("[New %s]\n",
3781 target_pid_to_str (temp
));
3785 status
->kind
= TARGET_WAITKIND_STOPPED
;
3786 status
->value
.sig
= 0;
3791 wstat
= (what
<< 8) | 0177;
3794 switch (what
) { /* FIXME: FAULTED_USE_SIGINFO */
3797 wstat
= (SIGTRAP
<< 8) | 0177;
3802 wstat
= (SIGTRAP
<< 8) | 0177;
3805 /* FIXME: use si_signo where possible. */
3807 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
3810 wstat
= (SIGILL
<< 8) | 0177;
3813 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
3816 wstat
= (SIGTRAP
<< 8) | 0177;
3820 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
3823 wstat
= (SIGSEGV
<< 8) | 0177;
3827 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
3830 wstat
= (SIGFPE
<< 8) | 0177;
3832 case FLTPAGE
: /* Recoverable page fault */
3833 default: /* FIXME: use si_signo if possible for fault */
3835 printf_filtered ("procfs:%d -- ", __LINE__
);
3836 printf_filtered ("child stopped for unknown reason:\n");
3837 proc_prettyprint_why (why
, what
, 1);
3838 error ("... giving up...");
3841 break; /* case PR_FAULTED: */
3842 default: /* switch (why) unmatched */
3843 printf_filtered ("procfs:%d -- ", __LINE__
);
3844 printf_filtered ("child stopped for unknown reason:\n");
3845 proc_prettyprint_why (why
, what
, 1);
3846 error ("... giving up...");
3850 * Got this far without error:
3851 * If retval isn't in the threads database, add it.
3854 retval
!= inferior_pid
&&
3855 !in_thread_list (retval
))
3858 * We have a new thread.
3859 * We need to add it both to GDB's list and to our own.
3860 * If we don't create a procinfo, resume may be unhappy
3863 printf_filtered ("[New %s]\n", target_pid_to_str (retval
));
3864 add_thread (retval
);
3865 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
3866 create_procinfo (PIDGET (retval
), TIDGET (retval
));
3868 /* In addition, it's possible that this is the first
3869 * new thread we've seen, in which case we may not
3870 * have created entries for inferior_pid yet.
3872 if (TIDGET (inferior_pid
) != 0)
3874 if (!in_thread_list (inferior_pid
))
3875 add_thread (inferior_pid
);
3876 if (find_procinfo (PIDGET (inferior_pid
),
3877 TIDGET (inferior_pid
)) == NULL
)
3878 create_procinfo (PIDGET (inferior_pid
),
3879 TIDGET (inferior_pid
));
3883 else /* flags do not indicate STOPPED */
3885 /* surely this can't happen... */
3886 printf_filtered ("procfs:%d -- process not stopped.\n",
3888 proc_prettyprint_flags (flags
, 1);
3889 error ("procfs: ...giving up...");
3894 store_waitstatus (status
, wstat
);
3900 /* Transfer LEN bytes between GDB address MYADDR and target address
3901 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
3902 otherwise transfer them from the target. TARGET is unused.
3904 The return value is 0 if an error occurred or no bytes were
3905 transferred. Otherwise, it will be a positive value which
3906 indicates the number of bytes transferred between gdb and the
3907 target. (Note that the interface also makes provisions for
3908 negative values, but this capability isn't implemented here.) */
3911 procfs_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
3912 struct target_ops
*target
)
3917 /* Find procinfo for main process */
3918 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
3919 if (pi
->as_fd
== 0 &&
3920 open_procinfo_files (pi
, FD_AS
) == 0)
3922 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
3926 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
3931 PROCFS_NOTE ("write memory: ");
3933 PROCFS_NOTE ("write memory: \n");
3935 nbytes
= write (pi
->as_fd
, myaddr
, len
);
3939 PROCFS_NOTE ("read memory: \n");
3940 nbytes
= read (pi
->as_fd
, myaddr
, len
);
3951 * Function: invalidate_cache
3953 * Called by target_resume before making child runnable.
3954 * Mark cached registers and status's invalid.
3955 * If there are "dirty" caches that need to be written back
3956 * to the child process, do that.
3958 * File descriptors are also cached.
3959 * As they are a limited resource, we cannot hold onto them indefinitely.
3960 * However, as they are expensive to open, we don't want to throw them
3961 * away indescriminately either. As a compromise, we will keep the
3962 * file descriptors for the parent process, but discard any file
3963 * descriptors we may have accumulated for the threads.
3966 * As this function is called by iterate_over_threads, it always
3967 * returns zero (so that iterate_over_threads will keep iterating).
3972 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
3975 * About to run the child; invalidate caches and do any other cleanup.
3979 if (pi
->gregs_dirty
)
3980 if (parent
== NULL
||
3981 proc_get_current_thread (parent
) != pi
->tid
)
3982 if (!proc_set_gregs (pi
)) /* flush gregs cache */
3983 proc_warn (pi
, "target_resume, set_gregs",
3985 if (FP0_REGNUM
>= 0)
3986 if (pi
->fpregs_dirty
)
3987 if (parent
== NULL
||
3988 proc_get_current_thread (parent
) != pi
->tid
)
3989 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
3990 proc_warn (pi
, "target_resume, set_fpregs",
3996 /* The presence of a parent indicates that this is an LWP.
3997 Close any file descriptors that it might have open.
3998 We don't do this to the master (parent) procinfo. */
4000 close_procinfo_files (pi
);
4002 pi
->gregs_valid
= 0;
4003 pi
->fpregs_valid
= 0;
4005 pi
->gregs_dirty
= 0;
4006 pi
->fpregs_dirty
= 0;
4008 pi
->status_valid
= 0;
4009 pi
->threads_valid
= 0;
4016 * Function: make_signal_thread_runnable
4018 * A callback function for iterate_over_threads.
4019 * Find the asynchronous signal thread, and make it runnable.
4020 * See if that helps matters any.
4024 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
4027 if (proc_flags (pi
) & PR_ASLWP
)
4029 if (!proc_run_process (pi
, 0, -1))
4030 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4039 * Function: target_resume
4041 * Make the child process runnable. Normally we will then call
4042 * procfs_wait and wait for it to stop again (unles gdb is async).
4045 * step: if true, then arrange for the child to stop again
4046 * after executing a single instruction.
4047 * signo: if zero, then cancel any pending signal.
4048 * If non-zero, then arrange for the indicated signal
4049 * to be delivered to the child when it runs.
4050 * pid: if -1, then allow any child thread to run.
4051 * if non-zero, then allow only the indicated thread to run.
4052 ******* (not implemented yet)
4056 procfs_resume (int pid
, int step
, enum target_signal signo
)
4058 procinfo
*pi
, *thread
;
4062 prrun.prflags |= PRSVADDR;
4063 prrun.pr_vaddr = $PC; set resume address
4064 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4065 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4066 prrun.prflags |= PRCFAULT; clear current fault.
4068 PRSTRACE and PRSFAULT can be done by other means
4069 (proc_trace_signals, proc_trace_faults)
4070 PRSVADDR is unnecessary.
4071 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4072 This basically leaves PRSTEP and PRCSIG.
4073 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4074 So basically PR_STEP is the sole argument that must be passed
4075 to proc_run_process (for use in the prrun struct by ioctl). */
4077 /* Find procinfo for main process */
4078 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4080 /* First cut: ignore pid argument */
4083 /* Convert signal to host numbering. */
4085 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4088 native_signo
= target_signal_to_host (signo
);
4090 pi
->ignore_next_sigstop
= 0;
4092 /* Running the process voids all cached registers and status. */
4093 /* Void the threads' caches first */
4094 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4095 /* Void the process procinfo's caches. */
4096 invalidate_cache (NULL
, pi
, NULL
);
4100 /* Resume a specific thread, presumably suppressing the others. */
4101 thread
= find_procinfo (PIDGET (pid
), TIDGET (pid
));
4103 warning ("procfs: resume can't find thread %d -- resuming all.",
4107 if (thread
->tid
!= 0)
4109 /* We're to resume a specific thread, and not the others.
4110 * Set the child process's PR_ASYNC flag.
4113 if (!proc_set_async (pi
))
4114 proc_error (pi
, "target_resume, set_async", __LINE__
);
4117 proc_iterate_over_threads (pi
,
4118 make_signal_thread_runnable
,
4121 pi
= thread
; /* substitute the thread's procinfo for run */
4126 if (!proc_run_process (pi
, step
, native_signo
))
4129 warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
4131 proc_error (pi
, "target_resume", __LINE__
);
4136 * Function: register_gdb_signals
4138 * Traverse the list of signals that GDB knows about
4139 * (see "handle" command), and arrange for the target
4140 * to be stopped or not, according to these settings.
4142 * Returns non-zero for success, zero for failure.
4146 register_gdb_signals (procinfo
*pi
, sigset_t
*signals
)
4150 for (signo
= 0; signo
< NSIG
; signo
++)
4151 if (signal_stop_state (target_signal_from_host (signo
)) == 0 &&
4152 signal_print_state (target_signal_from_host (signo
)) == 0 &&
4153 signal_pass_state (target_signal_from_host (signo
)) == 1)
4154 prdelset (signals
, signo
);
4156 praddset (signals
, signo
);
4158 return proc_set_traced_signals (pi
, signals
);
4162 * Function: target_notice_signals
4164 * Set up to trace signals in the child process.
4168 procfs_notice_signals (int pid
)
4171 procinfo
*pi
= find_procinfo_or_die (PIDGET (pid
), 0);
4173 if (proc_get_traced_signals (pi
, &signals
) &&
4174 register_gdb_signals (pi
, &signals
))
4177 proc_error (pi
, "notice_signals", __LINE__
);
4181 * Function: target_files_info
4183 * Print status information about the child process.
4187 procfs_files_info (struct target_ops
*ignore
)
4189 printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
4190 attach_flag
? "attached": "child",
4191 target_pid_to_str (inferior_pid
));
4195 * Function: target_open
4197 * A dummy: you don't open procfs.
4201 procfs_open (char *args
, int from_tty
)
4203 error ("Use the \"run\" command to start a Unix child process.");
4207 * Function: target_can_run
4209 * This tells GDB that this target vector can be invoked
4210 * for "run" or "attach".
4213 int procfs_suppress_run
= 0; /* Non-zero if procfs should pretend not to
4214 be a runnable target. Used by targets
4215 that can sit atop procfs, such as solaris
4220 procfs_can_run (void)
4222 /* This variable is controlled by modules that sit atop procfs that
4223 may layer their own process structure atop that provided here.
4224 sol-thread.c does this because of the Solaris two-level thread
4227 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
4229 return !procfs_suppress_run
;
4233 * Function: target_stop
4235 * Stop the child process asynchronously, as when the
4236 * gdb user types control-c or presses a "stop" button.
4238 * Works by sending kill(SIGINT) to the child's process group.
4244 extern pid_t inferior_process_group
;
4246 kill (-inferior_process_group
, SIGINT
);
4250 * Function: unconditionally_kill_inferior
4252 * Make it die. Wait for it to die. Clean up after it.
4253 * Note: this should only be applied to the real process,
4254 * not to an LWP, because of the check for parent-process.
4255 * If we need this to work for an LWP, it needs some more logic.
4259 unconditionally_kill_inferior (procinfo
*pi
)
4263 parent_pid
= proc_parent_pid (pi
);
4264 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4265 /* FIXME: use access functions */
4266 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4267 before the PIOCKILL, otherwise it might generate a corrupted core
4268 file for the inferior. */
4269 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4271 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4274 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4275 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4276 to kill the inferior, otherwise it might remain stopped with a
4278 We do not check the result of the PIOCSSIG, the inferior might have
4281 struct siginfo newsiginfo
;
4283 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4284 newsiginfo
.si_signo
= SIGKILL
;
4285 newsiginfo
.si_code
= 0;
4286 newsiginfo
.si_errno
= 0;
4287 newsiginfo
.si_pid
= getpid ();
4288 newsiginfo
.si_uid
= getuid ();
4289 /* FIXME: use proc_set_current_signal */
4290 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4292 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4293 if (!proc_kill (pi
, SIGKILL
))
4294 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4295 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4296 destroy_procinfo (pi
);
4298 /* If pi is GDB's child, wait for it to die. */
4299 if (parent_pid
== getpid ())
4300 /* FIXME: should we use waitpid to make sure we get the right event?
4301 Should we check the returned event? */
4306 ret
= waitpid (pi
->pid
, &status
, 0);
4314 * Function: target_kill_inferior
4316 * We're done debugging it, and we want it to go away.
4317 * Then we want GDB to forget all about it.
4321 procfs_kill_inferior (void)
4323 if (inferior_pid
!= 0) /* ? */
4325 /* Find procinfo for main process */
4326 procinfo
*pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4329 unconditionally_kill_inferior (pi
);
4330 target_mourn_inferior ();
4335 * Function: target_mourn_inferior
4337 * Forget we ever debugged this thing!
4341 procfs_mourn_inferior (void)
4345 if (inferior_pid
!= 0)
4347 /* Find procinfo for main process */
4348 pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4350 destroy_procinfo (pi
);
4352 unpush_target (&procfs_ops
);
4353 generic_mourn_inferior ();
4357 * Function: init_inferior
4359 * When GDB forks to create a runnable inferior process,
4360 * this function is called on the parent side of the fork.
4361 * It's job is to do whatever is necessary to make the child
4362 * ready to be debugged, and then wait for the child to synchronize.
4366 procfs_init_inferior (int pid
)
4372 /* This routine called on the parent side (GDB side)
4373 after GDB forks the inferior. */
4375 push_target (&procfs_ops
);
4377 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4378 perror ("procfs: out of memory in 'init_inferior'");
4380 if (!open_procinfo_files (pi
, FD_CTL
))
4381 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4385 open_procinfo_files // done
4388 procfs_notice_signals
4395 /* If not stopped yet, wait for it to stop. */
4396 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4397 !(proc_wait_for_stop (pi
)))
4398 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4400 /* Save some of the /proc state to be restored if we detach. */
4401 /* FIXME: Why? In case another debugger was debugging it?
4402 We're it's parent, for Ghu's sake! */
4403 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4404 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4405 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4406 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4407 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4408 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4409 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
4410 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4411 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
4412 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4414 /* Register to trace selected signals in the child. */
4415 prfillset (&signals
);
4416 if (!register_gdb_signals (pi
, &signals
))
4417 proc_error (pi
, "init_inferior, register_signals", __LINE__
);
4419 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4420 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4422 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4423 and possibly even turning ON kill-on-last-close at this point. But
4424 I can't make that change without careful testing which I don't have
4425 time to do right now... */
4426 /* Turn on run-on-last-close flag so that the child
4427 will die if GDB goes away for some reason. */
4428 if (!proc_set_run_on_last_close (pi
))
4429 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4431 /* The 'process ID' we return to GDB is composed of
4432 the actual process ID plus the lwp ID. */
4433 inferior_pid
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
4435 #ifdef START_INFERIOR_TRAPS_EXPECTED
4436 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4438 /* One trap to exec the shell, one to exec the program being debugged. */
4439 startup_inferior (2);
4440 #endif /* START_INFERIOR_TRAPS_EXPECTED */
4444 * Function: set_exec_trap
4446 * When GDB forks to create a new process, this function is called
4447 * on the child side of the fork before GDB exec's the user program.
4448 * Its job is to make the child minimally debuggable, so that the
4449 * parent GDB process can connect to the child and take over.
4450 * This function should do only the minimum to make that possible,
4451 * and to synchronize with the parent process. The parent process
4452 * should take care of the details.
4456 procfs_set_exec_trap (void)
4458 /* This routine called on the child side (inferior side)
4459 after GDB forks the inferior. It must use only local variables,
4460 because it may be sharing data space with its parent. */
4465 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4466 perror_with_name ("procfs: create_procinfo failed in child.");
4468 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4470 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4471 gdb_flush (gdb_stderr
);
4472 /* no need to call "dead_procinfo", because we're going to exit. */
4476 #ifdef PRFS_STOPEXEC /* defined on OSF */
4477 /* OSF method for tracing exec syscalls. Quoting:
4478 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4479 exits from exec system calls because of the user level loader. */
4480 /* FIXME: make nice and maybe move into an access function. */
4484 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4486 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4487 gdb_flush (gdb_stderr
);
4490 prfs_flags
|= PRFS_STOPEXEC
;
4492 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4494 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4495 gdb_flush (gdb_stderr
);
4499 #else /* not PRFS_STOPEXEC */
4500 /* Everyone else's (except OSF) method for tracing exec syscalls */
4502 Not all systems with /proc have all the exec* syscalls with the same
4503 names. On the SGI, for example, there is no SYS_exec, but there
4504 *is* a SYS_execv. So, we try to account for that. */
4506 premptyset (&exitset
);
4508 praddset (&exitset
, SYS_exec
);
4511 praddset (&exitset
, SYS_execve
);
4514 praddset (&exitset
, SYS_execv
);
4517 if (!proc_set_traced_sysexit (pi
, &exitset
))
4519 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4520 gdb_flush (gdb_stderr
);
4523 #endif /* PRFS_STOPEXEC */
4525 /* FIXME: should this be done in the parent instead? */
4526 /* Turn off inherit on fork flag so that all grand-children
4527 of gdb start with tracing flags cleared. */
4528 if (!proc_unset_inherit_on_fork (pi
))
4529 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4531 /* Turn off run on last close flag, so that the child process
4532 cannot run away just because we close our handle on it.
4533 We want it to wait for the parent to attach. */
4534 if (!proc_unset_run_on_last_close (pi
))
4535 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4537 /* FIXME: No need to destroy the procinfo --
4538 we have our own address space, and we're about to do an exec! */
4539 /*destroy_procinfo (pi);*/
4543 * Function: create_inferior
4545 * This function is called BEFORE gdb forks the inferior process.
4546 * Its only real responsibility is to set things up for the fork,
4547 * and tell GDB which two functions to call after the fork (one
4548 * for the parent, and one for the child).
4550 * This function does a complicated search for a unix shell program,
4551 * which it then uses to parse arguments and environment variables
4552 * to be sent to the child. I wonder whether this code could not
4553 * be abstracted out and shared with other unix targets such as
4558 procfs_create_inferior (char *exec_file
, char *allargs
, char **env
)
4560 char *shell_file
= getenv ("SHELL");
4562 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4565 /* We will be looking down the PATH to find shell_file. If we
4566 just do this the normal way (via execlp, which operates by
4567 attempting an exec for each element of the PATH until it
4568 finds one which succeeds), then there will be an exec for
4569 each failed attempt, each of which will cause a PR_SYSEXIT
4570 stop, and we won't know how to distinguish the PR_SYSEXIT's
4571 for these failed execs with the ones for successful execs
4572 (whether the exec has succeeded is stored at that time in the
4573 carry bit or some such architecture-specific and
4574 non-ABI-specified place).
4576 So I can't think of anything better than to search the PATH
4577 now. This has several disadvantages: (1) There is a race
4578 condition; if we find a file now and it is deleted before we
4579 exec it, we lose, even if the deletion leaves a valid file
4580 further down in the PATH, (2) there is no way to know exactly
4581 what an executable (in the sense of "capable of being
4582 exec'd") file is. Using access() loses because it may lose
4583 if the caller is the superuser; failing to use it loses if
4584 there are ACLs or some such. */
4588 /* FIXME-maybe: might want "set path" command so user can change what
4589 path is used from within GDB. */
4590 char *path
= getenv ("PATH");
4592 struct stat statbuf
;
4595 path
= "/bin:/usr/bin";
4597 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4598 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4600 p1
= strchr (p
, ':');
4605 strncpy (tryname
, p
, len
);
4606 tryname
[len
] = '\0';
4607 strcat (tryname
, "/");
4608 strcat (tryname
, shell_file
);
4609 if (access (tryname
, X_OK
) < 0)
4611 if (stat (tryname
, &statbuf
) < 0)
4613 if (!S_ISREG (statbuf
.st_mode
))
4614 /* We certainly need to reject directories. I'm not quite
4615 as sure about FIFOs, sockets, etc., but I kind of doubt
4616 that people want to exec() these things. */
4621 /* Not found. This must be an error rather than merely passing
4622 the file to execlp(), because execlp() would try all the
4623 exec()s, causing GDB to get confused. */
4624 error ("procfs:%d -- Can't find shell %s in PATH",
4625 __LINE__
, shell_file
);
4627 shell_file
= tryname
;
4630 fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4631 procfs_init_inferior
, NULL
, shell_file
);
4633 /* We are at the first instruction we care about. */
4634 /* Pedal to the metal... */
4636 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
4640 * Function: notice_thread
4642 * Callback for find_new_threads.
4643 * Calls "add_thread".
4647 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
4649 int gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4651 if (!in_thread_list (gdb_threadid
))
4652 add_thread (gdb_threadid
);
4658 * Function: target_find_new_threads
4660 * Query all the threads that the target knows about,
4661 * and give them back to GDB to add to its list.
4665 procfs_find_new_threads (void)
4669 /* Find procinfo for main process */
4670 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4671 proc_update_threads (pi
);
4672 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4676 * Function: target_thread_alive
4678 * Return true if the thread is still 'alive'.
4680 * This guy doesn't really seem to be doing his job.
4681 * Got to investigate how to tell when a thread is really gone.
4685 procfs_thread_alive (int pid
)
4690 proc
= PIDGET (pid
);
4691 thread
= TIDGET (pid
);
4692 /* If I don't know it, it ain't alive! */
4693 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4696 /* If I can't get its status, it ain't alive!
4697 What's more, I need to forget about it! */
4698 if (!proc_get_status (pi
))
4700 destroy_procinfo (pi
);
4703 /* I couldn't have got its status if it weren't alive, so it's alive. */
4708 * Function: target_pid_to_str
4710 * Return a string to be used to identify the thread in
4711 * the "info threads" display.
4715 procfs_pid_to_str (int pid
)
4717 static char buf
[80];
4721 proc
= PIDGET (pid
);
4722 thread
= TIDGET (pid
);
4723 pi
= find_procinfo (proc
, thread
);
4726 sprintf (buf
, "Process %d", proc
);
4728 sprintf (buf
, "LWP %d", thread
);
4733 * Function: procfs_set_watchpoint
4734 * Insert a watchpoint
4738 procfs_set_watchpoint (int pid
, CORE_ADDR addr
, int len
, int rwflag
, int after
)
4744 pi
= find_procinfo_or_die (pid
== -1 ?
4745 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4747 /* Translate from GDB's flags to /proc's */
4748 if (len
> 0) /* len == 0 means delete watchpoint */
4750 switch (rwflag
) { /* FIXME: need an enum! */
4751 case hw_write
: /* default watchpoint (write) */
4752 pflags
= WRITE_WATCHFLAG
;
4754 case hw_read
: /* read watchpoint */
4755 pflags
= READ_WATCHFLAG
;
4757 case hw_access
: /* access watchpoint */
4758 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
4760 case hw_execute
: /* execution HW breakpoint */
4761 pflags
= EXEC_WATCHFLAG
;
4763 default: /* Something weird. Return error. */
4766 if (after
) /* Stop after r/w access is completed. */
4767 pflags
|= AFTER_WATCHFLAG
;
4770 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
4772 if (errno
== E2BIG
) /* Typical error for no resources */
4773 return -1; /* fail */
4774 /* GDB may try to remove the same watchpoint twice.
4775 If a remove request returns no match, don't error. */
4776 if (errno
== ESRCH
&& len
== 0)
4777 return 0; /* ignore */
4778 proc_error (pi
, "set_watchpoint", __LINE__
);
4785 * Function: stopped_by_watchpoint
4787 * Returns non-zero if process is stopped on a hardware watchpoint fault,
4788 * else returns zero.
4792 procfs_stopped_by_watchpoint (int pid
)
4796 pi
= find_procinfo (pid
== -1 ?
4797 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4799 if (!pi
) /* If no process, then not stopped by watchpoint! */
4802 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
4804 if (proc_why (pi
) == PR_FAULTED
)
4807 if (proc_what (pi
) == FLTWATCH
)
4811 if (proc_what (pi
) == FLTKWATCH
)
4819 #ifdef TM_I386SOL2_H
4821 * Function: procfs_find_LDT_entry
4824 * int pid; // The GDB-style pid-plus-LWP.
4827 * pointer to the corresponding LDT entry.
4831 procfs_find_LDT_entry (int pid
)
4833 gdb_gregset_t
*gregs
;
4837 /* Find procinfo for the lwp. */
4838 if ((pi
= find_procinfo (PIDGET (pid
), TIDGET (pid
))) == NULL
)
4840 warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
4844 /* get its general registers. */
4845 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
4847 warning ("procfs_find_LDT_entry: could not read gregs for %d.",
4851 /* Now extract the GS register's lower 16 bits. */
4852 key
= (*gregs
)[GS
] & 0xffff;
4854 /* Find the matching entry and return it. */
4855 return proc_get_LDT_entry (pi
, key
);
4857 #endif /* TM_I386SOL2_H */
4862 info_proc_cmd (char *args
, int from_tty
)
4864 struct cleanup
*old_chain
;
4865 procinfo
*process
= NULL
;
4866 procinfo
*thread
= NULL
;
4872 old_chain
= make_cleanup (null_cleanup
, 0);
4875 if ((argv
= buildargv (args
)) == NULL
)
4878 make_cleanup_freeargv (argv
);
4880 while (argv
!= NULL
&& *argv
!= NULL
)
4882 if (isdigit (argv
[0][0]))
4884 pid
= strtoul (argv
[0], &tmp
, 10);
4886 tid
= strtoul (++tmp
, NULL
, 10);
4888 else if (argv
[0][0] == '/')
4890 tid
= strtoul (argv
[0] + 1, NULL
, 10);
4899 pid
= PIDGET (inferior_pid
);
4901 error ("No current process: you must name one.");
4904 /* Have pid, will travel.
4905 First see if it's a process we're already debugging. */
4906 process
= find_procinfo (pid
, 0);
4907 if (process
== NULL
)
4909 /* No. So open a procinfo for it, but
4910 remember to close it again when finished. */
4911 process
= create_procinfo (pid
, 0);
4912 make_cleanup (do_destroy_procinfo_cleanup
, process
);
4913 if (!open_procinfo_files (process
, FD_CTL
))
4914 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
4918 thread
= create_procinfo (pid
, tid
);
4922 printf_filtered ("process %d flags:\n", process
->pid
);
4923 proc_prettyprint_flags (proc_flags (process
), 1);
4924 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
4925 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
4926 if (proc_get_nthreads (process
) > 1)
4927 printf_filtered ("Process has %d threads.\n",
4928 proc_get_nthreads (process
));
4932 printf_filtered ("thread %d flags:\n", thread
->tid
);
4933 proc_prettyprint_flags (proc_flags (thread
), 1);
4934 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
4935 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
4938 do_cleanups (old_chain
);
4942 proc_trace_syscalls (char *args
, int from_tty
, int entry_or_exit
, int mode
)
4948 if (inferior_pid
<= 0)
4949 error ("you must be debugging a process to use this command.");
4951 if (args
== NULL
|| args
[0] == 0)
4952 error_no_arg ("system call to trace");
4954 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4955 if (isdigit (args
[0]))
4957 syscallnum
= atoi (args
);
4958 if (entry_or_exit
== PR_SYSENTRY
)
4959 sysset
= proc_get_traced_sysentry (pi
, NULL
);
4961 sysset
= proc_get_traced_sysexit (pi
, NULL
);
4964 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
4966 if (mode
== FLAG_SET
)
4967 praddset (sysset
, syscallnum
);
4969 prdelset (sysset
, syscallnum
);
4971 if (entry_or_exit
== PR_SYSENTRY
)
4973 if (!proc_set_traced_sysentry (pi
, sysset
))
4974 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
4978 if (!proc_set_traced_sysexit (pi
, sysset
))
4979 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
4985 proc_trace_sysentry_cmd (char *args
, int from_tty
)
4987 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
4991 proc_trace_sysexit_cmd (char *args
, int from_tty
)
4993 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
4997 proc_untrace_sysentry_cmd (char *args
, int from_tty
)
4999 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5003 proc_untrace_sysexit_cmd (char *args
, int from_tty
)
5005 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5010 _initialize_procfs (void)
5013 add_target (&procfs_ops
);
5014 add_info ("proc", info_proc_cmd
,
5015 "Show /proc process information about any running process.\
5016 Default is the process being debugged.");
5017 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5018 "Give a trace of entries into the syscall.");
5019 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5020 "Give a trace of exits from the syscall.");
5021 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5022 "Cancel a trace of entries into the syscall.");
5023 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5024 "Cancel a trace of exits from the syscall.");
5027 /* =================== END, GDB "MODULE" =================== */
5031 /* miscelaneous stubs: */
5032 /* The following satisfy a few random symbols mostly created by */
5033 /* the solaris threads implementation, which I will chase down */
5037 * Return a pid for which we guarantee
5038 * we will be able to find a 'live' procinfo.
5042 procfs_first_available (void)
5045 return procinfo_list
->pid
;