1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 Copyright 1999 Free Software Foundation, Inc.
3 Written by Michael Snyder at Cygnus Solutions.
4 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software Foundation,
20 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "gdbthread.h"
29 #if defined (NEW_PROC_API)
30 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
33 #include <sys/procfs.h>
34 #include <sys/fault.h>
35 #include <sys/syscall.h>
36 #include <sys/errno.h>
44 * This module provides the interface between GDB and the
45 * /proc file system, which is used on many versions of Unix
46 * as a means for debuggers to control other processes.
47 * Examples of the systems that use this interface are:
53 * /proc works by immitating a file system: you open a simulated file
54 * that represents the process you wish to interact with, and
55 * perform operations on that "file" in order to examine or change
56 * the state of the other process.
58 * The most important thing to know about /proc and this module
59 * is that there are two very different interfaces to /proc:
60 * One that uses the ioctl system call, and
61 * another that uses read and write system calls.
62 * This module has to support both /proc interfaces. This means
63 * that there are two different ways of doing every basic operation.
65 * In order to keep most of the code simple and clean, I have
66 * defined an interface "layer" which hides all these system calls.
67 * An ifdef (NEW_PROC_API) determines which interface we are using,
68 * and most or all occurrances of this ifdef should be confined to
69 * this interface layer.
73 /* Determine which /proc API we are using:
74 The ioctl API defines PIOCSTATUS, while
75 the read/write (multiple fd) API never does. */
78 #include <sys/types.h>
79 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
82 #include <fcntl.h> /* for O_RDONLY */
83 #include <unistd.h> /* for "X_OK" */
84 #include "gdb_stat.h" /* for struct stat */
86 /* Note: procfs-utils.h must be included after the above system header
87 files, because it redefines various system calls using macros.
88 This may be incompatible with the prototype declarations. */
90 #include "proc-utils.h"
92 /* =================== TARGET_OPS "MODULE" =================== */
95 * This module defines the GDB target vector and its methods.
98 static void procfs_open
PARAMS((char *, int));
99 static void procfs_attach
PARAMS ((char *, int));
100 static void procfs_detach
PARAMS ((char *, int));
101 static void procfs_resume
PARAMS ((int, int, enum target_signal
));
102 static int procfs_can_run
PARAMS ((void));
103 static void procfs_stop
PARAMS ((void));
104 static void procfs_files_info
PARAMS ((struct target_ops
*));
105 static void procfs_fetch_registers
PARAMS ((int));
106 static void procfs_store_registers
PARAMS ((int));
107 static void procfs_notice_signals
PARAMS ((int));
108 static void procfs_prepare_to_store
PARAMS ((void));
109 static void procfs_kill_inferior
PARAMS ((void));
110 static void procfs_mourn_inferior
PARAMS ((void));
111 static void procfs_create_inferior
PARAMS ((char *, char *, char **));
112 static int procfs_wait
PARAMS ((int,
113 struct target_waitstatus
*));
114 static int procfs_xfer_memory
PARAMS ((CORE_ADDR
,
116 struct target_ops
*));
118 static int procfs_thread_alive
PARAMS ((int));
120 void procfs_find_new_threads
PARAMS ((void));
121 char *procfs_pid_to_str
PARAMS ((int));
123 struct target_ops procfs_ops
; /* the target vector */
128 procfs_ops
.to_shortname
= "procfs";
129 procfs_ops
.to_longname
= "Unix /proc child process";
131 "Unix /proc child process (started by the \"run\" command).";
132 procfs_ops
.to_open
= procfs_open
;
133 procfs_ops
.to_can_run
= procfs_can_run
;
134 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
135 procfs_ops
.to_kill
= procfs_kill_inferior
;
136 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
137 procfs_ops
.to_attach
= procfs_attach
;
138 procfs_ops
.to_detach
= procfs_detach
;
139 procfs_ops
.to_wait
= procfs_wait
;
140 procfs_ops
.to_resume
= procfs_resume
;
141 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
142 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
143 procfs_ops
.to_store_registers
= procfs_store_registers
;
144 procfs_ops
.to_xfer_memory
= procfs_xfer_memory
;
145 procfs_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
146 procfs_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
147 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
148 procfs_ops
.to_files_info
= procfs_files_info
;
149 procfs_ops
.to_stop
= procfs_stop
;
151 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
152 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
153 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
154 procfs_ops
.to_terminal_ours
= terminal_ours
;
155 procfs_ops
.to_terminal_info
= child_terminal_info
;
157 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
158 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
159 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
161 procfs_ops
.to_has_all_memory
= 1;
162 procfs_ops
.to_has_memory
= 1;
163 procfs_ops
.to_has_execution
= 1;
164 procfs_ops
.to_has_stack
= 1;
165 procfs_ops
.to_has_registers
= 1;
166 procfs_ops
.to_stratum
= process_stratum
;
167 procfs_ops
.to_has_thread_control
= tc_schedlock
;
168 procfs_ops
.to_magic
= OPS_MAGIC
;
171 /* =================== END, TARGET_OPS "MODULE" =================== */
176 * Put any typedefs, defines etc. here that are required for
177 * the unification of code that handles different versions of /proc.
180 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
182 enum { READ_WATCHFLAG
= WA_READ
,
183 WRITE_WATCHFLAG
= WA_WRITE
,
184 EXEC_WATCHFLAG
= WA_EXEC
,
185 AFTER_WATCHFLAG
= WA_TRAPAFTER
188 #else /* Irix method for watchpoints */
189 enum { READ_WATCHFLAG
= MA_READ
,
190 WRITE_WATCHFLAG
= MA_WRITE
,
191 EXEC_WATCHFLAG
= MA_EXEC
,
192 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
199 /* =================== STRUCT PROCINFO "MODULE" =================== */
201 /* FIXME: this comment will soon be out of date W.R.T. threads. */
203 /* The procinfo struct is a wrapper to hold all the state information
204 concerning a /proc process. There should be exactly one procinfo
205 for each process, and since GDB currently can debug only one
206 process at a time, that means there should be only one procinfo.
207 All of the LWP's of a process can be accessed indirectly thru the
208 single process procinfo.
210 However, against the day when GDB may debug more than one process,
211 this data structure is kept in a list (which for now will hold no
212 more than one member), and many functions will have a pointer to a
213 procinfo as an argument.
215 There will be a separate procinfo structure for use by the (not yet
216 implemented) "info proc" command, so that we can print useful
217 information about any random process without interfering with the
218 inferior's procinfo information. */
221 /* format strings for /proc paths */
222 # ifndef CTL_PROC_NAME_FMT
223 # define MAIN_PROC_NAME_FMT "/proc/%d"
224 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
225 # define AS_PROC_NAME_FMT "/proc/%d/as"
226 # define MAP_PROC_NAME_FMT "/proc/%d/map"
227 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
228 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
230 /* the name of the proc status struct depends on the implementation */
231 typedef pstatus_t gdb_prstatus_t
;
232 typedef lwpstatus_t gdb_lwpstatus_t
;
233 #else /* ! NEW_PROC_API */
234 /* format strings for /proc paths */
235 # ifndef CTL_PROC_NAME_FMT
236 # define MAIN_PROC_NAME_FMT "/proc/%05d"
237 # define CTL_PROC_NAME_FMT "/proc/%05d"
238 # define AS_PROC_NAME_FMT "/proc/%05d"
239 # define MAP_PROC_NAME_FMT "/proc/%05d"
240 # define STATUS_PROC_NAME_FMT "/proc/%05d"
241 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
243 /* the name of the proc status struct depends on the implementation */
244 typedef prstatus_t gdb_prstatus_t
;
245 typedef prstatus_t gdb_lwpstatus_t
;
246 #endif /* NEW_PROC_API */
249 /* These #ifdefs are for sol2.x in particular. sol2.x has
250 both a "gregset_t" and a "prgregset_t", which have
251 similar uses but different layouts. sol2.x gdb tries to
252 use prgregset_t (and prfpregset_t) everywhere. */
254 #ifdef GDB_GREGSET_TYPE
255 typedef GDB_GREGSET_TYPE gdb_gregset_t
;
257 typedef gregset_t gdb_gregset_t
;
260 #ifdef GDB_FPREGSET_TYPE
261 typedef GDB_FPREGSET_TYPE gdb_fpregset_t
;
263 typedef fpregset_t gdb_fpregset_t
;
266 /* Provide default composite pid manipulation macros for systems that
267 don't have threads. */
270 #define PIDGET(PID) (PID)
271 #define TIDGET(PID) (PID)
274 #define MERGEPID(PID, TID) (PID)
277 typedef struct procinfo
{
278 struct procinfo
*next
;
279 int pid
; /* Process ID */
280 int tid
; /* Thread/LWP id */
284 int ignore_next_sigstop
;
286 /* The following four fd fields may be identical, or may contain
287 several different fd's, depending on the version of /proc
288 (old ioctl or new read/write). */
290 int ctl_fd
; /* File descriptor for /proc control file */
292 * The next three file descriptors are actually only needed in the
293 * read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
294 * However, to avoid a bunch of #ifdefs in the code, we will use
295 * them uniformly by (in the case of the ioctl single-file-descriptor
296 * implementation) filling them with copies of the control fd.
298 int status_fd
; /* File descriptor for /proc status file */
299 int as_fd
; /* File descriptor for /proc as file */
301 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
303 fltset_t saved_fltset
; /* Saved traced hardware fault set */
304 sigset_t saved_sigset
; /* Saved traced signal set */
305 sigset_t saved_sighold
; /* Saved held signal set */
306 sysset_t saved_exitset
; /* Saved traced system call exit set */
307 sysset_t saved_entryset
; /* Saved traced system call entry set */
309 gdb_prstatus_t prstatus
; /* Current process status info */
312 gdb_fpregset_t fpregset
; /* Current floating point registers */
315 struct procinfo
*thread_list
;
317 int status_valid
: 1;
319 int fpregs_valid
: 1;
320 int threads_valid
: 1;
323 static char errmsg
[128]; /* shared error msg buffer */
325 /* Function prototypes for procinfo module: */
327 static procinfo
*find_procinfo_or_die
PARAMS ((int pid
, int tid
));
328 static procinfo
*find_procinfo
PARAMS ((int pid
, int tid
));
329 static procinfo
*create_procinfo
PARAMS ((int pid
, int tid
));
330 static void destroy_procinfo
PARAMS ((procinfo
*p
));
331 static void dead_procinfo
PARAMS ((procinfo
*p
,
332 char *msg
, int killp
));
333 static int open_procinfo_files
PARAMS ((procinfo
*p
, int which
));
334 static void close_procinfo_files
PARAMS ((procinfo
*p
));
336 /* The head of the procinfo list: */
337 static procinfo
* procinfo_list
;
340 * Function: find_procinfo
342 * Search the procinfo list.
344 * Returns: pointer to procinfo, or NULL if not found.
348 find_procinfo (pid
, tid
)
354 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
361 /* Don't check threads_valid. If we're updating the
362 thread_list, we want to find whatever threads are already
363 here. This means that in general it is the caller's
364 responsibility to check threads_valid and update before
365 calling find_procinfo, if the caller wants to find a new
368 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
377 * Function: find_procinfo_or_die
379 * Calls find_procinfo, but errors on failure.
383 find_procinfo_or_die (pid
, tid
)
387 procinfo
*pi
= find_procinfo (pid
, tid
);
392 error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",
395 error ("procfs: couldn't find pid %d in procinfo list.", pid
);
401 * Function: open_procinfo_files
403 * Open the file descriptor for the process or LWP.
404 * ifdef NEW_PROC_API, we only open the control file descriptor;
405 * the others are opened lazily as needed.
406 * else (if not NEW_PROC_API), there is only one real
407 * file descriptor, but we keep multiple copies of it so that
408 * the code that uses them does not have to be #ifdef'd.
410 * Return: file descriptor, or zero for failure.
413 enum { FD_CTL
, FD_STATUS
, FD_AS
};
416 open_procinfo_files (pi
, which
)
421 char tmp
[MAX_PROC_NAME_SIZE
];
426 * This function is getting ALMOST long enough to break up into several.
427 * Here is some rationale:
429 * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
430 * There are several file descriptors that may need to be open
431 * for any given process or LWP. The ones we're intereted in are:
432 * - control (ctl) write-only change the state
433 * - status (status) read-only query the state
434 * - address space (as) read/write access memory
435 * - map (map) read-only virtual addr map
436 * Most of these are opened lazily as they are needed.
437 * The pathnames for the 'files' for an LWP look slightly
438 * different from those of a first-class process:
439 * Pathnames for a process (<proc-id>):
440 * /proc/<proc-id>/ctl
441 * /proc/<proc-id>/status
443 * /proc/<proc-id>/map
444 * Pathnames for an LWP (lwp-id):
445 * /proc/<proc-id>/lwp/<lwp-id>/lwpctl
446 * /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
447 * An LWP has no map or address space file descriptor, since
448 * the memory map and address space are shared by all LWPs.
450 * Everyone else (Solaris 2.5, Irix, OSF)
451 * There is only one file descriptor for each process or LWP.
452 * For convenience, we copy the same file descriptor into all
453 * three fields of the procinfo struct (ctl_fd, status_fd, and
454 * as_fd, see NEW_PROC_API above) so that code that uses them
455 * doesn't need any #ifdef's.
460 * Each LWP has an independent file descriptor, but these
461 * are not obtained via the 'open' system call like the rest:
462 * instead, they're obtained thru an ioctl call (PIOCOPENLWP)
463 * to the file descriptor of the parent process.
466 * These do not even have their own independent file descriptor.
467 * All operations are carried out on the file descriptor of the
468 * parent process. Therefore we just call open again for each
469 * thread, getting a new handle for the same 'file'.
474 * In this case, there are several different file descriptors that
475 * we might be asked to open. The control file descriptor will be
476 * opened early, but the others will be opened lazily as they are
480 strcpy (tmp
, pi
->pathname
);
481 switch (which
) { /* which file descriptor to open? */
484 strcat (tmp
, "/lwpctl");
486 strcat (tmp
, "/ctl");
487 fd
= open (tmp
, O_WRONLY
);
494 return 0; /* there is no 'as' file descriptor for an lwp */
496 fd
= open (tmp
, O_RDWR
);
503 strcat (tmp
, "/lwpstatus");
505 strcat (tmp
, "/status");
506 fd
= open (tmp
, O_RDONLY
);
512 return 0; /* unknown file descriptor */
514 #else /* not NEW_PROC_API */
516 * In this case, there is only one file descriptor for each procinfo
517 * (ie. each process or LWP). In fact, only the file descriptor for
518 * the process can actually be opened by an 'open' system call.
519 * The ones for the LWPs have to be obtained thru an IOCTL call
520 * on the process's file descriptor.
522 * For convenience, we copy each procinfo's single file descriptor
523 * into all of the fields occupied by the several file descriptors
524 * of the NEW_PROC_API implementation. That way, the code that uses
525 * them can be written without ifdefs.
529 #ifdef PIOCTSTATUS /* OSF */
530 if ((fd
= open (pi
->pathname
, O_RDWR
)) == 0) /* Only one FD; just open it. */
532 #else /* Sol 2.5, Irix, other? */
533 if (pi
->tid
== 0) /* Master procinfo for the process */
535 fd
= open (pi
->pathname
, O_RDWR
);
539 else /* LWP thread procinfo */
541 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
545 /* Find the procinfo for the entire process. */
546 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
549 /* Now obtain the file descriptor for the LWP. */
550 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) <= 0)
552 #else /* Irix, other? */
553 return 0; /* Don't know how to open threads */
554 #endif /* Sol 2.5 PIOCOPENLWP */
556 #endif /* OSF PIOCTSTATUS */
557 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
558 #endif /* NEW_PROC_API */
560 return 1; /* success */
564 * Function: create_procinfo
566 * Allocate a data structure and link it into the procinfo list.
567 * (First tries to find a pre-existing one (FIXME: why?)
569 * Return: pointer to new procinfo struct.
573 create_procinfo (pid
, tid
)
577 procinfo
*pi
, *parent
;
579 if ((pi
= find_procinfo (pid
, tid
)))
580 return pi
; /* Already exists, nothing to do. */
582 /* find parent before doing malloc, to save having to cleanup */
584 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
586 doesn't exist yet? */
588 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
589 memset (pi
, 0, sizeof (procinfo
));
593 /* Chain into list. */
596 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
597 pi
->next
= procinfo_list
;
603 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
605 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
607 pi
->next
= parent
->thread_list
;
608 parent
->thread_list
= pi
;
614 * Function: close_procinfo_files
616 * Close all file descriptors associated with the procinfo
620 close_procinfo_files (pi
)
628 if (pi
->status_fd
> 0)
629 close (pi
->status_fd
);
631 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
635 * Function: destroy_procinfo
637 * Destructor function. Close, unlink and deallocate the object.
641 destroy_one_procinfo (list
, pi
)
647 /* Step one: unlink the procinfo from its list */
651 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
654 ptr
->next
= pi
->next
;
658 /* Step two: close any open file descriptors */
659 close_procinfo_files (pi
);
661 /* Step three: free the memory. */
666 destroy_procinfo (pi
)
671 if (pi
->tid
!= 0) /* destroy a thread procinfo */
673 tmp
= find_procinfo (pi
->pid
, 0); /* find the parent process */
674 destroy_one_procinfo (&tmp
->thread_list
, pi
);
676 else /* destroy a process procinfo and all its threads */
678 /* First destroy the children, if any; */
679 while (pi
->thread_list
!= NULL
)
680 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
681 /* Then destroy the parent. Genocide!!! */
682 destroy_one_procinfo (&procinfo_list
, pi
);
686 enum { NOKILL
, KILL
};
689 * Function: dead_procinfo
691 * To be called on a non_recoverable error for a procinfo.
692 * Prints error messages, optionally sends a SIGKILL to the process,
693 * then destroys the data structure.
697 dead_procinfo (pi
, msg
, kill_p
)
706 print_sys_errmsg (pi
->pathname
, errno
);
710 sprintf (procfile
, "process %d", pi
->pid
);
711 print_sys_errmsg (procfile
, errno
);
714 kill (pi
->pid
, SIGKILL
);
716 destroy_procinfo (pi
);
720 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
722 /* =================== /proc "MODULE" =================== */
725 * This "module" is the interface layer between the /proc system API
726 * and the gdb target vector functions. This layer consists of
727 * access functions that encapsulate each of the basic operations
728 * that we need to use from the /proc API.
730 * The main motivation for this layer is to hide the fact that
731 * there are two very different implementations of the /proc API.
732 * Rather than have a bunch of #ifdefs all thru the gdb target vector
733 * functions, we do our best to hide them all in here.
736 int proc_get_status
PARAMS ((procinfo
*pi
));
737 long proc_flags
PARAMS ((procinfo
*pi
));
738 int proc_why
PARAMS ((procinfo
*pi
));
739 int proc_what
PARAMS ((procinfo
*pi
));
740 int proc_set_run_on_last_close
PARAMS ((procinfo
*pi
));
741 int proc_unset_run_on_last_close
PARAMS ((procinfo
*pi
));
742 int proc_set_inherit_on_fork
PARAMS ((procinfo
*pi
));
743 int proc_unset_inherit_on_fork
PARAMS ((procinfo
*pi
));
744 int proc_set_async
PARAMS ((procinfo
*pi
));
745 int proc_unset_async
PARAMS ((procinfo
*pi
));
746 int proc_stop_process
PARAMS ((procinfo
*pi
));
747 int proc_trace_signal
PARAMS ((procinfo
*pi
, int signo
));
748 int proc_ignore_signal
PARAMS ((procinfo
*pi
, int signo
));
749 int proc_clear_current_fault
PARAMS ((procinfo
*pi
));
750 int proc_set_current_signal
PARAMS ((procinfo
*pi
, int signo
));
751 int proc_clear_current_signal
PARAMS ((procinfo
*pi
));
752 int proc_set_gregs
PARAMS ((procinfo
*pi
));
753 int proc_set_fpregs
PARAMS ((procinfo
*pi
));
754 int proc_wait_for_stop
PARAMS ((procinfo
*pi
));
755 int proc_run_process
PARAMS ((procinfo
*pi
, int step
, int signo
));
756 int proc_kill
PARAMS ((procinfo
*pi
, int signo
));
757 int proc_parent_pid
PARAMS ((procinfo
*pi
));
758 int proc_get_nthreads
PARAMS ((procinfo
*pi
));
759 int proc_get_current_thread
PARAMS ((procinfo
*pi
));
760 int proc_set_held_signals
PARAMS ((procinfo
*pi
, sigset_t
*sighold
));
761 int proc_set_traced_sysexit
PARAMS ((procinfo
*pi
, sysset_t
*sysset
));
762 int proc_set_traced_sysentry
PARAMS ((procinfo
*pi
, sysset_t
*sysset
));
763 int proc_set_traced_faults
PARAMS ((procinfo
*pi
, fltset_t
*fltset
));
764 int proc_set_traced_signals
PARAMS ((procinfo
*pi
, sigset_t
*sigset
));
766 int proc_update_threads
PARAMS ((procinfo
*pi
));
767 int proc_iterate_over_threads
PARAMS ((procinfo
*pi
,
768 int (*func
) PARAMS ((procinfo
*,
773 gdb_gregset_t
*proc_get_gregs
PARAMS ((procinfo
*pi
));
774 gdb_fpregset_t
*proc_get_fpregs
PARAMS ((procinfo
*pi
));
775 sysset_t
*proc_get_traced_sysexit
PARAMS ((procinfo
*pi
, sysset_t
*save
));
776 sysset_t
*proc_get_traced_sysentry
PARAMS ((procinfo
*pi
, sysset_t
*save
));
777 fltset_t
*proc_get_traced_faults
PARAMS ((procinfo
*pi
, fltset_t
*save
));
778 sigset_t
*proc_get_traced_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
779 sigset_t
*proc_get_held_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
780 sigset_t
*proc_get_pending_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
781 struct sigaction
*proc_get_signal_actions
PARAMS ((procinfo
*pi
,
782 struct sigaction
*save
));
784 void proc_warn
PARAMS ((procinfo
*pi
, char *func
, int line
));
785 void proc_error
PARAMS ((procinfo
*pi
, char *func
, int line
));
788 proc_warn (pi
, func
, line
)
793 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
794 print_sys_errmsg (errmsg
, errno
);
798 proc_error (pi
, func
, line
)
803 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
804 perror_with_name (errmsg
);
808 * Function: proc_get_status
810 * Updates the status struct in the procinfo.
811 * There is a 'valid' flag, to let other functions know when
812 * this function needs to be called (so the status is only
813 * read when it is needed). The status file descriptor is
814 * also only opened when it is needed.
816 * Return: non-zero for success, zero for failure.
823 /* Status file descriptor is opened "lazily" */
824 if (pi
->status_fd
== 0 &&
825 open_procinfo_files (pi
, FD_STATUS
) == 0)
827 pi
->status_valid
= 0;
832 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
833 pi
->status_valid
= 0; /* fail */
836 /* Sigh... I have to read a different data structure,
837 depending on whether this is a main process or an LWP. */
839 pi
->status_valid
= (read (pi
->status_fd
,
840 (char *) &pi
->prstatus
.pr_lwp
,
841 sizeof (lwpstatus_t
))
842 == sizeof (lwpstatus_t
));
845 pi
->status_valid
= (read (pi
->status_fd
,
846 (char *) &pi
->prstatus
,
847 sizeof (gdb_prstatus_t
))
848 == sizeof (gdb_prstatus_t
));
849 #if 0 /*def UNIXWARE*/
850 if (pi
->status_valid
&&
851 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
852 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
853 /* Unixware peculiarity -- read the damn thing again! */
854 pi
->status_valid
= (read (pi
->status_fd
,
855 (char *) &pi
->prstatus
,
856 sizeof (gdb_prstatus_t
))
857 == sizeof (gdb_prstatus_t
));
858 #endif /* UNIXWARE */
861 #else /* ioctl method */
862 #ifdef PIOCTSTATUS /* osf */
863 if (pi
->tid
== 0) /* main process */
865 /* Just read the danged status. Now isn't that simple? */
867 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
874 tid_t pr_error_thread
;
875 struct prstatus status
;
878 thread_status
.pr_count
= 1;
879 thread_status
.status
.pr_tid
= pi
->tid
;
880 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
883 memcpy (&pi
->prstatus
, &thread_status
.status
,
884 sizeof (pi
->prstatus
));
885 pi
->status_valid
= 1;
889 /* Just read the danged status. Now isn't that simple? */
890 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
894 if (pi
->status_valid
)
896 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
899 proc_get_current_thread (pi
));
902 /* The status struct includes general regs, so mark them valid too */
903 pi
->gregs_valid
= pi
->status_valid
;
905 /* In the read/write multiple-fd model,
906 the status struct includes the fp regs too, so mark them valid too */
907 pi
->fpregs_valid
= pi
->status_valid
;
909 return pi
->status_valid
; /* True if success, false if failure. */
913 * Function: proc_flags
915 * returns the process flags (pr_flags field).
922 if (!pi
->status_valid
)
923 if (!proc_get_status (pi
))
924 return 0; /* FIXME: not a good failure value (but what is?) */
928 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
929 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
930 The two sets of flags don't overlap. */
931 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
933 return pi
->prstatus
.pr_lwp
.pr_flags
;
936 return pi
->prstatus
.pr_flags
;
943 * returns the pr_why field (why the process stopped).
950 if (!pi
->status_valid
)
951 if (!proc_get_status (pi
))
952 return 0; /* FIXME: not a good failure value (but what is?) */
955 return pi
->prstatus
.pr_lwp
.pr_why
;
957 return pi
->prstatus
.pr_why
;
962 * Function: proc_what
964 * returns the pr_what field (details of why the process stopped).
971 if (!pi
->status_valid
)
972 if (!proc_get_status (pi
))
973 return 0; /* FIXME: not a good failure value (but what is?) */
976 return pi
->prstatus
.pr_lwp
.pr_what
;
978 return pi
->prstatus
.pr_what
;
982 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
984 * Function: proc_nsysarg
986 * returns the pr_nsysarg field (number of args to the current syscall).
993 if (!pi
->status_valid
)
994 if (!proc_get_status (pi
))
998 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1000 return pi
->prstatus
.pr_nsysarg
;
1005 * Function: proc_sysargs
1007 * returns the pr_sysarg field (pointer to the arguments of current syscall).
1014 if (!pi
->status_valid
)
1015 if (!proc_get_status (pi
))
1019 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1021 return (long *) &pi
->prstatus
.pr_sysarg
;
1026 * Function: proc_syscall
1028 * returns the pr_syscall field (id of current syscall if we are in one).
1035 if (!pi
->status_valid
)
1036 if (!proc_get_status (pi
))
1040 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1042 return pi
->prstatus
.pr_syscall
;
1045 #endif /* PIOCSSPCACT */
1048 * Function: proc_cursig:
1050 * returns the pr_cursig field (current signal).
1054 proc_cursig (struct procinfo
*pi
)
1056 if (!pi
->status_valid
)
1057 if (!proc_get_status (pi
))
1058 return 0; /* FIXME: not a good failure value (but what is?) */
1061 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1063 return pi
->prstatus
.pr_cursig
;
1068 * Function: proc_modify_flag
1070 * === I appologize for the messiness of this function.
1071 * === This is an area where the different versions of
1072 * === /proc are more inconsistent than usual. MVS
1074 * Set or reset any of the following process flags:
1075 * PR_FORK -- forked child will inherit trace flags
1076 * PR_RLC -- traced process runs when last /proc file closed.
1077 * PR_KLC -- traced process is killed when last /proc file closed.
1078 * PR_ASYNC -- LWP's get to run/stop independently.
1080 * There are three methods for doing this function:
1081 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1083 * 2) Middle: PIOCSET/PIOCRESET
1085 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1088 * Note: Irix does not define PR_ASYNC.
1089 * Note: OSF does not define PR_KLC.
1090 * Note: OSF is the only one that can ONLY use the oldest method.
1093 * pi -- the procinfo
1094 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1095 * mode -- 1 for set, 0 for reset.
1097 * Returns non-zero for success, zero for failure.
1100 enum { FLAG_RESET
, FLAG_SET
};
1103 proc_modify_flag (pi
, flag
, mode
)
1108 long win
= 0; /* default to fail */
1111 * These operations affect the process as a whole, and applying
1112 * them to an individual LWP has the same meaning as applying them
1113 * to the main process. Therefore, if we're ever called with a
1114 * pointer to an LWP's procinfo, let's substitute the process's
1115 * procinfo and avoid opening the LWP's file descriptor
1120 pi
= find_procinfo_or_die (pi
->pid
, 0);
1122 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
1123 /* First normalize the PCUNSET/PCRESET command opcode
1124 (which for no obvious reason has a different definition
1125 from one operating system to the next...) */
1127 #define GDBRESET PCUNSET
1130 #define GDBRESET PCRESET
1135 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC) */
1137 else /* Reset the flag */
1141 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1144 #ifdef PIOCSET /* Irix/Sol5 method */
1145 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
1147 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1149 else /* Reset the flag */
1151 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1155 #ifdef PIOCSRLC /* Oldest method: OSF */
1158 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1160 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1162 else /* Clear run-on-last-close */
1164 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1168 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1170 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1172 else /* Clear inherit-on-fork */
1174 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1178 win
= 0; /* fail -- unknown flag (can't do PR_ASYNC) */
1185 /* The above operation renders the procinfo's cached pstatus obsolete. */
1186 pi
->status_valid
= 0;
1189 warning ("procfs: modify_flag failed to turn %s %s",
1190 flag
== PR_FORK
? "PR_FORK" :
1191 flag
== PR_RLC
? "PR_RLC" :
1193 flag
== PR_ASYNC
? "PR_ASYNC" :
1196 flag
== PR_KLC
? "PR_KLC" :
1199 mode
== FLAG_RESET
? "off" : "on");
1205 * Function: proc_set_run_on_last_close
1207 * Set the run_on_last_close flag.
1208 * Process with all threads will become runnable
1209 * when debugger closes all /proc fds.
1211 * Returns non-zero for success, zero for failure.
1215 proc_set_run_on_last_close (pi
)
1218 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1222 * Function: proc_unset_run_on_last_close
1224 * Reset the run_on_last_close flag.
1225 * Process will NOT become runnable
1226 * when debugger closes its file handles.
1228 * Returns non-zero for success, zero for failure.
1232 proc_unset_run_on_last_close (pi
)
1235 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1240 * Function: proc_set_kill_on_last_close
1242 * Set the kill_on_last_close flag.
1243 * Process with all threads will be killed when debugger
1244 * closes all /proc fds (or debugger exits or dies).
1246 * Returns non-zero for success, zero for failure.
1250 proc_set_kill_on_last_close (pi
)
1253 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1257 * Function: proc_unset_kill_on_last_close
1259 * Reset the kill_on_last_close flag.
1260 * Process will NOT be killed when debugger
1261 * closes its file handles (or exits or dies).
1263 * Returns non-zero for success, zero for failure.
1267 proc_unset_kill_on_last_close (pi
)
1270 return proc_modify_flag (pi
, PR_KLC
, FLAG_RESET
);
1275 * Function: proc_set_inherit_on_fork
1277 * Set inherit_on_fork flag.
1278 * If the process forks a child while we are registered for events
1279 * in the parent, then we will also recieve events from the child.
1281 * Returns non-zero for success, zero for failure.
1285 proc_set_inherit_on_fork (pi
)
1288 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1292 * Function: proc_unset_inherit_on_fork
1294 * Reset inherit_on_fork flag.
1295 * If the process forks a child while we are registered for events
1296 * in the parent, then we will NOT recieve events from the child.
1298 * Returns non-zero for success, zero for failure.
1302 proc_unset_inherit_on_fork (pi
)
1305 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1310 * Function: proc_set_async
1312 * Set PR_ASYNC flag.
1313 * If one LWP stops because of a debug event (signal etc.),
1314 * the remaining LWPs will continue to run.
1316 * Returns non-zero for success, zero for failure.
1323 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1327 * Function: proc_unset_async
1329 * Reset PR_ASYNC flag.
1330 * If one LWP stops because of a debug event (signal etc.),
1331 * then all other LWPs will stop as well.
1333 * Returns non-zero for success, zero for failure.
1337 proc_unset_async (pi
)
1340 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1342 #endif /* PR_ASYNC */
1345 * Function: proc_stop_process
1347 * Request the process/LWP to stop. Does not wait.
1348 * Returns non-zero for success, zero for failure.
1352 proc_stop_process (pi
)
1358 * We might conceivably apply this operation to an LWP, and
1359 * the LWP's ctl file descriptor might not be open.
1362 if (pi
->ctl_fd
== 0 &&
1363 open_procinfo_files (pi
, FD_CTL
) == 0)
1369 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1370 #else /* ioctl method */
1371 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1372 /* Note: the call also reads the prstatus. */
1375 pi
->status_valid
= 1;
1376 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1379 proc_get_current_thread (pi
));
1388 * Function: proc_wait_for_stop
1390 * Wait for the process or LWP to stop (block until it does).
1391 * Returns non-zero for success, zero for failure.
1395 proc_wait_for_stop (pi
)
1401 * We should never have to apply this operation to any procinfo
1402 * except the one for the main process. If that ever changes
1403 * for any reason, then take out the following clause and
1404 * replace it with one that makes sure the ctl_fd is open.
1408 pi
= find_procinfo_or_die (pi
->pid
, 0);
1413 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1414 /* We been runnin' and we stopped -- need to update status. */
1415 pi
->status_valid
= 0;
1417 #else /* ioctl method */
1418 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1419 /* Above call also refreshes the prstatus. */
1422 pi
->status_valid
= 1;
1423 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1426 proc_get_current_thread (pi
));
1434 * Function: proc_run_process
1436 * Make the process or LWP runnable.
1437 * Options (not all are implemented):
1439 * - clear current fault
1440 * - clear current signal
1441 * - abort the current system call
1442 * - stop as soon as finished with system call
1443 * - (ioctl): set traced signal set
1444 * - (ioctl): set held signal set
1445 * - (ioctl): set traced fault set
1446 * - (ioctl): set start pc (vaddr)
1447 * Always clear the current fault.
1448 * Clear the current signal if 'signo' is zero.
1451 * pi the process or LWP to operate on.
1452 * step if true, set the process or LWP to trap after one instr.
1453 * signo if zero, clear the current signal if any.
1454 * if non-zero, set the current signal to this one.
1456 * Returns non-zero for success, zero for failure.
1460 proc_run_process (pi
, step
, signo
)
1469 * We will probably have to apply this operation to individual threads,
1470 * so make sure the control file descriptor is open.
1473 if (pi
->ctl_fd
== 0 &&
1474 open_procinfo_files (pi
, FD_CTL
) == 0)
1479 runflags
= PRCFAULT
; /* always clear current fault */
1484 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals */
1485 proc_set_current_signal (pi
, signo
);
1493 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1495 #else /* ioctl method */
1499 memset (&prrun
, 0, sizeof (prrun
));
1500 prrun
.pr_flags
= runflags
;
1501 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1509 * Function: proc_set_traced_signals
1511 * Register to trace signals in the process or LWP.
1512 * Returns non-zero for success, zero for failure.
1516 proc_set_traced_signals (pi
, sigset
)
1523 * We should never have to apply this operation to any procinfo
1524 * except the one for the main process. If that ever changes
1525 * for any reason, then take out the following clause and
1526 * replace it with one that makes sure the ctl_fd is open.
1530 pi
= find_procinfo_or_die (pi
->pid
, 0);
1536 /* Use char array to avoid alignment issues. */
1537 char sigset
[sizeof (sigset_t
)];
1541 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
1543 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1545 #else /* ioctl method */
1546 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1548 /* The above operation renders the procinfo's cached pstatus obsolete. */
1549 pi
->status_valid
= 0;
1552 warning ("procfs: set_traced_signals failed");
1557 * Function: proc_set_traced_faults
1559 * Register to trace hardware faults in the process or LWP.
1560 * Returns non-zero for success, zero for failure.
1564 proc_set_traced_faults (pi
, fltset
)
1571 * We should never have to apply this operation to any procinfo
1572 * except the one for the main process. If that ever changes
1573 * for any reason, then take out the following clause and
1574 * replace it with one that makes sure the ctl_fd is open.
1578 pi
= find_procinfo_or_die (pi
->pid
, 0);
1584 /* Use char array to avoid alignment issues. */
1585 char fltset
[sizeof (fltset_t
)];
1589 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1591 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1593 #else /* ioctl method */
1594 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1596 /* The above operation renders the procinfo's cached pstatus obsolete. */
1597 pi
->status_valid
= 0;
1603 * Function: proc_set_traced_sysentry
1605 * Register to trace entry to system calls in the process or LWP.
1606 * Returns non-zero for success, zero for failure.
1610 proc_set_traced_sysentry (pi
, sysset
)
1617 * We should never have to apply this operation to any procinfo
1618 * except the one for the main process. If that ever changes
1619 * for any reason, then take out the following clause and
1620 * replace it with one that makes sure the ctl_fd is open.
1624 pi
= find_procinfo_or_die (pi
->pid
, 0);
1630 /* Use char array to avoid alignment issues. */
1631 char sysset
[sizeof (sysset_t
)];
1635 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1637 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1639 #else /* ioctl method */
1640 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1642 /* The above operation renders the procinfo's cached pstatus obsolete. */
1643 pi
->status_valid
= 0;
1649 * Function: proc_set_traced_sysexit
1651 * Register to trace exit from system calls in the process or LWP.
1652 * Returns non-zero for success, zero for failure.
1656 proc_set_traced_sysexit (pi
, sysset
)
1663 * We should never have to apply this operation to any procinfo
1664 * except the one for the main process. If that ever changes
1665 * for any reason, then take out the following clause and
1666 * replace it with one that makes sure the ctl_fd is open.
1670 pi
= find_procinfo_or_die (pi
->pid
, 0);
1676 /* Use char array to avoid alignment issues. */
1677 char sysset
[sizeof (sysset_t
)];
1681 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1683 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1685 #else /* ioctl method */
1686 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1688 /* The above operation renders the procinfo's cached pstatus obsolete. */
1689 pi
->status_valid
= 0;
1695 * Function: proc_set_held_signals
1697 * Specify the set of blocked / held signals in the process or LWP.
1698 * Returns non-zero for success, zero for failure.
1702 proc_set_held_signals (pi
, sighold
)
1709 * We should never have to apply this operation to any procinfo
1710 * except the one for the main process. If that ever changes
1711 * for any reason, then take out the following clause and
1712 * replace it with one that makes sure the ctl_fd is open.
1716 pi
= find_procinfo_or_die (pi
->pid
, 0);
1722 /* Use char array to avoid alignment issues. */
1723 char hold
[sizeof (sigset_t
)];
1727 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1728 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1731 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1733 /* The above operation renders the procinfo's cached pstatus obsolete. */
1734 pi
->status_valid
= 0;
1740 * Function: proc_get_pending_signals
1742 * returns the set of signals that are pending in the process or LWP.
1743 * Will also copy the sigset if 'save' is non-zero.
1747 proc_get_pending_signals (pi
, save
)
1751 sigset_t
*ret
= NULL
;
1754 * We should never have to apply this operation to any procinfo
1755 * except the one for the main process. If that ever changes
1756 * for any reason, then take out the following clause and
1757 * replace it with one that makes sure the ctl_fd is open.
1761 pi
= find_procinfo_or_die (pi
->pid
, 0);
1763 if (!pi
->status_valid
)
1764 if (!proc_get_status (pi
))
1768 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
1770 ret
= &pi
->prstatus
.pr_sigpend
;
1773 memcpy (save
, ret
, sizeof (sigset_t
));
1779 * Function: proc_get_signal_actions
1781 * returns the set of signal actions.
1782 * Will also copy the sigactionset if 'save' is non-zero.
1786 proc_get_signal_actions (pi
, save
)
1788 struct sigaction
*save
;
1790 struct sigaction
*ret
= NULL
;
1793 * We should never have to apply this operation to any procinfo
1794 * except the one for the main process. If that ever changes
1795 * for any reason, then take out the following clause and
1796 * replace it with one that makes sure the ctl_fd is open.
1800 pi
= find_procinfo_or_die (pi
->pid
, 0);
1802 if (!pi
->status_valid
)
1803 if (!proc_get_status (pi
))
1807 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
1809 ret
= &pi
->prstatus
.pr_action
;
1812 memcpy (save
, ret
, sizeof (struct sigaction
));
1818 * Function: proc_get_held_signals
1820 * returns the set of signals that are held / blocked.
1821 * Will also copy the sigset if 'save' is non-zero.
1825 proc_get_held_signals (pi
, save
)
1829 sigset_t
*ret
= NULL
;
1832 * We should never have to apply this operation to any procinfo
1833 * except the one for the main process. If that ever changes
1834 * for any reason, then take out the following clause and
1835 * replace it with one that makes sure the ctl_fd is open.
1839 pi
= find_procinfo_or_die (pi
->pid
, 0);
1842 if (!pi
->status_valid
)
1843 if (!proc_get_status (pi
))
1847 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1849 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1850 #endif /* UNIXWARE */
1851 #else /* not NEW_PROC_API */
1853 static sigset_t sigheld
;
1855 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1858 #endif /* NEW_PROC_API */
1860 memcpy (save
, ret
, sizeof (sigset_t
));
1866 * Function: proc_get_traced_signals
1868 * returns the set of signals that are traced / debugged.
1869 * Will also copy the sigset if 'save' is non-zero.
1873 proc_get_traced_signals (pi
, save
)
1877 sigset_t
*ret
= NULL
;
1880 * We should never have to apply this operation to any procinfo
1881 * except the one for the main process. If that ever changes
1882 * for any reason, then take out the following clause and
1883 * replace it with one that makes sure the ctl_fd is open.
1887 pi
= find_procinfo_or_die (pi
->pid
, 0);
1890 if (!pi
->status_valid
)
1891 if (!proc_get_status (pi
))
1894 ret
= &pi
->prstatus
.pr_sigtrace
;
1897 static sigset_t sigtrace
;
1899 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
1904 memcpy (save
, ret
, sizeof (sigset_t
));
1910 * Function: proc_trace_signal
1912 * Add 'signo' to the set of signals that are traced.
1913 * Returns non-zero for success, zero for failure.
1917 proc_trace_signal (pi
, signo
)
1924 * We should never have to apply this operation to any procinfo
1925 * except the one for the main process. If that ever changes
1926 * for any reason, then take out the following clause and
1927 * replace it with one that makes sure the ctl_fd is open.
1931 pi
= find_procinfo_or_die (pi
->pid
, 0);
1935 if (proc_get_traced_signals (pi
, &temp
))
1937 praddset (&temp
, signo
);
1938 return proc_set_traced_signals (pi
, &temp
);
1942 return 0; /* failure */
1946 * Function: proc_ignore_signal
1948 * Remove 'signo' from the set of signals that are traced.
1949 * Returns non-zero for success, zero for failure.
1953 proc_ignore_signal (pi
, signo
)
1960 * We should never have to apply this operation to any procinfo
1961 * except the one for the main process. If that ever changes
1962 * for any reason, then take out the following clause and
1963 * replace it with one that makes sure the ctl_fd is open.
1967 pi
= find_procinfo_or_die (pi
->pid
, 0);
1971 if (proc_get_traced_signals (pi
, &temp
))
1973 prdelset (&temp
, signo
);
1974 return proc_set_traced_signals (pi
, &temp
);
1978 return 0; /* failure */
1982 * Function: proc_get_traced_faults
1984 * returns the set of hardware faults that are traced /debugged.
1985 * Will also copy the faultset if 'save' is non-zero.
1989 proc_get_traced_faults (pi
, save
)
1993 fltset_t
*ret
= NULL
;
1996 * We should never have to apply this operation to any procinfo
1997 * except the one for the main process. If that ever changes
1998 * for any reason, then take out the following clause and
1999 * replace it with one that makes sure the ctl_fd is open.
2003 pi
= find_procinfo_or_die (pi
->pid
, 0);
2006 if (!pi
->status_valid
)
2007 if (!proc_get_status (pi
))
2010 ret
= &pi
->prstatus
.pr_flttrace
;
2013 static fltset_t flttrace
;
2015 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
2020 memcpy (save
, ret
, sizeof (fltset_t
));
2026 * Function: proc_get_traced_sysentry
2028 * returns the set of syscalls that are traced /debugged on entry.
2029 * Will also copy the syscall set if 'save' is non-zero.
2033 proc_get_traced_sysentry (pi
, save
)
2037 sysset_t
*ret
= NULL
;
2040 * We should never have to apply this operation to any procinfo
2041 * except the one for the main process. If that ever changes
2042 * for any reason, then take out the following clause and
2043 * replace it with one that makes sure the ctl_fd is open.
2047 pi
= find_procinfo_or_die (pi
->pid
, 0);
2050 if (!pi
->status_valid
)
2051 if (!proc_get_status (pi
))
2054 ret
= &pi
->prstatus
.pr_sysentry
;
2057 static sysset_t sysentry
;
2059 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
2064 memcpy (save
, ret
, sizeof (sysset_t
));
2070 * Function: proc_get_traced_sysexit
2072 * returns the set of syscalls that are traced /debugged on exit.
2073 * Will also copy the syscall set if 'save' is non-zero.
2077 proc_get_traced_sysexit (pi
, save
)
2081 sysset_t
* ret
= NULL
;
2084 * We should never have to apply this operation to any procinfo
2085 * except the one for the main process. If that ever changes
2086 * for any reason, then take out the following clause and
2087 * replace it with one that makes sure the ctl_fd is open.
2091 pi
= find_procinfo_or_die (pi
->pid
, 0);
2094 if (!pi
->status_valid
)
2095 if (!proc_get_status (pi
))
2098 ret
= &pi
->prstatus
.pr_sysexit
;
2101 static sysset_t sysexit
;
2103 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2108 memcpy (save
, ret
, sizeof (sysset_t
));
2114 * Function: proc_clear_current_fault
2116 * The current fault (if any) is cleared; the associated signal
2117 * will not be sent to the process or LWP when it resumes.
2118 * Returns non-zero for success, zero for failure.
2122 proc_clear_current_fault (pi
)
2128 * We should never have to apply this operation to any procinfo
2129 * except the one for the main process. If that ever changes
2130 * for any reason, then take out the following clause and
2131 * replace it with one that makes sure the ctl_fd is open.
2135 pi
= find_procinfo_or_die (pi
->pid
, 0);
2139 long cmd
= PCCFAULT
;
2140 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2143 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2150 * Function: proc_set_current_signal
2152 * Set the "current signal" that will be delivered next to the process.
2153 * NOTE: semantics are different from those of KILL.
2154 * This signal will be delivered to the process or LWP
2155 * immediately when it is resumed (even if the signal is held/blocked);
2156 * it will NOT immediately cause another event of interest, and will NOT
2157 * first trap back to the debugger.
2159 * Returns non-zero for success, zero for failure.
2163 proc_set_current_signal (pi
, signo
)
2170 /* Use char array to avoid alignment issues. */
2171 char sinfo
[sizeof (struct siginfo
)];
2173 struct siginfo
*mysinfo
;
2176 * We should never have to apply this operation to any procinfo
2177 * except the one for the main process. If that ever changes
2178 * for any reason, then take out the following clause and
2179 * replace it with one that makes sure the ctl_fd is open.
2183 pi
= find_procinfo_or_die (pi
->pid
, 0);
2185 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2186 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2187 * receives a PIOCSSIG with a signal identical to the current signal,
2188 * it messes up the current signal. Work around the kernel bug.
2191 signo
== proc_cursig (pi
))
2192 return 1; /* I assume this is a success? */
2195 /* The pointer is just a type alias. */
2196 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2197 mysinfo
->si_signo
= signo
;
2198 mysinfo
->si_code
= 0;
2199 mysinfo
->si_pid
= getpid (); /* ?why? */
2200 mysinfo
->si_uid
= getuid (); /* ?why? */
2204 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2206 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2213 * Function: proc_clear_current_signal
2215 * The current signal (if any) is cleared, and
2216 * is not sent to the process or LWP when it resumes.
2217 * Returns non-zero for success, zero for failure.
2221 proc_clear_current_signal (pi
)
2227 * We should never have to apply this operation to any procinfo
2228 * except the one for the main process. If that ever changes
2229 * for any reason, then take out the following clause and
2230 * replace it with one that makes sure the ctl_fd is open.
2234 pi
= find_procinfo_or_die (pi
->pid
, 0);
2240 /* Use char array to avoid alignment issues. */
2241 char sinfo
[sizeof (struct siginfo
)];
2243 struct siginfo
*mysinfo
;
2246 /* The pointer is just a type alias. */
2247 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2248 mysinfo
->si_signo
= 0;
2249 mysinfo
->si_code
= 0;
2250 mysinfo
->si_errno
= 0;
2251 mysinfo
->si_pid
= getpid (); /* ?why? */
2252 mysinfo
->si_uid
= getuid (); /* ?why? */
2254 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2257 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2264 * Function: proc_get_gregs
2266 * Get the general registers for the process or LWP.
2267 * Returns non-zero for success, zero for failure.
2274 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2275 if (!proc_get_status (pi
))
2279 * OK, sorry about the ifdef's.
2280 * There's three cases instead of two, because
2281 * in this instance Unixware and Solaris/RW differ.
2285 #ifdef UNIXWARE /* ugh, a true architecture dependency */
2286 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2287 #else /* not Unixware */
2288 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2289 #endif /* Unixware */
2290 #else /* not NEW_PROC_API */
2291 return &pi
->prstatus
.pr_reg
;
2292 #endif /* NEW_PROC_API */
2296 * Function: proc_get_fpregs
2298 * Get the floating point registers for the process or LWP.
2299 * Returns non-zero for success, zero for failure.
2303 proc_get_fpregs (pi
)
2307 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2308 if (!proc_get_status (pi
))
2311 #ifdef UNIXWARE /* a true architecture dependency */
2312 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2314 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2315 #endif /* Unixware */
2317 #else /* not NEW_PROC_API */
2318 if (pi
->fpregs_valid
)
2319 return &pi
->fpregset
; /* already got 'em */
2322 if (pi
->ctl_fd
== 0 &&
2323 open_procinfo_files (pi
, FD_CTL
) == 0)
2332 tid_t pr_error_thread
;
2333 tfpregset_t thread_1
;
2336 thread_fpregs
.pr_count
= 1;
2337 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2340 ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2342 pi
->fpregs_valid
= 1;
2343 return &pi
->fpregset
; /* got 'em now! */
2345 else if (pi
->tid
!= 0 &&
2346 ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2348 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2349 sizeof (pi
->fpregset
));
2350 pi
->fpregs_valid
= 1;
2351 return &pi
->fpregset
; /* got 'em now! */
2358 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2360 pi
->fpregs_valid
= 1;
2361 return &pi
->fpregset
; /* got 'em now! */
2374 * Function: proc_set_gregs
2376 * Write the general registers back to the process or LWP.
2377 * Returns non-zero for success, zero for failure.
2384 gdb_gregset_t
*gregs
;
2387 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2388 return 0; /* get_regs has already warned */
2390 if (pi
->ctl_fd
== 0 &&
2391 open_procinfo_files (pi
, FD_CTL
) == 0)
2400 /* Use char array to avoid alignment issues. */
2401 char gregs
[sizeof (gdb_gregset_t
)];
2405 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2406 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2408 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2412 /* Policy: writing the regs invalidates our cache. */
2413 pi
->gregs_valid
= 0;
2418 * Function: proc_set_fpregs
2420 * Modify the floating point register set of the process or LWP.
2421 * Returns non-zero for success, zero for failure.
2425 proc_set_fpregs (pi
)
2428 gdb_fpregset_t
*fpregs
;
2431 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
2432 return 0; /* get_fpregs has already warned */
2434 if (pi
->ctl_fd
== 0 &&
2435 open_procinfo_files (pi
, FD_CTL
) == 0)
2444 /* Use char array to avoid alignment issues. */
2445 char fpregs
[sizeof (gdb_fpregset_t
)];
2449 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2450 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2454 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2459 tid_t pr_error_thread
;
2460 tfpregset_t thread_1
;
2463 thread_fpregs
.pr_count
= 1;
2464 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2465 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2467 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2470 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2471 #endif /* osf PIOCTSFPREG */
2472 #endif /* NEW_PROC_API */
2475 /* Policy: writing the regs invalidates our cache. */
2476 pi
->fpregs_valid
= 0;
2481 * Function: proc_kill
2483 * Send a signal to the proc or lwp with the semantics of "kill()".
2484 * Returns non-zero for success, zero for failure.
2488 proc_kill (pi
, signo
)
2495 * We might conceivably apply this operation to an LWP, and
2496 * the LWP's ctl file descriptor might not be open.
2499 if (pi
->ctl_fd
== 0 &&
2500 open_procinfo_files (pi
, FD_CTL
) == 0)
2511 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2512 #else /* ioctl method */
2513 /* FIXME: do I need the Alpha OSF fixups present in
2514 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2515 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2523 * Function: proc_parent_pid
2525 * Find the pid of the process that started this one.
2526 * Returns the parent process pid, or zero.
2530 proc_parent_pid (pi
)
2534 * We should never have to apply this operation to any procinfo
2535 * except the one for the main process. If that ever changes
2536 * for any reason, then take out the following clause and
2537 * replace it with one that makes sure the ctl_fd is open.
2541 pi
= find_procinfo_or_die (pi
->pid
, 0);
2543 if (!pi
->status_valid
)
2544 if (!proc_get_status (pi
))
2547 return pi
->prstatus
.pr_ppid
;
2552 * Function: proc_set_watchpoint
2557 proc_set_watchpoint (pi
, addr
, len
, wflags
)
2563 #if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
2566 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
2567 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
2572 char watch
[sizeof (prwatch_t
)];
2576 pwatch
= (prwatch_t
*) &arg
.watch
;
2577 pwatch
->pr_vaddr
= addr
;
2578 pwatch
->pr_size
= len
;
2579 pwatch
->pr_wflags
= wflags
;
2580 #if defined(NEW_PROC_API) && defined (PCWATCH)
2582 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2584 #if defined (PIOCSWATCH)
2585 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, pwatch
) >= 0);
2587 return 0; /* Fail */
2595 * Function: proc_iterate_over_mappings
2597 * Given a pointer to a function, call that function once for every
2598 * mapped address space in the process. The callback function
2599 * receives an open file descriptor for the file corresponding to
2600 * that mapped address space (if there is one), and the base address
2601 * of the mapped space. Quit when the callback function returns a
2602 * nonzero value, or at teh end of the mappings.
2604 * Returns: the first non-zero return value of the callback function,
2608 /* FIXME: it's probably a waste to cache this FD.
2609 It doesn't get called that often... and if I open it
2610 every time, I don't need to lseek it. */
2612 proc_iterate_over_mappings (func
)
2613 int (*func
) PARAMS ((int, CORE_ADDR
));
2617 #ifndef NEW_PROC_API /* avoid compiler warning */
2622 char pathname
[MAX_PROC_NAME_SIZE
];
2627 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
2631 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
2632 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
2633 proc_error (pi
, "proc_iterate_over_mappings (open)", __LINE__
);
2635 /* Make sure it gets closed again. */
2636 make_cleanup ((make_cleanup_func
) close
, (void *) map_fd
);
2638 /* Allocate space for mapping (lifetime only for this function). */
2639 map
= alloca (sizeof (struct prmap
));
2641 /* Now read the mappings from the file,
2642 open a file descriptor for those that have a name,
2643 and call the callback function. */
2644 while (read (map_fd
,
2646 sizeof (struct prmap
)) == sizeof (struct prmap
))
2648 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
2650 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
2653 if (map
->pr_mapname
[0] == 0)
2655 fd
= -1; /* no map file */
2659 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
2660 /* Note: caller's responsibility to close this fd! */
2661 fd
= open (name
, O_RDONLY
);
2662 /* Note: we don't test the above call for failure;
2663 we just pass the FD on as given. Sometimes there is
2664 no file, so the ioctl may return failure, but that's
2668 /* Stop looping if the callback returns non-zero. */
2669 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
)) != 0)
2673 /* Get the number of mapping entries. */
2674 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmaps
) < 0)
2675 proc_error (pi
, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__
);
2677 /* Allocate space for mappings (lifetime only this function). */
2678 map
= (struct prmap
*) alloca ((nmaps
+ 1) * sizeof (struct prmap
));
2680 /* Read in all the mappings. */
2681 if (ioctl (pi
->ctl_fd
, PIOCMAP
, map
) < 0)
2682 proc_error (pi
, "proc_iterate_over_mappings (PIOCMAP)", __LINE__
);
2684 /* Now loop through the mappings, open an fd for each, and
2685 call the callback function. */
2687 i
< nmaps
&& map
[i
].pr_size
!= 0;
2690 /* Note: caller's responsibility to close this fd! */
2691 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
[i
].pr_vaddr
);
2692 /* Note: we don't test the above call for failure;
2693 we just pass the FD on as given. Sometimes there is
2694 no file, so the ioctl may return failure, but that's
2697 /* Stop looping if the callback returns non-zero. */
2698 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
[i
].pr_vaddr
)) != 0)
2706 #ifdef TM_I386SOL2_H /* Is it hokey to use this? */
2708 #include <sys/sysi86.h>
2711 * Function: proc_get_LDT_entry
2717 * The 'key' is actually the value of the lower 16 bits of
2718 * the GS register for the LWP that we're interested in.
2720 * Return: matching ssh struct (LDT entry).
2724 proc_get_LDT_entry (pi
, key
)
2728 static struct ssd
*ldt_entry
= NULL
;
2730 char pathname
[MAX_PROC_NAME_SIZE
];
2731 struct cleanup
*old_chain
= NULL
;
2734 /* Allocate space for one LDT entry.
2735 This alloc must persist, because we return a pointer to it. */
2736 if (ldt_entry
== NULL
)
2737 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2739 /* Open the file descriptor for the LDT table. */
2740 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2741 if ((fd
= open (pathname
, O_RDONLY
)) < 0)
2743 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2746 /* Make sure it gets closed again! */
2747 old_chain
= make_cleanup ((make_cleanup_func
) close
, (void *) fd
);
2749 /* Now 'read' thru the table, find a match and return it. */
2750 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2752 if (ldt_entry
->sel
== 0 &&
2753 ldt_entry
->bo
== 0 &&
2754 ldt_entry
->acc1
== 0 &&
2755 ldt_entry
->acc2
== 0)
2756 break; /* end of table */
2757 /* If key matches, return this entry. */
2758 if (ldt_entry
->sel
== key
)
2761 /* Loop ended, match not found. */
2765 static int nalloc
= 0;
2767 /* Get the number of LDT entries. */
2768 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2770 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2774 /* Allocate space for the number of LDT entries. */
2775 /* This alloc has to persist, 'cause we return a pointer to it. */
2778 ldt_entry
= (struct ssd
*)
2779 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2783 /* Read the whole table in one gulp. */
2784 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2786 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2790 /* Search the table and return the (first) entry matching 'key'. */
2791 for (i
= 0; i
< nldt
; i
++)
2792 if (ldt_entry
[i
].sel
== key
)
2793 return &ldt_entry
[i
];
2795 /* Loop ended, match not found. */
2800 #endif /* TM_I386SOL2_H */
2802 /* =============== END, non-thread part of /proc "MODULE" =============== */
2804 /* =================== Thread "MODULE" =================== */
2806 /* NOTE: you'll see more ifdefs and duplication of functions here,
2807 since there is a different way to do threads on every OS. */
2810 * Function: proc_get_nthreads
2812 * Return the number of threads for the process
2815 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2820 proc_get_nthreads (pi
)
2825 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2826 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2832 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2834 * Solaris and Unixware version
2837 proc_get_nthreads (pi
)
2840 if (!pi
->status_valid
)
2841 if (!proc_get_status (pi
))
2845 * NEW_PROC_API: only works for the process procinfo,
2846 * because the LWP procinfos do not get prstatus filled in.
2849 if (pi
->tid
!= 0) /* find the parent process procinfo */
2850 pi
= find_procinfo_or_die (pi
->pid
, 0);
2852 return pi
->prstatus
.pr_nlwp
;
2860 proc_get_nthreads (pi
)
2869 * Function: proc_get_current_thread (LWP version)
2871 * Return the ID of the thread that had an event of interest.
2872 * (ie. the one that hit a breakpoint or other traced event).
2873 * All other things being equal, this should be the ID of a
2874 * thread that is currently executing.
2877 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2879 * Solaris and Unixware version
2882 proc_get_current_thread (pi
)
2886 * Note: this should be applied to the root procinfo for the process,
2887 * not to the procinfo for an LWP. If applied to the procinfo for
2888 * an LWP, it will simply return that LWP's ID. In that case,
2889 * find the parent process procinfo.
2893 pi
= find_procinfo_or_die (pi
->pid
, 0);
2895 if (!pi
->status_valid
)
2896 if (!proc_get_status (pi
))
2900 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2902 return pi
->prstatus
.pr_who
;
2907 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2912 proc_get_current_thread (pi
)
2915 #if 0 /* FIXME: not ready for prime time? */
2916 return pi
->prstatus
.pr_tid
;
2927 proc_get_current_thread (pi
)
2937 * Function: proc_update_threads
2939 * Discover the IDs of all the threads within the process, and
2940 * create a procinfo for each of them (chained to the parent).
2942 * This unfortunately requires a different method on every OS.
2944 * Return: non-zero for success, zero for failure.
2948 proc_delete_dead_threads (parent
, thread
, ignore
)
2953 if (thread
&& parent
) /* sanity */
2955 thread
->status_valid
= 0;
2956 if (!proc_get_status (thread
))
2957 destroy_one_procinfo (&parent
->thread_list
, thread
);
2959 return 0; /* keep iterating */
2962 #if defined (PIOCLSTATUS)
2964 * Solaris 2.5 (ioctl) version
2967 proc_update_threads (pi
)
2970 gdb_prstatus_t
*prstatus
;
2971 struct cleanup
*old_chain
= NULL
;
2976 * We should never have to apply this operation to any procinfo
2977 * except the one for the main process. If that ever changes
2978 * for any reason, then take out the following clause and
2979 * replace it with one that makes sure the ctl_fd is open.
2983 pi
= find_procinfo_or_die (pi
->pid
, 0);
2985 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2987 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2988 return 1; /* Process is not multi-threaded; nothing to do. */
2990 if ((prstatus
= (gdb_prstatus_t
*)
2991 malloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1))) == 0)
2992 perror_with_name ("procfs: malloc failed in update_threads");
2994 old_chain
= make_cleanup (free
, prstatus
);
2995 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2996 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2998 /* Skip element zero, which represents the process as a whole. */
2999 for (i
= 1; i
< nlwp
+ 1; i
++)
3001 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
3002 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3004 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
3005 thread
->status_valid
= 1;
3007 pi
->threads_valid
= 1;
3008 do_cleanups (old_chain
);
3014 * Unixware and Solaris 6 (and later) version
3017 proc_update_threads (pi
)
3020 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3021 struct dirent
*direntry
;
3022 struct cleanup
*old_chain
= NULL
;
3028 * We should never have to apply this operation to any procinfo
3029 * except the one for the main process. If that ever changes
3030 * for any reason, then take out the following clause and
3031 * replace it with one that makes sure the ctl_fd is open.
3035 pi
= find_procinfo_or_die (pi
->pid
, 0);
3037 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3042 * Note: this brute-force method is the only way I know of
3043 * to accomplish this task on Unixware. This method will
3044 * also work on Solaris 2.6 and 2.7. There is a much simpler
3045 * and more elegant way to do this on Solaris, but the margins
3046 * of this manuscript are too small to write it here... ;-)
3049 strcpy (pathname
, pi
->pathname
);
3050 strcat (pathname
, "/lwp");
3051 if ((dirp
= opendir (pathname
)) == NULL
)
3052 proc_error (pi
, "update_threads, opendir", __LINE__
);
3054 old_chain
= make_cleanup ((make_cleanup_func
) closedir
, dirp
);
3055 while ((direntry
= readdir (dirp
)) != NULL
)
3056 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3058 lwpid
= atoi (&direntry
->d_name
[0]);
3059 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3060 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3062 pi
->threads_valid
= 1;
3063 do_cleanups (old_chain
);
3072 proc_update_threads (pi
)
3079 * We should never have to apply this operation to any procinfo
3080 * except the one for the main process. If that ever changes
3081 * for any reason, then take out the following clause and
3082 * replace it with one that makes sure the ctl_fd is open.
3086 pi
= find_procinfo_or_die (pi
->pid
, 0);
3088 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3090 nthreads
= proc_get_nthreads (pi
);
3092 return 0; /* nothing to do for 1 or fewer threads */
3094 if ((threads
= malloc (nthreads
* sizeof (tid_t
))) == NULL
)
3095 proc_error (pi
, "update_threads, malloc", __LINE__
);
3097 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3098 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3100 for (i
= 0; i
< nthreads
; i
++)
3102 if (!find_procinfo (pi
->pid
, threads
[i
]))
3103 if (!create_procinfo (pi
->pid
, threads
[i
]))
3104 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3106 pi
->threads_valid
= 1;
3114 proc_update_threads (pi
)
3119 #endif /* OSF PIOCTLIST */
3120 #endif /* NEW_PROC_API */
3121 #endif /* SOL 2.5 PIOCLSTATUS */
3124 * Function: proc_iterate_over_threads
3127 * Given a pointer to a function, call that function once
3128 * for each lwp in the procinfo list, until the function
3129 * returns non-zero, in which event return the value
3130 * returned by the function.
3132 * Note: this function does NOT call update_threads.
3133 * If you want to discover new threads first, you must
3134 * call that function explicitly. This function just makes
3135 * a quick pass over the currently-known procinfos.
3138 * pi - parent process procinfo
3139 * func - per-thread function
3140 * ptr - opaque parameter for function.
3143 * First non-zero return value from the callee, or zero.
3147 proc_iterate_over_threads (pi
, func
, ptr
)
3149 int (*func
) PARAMS ((procinfo
*, procinfo
*, void *));
3152 procinfo
*thread
, *next
;
3156 * We should never have to apply this operation to any procinfo
3157 * except the one for the main process. If that ever changes
3158 * for any reason, then take out the following clause and
3159 * replace it with one that makes sure the ctl_fd is open.
3163 pi
= find_procinfo_or_die (pi
->pid
, 0);
3165 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3167 next
= thread
->next
; /* in case thread is destroyed */
3168 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3175 /* =================== END, Thread "MODULE" =================== */
3177 /* =================== END, /proc "MODULE" =================== */
3179 /* =================== GDB "MODULE" =================== */
3182 * Here are all of the gdb target vector functions and their friends.
3185 static int do_attach
PARAMS ((int pid
));
3186 static void do_detach
PARAMS ((int signo
));
3187 static int register_gdb_signals
PARAMS ((procinfo
*, sigset_t
*));
3190 * Function: procfs_debug_inferior
3192 * Sets up the inferior to be debugged.
3193 * Registers to trace signals, hardware faults, and syscalls.
3194 * Note: does not set RLC flag: caller may want to customize that.
3196 * Returns: zero for success (note! unlike most functions in this module)
3197 * On failure, returns the LINE NUMBER where it failed!
3201 procfs_debug_inferior (pi
)
3204 fltset_t traced_faults
;
3205 sigset_t traced_signals
;
3206 sysset_t traced_syscall_entries
;
3207 sysset_t traced_syscall_exits
;
3209 #ifdef PROCFS_DONT_TRACE_FAULTS
3210 /* On some systems (OSF), we don't trace hardware faults.
3211 Apparently it's enough that we catch them as signals.
3212 Wonder why we don't just do that in general? */
3213 premptyset (&traced_faults
); /* don't trace faults. */
3215 /* Register to trace hardware faults in the child. */
3216 prfillset (&traced_faults
); /* trace all faults... */
3217 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3219 if (!proc_set_traced_faults (pi
, &traced_faults
))
3222 /* Register to trace selected signals in the child. */
3223 premptyset (&traced_signals
);
3224 if (!register_gdb_signals (pi
, &traced_signals
))
3227 /* Register to trace the 'exit' system call (on entry). */
3228 premptyset (&traced_syscall_entries
);
3229 praddset (&traced_syscall_entries
, SYS_exit
);
3231 praddset (&traced_syscall_entries
, SYS_lwpexit
); /* And _lwp_exit... */
3234 praddset (&traced_syscall_entries
, SYS_lwp_exit
);
3237 if (!proc_set_traced_sysentry (pi
, &traced_syscall_entries
))
3240 #ifdef PRFS_STOPEXEC /* defined on OSF */
3241 /* OSF method for tracing exec syscalls. Quoting:
3242 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3243 exits from exec system calls because of the user level loader. */
3244 /* FIXME: make nice and maybe move into an access function. */
3248 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3251 prfs_flags
|= PRFS_STOPEXEC
;
3253 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3256 #else /* not PRFS_STOPEXEC */
3257 /* Everyone else's (except OSF) method for tracing exec syscalls */
3259 Not all systems with /proc have all the exec* syscalls with the same
3260 names. On the SGI, for example, there is no SYS_exec, but there
3261 *is* a SYS_execv. So, we try to account for that. */
3263 premptyset (&traced_syscall_exits
);
3265 praddset (&traced_syscall_exits
, SYS_exec
);
3268 praddset (&traced_syscall_exits
, SYS_execve
);
3271 praddset (&traced_syscall_exits
, SYS_execv
);
3274 #ifdef SYS_lwpcreate
3275 praddset (&traced_syscall_exits
, SYS_lwpcreate
);
3276 praddset (&traced_syscall_exits
, SYS_lwpexit
);
3279 #ifdef SYS_lwp_create /* FIXME: once only, please */
3280 praddset (&traced_syscall_exits
, SYS_lwp_create
);
3281 praddset (&traced_syscall_exits
, SYS_lwp_exit
);
3285 if (!proc_set_traced_sysexit (pi
, &traced_syscall_exits
))
3288 #endif /* PRFS_STOPEXEC */
3293 procfs_attach (args
, from_tty
)
3301 error_no_arg ("process-id to attach");
3304 if (pid
== getpid ())
3305 error ("Attaching GDB to itself is not a good idea...");
3309 exec_file
= get_exec_file (0);
3312 printf_filtered ("Attaching to program `%s', %s\n",
3313 exec_file
, target_pid_to_str (pid
));
3315 printf_filtered ("Attaching to %s\n", target_pid_to_str (pid
));
3319 inferior_pid
= do_attach (pid
);
3320 push_target (&procfs_ops
);
3324 procfs_detach (args
, from_tty
)
3333 exec_file
= get_exec_file (0);
3336 printf_filtered ("Detaching from program: %s %s\n",
3337 exec_file
, target_pid_to_str (inferior_pid
));
3341 signo
= atoi (args
);
3345 unpush_target (&procfs_ops
); /* Pop out of handling an inferior */
3355 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
3356 perror ("procfs: out of memory in 'attach'");
3358 if (!open_procinfo_files (pi
, FD_CTL
))
3360 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3361 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3363 dead_procinfo (pi
, errmsg
, NOKILL
);
3366 /* Stop the process (if it isn't already stopped). */
3367 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3369 pi
->was_stopped
= 1;
3370 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3374 pi
->was_stopped
= 0;
3375 /* Set the process to run again when we close it. */
3376 if (!proc_set_run_on_last_close (pi
))
3377 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3379 /* Now stop the process. */
3380 if (!proc_stop_process (pi
))
3381 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3382 pi
->ignore_next_sigstop
= 1;
3384 /* Save some of the /proc state to be restored if we detach. */
3385 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3386 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3387 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3388 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3389 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
3390 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3392 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
3393 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3395 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3396 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3398 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3399 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3401 /* Let GDB know that the inferior was attached. */
3403 return MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3412 /* Find procinfo for the main process */
3413 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0); /* FIXME: threads */
3415 if (!proc_set_current_signal (pi
, signo
))
3416 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3418 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3419 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3421 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3422 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3424 if (!proc_set_traced_sysentry (pi
, &pi
->saved_entryset
))
3425 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3427 if (!proc_set_traced_sysexit (pi
, &pi
->saved_exitset
))
3428 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3430 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3431 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3433 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3434 if (signo
|| !(pi
->was_stopped
) ||
3435 query ("Was stopped when attached, make it runnable again? "))
3437 /* Clear any pending signal. */
3438 if (!proc_clear_current_fault (pi
))
3439 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3441 if (!proc_set_run_on_last_close (pi
))
3442 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3446 destroy_procinfo (pi
);
3452 * Since the /proc interface cannot give us individual registers,
3453 * we pay no attention to the (regno) argument, and just fetch them all.
3454 * This results in the possibility that we will do unnecessarily many
3455 * fetches, since we may be called repeatedly for individual registers.
3456 * So we cache the results, and mark the cache invalid when the process
3460 /* These could go in a header file, but the many and various
3461 definitions of gregset_t would make it tricky and ugly. Several
3462 different native operating systems (notably Solaris and Linux) have
3463 various different definitions for gregset_t and fpregset_t. We
3464 have been kludging around this problem for a while, it would be
3465 nice if someday we came up with a prettier way of handling it
3468 extern void fill_gregset (gdb_gregset_t
*, int);
3469 extern void fill_fpregset (gdb_fpregset_t
*, int);
3470 extern void supply_gregset (gdb_gregset_t
*);
3471 extern void supply_fpregset (gdb_fpregset_t
*);
3474 procfs_fetch_registers (regno
)
3477 gdb_fpregset_t
*fpregs
;
3478 gdb_gregset_t
*gregs
;
3483 pid
= PIDGET (inferior_pid
);
3484 tid
= TIDGET (inferior_pid
);
3486 /* First look up procinfo for the main process. */
3487 pi
= find_procinfo_or_die (pid
, 0);
3489 /* If the event thread is not the same as GDB's requested thread
3490 (ie. inferior_pid), then look up procinfo for the requested
3493 (tid
!= proc_get_current_thread (pi
)))
3494 pi
= find_procinfo_or_die (pid
, tid
);
3497 error ("procfs: fetch_registers failed to find procinfo for %s",
3498 target_pid_to_str (inferior_pid
));
3500 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3501 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3503 supply_gregset (gregs
);
3505 #if defined (FP0_REGNUM) /* need floating point? */
3506 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3507 regno
== PC_REGNUM
||
3508 (NPC_REGNUM
>= 0 && regno
== NPC_REGNUM
) ||
3509 regno
== FP_REGNUM
||
3511 return; /* not a floating point register */
3513 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3514 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3516 supply_fpregset (fpregs
);
3520 /* Get ready to modify the registers array. On machines which store
3521 individual registers, this doesn't need to do anything. On
3522 machines which store all the registers in one fell swoop, such as
3523 /proc, this makes sure that registers contains all the registers
3524 from the program being debugged. */
3527 procfs_prepare_to_store ()
3529 #ifdef CHILD_PREPARE_TO_STORE
3530 CHILD_PREPARE_TO_STORE ();
3537 * Since the /proc interface will not read individual registers,
3538 * we will cache these requests until the process is resumed, and
3539 * only then write them back to the inferior process.
3541 * FIXME: is that a really bad idea? Have to think about cases
3542 * where writing one register might affect the value of others, etc.
3546 procfs_store_registers (regno
)
3549 gdb_fpregset_t
*fpregs
;
3550 gdb_gregset_t
*gregs
;
3555 pid
= PIDGET (inferior_pid
);
3556 tid
= TIDGET (inferior_pid
);
3558 /* First find procinfo for main process */
3559 pi
= find_procinfo_or_die (pid
, 0);
3561 /* If current lwp for process is not the same as requested thread
3562 (ie. inferior_pid), then find procinfo for the requested thread. */
3565 (tid
!= proc_get_current_thread (pi
)))
3566 pi
= find_procinfo_or_die (pid
, tid
);
3569 error ("procfs: store_registers: failed to find procinfo for %s",
3570 target_pid_to_str (inferior_pid
));
3572 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3573 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3575 fill_gregset (gregs
, regno
);
3576 if (!proc_set_gregs (pi
))
3577 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3579 #if defined (FP0_REGNUM) /* need floating point? */
3580 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3581 regno
== PC_REGNUM
||
3582 (NPC_REGNUM
>= 0 && regno
== NPC_REGNUM
) ||
3583 regno
== FP_REGNUM
||
3585 return; /* not a floating point register */
3587 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3588 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3590 fill_fpregset (fpregs
, regno
);
3591 if (!proc_set_fpregs (pi
))
3592 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3597 * Function: target_wait
3599 * Retrieve the next stop event from the child process.
3600 * If child has not stopped yet, wait for it to stop.
3601 * Translate /proc eventcodes (or possibly wait eventcodes)
3602 * into gdb internal event codes.
3604 * Return: id of process (and possibly thread) that incurred the event.
3605 * event codes are returned thru a pointer parameter.
3609 procfs_wait (pid
, status
)
3611 struct target_waitstatus
*status
;
3613 /* First cut: loosely based on original version 2.1 */
3617 int why
, what
, flags
;
3626 /* Find procinfo for main process */
3627 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
3630 /* We must assume that the status is stale now... */
3631 pi
->status_valid
= 0;
3632 pi
->gregs_valid
= 0;
3633 pi
->fpregs_valid
= 0;
3635 #if 0 /* just try this out... */
3636 flags
= proc_flags (pi
);
3637 why
= proc_why (pi
);
3638 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3639 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3641 /* If child is not stopped, wait for it to stop. */
3642 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3643 !proc_wait_for_stop (pi
))
3645 /* wait_for_stop failed: has the child terminated? */
3646 if (errno
== ENOENT
)
3648 /* /proc file not found; presumably child has terminated. */
3649 retval
= wait (&wstat
); /* "wait" for the child's exit */
3651 if (retval
!= PIDGET (inferior_pid
)) /* wrong child? */
3652 error ("procfs: couldn't stop process %d: wait returned %d\n",
3653 inferior_pid
, retval
);
3654 /* FIXME: might I not just use waitpid?
3655 Or try find_procinfo to see if I know about this child? */
3659 /* Unknown error from wait_for_stop. */
3660 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3665 /* This long block is reached if either:
3666 a) the child was already stopped, or
3667 b) we successfully waited for the child with wait_for_stop.
3668 This block will analyze the /proc status, and translate it
3669 into a waitstatus for GDB.
3671 If we actually had to call wait because the /proc file
3672 is gone (child terminated), then we skip this block,
3673 because we already have a waitstatus. */
3675 flags
= proc_flags (pi
);
3676 why
= proc_why (pi
);
3677 what
= proc_what (pi
);
3679 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3682 /* If it's running async (for single_thread control),
3683 set it back to normal again. */
3684 if (flags
& PR_ASYNC
)
3685 if (!proc_unset_async (pi
))
3686 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3690 proc_prettyprint_why (why
, what
, 1);
3692 /* The 'pid' we will return to GDB is composed of
3693 the process ID plus the lwp ID. */
3694 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3698 wstat
= (what
<< 8) | 0177;
3708 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3709 printf_filtered ("[%s exited]\n",
3710 target_pid_to_str (retval
));
3711 delete_thread (retval
);
3712 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3714 #endif /* _lwp_exit */
3717 /* Handle SYS_exit call only */
3718 /* Stopped at entry to SYS_exit.
3719 Make it runnable, resume it, then use
3720 the wait system call to get its exit code.
3721 Proc_run_process always clears the current
3723 Then return its exit status. */
3724 pi
->status_valid
= 0;
3726 /* FIXME: what we should do is return
3727 TARGET_WAITKIND_SPURIOUS. */
3728 if (!proc_run_process (pi
, 0, 0))
3729 proc_error (pi
, "target_wait, run_process", __LINE__
);
3732 /* Don't call wait: simulate waiting for exit,
3733 return a "success" exit code. Bogus: what if
3734 it returns something else? */
3736 retval
= inferior_pid
; /* ? ? ? */
3740 int temp
= wait (&wstat
);
3742 /* FIXME: shouldn't I make sure I get the right
3743 event from the right process? If (for
3744 instance) I have killed an earlier inferior
3745 process but failed to clean up after it
3746 somehow, I could get its termination event
3749 /* If wait returns -1, that's what we return to GDB. */
3755 printf_filtered ("procfs: trapped on entry to ");
3756 proc_prettyprint_syscall (proc_what (pi
), 0);
3757 printf_filtered ("\n");
3760 long i
, nsysargs
, *sysargs
;
3762 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3763 (sysargs
= proc_sysargs (pi
)) != NULL
)
3765 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3766 for (i
= 0; i
< nsysargs
; i
++)
3767 printf_filtered ("#%ld: 0x%08lx\n",
3775 /* How to exit gracefully, returning "unknown event" */
3776 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3777 return inferior_pid
;
3781 /* How to keep going without returning to wfi: */
3782 target_resume (pid
, 0, TARGET_SIGNAL_0
);
3799 /* Hopefully this is our own "fork-child" execing
3800 the real child. Hoax this event into a trap, and
3801 GDB will see the child about to execute its start
3803 wstat
= (SIGTRAP
<< 8) | 0177;
3805 #ifdef SYS_lwp_create
3806 case SYS_lwp_create
:
3808 #ifdef SYS_lwpcreate
3811 #if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
3813 * This syscall is somewhat like fork/exec.
3814 * We will get the event twice: once for the parent LWP,
3815 * and once for the child. We should already know about
3816 * the parent LWP, but the child will be new to us. So,
3817 * whenever we get this event, if it represents a new
3818 * thread, simply add the thread to the list.
3821 /* If not in procinfo list, add it. */
3822 temp
= proc_get_current_thread (pi
);
3823 if (!find_procinfo (pi
->pid
, temp
))
3824 create_procinfo (pi
->pid
, temp
);
3826 temp
= MERGEPID (pi
->pid
, temp
);
3827 /* If not in GDB's thread list, add it. */
3828 if (!in_thread_list (temp
))
3830 printf_filtered ("[New %s]\n", target_pid_to_str (temp
));
3833 /* Return to WFI, but tell it to immediately resume. */
3834 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3835 return inferior_pid
;
3836 #endif /* _lwp_create */
3844 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3845 printf_filtered ("[%s exited]\n",
3846 target_pid_to_str (retval
));
3847 delete_thread (retval
);
3848 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3850 #endif /* _lwp_exit */
3854 /* Nothing to do here for now. The old procfs
3855 seemed to use this event to handle threads on
3856 older (non-LWP) systems, where I'm assuming that
3857 threads were actually separate processes. Irix,
3858 maybe? Anyway, low priority for now. */
3862 /* FIXME: do we need to handle this? Investigate. */
3866 /* FIXME: see above. */
3869 printf_filtered ("procfs: trapped on exit from ");
3870 proc_prettyprint_syscall (proc_what (pi
), 0);
3871 printf_filtered ("\n");
3874 long i
, nsysargs
, *sysargs
;
3876 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3877 (sysargs
= proc_sysargs (pi
)) != NULL
)
3879 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3880 for (i
= 0; i
< nsysargs
; i
++)
3881 printf_filtered ("#%ld: 0x%08lx\n",
3886 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3887 return inferior_pid
;
3892 wstat
= (SIGSTOP
<< 8) | 0177;
3897 printf_filtered ("Retry #%d:\n", retry
);
3898 pi
->status_valid
= 0;
3903 /* If not in procinfo list, add it. */
3904 temp
= proc_get_current_thread (pi
);
3905 if (!find_procinfo (pi
->pid
, temp
))
3906 create_procinfo (pi
->pid
, temp
);
3908 /* If not in GDB's thread list, add it. */
3909 temp
= MERGEPID (pi
->pid
, temp
);
3910 if (!in_thread_list (temp
))
3912 printf_filtered ("[New %s]\n",
3913 target_pid_to_str (temp
));
3917 status
->kind
= TARGET_WAITKIND_STOPPED
;
3918 status
->value
.sig
= 0;
3923 wstat
= (what
<< 8) | 0177;
3926 switch (what
) { /* FIXME: FAULTED_USE_SIGINFO */
3929 wstat
= (SIGTRAP
<< 8) | 0177;
3934 wstat
= (SIGTRAP
<< 8) | 0177;
3937 /* FIXME: use si_signo where possible. */
3939 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
3942 wstat
= (SIGILL
<< 8) | 0177;
3945 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
3948 wstat
= (SIGTRAP
<< 8) | 0177;
3952 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
3955 wstat
= (SIGSEGV
<< 8) | 0177;
3959 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
3962 wstat
= (SIGFPE
<< 8) | 0177;
3964 case FLTPAGE
: /* Recoverable page fault */
3965 default: /* FIXME: use si_signo if possible for fault */
3967 printf_filtered ("procfs:%d -- ", __LINE__
);
3968 printf_filtered ("child stopped for unknown reason:\n");
3969 proc_prettyprint_why (why
, what
, 1);
3970 error ("... giving up...");
3973 break; /* case PR_FAULTED: */
3974 default: /* switch (why) unmatched */
3975 printf_filtered ("procfs:%d -- ", __LINE__
);
3976 printf_filtered ("child stopped for unknown reason:\n");
3977 proc_prettyprint_why (why
, what
, 1);
3978 error ("... giving up...");
3982 * Got this far without error:
3983 * If retval isn't in the threads database, add it.
3986 retval
!= inferior_pid
&&
3987 !in_thread_list (retval
))
3990 * We have a new thread.
3991 * We need to add it both to GDB's list and to our own.
3992 * If we don't create a procinfo, resume may be unhappy
3995 printf_filtered ("[New %s]\n", target_pid_to_str (retval
));
3996 add_thread (retval
);
3997 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
3998 create_procinfo (PIDGET (retval
), TIDGET (retval
));
4000 /* In addition, it's possible that this is the first
4001 * new thread we've seen, in which case we may not
4002 * have created entries for inferior_pid yet.
4004 if (TIDGET (inferior_pid
) != 0)
4006 if (!in_thread_list (inferior_pid
))
4007 add_thread (inferior_pid
);
4008 if (find_procinfo (PIDGET (inferior_pid
),
4009 TIDGET (inferior_pid
)) == NULL
)
4010 create_procinfo (PIDGET (inferior_pid
),
4011 TIDGET (inferior_pid
));
4015 else /* flags do not indicate STOPPED */
4017 /* surely this can't happen... */
4018 printf_filtered ("procfs:%d -- process not stopped.\n",
4020 proc_prettyprint_flags (flags
, 1);
4021 error ("procfs: ...giving up...");
4026 store_waitstatus (status
, wstat
);
4033 procfs_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
4038 struct target_ops
*target
; /* ignored */
4043 /* Find procinfo for main process */
4044 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4045 if (pi
->as_fd
== 0 &&
4046 open_procinfo_files (pi
, FD_AS
) == 0)
4048 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4052 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4057 PROCFS_NOTE ("write memory: ");
4059 PROCFS_NOTE ("write memory: \n");
4061 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4065 PROCFS_NOTE ("read memory: \n");
4066 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4077 * Function: invalidate_cache
4079 * Called by target_resume before making child runnable.
4080 * Mark cached registers and status's invalid.
4081 * If there are "dirty" caches that need to be written back
4082 * to the child process, do that.
4084 * File descriptors are also cached.
4085 * As they are a limited resource, we cannot hold onto them indefinitely.
4086 * However, as they are expensive to open, we don't want to throw them
4087 * away indescriminately either. As a compromise, we will keep the
4088 * file descriptors for the parent process, but discard any file
4089 * descriptors we may have accumulated for the threads.
4092 * As this function is called by iterate_over_threads, it always
4093 * returns zero (so that iterate_over_threads will keep iterating).
4098 invalidate_cache (parent
, pi
, ptr
)
4104 * About to run the child; invalidate caches and do any other cleanup.
4108 if (pi
->gregs_dirty
)
4109 if (parent
== NULL
||
4110 proc_get_current_thread (parent
) != pi
->tid
)
4111 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4112 proc_warn (pi
, "target_resume, set_gregs",
4115 if (pi
->fpregs_dirty
)
4116 if (parent
== NULL
||
4117 proc_get_current_thread (parent
) != pi
->tid
)
4118 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4119 proc_warn (pi
, "target_resume, set_fpregs",
4126 /* The presence of a parent indicates that this is an LWP.
4127 Close any file descriptors that it might have open.
4128 We don't do this to the master (parent) procinfo. */
4130 close_procinfo_files (pi
);
4132 pi
->gregs_valid
= 0;
4133 pi
->fpregs_valid
= 0;
4135 pi
->gregs_dirty
= 0;
4136 pi
->fpregs_dirty
= 0;
4138 pi
->status_valid
= 0;
4139 pi
->threads_valid
= 0;
4146 * Function: make_signal_thread_runnable
4148 * A callback function for iterate_over_threads.
4149 * Find the asynchronous signal thread, and make it runnable.
4150 * See if that helps matters any.
4154 make_signal_thread_runnable (process
, pi
, ptr
)
4160 if (proc_flags (pi
) & PR_ASLWP
)
4162 if (!proc_run_process (pi
, 0, -1))
4163 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4172 * Function: target_resume
4174 * Make the child process runnable. Normally we will then call
4175 * procfs_wait and wait for it to stop again (unles gdb is async).
4178 * step: if true, then arrange for the child to stop again
4179 * after executing a single instruction.
4180 * signo: if zero, then cancel any pending signal.
4181 * If non-zero, then arrange for the indicated signal
4182 * to be delivered to the child when it runs.
4183 * pid: if -1, then allow any child thread to run.
4184 * if non-zero, then allow only the indicated thread to run.
4185 ******* (not implemented yet)
4189 procfs_resume (pid
, step
, signo
)
4192 enum target_signal signo
;
4194 procinfo
*pi
, *thread
;
4198 prrun.prflags |= PRSVADDR;
4199 prrun.pr_vaddr = $PC; set resume address
4200 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4201 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4202 prrun.prflags |= PRCFAULT; clear current fault.
4204 PRSTRACE and PRSFAULT can be done by other means
4205 (proc_trace_signals, proc_trace_faults)
4206 PRSVADDR is unnecessary.
4207 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4208 This basically leaves PRSTEP and PRCSIG.
4209 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4210 So basically PR_STEP is the sole argument that must be passed
4211 to proc_run_process (for use in the prrun struct by ioctl). */
4213 /* Find procinfo for main process */
4214 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4216 /* First cut: ignore pid argument */
4219 /* Convert signal to host numbering. */
4221 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4224 native_signo
= target_signal_to_host (signo
);
4226 pi
->ignore_next_sigstop
= 0;
4228 /* Running the process voids all cached registers and status. */
4229 /* Void the threads' caches first */
4230 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4231 /* Void the process procinfo's caches. */
4232 invalidate_cache (NULL
, pi
, NULL
);
4236 /* Resume a specific thread, presumably suppressing the others. */
4237 thread
= find_procinfo (PIDGET (pid
), TIDGET (pid
));
4239 warning ("procfs: resume can't find thread %d -- resuming all.",
4243 if (thread
->tid
!= 0)
4245 /* We're to resume a specific thread, and not the others.
4246 * Set the child process's PR_ASYNC flag.
4249 if (!proc_set_async (pi
))
4250 proc_error (pi
, "target_resume, set_async", __LINE__
);
4253 proc_iterate_over_threads (pi
,
4254 make_signal_thread_runnable
,
4257 pi
= thread
; /* substitute the thread's procinfo for run */
4262 if (!proc_run_process (pi
, step
, native_signo
))
4265 warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
4267 proc_error (pi
, "target_resume", __LINE__
);
4272 * Function: register_gdb_signals
4274 * Traverse the list of signals that GDB knows about
4275 * (see "handle" command), and arrange for the target
4276 * to be stopped or not, according to these settings.
4278 * Returns non-zero for success, zero for failure.
4282 register_gdb_signals (pi
, signals
)
4288 for (signo
= 0; signo
< NSIG
; signo
++)
4289 if (signal_stop_state (target_signal_from_host (signo
)) == 0 &&
4290 signal_print_state (target_signal_from_host (signo
)) == 0 &&
4291 signal_pass_state (target_signal_from_host (signo
)) == 1)
4292 prdelset (signals
, signo
);
4294 praddset (signals
, signo
);
4296 return proc_set_traced_signals (pi
, signals
);
4300 * Function: target_notice_signals
4302 * Set up to trace signals in the child process.
4306 procfs_notice_signals (pid
)
4310 procinfo
*pi
= find_procinfo_or_die (PIDGET (pid
), 0);
4312 if (proc_get_traced_signals (pi
, &signals
) &&
4313 register_gdb_signals (pi
, &signals
))
4316 proc_error (pi
, "notice_signals", __LINE__
);
4320 * Function: target_files_info
4322 * Print status information about the child process.
4326 procfs_files_info (ignore
)
4327 struct target_ops
*ignore
;
4329 printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
4330 attach_flag
? "attached": "child",
4331 target_pid_to_str (inferior_pid
));
4335 * Function: target_open
4337 * A dummy: you don't open procfs.
4341 procfs_open (args
, from_tty
)
4345 error ("Use the \"run\" command to start a Unix child process.");
4349 * Function: target_can_run
4351 * This tells GDB that this target vector can be invoked
4352 * for "run" or "attach".
4355 int procfs_suppress_run
= 0; /* Non-zero if procfs should pretend not to
4356 be a runnable target. Used by targets
4357 that can sit atop procfs, such as solaris
4364 /* This variable is controlled by modules that sit atop procfs that
4365 may layer their own process structure atop that provided here.
4366 sol-thread.c does this because of the Solaris two-level thread
4369 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
4371 return !procfs_suppress_run
;
4375 * Function: target_stop
4377 * Stop the child process asynchronously, as when the
4378 * gdb user types control-c or presses a "stop" button.
4380 * Works by sending kill(SIGINT) to the child's process group.
4386 extern pid_t inferior_process_group
;
4388 kill (-inferior_process_group
, SIGINT
);
4392 * Function: unconditionally_kill_inferior
4394 * Make it die. Wait for it to die. Clean up after it.
4395 * Note: this should only be applied to the real process,
4396 * not to an LWP, because of the check for parent-process.
4397 * If we need this to work for an LWP, it needs some more logic.
4401 unconditionally_kill_inferior (pi
)
4406 parent_pid
= proc_parent_pid (pi
);
4407 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4408 /* FIXME: use access functions */
4409 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4410 before the PIOCKILL, otherwise it might generate a corrupted core
4411 file for the inferior. */
4412 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4414 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4417 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4418 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4419 to kill the inferior, otherwise it might remain stopped with a
4421 We do not check the result of the PIOCSSIG, the inferior might have
4424 struct siginfo newsiginfo
;
4426 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4427 newsiginfo
.si_signo
= SIGKILL
;
4428 newsiginfo
.si_code
= 0;
4429 newsiginfo
.si_errno
= 0;
4430 newsiginfo
.si_pid
= getpid ();
4431 newsiginfo
.si_uid
= getuid ();
4432 /* FIXME: use proc_set_current_signal */
4433 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4435 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4436 if (!proc_kill (pi
, SIGKILL
))
4437 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4438 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4439 destroy_procinfo (pi
);
4441 /* If pi is GDB's child, wait for it to die. */
4442 if (parent_pid
== getpid ())
4443 /* FIXME: should we use waitpid to make sure we get the right event?
4444 Should we check the returned event? */
4449 ret
= waitpid (pi
->pid
, &status
, 0);
4457 * Function: target_kill_inferior
4459 * We're done debugging it, and we want it to go away.
4460 * Then we want GDB to forget all about it.
4464 procfs_kill_inferior ()
4466 if (inferior_pid
!= 0) /* ? */
4468 /* Find procinfo for main process */
4469 procinfo
*pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4472 unconditionally_kill_inferior (pi
);
4473 target_mourn_inferior ();
4478 * Function: target_mourn_inferior
4480 * Forget we ever debugged this thing!
4484 procfs_mourn_inferior ()
4488 if (inferior_pid
!= 0)
4490 /* Find procinfo for main process */
4491 pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4493 destroy_procinfo (pi
);
4495 unpush_target (&procfs_ops
);
4496 generic_mourn_inferior ();
4500 * Function: init_inferior
4502 * When GDB forks to create a runnable inferior process,
4503 * this function is called on the parent side of the fork.
4504 * It's job is to do whatever is necessary to make the child
4505 * ready to be debugged, and then wait for the child to synchronize.
4509 procfs_init_inferior (pid
)
4516 /* This routine called on the parent side (GDB side)
4517 after GDB forks the inferior. */
4519 push_target (&procfs_ops
);
4521 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4522 perror ("procfs: out of memory in 'init_inferior'");
4524 if (!open_procinfo_files (pi
, FD_CTL
))
4525 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4529 open_procinfo_files // done
4532 procfs_notice_signals
4539 /* If not stopped yet, wait for it to stop. */
4540 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4541 !(proc_wait_for_stop (pi
)))
4542 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4544 /* Save some of the /proc state to be restored if we detach. */
4545 /* FIXME: Why? In case another debugger was debugging it?
4546 We're it's parent, for Ghu's sake! */
4547 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4548 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4549 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4550 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4551 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4552 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4553 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
4554 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4555 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
4556 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4558 /* Register to trace selected signals in the child. */
4559 prfillset (&signals
);
4560 if (!register_gdb_signals (pi
, &signals
))
4561 proc_error (pi
, "init_inferior, register_signals", __LINE__
);
4563 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4564 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4566 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4567 and possibly even turning ON kill-on-last-close at this point. But
4568 I can't make that change without careful testing which I don't have
4569 time to do right now... */
4570 /* Turn on run-on-last-close flag so that the child
4571 will die if GDB goes away for some reason. */
4572 if (!proc_set_run_on_last_close (pi
))
4573 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4575 /* The 'process ID' we return to GDB is composed of
4576 the actual process ID plus the lwp ID. */
4577 inferior_pid
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
4579 #ifdef START_INFERIOR_TRAPS_EXPECTED
4580 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4582 /* One trap to exec the shell, one to exec the program being debugged. */
4583 startup_inferior (2);
4584 #endif /* START_INFERIOR_TRAPS_EXPECTED */
4588 * Function: set_exec_trap
4590 * When GDB forks to create a new process, this function is called
4591 * on the child side of the fork before GDB exec's the user program.
4592 * Its job is to make the child minimally debuggable, so that the
4593 * parent GDB process can connect to the child and take over.
4594 * This function should do only the minimum to make that possible,
4595 * and to synchronize with the parent process. The parent process
4596 * should take care of the details.
4600 procfs_set_exec_trap ()
4602 /* This routine called on the child side (inferior side)
4603 after GDB forks the inferior. It must use only local variables,
4604 because it may be sharing data space with its parent. */
4609 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4610 perror_with_name ("procfs: create_procinfo failed in child.");
4612 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4614 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4615 gdb_flush (gdb_stderr
);
4616 /* no need to call "dead_procinfo", because we're going to exit. */
4620 #ifdef PRFS_STOPEXEC /* defined on OSF */
4621 /* OSF method for tracing exec syscalls. Quoting:
4622 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4623 exits from exec system calls because of the user level loader. */
4624 /* FIXME: make nice and maybe move into an access function. */
4628 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4630 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4631 gdb_flush (gdb_stderr
);
4634 prfs_flags
|= PRFS_STOPEXEC
;
4636 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4638 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4639 gdb_flush (gdb_stderr
);
4643 #else /* not PRFS_STOPEXEC */
4644 /* Everyone else's (except OSF) method for tracing exec syscalls */
4646 Not all systems with /proc have all the exec* syscalls with the same
4647 names. On the SGI, for example, there is no SYS_exec, but there
4648 *is* a SYS_execv. So, we try to account for that. */
4650 premptyset (&exitset
);
4652 praddset (&exitset
, SYS_exec
);
4655 praddset (&exitset
, SYS_execve
);
4658 praddset (&exitset
, SYS_execv
);
4661 if (!proc_set_traced_sysexit (pi
, &exitset
))
4663 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4664 gdb_flush (gdb_stderr
);
4667 #endif /* PRFS_STOPEXEC */
4669 /* FIXME: should this be done in the parent instead? */
4670 /* Turn off inherit on fork flag so that all grand-children
4671 of gdb start with tracing flags cleared. */
4672 if (!proc_unset_inherit_on_fork (pi
))
4673 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4675 /* Turn off run on last close flag, so that the child process
4676 cannot run away just because we close our handle on it.
4677 We want it to wait for the parent to attach. */
4678 if (!proc_unset_run_on_last_close (pi
))
4679 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4681 /* FIXME: No need to destroy the procinfo --
4682 we have our own address space, and we're about to do an exec! */
4683 /*destroy_procinfo (pi);*/
4687 * Function: create_inferior
4689 * This function is called BEFORE gdb forks the inferior process.
4690 * Its only real responsibility is to set things up for the fork,
4691 * and tell GDB which two functions to call after the fork (one
4692 * for the parent, and one for the child).
4694 * This function does a complicated search for a unix shell program,
4695 * which it then uses to parse arguments and environment variables
4696 * to be sent to the child. I wonder whether this code could not
4697 * be abstracted out and shared with other unix targets such as
4702 procfs_create_inferior (exec_file
, allargs
, env
)
4707 char *shell_file
= getenv ("SHELL");
4709 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4712 /* We will be looking down the PATH to find shell_file. If we
4713 just do this the normal way (via execlp, which operates by
4714 attempting an exec for each element of the PATH until it
4715 finds one which succeeds), then there will be an exec for
4716 each failed attempt, each of which will cause a PR_SYSEXIT
4717 stop, and we won't know how to distinguish the PR_SYSEXIT's
4718 for these failed execs with the ones for successful execs
4719 (whether the exec has succeeded is stored at that time in the
4720 carry bit or some such architecture-specific and
4721 non-ABI-specified place).
4723 So I can't think of anything better than to search the PATH
4724 now. This has several disadvantages: (1) There is a race
4725 condition; if we find a file now and it is deleted before we
4726 exec it, we lose, even if the deletion leaves a valid file
4727 further down in the PATH, (2) there is no way to know exactly
4728 what an executable (in the sense of "capable of being
4729 exec'd") file is. Using access() loses because it may lose
4730 if the caller is the superuser; failing to use it loses if
4731 there are ACLs or some such. */
4735 /* FIXME-maybe: might want "set path" command so user can change what
4736 path is used from within GDB. */
4737 char *path
= getenv ("PATH");
4739 struct stat statbuf
;
4742 path
= "/bin:/usr/bin";
4744 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4745 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4747 p1
= strchr (p
, ':');
4752 strncpy (tryname
, p
, len
);
4753 tryname
[len
] = '\0';
4754 strcat (tryname
, "/");
4755 strcat (tryname
, shell_file
);
4756 if (access (tryname
, X_OK
) < 0)
4758 if (stat (tryname
, &statbuf
) < 0)
4760 if (!S_ISREG (statbuf
.st_mode
))
4761 /* We certainly need to reject directories. I'm not quite
4762 as sure about FIFOs, sockets, etc., but I kind of doubt
4763 that people want to exec() these things. */
4768 /* Not found. This must be an error rather than merely passing
4769 the file to execlp(), because execlp() would try all the
4770 exec()s, causing GDB to get confused. */
4771 error ("procfs:%d -- Can't find shell %s in PATH",
4772 __LINE__
, shell_file
);
4774 shell_file
= tryname
;
4777 fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4778 procfs_init_inferior
, NULL
, shell_file
);
4780 /* We are at the first instruction we care about. */
4781 /* Pedal to the metal... */
4783 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
4787 * Function: notice_thread
4789 * Callback for find_new_threads.
4790 * Calls "add_thread".
4794 procfs_notice_thread (pi
, thread
, ptr
)
4799 int gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4801 if (!in_thread_list (gdb_threadid
))
4802 add_thread (gdb_threadid
);
4808 * Function: target_find_new_threads
4810 * Query all the threads that the target knows about,
4811 * and give them back to GDB to add to its list.
4815 procfs_find_new_threads ()
4819 /* Find procinfo for main process */
4820 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4821 proc_update_threads (pi
);
4822 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4826 * Function: target_thread_alive
4828 * Return true if the thread is still 'alive'.
4830 * This guy doesn't really seem to be doing his job.
4831 * Got to investigate how to tell when a thread is really gone.
4835 procfs_thread_alive (pid
)
4841 proc
= PIDGET (pid
);
4842 thread
= TIDGET (pid
);
4843 /* If I don't know it, it ain't alive! */
4844 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4847 /* If I can't get its status, it ain't alive!
4848 What's more, I need to forget about it! */
4849 if (!proc_get_status (pi
))
4851 destroy_procinfo (pi
);
4854 /* I couldn't have got its status if it weren't alive, so it's alive. */
4859 * Function: target_pid_to_str
4861 * Return a string to be used to identify the thread in
4862 * the "info threads" display.
4866 procfs_pid_to_str (pid
)
4869 static char buf
[80];
4873 proc
= PIDGET (pid
);
4874 thread
= TIDGET (pid
);
4875 pi
= find_procinfo (proc
, thread
);
4878 sprintf (buf
, "Process %d", proc
);
4880 sprintf (buf
, "LWP %d", thread
);
4885 * Function: procfs_set_watchpoint
4886 * Insert a watchpoint
4890 procfs_set_watchpoint (pid
, addr
, len
, rwflag
, after
)
4901 pi
= find_procinfo_or_die (pid
== -1 ?
4902 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4904 /* Translate from GDB's flags to /proc's */
4905 if (len
> 0) /* len == 0 means delete watchpoint */
4907 switch (rwflag
) { /* FIXME: need an enum! */
4908 case hw_write
: /* default watchpoint (write) */
4909 pflags
= WRITE_WATCHFLAG
;
4911 case hw_read
: /* read watchpoint */
4912 pflags
= READ_WATCHFLAG
;
4914 case hw_access
: /* access watchpoint */
4915 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
4917 case hw_execute
: /* execution HW breakpoint */
4918 pflags
= EXEC_WATCHFLAG
;
4920 default: /* Something weird. Return error. */
4923 if (after
) /* Stop after r/w access is completed. */
4924 pflags
|= AFTER_WATCHFLAG
;
4927 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
4929 if (errno
== E2BIG
) /* Typical error for no resources */
4930 return -1; /* fail */
4931 /* GDB may try to remove the same watchpoint twice.
4932 If a remove request returns no match, don't error. */
4933 if (errno
== ESRCH
&& len
== 0)
4934 return 0; /* ignore */
4935 proc_error (pi
, "set_watchpoint", __LINE__
);
4942 * Function: stopped_by_watchpoint
4944 * Returns non-zero if process is stopped on a hardware watchpoint fault,
4945 * else returns zero.
4949 procfs_stopped_by_watchpoint (pid
)
4954 pi
= find_procinfo_or_die (pid
== -1 ?
4955 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4956 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
4958 if (proc_why (pi
) == PR_FAULTED
)
4961 if (proc_what (pi
) == FLTWATCH
)
4965 if (proc_what (pi
) == FLTKWATCH
)
4973 #ifdef TM_I386SOL2_H
4975 * Function: procfs_find_LDT_entry
4978 * int pid; // The GDB-style pid-plus-LWP.
4981 * pointer to the corresponding LDT entry.
4985 procfs_find_LDT_entry (pid
)
4988 gdb_gregset_t
*gregs
;
4992 /* Find procinfo for the lwp. */
4993 if ((pi
= find_procinfo (PIDGET (pid
), TIDGET (pid
))) == NULL
)
4995 warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
4999 /* get its general registers. */
5000 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
5002 warning ("procfs_find_LDT_entry: could not read gregs for %d.",
5006 /* Now extract the GS register's lower 16 bits. */
5007 key
= (*gregs
)[GS
] & 0xffff;
5009 /* Find the matching entry and return it. */
5010 return proc_get_LDT_entry (pi
, key
);
5012 #endif /* TM_I386SOL2_H */
5017 info_proc_cmd (args
, from_tty
)
5021 struct cleanup
*old_chain
;
5022 procinfo
*process
= NULL
;
5023 procinfo
*thread
= NULL
;
5029 old_chain
= make_cleanup (null_cleanup
, 0);
5032 if ((argv
= buildargv (args
)) == NULL
)
5035 make_cleanup ((make_cleanup_func
) freeargv
, argv
);
5037 while (argv
!= NULL
&& *argv
!= NULL
)
5039 if (isdigit (argv
[0][0]))
5041 pid
= strtoul (argv
[0], &tmp
, 10);
5043 tid
= strtoul (++tmp
, NULL
, 10);
5045 else if (argv
[0][0] == '/')
5047 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5056 pid
= PIDGET (inferior_pid
);
5058 error ("No current process: you must name one.");
5061 /* Have pid, will travel.
5062 First see if it's a process we're already debugging. */
5063 process
= find_procinfo (pid
, 0);
5064 if (process
== NULL
)
5066 /* No. So open a procinfo for it, but
5067 remember to close it again when finished. */
5068 process
= create_procinfo (pid
, 0);
5069 make_cleanup ((make_cleanup_func
) destroy_procinfo
, process
);
5070 if (!open_procinfo_files (process
, FD_CTL
))
5071 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5075 thread
= create_procinfo (pid
, tid
);
5079 printf_filtered ("process %d flags:\n", process
->pid
);
5080 proc_prettyprint_flags (proc_flags (process
), 1);
5081 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5082 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5083 if (proc_get_nthreads (process
) > 1)
5084 printf_filtered ("Process has %d threads.\n",
5085 proc_get_nthreads (process
));
5089 printf_filtered ("thread %d flags:\n", thread
->tid
);
5090 proc_prettyprint_flags (proc_flags (thread
), 1);
5091 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5092 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5095 do_cleanups (old_chain
);
5099 proc_trace_syscalls (args
, from_tty
, entry_or_exit
, mode
)
5109 if (inferior_pid
<= 0)
5110 error ("you must be debugging a process to use this command.");
5112 if (args
== NULL
|| args
[0] == 0)
5113 error_no_arg ("system call to trace");
5115 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
5116 if (isdigit (args
[0]))
5118 syscallnum
= atoi (args
);
5119 if (entry_or_exit
== PR_SYSENTRY
)
5120 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5122 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5125 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5127 if (mode
== FLAG_SET
)
5128 praddset (sysset
, syscallnum
);
5130 prdelset (sysset
, syscallnum
);
5132 if (entry_or_exit
== PR_SYSENTRY
)
5134 if (!proc_set_traced_sysentry (pi
, sysset
))
5135 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5139 if (!proc_set_traced_sysexit (pi
, sysset
))
5140 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5146 proc_trace_sysentry_cmd (args
, from_tty
)
5150 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5154 proc_trace_sysexit_cmd (args
, from_tty
)
5158 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5162 proc_untrace_sysentry_cmd (args
, from_tty
)
5166 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5170 proc_untrace_sysexit_cmd (args
, from_tty
)
5174 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5179 _initialize_procfs ()
5182 add_target (&procfs_ops
);
5183 add_info ("proc", info_proc_cmd
,
5184 "Show /proc process information about any running process.\
5185 Default is the process being debugged.");
5186 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5187 "Give a trace of entries into the syscall.");
5188 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5189 "Give a trace of exits from the syscall.");
5190 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5191 "Cancel a trace of entries into the syscall.");
5192 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5193 "Cancel a trace of exits from the syscall.");
5196 /* =================== END, GDB "MODULE" =================== */
5200 /* miscelaneous stubs: */
5201 /* The following satisfy a few random symbols mostly created by */
5202 /* the solaris threads implementation, which I will chase down */
5206 * Return a pid for which we guarantee
5207 * we will be able to find a 'live' procinfo.
5211 procfs_first_available ()
5214 return procinfo_list
->pid
;