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. */
28 #if defined (NEW_PROC_API)
29 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
32 #include <sys/procfs.h>
33 #include <sys/fault.h>
34 #include <sys/syscall.h>
35 #include <sys/errno.h>
40 * This module provides the interface between GDB and the
41 * /proc file system, which is used on many versions of Unix
42 * as a means for debuggers to control other processes.
43 * Examples of the systems that use this interface are:
49 * /proc works by immitating a file system: you open a simulated file
50 * that represents the process you wish to interact with, and
51 * perform operations on that "file" in order to examine or change
52 * the state of the other process.
54 * The most important thing to know about /proc and this module
55 * is that there are two very different interfaces to /proc:
56 * One that uses the ioctl system call, and
57 * another that uses read and write system calls.
58 * This module has to support both /proc interfaces. This means
59 * that there are two different ways of doing every basic operation.
61 * In order to keep most of the code simple and clean, I have
62 * defined an interface "layer" which hides all these system calls.
63 * An ifdef (NEW_PROC_API) determines which interface we are using,
64 * and most or all occurrances of this ifdef should be confined to
65 * this interface layer.
69 /* Determine which /proc API we are using:
70 The ioctl API defines PIOCSTATUS, while
71 the read/write (multiple fd) API never does. */
74 #include <sys/types.h>
75 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
78 #include <fcntl.h> /* for O_RDONLY */
79 #include <unistd.h> /* for "X_OK" */
80 #include "gdb_stat.h" /* for struct stat */
82 /* =================== TARGET_OPS "MODULE" =================== */
85 * This module defines the GDB target vector and its methods.
88 static void procfs_open
PARAMS((char *, int));
89 static void procfs_attach
PARAMS ((char *, int));
90 static void procfs_detach
PARAMS ((char *, int));
91 static void procfs_resume
PARAMS ((int, int, enum target_signal
));
92 static int procfs_can_run
PARAMS ((void));
93 static void procfs_stop
PARAMS ((void));
94 static void procfs_files_info
PARAMS ((struct target_ops
*));
95 static void procfs_fetch_registers
PARAMS ((int));
96 static void procfs_store_registers
PARAMS ((int));
97 static void procfs_notice_signals
PARAMS ((int));
98 static void procfs_prepare_to_store
PARAMS ((void));
99 static void procfs_kill_inferior
PARAMS ((void));
100 static void procfs_mourn_inferior
PARAMS ((void));
101 static void procfs_create_inferior
PARAMS ((char *, char *, char **));
102 static int procfs_wait
PARAMS ((int,
103 struct target_waitstatus
*));
104 static int procfs_xfer_memory
PARAMS ((CORE_ADDR
,
106 struct target_ops
*));
108 static int procfs_thread_alive
PARAMS ((int));
110 void procfs_find_new_threads
PARAMS ((void));
111 char *procfs_pid_to_str
PARAMS ((int));
113 struct target_ops procfs_ops
; /* the target vector */
118 procfs_ops
.to_shortname
= "procfs";
119 procfs_ops
.to_longname
= "Unix /proc child process";
121 "Unix /proc child process (started by the \"run\" command).";
122 procfs_ops
.to_open
= procfs_open
;
123 procfs_ops
.to_can_run
= procfs_can_run
;
124 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
125 procfs_ops
.to_kill
= procfs_kill_inferior
;
126 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
127 procfs_ops
.to_attach
= procfs_attach
;
128 procfs_ops
.to_detach
= procfs_detach
;
129 procfs_ops
.to_wait
= procfs_wait
;
130 procfs_ops
.to_resume
= procfs_resume
;
131 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
132 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
133 procfs_ops
.to_store_registers
= procfs_store_registers
;
134 procfs_ops
.to_xfer_memory
= procfs_xfer_memory
;
135 procfs_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
136 procfs_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
137 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
138 procfs_ops
.to_files_info
= procfs_files_info
;
139 procfs_ops
.to_stop
= procfs_stop
;
141 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
142 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
143 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
144 procfs_ops
.to_terminal_ours
= terminal_ours
;
145 procfs_ops
.to_terminal_info
= child_terminal_info
;
147 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
148 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
149 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
151 procfs_ops
.to_has_execution
= 1;
152 procfs_ops
.to_has_stack
= 1;
153 procfs_ops
.to_has_registers
= 1;
154 procfs_ops
.to_stratum
= process_stratum
;
155 procfs_ops
.to_has_thread_control
= tc_schedlock
;
156 procfs_ops
.to_magic
= OPS_MAGIC
;
159 /* =================== END, TARGET_OPS "MODULE" =================== */
162 * Temporary debugging code:
164 * These macros allow me to trace the system calls that we make
165 * to control the child process. This is quite handy for comparing
166 * with the older version of procfs.
171 extern int write_with_trace
PARAMS ((int, void *, size_t, char *, int));
172 extern off_t lseek_with_trace
PARAMS ((int, off_t
, int, char *, int));
175 #define write(X,Y,Z) write_with_trace (X, Y, Z, __FILE__, __LINE__)
178 #define lseek(X,Y,Z) lseek_with_trace (X, Y, Z, __FILE__, __LINE__)
180 extern int ioctl_with_trace
PARAMS ((int, long, void *, char *, int));
181 #define ioctl(X,Y,Z) ioctl_with_trace (X, Y, Z, __FILE__, __LINE__)
183 #define open(X,Y) open_with_trace (X, Y, __FILE__, __LINE__)
184 #define close(X) close_with_trace (X, __FILE__, __LINE__)
185 #define wait(X) wait_with_trace (X, __FILE__, __LINE__)
188 #define PROCFS_NOTE(X) procfs_note (X, __FILE__, __LINE__)
189 #define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T) \
190 proc_prettyfprint_status (X, Y, Z, T)
192 #define PROCFS_NOTE(X)
193 #define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T)
197 #define PROCFS_NOTE(X)
198 #define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T)
203 #define PROCFS_NOTE(X)
210 * Put any typedefs, defines etc. here that are required for
211 * the unification of code that handles different versions of /proc.
214 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
216 enum { READ_WATCHFLAG
= WA_READ
,
217 WRITE_WATCHFLAG
= WA_WRITE
,
218 EXEC_WATCHFLAG
= WA_EXEC
,
219 AFTER_WATCHFLAG
= WA_TRAPAFTER
222 #else /* Irix method for watchpoints */
223 enum { READ_WATCHFLAG
= MA_READ
,
224 WRITE_WATCHFLAG
= MA_WRITE
,
225 EXEC_WATCHFLAG
= MA_EXEC
,
226 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
233 /* =================== STRUCT PROCINFO "MODULE" =================== */
235 /* FIXME: this comment will soon be out of date W.R.T. threads. */
237 /* The procinfo struct is a wrapper to hold all the state information
238 concerning a /proc process. There should be exactly one procinfo
239 for each process, and since GDB currently can debug only one
240 process at a time, that means there should be only one procinfo.
241 All of the LWP's of a process can be accessed indirectly thru the
242 single process procinfo.
244 However, against the day when GDB may debug more than one process,
245 this data structure is kept in a list (which for now will hold no
246 more than one member), and many functions will have a pointer to a
247 procinfo as an argument.
249 There will be a separate procinfo structure for use by the (not yet
250 implemented) "info proc" command, so that we can print useful
251 information about any random process without interfering with the
252 inferior's procinfo information. */
255 /* format strings for /proc paths */
256 # ifndef CTL_PROC_NAME_FMT
257 # define MAIN_PROC_NAME_FMT "/proc/%d"
258 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
259 # define AS_PROC_NAME_FMT "/proc/%d/as"
260 # define MAP_PROC_NAME_FMT "/proc/%d/map"
261 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
262 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
264 /* the name of the proc status struct depends on the implementation */
265 typedef pstatus_t gdb_prstatus_t
;
266 typedef lwpstatus_t gdb_lwpstatus_t
;
267 #else /* ! NEW_PROC_API */
268 /* format strings for /proc paths */
269 # ifndef CTL_PROC_NAME_FMT
270 # define MAIN_PROC_NAME_FMT "/proc/%05d"
271 # define CTL_PROC_NAME_FMT "/proc/%05d"
272 # define AS_PROC_NAME_FMT "/proc/%05d"
273 # define MAP_PROC_NAME_FMT "/proc/%05d"
274 # define STATUS_PROC_NAME_FMT "/proc/%05d"
275 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
277 /* the name of the proc status struct depends on the implementation */
278 typedef prstatus_t gdb_prstatus_t
;
279 typedef prstatus_t gdb_lwpstatus_t
;
280 #endif /* NEW_PROC_API */
283 /* These #ifdefs are for sol2.x in particular. sol2.x has
284 both a "gregset_t" and a "prgregset_t", which have
285 similar uses but different layouts. sol2.x gdb tries to
286 use prgregset_t (and prfpregset_t) everywhere. */
288 #ifdef GDB_GREGSET_TYPE
289 typedef GDB_GREGSET_TYPE gdb_gregset_t
;
291 typedef gregset_t gdb_gregset_t
;
294 #ifdef GDB_FPREGSET_TYPE
295 typedef GDB_FPREGSET_TYPE gdb_fpregset_t
;
297 typedef fpregset_t gdb_fpregset_t
;
300 /* The PIDs that we pass to and from GDB will be composed from
301 the actual PID plus the LWPID. These macros will be used to
302 compose and decompose them. */
305 #define PIDGET(PID) (((PID) & 0xffff))
309 #define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
313 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
316 typedef struct procinfo
{
317 struct procinfo
*next
;
318 int pid
; /* Process ID */
319 int tid
; /* Thread/LWP id */
323 int ignore_next_sigstop
;
325 /* The following four fd fields may be identical, or may contain
326 several different fd's, depending on the version of /proc
327 (old ioctl or new read/write). */
329 int ctl_fd
; /* File descriptor for /proc control file */
331 * The next three file descriptors are actually only needed in the
332 * read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
333 * However, to avoid a bunch of #ifdefs in the code, we will use
334 * them uniformly by (in the case of the ioctl single-file-descriptor
335 * implementation) filling them with copies of the control fd.
337 int status_fd
; /* File descriptor for /proc status file */
338 int as_fd
; /* File descriptor for /proc as file */
340 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
342 fltset_t saved_fltset
; /* Saved traced hardware fault set */
343 sigset_t saved_sigset
; /* Saved traced signal set */
344 sigset_t saved_sighold
; /* Saved held signal set */
345 sysset_t saved_exitset
; /* Saved traced system call exit set */
346 sysset_t saved_entryset
; /* Saved traced system call entry set */
348 gdb_prstatus_t prstatus
; /* Current process status info */
351 gdb_fpregset_t fpregset
; /* Current floating point registers */
354 struct procinfo
*thread_list
;
356 int status_valid
: 1;
358 int fpregs_valid
: 1;
359 int threads_valid
: 1;
362 static char errmsg
[128]; /* shared error msg buffer */
364 /* Function prototypes for procinfo module: */
366 static procinfo
*find_procinfo_or_die
PARAMS ((int pid
, int tid
));
367 static procinfo
*find_procinfo
PARAMS ((int pid
, int tid
));
368 static procinfo
*create_procinfo
PARAMS ((int pid
, int tid
));
369 static void destroy_procinfo
PARAMS ((procinfo
*p
));
370 static void dead_procinfo
PARAMS ((procinfo
*p
,
371 char *msg
, int killp
));
372 static int open_procinfo_files
PARAMS ((procinfo
*p
, int which
));
373 static void close_procinfo_files
PARAMS ((procinfo
*p
));
375 /* The head of the procinfo list: */
376 static procinfo
* procinfo_list
;
379 * Function: find_procinfo
381 * Search the procinfo list.
383 * Returns: pointer to procinfo, or NULL if not found.
387 find_procinfo (pid
, tid
)
393 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
400 /* Don't check threads_valid. If we're updating the
401 thread_list, we want to find whatever threads are already
402 here. This means that in general it is the caller's
403 responsibility to check threads_valid and update before
404 calling find_procinfo, if the caller wants to find a new
407 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
416 * Function: find_procinfo_or_die
418 * Calls find_procinfo, but errors on failure.
422 find_procinfo_or_die (pid
, tid
)
426 procinfo
*pi
= find_procinfo (pid
, tid
);
430 error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",
433 error ("procfs: couldn't find pid %d in procinfo list.", pid
);
438 * Function: open_procinfo_files
440 * Open the file descriptor for the process or LWP.
441 * ifdef NEW_PROC_API, we only open the control file descriptor;
442 * the others are opened lazily as needed.
443 * else (if not NEW_PROC_API), there is only one real
444 * file descriptor, but we keep multiple copies of it so that
445 * the code that uses them does not have to be #ifdef'd.
447 * Return: file descriptor, or zero for failure.
450 enum { FD_CTL
, FD_STATUS
, FD_AS
};
453 open_procinfo_files (pi
, which
)
457 char tmp
[MAX_PROC_NAME_SIZE
];
461 * This function is getting ALMOST long enough to break up into several.
462 * Here is some rationale:
464 * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
465 * There are several file descriptors that may need to be open
466 * for any given process or LWP. The ones we're intereted in are:
467 * - control (ctl) write-only change the state
468 * - status (status) read-only query the state
469 * - address space (as) read/write access memory
470 * - map (map) read-only virtual addr map
471 * Most of these are opened lazily as they are needed.
472 * The pathnames for the 'files' for an LWP look slightly
473 * different from those of a first-class process:
474 * Pathnames for a process (<proc-id>):
475 * /proc/<proc-id>/ctl
476 * /proc/<proc-id>/status
478 * /proc/<proc-id>/map
479 * Pathnames for an LWP (lwp-id):
480 * /proc/<proc-id>/lwp/<lwp-id>/lwpctl
481 * /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
482 * An LWP has no map or address space file descriptor, since
483 * the memory map and address space are shared by all LWPs.
485 * Everyone else (Solaris 2.5, Irix, OSF)
486 * There is only one file descriptor for each process or LWP.
487 * For convenience, we copy the same file descriptor into all
488 * three fields of the procinfo struct (ctl_fd, status_fd, and
489 * as_fd, see NEW_PROC_API above) so that code that uses them
490 * doesn't need any #ifdef's.
495 * Each LWP has an independent file descriptor, but these
496 * are not obtained via the 'open' system call like the rest:
497 * instead, they're obtained thru an ioctl call (PIOCOPENLWP)
498 * to the file descriptor of the parent process.
501 * These do not even have their own independent file descriptor.
502 * All operations are carried out on the file descriptor of the
503 * parent process. Therefore we just call open again for each
504 * thread, getting a new handle for the same 'file'.
509 * In this case, there are several different file descriptors that
510 * we might be asked to open. The control file descriptor will be
511 * opened early, but the others will be opened lazily as they are
515 strcpy (tmp
, pi
->pathname
);
516 switch (which
) { /* which file descriptor to open? */
519 strcat (tmp
, "/lwpctl");
521 strcat (tmp
, "/ctl");
522 fd
= open (tmp
, O_WRONLY
);
529 return 0; /* there is no 'as' file descriptor for an lwp */
531 fd
= open (tmp
, O_RDWR
);
538 strcat (tmp
, "/lwpstatus");
540 strcat (tmp
, "/status");
541 fd
= open (tmp
, O_RDONLY
);
547 return 0; /* unknown file descriptor */
549 #else /* not NEW_PROC_API */
551 * In this case, there is only one file descriptor for each procinfo
552 * (ie. each process or LWP). In fact, only the file descriptor for
553 * the process can actually be opened by an 'open' system call.
554 * The ones for the LWPs have to be obtained thru an IOCTL call
555 * on the process's file descriptor.
557 * For convenience, we copy each procinfo's single file descriptor
558 * into all of the fields occupied by the several file descriptors
559 * of the NEW_PROC_API implementation. That way, the code that uses
560 * them can be written without ifdefs.
564 #ifdef PIOCTSTATUS /* OSF */
565 if ((fd
= open (pi
->pathname
, O_RDWR
)) == 0) /* Only one FD; just open it. */
567 #else /* Sol 2.5, Irix, other? */
568 if (pi
->tid
== 0) /* Master procinfo for the process */
570 fd
= open (pi
->pathname
, O_RDWR
);
574 else /* LWP thread procinfo */
576 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
580 /* Find the procinfo for the entire process. */
581 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
584 /* Now obtain the file descriptor for the LWP. */
585 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) <= 0)
587 #else /* Irix, other? */
588 return 0; /* Don't know how to open threads */
589 #endif /* Sol 2.5 PIOCOPENLWP */
591 #endif /* OSF PIOCTSTATUS */
592 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
593 #endif /* NEW_PROC_API */
595 return 1; /* success */
599 * Function: create_procinfo
601 * Allocate a data structure and link it into the procinfo list.
602 * (First tries to find a pre-existing one (FIXME: why???)
604 * Return: pointer to new procinfo struct.
608 create_procinfo (pid
, tid
)
612 procinfo
*pi
, *parent
;
614 if (pi
= find_procinfo (pid
, tid
))
615 return pi
; /* Already exists, nothing to do. */
617 /* find parent before doing malloc, to save having to cleanup */
619 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
621 doesn't exist yet? */
623 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
624 memset (pi
, 0, sizeof (procinfo
));
628 /* Chain into list. */
631 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
632 pi
->next
= procinfo_list
;
638 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
640 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
642 pi
->next
= parent
->thread_list
;
643 parent
->thread_list
= pi
;
649 * Function: close_procinfo_files
651 * Close all file descriptors associated with the procinfo
655 close_procinfo_files (pi
)
663 if (pi
->status_fd
> 0)
664 close (pi
->status_fd
);
666 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
670 * Function: destroy_procinfo
672 * Destructor function. Close, unlink and deallocate the object.
676 destroy_one_procinfo (list
, pi
)
682 /* Step one: unlink the procinfo from its list */
686 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
689 ptr
->next
= pi
->next
;
693 /* Step two: close any open file descriptors */
694 close_procinfo_files (pi
);
696 /* Step three: free the memory. */
701 destroy_procinfo (pi
)
706 if (pi
->tid
!= 0) /* destroy a thread procinfo */
708 tmp
= find_procinfo (pi
->pid
, 0); /* find the parent process */
709 destroy_one_procinfo (&tmp
->thread_list
, pi
);
711 else /* destroy a process procinfo and all its threads */
713 /* First destroy the children, if any; */
714 while (pi
->thread_list
!= NULL
)
715 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
716 /* Then destroy the parent. Genocide!!! */
717 destroy_one_procinfo (&procinfo_list
, pi
);
721 enum { NOKILL
, KILL
};
724 * Function: dead_procinfo
726 * To be called on a non_recoverable error for a procinfo.
727 * Prints error messages, optionally sends a SIGKILL to the process,
728 * then destroys the data structure.
732 dead_procinfo (pi
, msg
, kill_p
)
741 print_sys_errmsg (pi
->pathname
, errno
);
745 sprintf (procfile
, "process %d", pi
->pid
);
746 print_sys_errmsg (procfile
, errno
);
749 kill (pi
->pid
, SIGKILL
);
751 destroy_procinfo (pi
);
755 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
757 /* =================== /proc "MODULE" =================== */
760 * This "module" is the interface layer between the /proc system API
761 * and the gdb target vector functions. This layer consists of
762 * access functions that encapsulate each of the basic operations
763 * that we need to use from the /proc API.
765 * The main motivation for this layer is to hide the fact that
766 * there are two very different implementations of the /proc API.
767 * Rather than have a bunch of #ifdefs all thru the gdb target vector
768 * functions, we do our best to hide them all in here.
771 int proc_get_status
PARAMS ((procinfo
*pi
));
772 long proc_flags
PARAMS ((procinfo
*pi
));
773 int proc_why
PARAMS ((procinfo
*pi
));
774 int proc_what
PARAMS ((procinfo
*pi
));
775 int proc_set_run_on_last_close
PARAMS ((procinfo
*pi
));
776 int proc_unset_run_on_last_close
PARAMS ((procinfo
*pi
));
777 int proc_set_inherit_on_fork
PARAMS ((procinfo
*pi
));
778 int proc_unset_inherit_on_fork
PARAMS ((procinfo
*pi
));
779 int proc_set_async
PARAMS ((procinfo
*pi
));
780 int proc_unset_async
PARAMS ((procinfo
*pi
));
781 int proc_stop_process
PARAMS ((procinfo
*pi
));
782 int proc_trace_signal
PARAMS ((procinfo
*pi
, int signo
));
783 int proc_ignore_signal
PARAMS ((procinfo
*pi
, int signo
));
784 int proc_clear_current_fault
PARAMS ((procinfo
*pi
));
785 int proc_set_current_signal
PARAMS ((procinfo
*pi
, int signo
));
786 int proc_clear_current_signal
PARAMS ((procinfo
*pi
));
787 int proc_set_gregs
PARAMS ((procinfo
*pi
));
788 int proc_set_fpregs
PARAMS ((procinfo
*pi
));
789 int proc_wait_for_stop
PARAMS ((procinfo
*pi
));
790 int proc_run_process
PARAMS ((procinfo
*pi
, int step
, int signo
));
791 int proc_kill
PARAMS ((procinfo
*pi
, int signo
));
792 int proc_parent_pid
PARAMS ((procinfo
*pi
));
793 int proc_get_nthreads
PARAMS ((procinfo
*pi
));
794 int proc_get_current_thread
PARAMS ((procinfo
*pi
));
795 int proc_set_held_signals
PARAMS ((procinfo
*pi
, sigset_t
*sighold
));
796 int proc_set_traced_sysexit
PARAMS ((procinfo
*pi
, sysset_t
*sysset
));
797 int proc_set_traced_sysentry
PARAMS ((procinfo
*pi
, sysset_t
*sysset
));
798 int proc_set_traced_faults
PARAMS ((procinfo
*pi
, fltset_t
*fltset
));
799 int proc_set_traced_signals
PARAMS ((procinfo
*pi
, sigset_t
*sigset
));
801 int proc_update_threads
PARAMS ((procinfo
*pi
));
802 int proc_iterate_over_threads
PARAMS ((procinfo
*pi
,
803 int (*func
) PARAMS ((procinfo
*,
808 gdb_gregset_t
*proc_get_gregs
PARAMS ((procinfo
*pi
));
809 gdb_fpregset_t
*proc_get_fpregs
PARAMS ((procinfo
*pi
));
810 sysset_t
*proc_get_traced_sysexit
PARAMS ((procinfo
*pi
, sysset_t
*save
));
811 sysset_t
*proc_get_traced_sysentry
PARAMS ((procinfo
*pi
, sysset_t
*save
));
812 fltset_t
*proc_get_traced_faults
PARAMS ((procinfo
*pi
, fltset_t
*save
));
813 sigset_t
*proc_get_traced_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
814 sigset_t
*proc_get_held_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
815 sigset_t
*proc_get_pending_signals
PARAMS ((procinfo
*pi
, sigset_t
*save
));
816 struct sigaction
*proc_get_signal_actions
PARAMS ((procinfo
*pi
,
817 struct sigaction
*save
));
819 void proc_warn
PARAMS ((procinfo
*pi
, char *func
, int line
));
820 void proc_error
PARAMS ((procinfo
*pi
, char *func
, int line
));
823 proc_warn (pi
, func
, line
)
828 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
829 print_sys_errmsg (errmsg
, errno
);
833 proc_error (pi
, func
, line
)
838 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
839 perror_with_name (errmsg
);
843 * Function: proc_get_status
845 * Updates the status struct in the procinfo.
846 * There is a 'valid' flag, to let other functions know when
847 * this function needs to be called (so the status is only
848 * read when it is needed). The status file descriptor is
849 * also only opened when it is needed.
851 * Return: non-zero for success, zero for failure.
858 /* Status file descriptor is opened "lazily" */
859 if (pi
->status_fd
== 0 &&
860 open_procinfo_files (pi
, FD_STATUS
) == 0)
862 pi
->status_valid
= 0;
867 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
868 pi
->status_valid
= 0; /* fail */
871 /* Sigh... I have to read a different data structure,
872 depending on whether this is a main process or an LWP. */
874 pi
->status_valid
= (read (pi
->status_fd
,
875 (char *) &pi
->prstatus
.pr_lwp
,
876 sizeof (lwpstatus_t
))
877 == sizeof (lwpstatus_t
));
880 pi
->status_valid
= (read (pi
->status_fd
,
881 (char *) &pi
->prstatus
,
882 sizeof (gdb_prstatus_t
))
883 == sizeof (gdb_prstatus_t
));
884 #if 0 /*def UNIXWARE*/
885 if (pi
->status_valid
&&
886 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
887 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
888 /* Unixware peculiarity -- read the damn thing again! */
889 pi
->status_valid
= (read (pi
->status_fd
,
890 (char *) &pi
->prstatus
,
891 sizeof (gdb_prstatus_t
))
892 == sizeof (gdb_prstatus_t
));
893 #endif /* UNIXWARE */
896 #else /* ioctl method */
897 #ifdef PIOCTSTATUS /* osf */
898 if (pi
->tid
== 0) /* main process */
900 /* Just read the danged status. Now isn't that simple? */
902 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
909 tid_t pr_error_thread
;
910 struct prstatus status
;
913 thread_status
.pr_count
= 1;
914 thread_status
.status
.pr_tid
= pi
->tid
;
915 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
918 memcpy (&pi
->prstatus
, &thread_status
.status
,
919 sizeof (pi
->prstatus
));
920 pi
->status_valid
= 1;
924 /* Just read the danged status. Now isn't that simple? */
925 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
929 if (pi
->status_valid
)
931 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
934 proc_get_current_thread (pi
));
937 /* The status struct includes general regs, so mark them valid too */
938 pi
->gregs_valid
= pi
->status_valid
;
940 /* In the read/write multiple-fd model,
941 the status struct includes the fp regs too, so mark them valid too */
942 pi
->fpregs_valid
= pi
->status_valid
;
944 return pi
->status_valid
; /* True if success, false if failure. */
948 * Function: proc_flags
950 * returns the process flags (pr_flags field).
957 if (!pi
->status_valid
)
958 if (!proc_get_status (pi
))
959 return 0; /* FIXME: not a good failure value (but what is?) */
962 return pi
->prstatus
.pr_lwp
.pr_flags
;
964 return pi
->prstatus
.pr_flags
;
971 * returns the pr_why field (why the process stopped).
978 if (!pi
->status_valid
)
979 if (!proc_get_status (pi
))
980 return 0; /* FIXME: not a good failure value (but what is?) */
983 return pi
->prstatus
.pr_lwp
.pr_why
;
985 return pi
->prstatus
.pr_why
;
990 * Function: proc_what
992 * returns the pr_what field (details of why the process stopped).
999 if (!pi
->status_valid
)
1000 if (!proc_get_status (pi
))
1001 return 0; /* FIXME: not a good failure value (but what is?) */
1004 return pi
->prstatus
.pr_lwp
.pr_what
;
1006 return pi
->prstatus
.pr_what
;
1010 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1012 * Function: proc_nsysarg
1014 * returns the pr_nsysarg field (number of args to the current syscall).
1021 if (!pi
->status_valid
)
1022 if (!proc_get_status (pi
))
1026 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1028 return pi
->prstatus
.pr_nsysarg
;
1033 * Function: proc_sysargs
1035 * returns the pr_sysarg field (pointer to the arguments of current syscall).
1042 if (!pi
->status_valid
)
1043 if (!proc_get_status (pi
))
1047 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1049 return (long *) &pi
->prstatus
.pr_sysarg
;
1054 * Function: proc_syscall
1056 * returns the pr_syscall field (id of current syscall if we are in one).
1063 if (!pi
->status_valid
)
1064 if (!proc_get_status (pi
))
1068 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1070 return pi
->prstatus
.pr_syscall
;
1073 #endif /* PIOCSSPCACT */
1076 * Function: proc_cursig:
1078 * returns the pr_cursig field (current signal).
1082 proc_cursig (struct procinfo
*pi
)
1084 if (!pi
->status_valid
)
1085 if (!proc_get_status (pi
))
1086 return 0; /* FIXME: not a good failure value (but what is?) */
1089 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1091 return pi
->prstatus
.pr_cursig
;
1096 * Function: proc_modify_flags
1098 * === I appologize for the messiness of this function.
1099 * === This is an area where the different versions of
1100 * === /proc are more inconsistent than usual. MVS
1102 * Set or reset any of the following process flags:
1103 * PR_FORK -- forked child will inherit trace flags
1104 * PR_RLC -- traced process runs when last /proc file closed.
1105 * PR_ASYNC -- LWP's get to run/stop independently.
1107 * There are three methods for doing this function:
1108 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1110 * 2) Middle: PIOCSET/PIOCRESET
1112 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1115 * Note: Irix does not define PR_ASYNC.
1116 * Note: OSF is the only one that can ONLY use the oldest method.
1119 * pi -- the procinfo
1120 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1121 * mode -- 1 for set, 0 for reset.
1123 * Returns non-zero for success, zero for failure.
1126 enum { FLAG_RESET
, FLAG_SET
};
1129 proc_modify_flag (pi
, flag
, mode
)
1134 long win
= 0; /* default to fail */
1137 * These operations affect the process as a whole, and applying
1138 * them to an individual LWP has the same meaning as applying them
1139 * to the main process. Therefore, if we're ever called with a
1140 * pointer to an LWP's procinfo, let's substitute the process's
1141 * procinfo and avoid opening the LWP's file descriptor
1146 pi
= find_procinfo_or_die (pi
->pid
, 0);
1148 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
1149 /* First normalize the PCUNSET/PCRESET command opcode
1150 (which for no obvious reason has a different definition
1151 from one operating system to the next...) */
1153 #define GDBRESET PCUNSET
1156 #define GDBRESET PCRESET
1161 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC) */
1163 else /* Reset the flag */
1167 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1170 #ifdef PIOCSET /* Irix/Sol5 method */
1171 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
1173 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1175 else /* Reset the flag */
1177 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1181 #ifdef PIOCSRLC /* Oldest method: OSF */
1184 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1186 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1188 else /* Clear run-on-last-close */
1190 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1194 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1196 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1198 else /* Clear inherit-on-fork */
1200 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1204 win
= 0; /* fail -- unknown flag (can't do PR_ASYNC) */
1211 /* The above operation renders the procinfo's cached pstatus obsolete. */
1212 pi
->status_valid
= 0;
1215 warning ("procfs: modify_flag failed to turn %s %s",
1216 flag
== PR_FORK
? "PR_FORK" :
1217 flag
== PR_RLC
? "PR_RLC" :
1219 flag
== PR_ASYNC
? "PR_ASYNC" :
1222 mode
== FLAG_RESET
? "off" : "on");
1228 * Function: proc_set_run_on_last_close
1230 * Set the run_on_last_close flag.
1231 * Process with all threads will become runnable
1232 * when debugger closes all /proc fds.
1234 * Returns non-zero for success, zero for failure.
1238 proc_set_run_on_last_close (pi
)
1241 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1245 * Function: proc_unset_run_on_last_close
1247 * Reset the run_on_last_close flag.
1248 * Process will NOT become runnable
1249 * when debugger closes its file handles.
1251 * Returns non-zero for success, zero for failure.
1255 proc_unset_run_on_last_close (pi
)
1258 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1262 * Function: proc_set_inherit_on_fork
1264 * Set inherit_on_fork flag.
1265 * If the process forks a child while we are registered for events
1266 * in the parent, then we will also recieve events from the child.
1268 * Returns non-zero for success, zero for failure.
1272 proc_set_inherit_on_fork (pi
)
1275 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1279 * Function: proc_unset_inherit_on_fork
1281 * Reset inherit_on_fork flag.
1282 * If the process forks a child while we are registered for events
1283 * in the parent, then we will NOT recieve events from the child.
1285 * Returns non-zero for success, zero for failure.
1289 proc_unset_inherit_on_fork (pi
)
1292 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1297 * Function: proc_set_async
1299 * Set PR_ASYNC flag.
1300 * If one LWP stops because of a debug event (signal etc.),
1301 * the remaining LWPs will continue to run.
1303 * Returns non-zero for success, zero for failure.
1310 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1314 * Function: proc_unset_async
1316 * Reset PR_ASYNC flag.
1317 * If one LWP stops because of a debug event (signal etc.),
1318 * then all other LWPs will stop as well.
1320 * Returns non-zero for success, zero for failure.
1324 proc_unset_async (pi
)
1327 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1329 #endif /* PR_ASYNC */
1332 * Function: proc_stop_process
1334 * Request the process/LWP to stop. Does not wait.
1335 * Returns non-zero for success, zero for failure.
1339 proc_stop_process (pi
)
1345 * We might conceivably apply this operation to an LWP, and
1346 * the LWP's ctl file descriptor might not be open.
1349 if (pi
->ctl_fd
== 0 &&
1350 open_procinfo_files (pi
, FD_CTL
) == 0)
1356 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1357 #else /* ioctl method */
1358 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1359 /* Note: the call also reads the prstatus. */
1362 pi
->status_valid
= 1;
1363 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1366 proc_get_current_thread (pi
));
1375 * Function: proc_wait_for_stop
1377 * Wait for the process or LWP to stop (block until it does).
1378 * Returns non-zero for success, zero for failure.
1382 proc_wait_for_stop (pi
)
1388 * We should never have to apply this operation to any procinfo
1389 * except the one for the main process. If that ever changes
1390 * for any reason, then take out the following clause and
1391 * replace it with one that makes sure the ctl_fd is open.
1395 pi
= find_procinfo_or_die (pi
->pid
, 0);
1400 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1401 /* We been runnin' and we stopped -- need to update status. */
1402 pi
->status_valid
= 0;
1404 #else /* ioctl method */
1405 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1406 /* Above call also refreshes the prstatus. */
1409 pi
->status_valid
= 1;
1410 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1413 proc_get_current_thread (pi
));
1421 * Function: proc_run_process
1423 * Make the process or LWP runnable.
1424 * Options (not all are implemented):
1426 * - clear current fault
1427 * - clear current signal
1428 * - abort the current system call
1429 * - stop as soon as finished with system call
1430 * - (ioctl): set traced signal set
1431 * - (ioctl): set held signal set
1432 * - (ioctl): set traced fault set
1433 * - (ioctl): set start pc (vaddr)
1434 * Always clear the current fault.
1435 * Clear the current signal if 'signo' is zero.
1438 * pi the process or LWP to operate on.
1439 * step if true, set the process or LWP to trap after one instr.
1440 * signo if zero, clear the current signal if any.
1441 * if non-zero, set the current signal to this one.
1443 * Returns non-zero for success, zero for failure.
1447 proc_run_process (pi
, step
, signo
)
1456 * We will probably have to apply this operation to individual threads,
1457 * so make sure the control file descriptor is open.
1460 if (pi
->ctl_fd
== 0 &&
1461 open_procinfo_files (pi
, FD_CTL
) == 0)
1466 runflags
= PRCFAULT
; /* always clear current fault */
1471 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals */
1472 proc_set_current_signal (pi
, signo
);
1480 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1482 #else /* ioctl method */
1486 memset (&prrun
, 0, sizeof (prrun
));
1487 prrun
.pr_flags
= runflags
;
1488 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1496 * Function: proc_set_traced_signals
1498 * Register to trace signals in the process or LWP.
1499 * Returns non-zero for success, zero for failure.
1503 proc_set_traced_signals (pi
, sigset
)
1510 * We should never have to apply this operation to any procinfo
1511 * except the one for the main process. If that ever changes
1512 * for any reason, then take out the following clause and
1513 * replace it with one that makes sure the ctl_fd is open.
1517 pi
= find_procinfo_or_die (pi
->pid
, 0);
1523 /* Use char array to avoid alignment issues. */
1524 char sigset
[sizeof (sigset_t
)];
1528 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
1530 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1532 #else /* ioctl method */
1533 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1535 /* The above operation renders the procinfo's cached pstatus obsolete. */
1536 pi
->status_valid
= 0;
1539 warning ("procfs: set_traced_signals failed");
1544 * Function: proc_set_traced_faults
1546 * Register to trace hardware faults in the process or LWP.
1547 * Returns non-zero for success, zero for failure.
1551 proc_set_traced_faults (pi
, fltset
)
1558 * We should never have to apply this operation to any procinfo
1559 * except the one for the main process. If that ever changes
1560 * for any reason, then take out the following clause and
1561 * replace it with one that makes sure the ctl_fd is open.
1565 pi
= find_procinfo_or_die (pi
->pid
, 0);
1571 /* Use char array to avoid alignment issues. */
1572 char fltset
[sizeof (fltset_t
)];
1576 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1578 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1580 #else /* ioctl method */
1581 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1583 /* The above operation renders the procinfo's cached pstatus obsolete. */
1584 pi
->status_valid
= 0;
1590 * Function: proc_set_traced_sysentry
1592 * Register to trace entry to system calls in the process or LWP.
1593 * Returns non-zero for success, zero for failure.
1597 proc_set_traced_sysentry (pi
, sysset
)
1604 * We should never have to apply this operation to any procinfo
1605 * except the one for the main process. If that ever changes
1606 * for any reason, then take out the following clause and
1607 * replace it with one that makes sure the ctl_fd is open.
1611 pi
= find_procinfo_or_die (pi
->pid
, 0);
1617 /* Use char array to avoid alignment issues. */
1618 char sysset
[sizeof (sysset_t
)];
1622 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1624 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1626 #else /* ioctl method */
1627 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1629 /* The above operation renders the procinfo's cached pstatus obsolete. */
1630 pi
->status_valid
= 0;
1636 * Function: proc_set_traced_sysexit
1638 * Register to trace exit from system calls in the process or LWP.
1639 * Returns non-zero for success, zero for failure.
1643 proc_set_traced_sysexit (pi
, sysset
)
1650 * We should never have to apply this operation to any procinfo
1651 * except the one for the main process. If that ever changes
1652 * for any reason, then take out the following clause and
1653 * replace it with one that makes sure the ctl_fd is open.
1657 pi
= find_procinfo_or_die (pi
->pid
, 0);
1663 /* Use char array to avoid alignment issues. */
1664 char sysset
[sizeof (sysset_t
)];
1668 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1670 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1672 #else /* ioctl method */
1673 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1675 /* The above operation renders the procinfo's cached pstatus obsolete. */
1676 pi
->status_valid
= 0;
1682 * Function: proc_set_held_signals
1684 * Specify the set of blocked / held signals in the process or LWP.
1685 * Returns non-zero for success, zero for failure.
1689 proc_set_held_signals (pi
, sighold
)
1696 * We should never have to apply this operation to any procinfo
1697 * except the one for the main process. If that ever changes
1698 * for any reason, then take out the following clause and
1699 * replace it with one that makes sure the ctl_fd is open.
1703 pi
= find_procinfo_or_die (pi
->pid
, 0);
1709 /* Use char array to avoid alignment issues. */
1710 char hold
[sizeof (sigset_t
)];
1714 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1715 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1718 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1720 /* The above operation renders the procinfo's cached pstatus obsolete. */
1721 pi
->status_valid
= 0;
1727 * Function: proc_get_pending_signals
1729 * returns the set of signals that are pending in the process or LWP.
1730 * Will also copy the sigset if 'save' is non-zero.
1734 proc_get_pending_signals (pi
, save
)
1738 sigset_t
*ret
= NULL
;
1741 * We should never have to apply this operation to any procinfo
1742 * except the one for the main process. If that ever changes
1743 * for any reason, then take out the following clause and
1744 * replace it with one that makes sure the ctl_fd is open.
1748 pi
= find_procinfo_or_die (pi
->pid
, 0);
1750 if (!pi
->status_valid
)
1751 if (!proc_get_status (pi
))
1755 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
1757 ret
= &pi
->prstatus
.pr_sigpend
;
1760 memcpy (save
, ret
, sizeof (sigset_t
));
1766 * Function: proc_get_signal_actions
1768 * returns the set of signal actions.
1769 * Will also copy the sigactionset if 'save' is non-zero.
1773 proc_get_signal_actions (pi
, save
)
1775 struct sigaction
*save
;
1777 struct sigaction
*ret
= NULL
;
1780 * We should never have to apply this operation to any procinfo
1781 * except the one for the main process. If that ever changes
1782 * for any reason, then take out the following clause and
1783 * replace it with one that makes sure the ctl_fd is open.
1787 pi
= find_procinfo_or_die (pi
->pid
, 0);
1789 if (!pi
->status_valid
)
1790 if (!proc_get_status (pi
))
1794 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
1796 ret
= &pi
->prstatus
.pr_action
;
1799 memcpy (save
, ret
, sizeof (struct sigaction
));
1805 * Function: proc_get_held_signals
1807 * returns the set of signals that are held / blocked.
1808 * Will also copy the sigset if 'save' is non-zero.
1812 proc_get_held_signals (pi
, save
)
1816 sigset_t
*ret
= NULL
;
1819 * We should never have to apply this operation to any procinfo
1820 * except the one for the main process. If that ever changes
1821 * for any reason, then take out the following clause and
1822 * replace it with one that makes sure the ctl_fd is open.
1826 pi
= find_procinfo_or_die (pi
->pid
, 0);
1829 if (!pi
->status_valid
)
1830 if (!proc_get_status (pi
))
1834 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1836 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1837 #endif /* UNIXWARE */
1838 #else /* not NEW_PROC_API */
1840 static sigset_t sigheld
;
1842 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1845 #endif /* NEW_PROC_API */
1847 memcpy (save
, ret
, sizeof (sigset_t
));
1853 * Function: proc_get_traced_signals
1855 * returns the set of signals that are traced / debugged.
1856 * Will also copy the sigset if 'save' is non-zero.
1860 proc_get_traced_signals (pi
, save
)
1864 sigset_t
*ret
= NULL
;
1867 * We should never have to apply this operation to any procinfo
1868 * except the one for the main process. If that ever changes
1869 * for any reason, then take out the following clause and
1870 * replace it with one that makes sure the ctl_fd is open.
1874 pi
= find_procinfo_or_die (pi
->pid
, 0);
1877 if (!pi
->status_valid
)
1878 if (!proc_get_status (pi
))
1881 ret
= &pi
->prstatus
.pr_sigtrace
;
1884 static sigset_t sigtrace
;
1886 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
1891 memcpy (save
, ret
, sizeof (sigset_t
));
1897 * Function: proc_trace_signal
1899 * Add 'signo' to the set of signals that are traced.
1900 * Returns non-zero for success, zero for failure.
1904 proc_trace_signal (pi
, signo
)
1911 * We should never have to apply this operation to any procinfo
1912 * except the one for the main process. If that ever changes
1913 * for any reason, then take out the following clause and
1914 * replace it with one that makes sure the ctl_fd is open.
1918 pi
= find_procinfo_or_die (pi
->pid
, 0);
1922 if (proc_get_traced_signals (pi
, &temp
))
1924 praddset (&temp
, signo
);
1925 return proc_set_traced_signals (pi
, &temp
);
1929 return 0; /* failure */
1933 * Function: proc_ignore_signal
1935 * Remove 'signo' from the set of signals that are traced.
1936 * Returns non-zero for success, zero for failure.
1940 proc_ignore_signal (pi
, signo
)
1947 * We should never have to apply this operation to any procinfo
1948 * except the one for the main process. If that ever changes
1949 * for any reason, then take out the following clause and
1950 * replace it with one that makes sure the ctl_fd is open.
1954 pi
= find_procinfo_or_die (pi
->pid
, 0);
1958 if (proc_get_traced_signals (pi
, &temp
))
1960 prdelset (&temp
, signo
);
1961 return proc_set_traced_signals (pi
, &temp
);
1965 return 0; /* failure */
1969 * Function: proc_get_traced_faults
1971 * returns the set of hardware faults that are traced /debugged.
1972 * Will also copy the faultset if 'save' is non-zero.
1976 proc_get_traced_faults (pi
, save
)
1980 fltset_t
*ret
= NULL
;
1983 * We should never have to apply this operation to any procinfo
1984 * except the one for the main process. If that ever changes
1985 * for any reason, then take out the following clause and
1986 * replace it with one that makes sure the ctl_fd is open.
1990 pi
= find_procinfo_or_die (pi
->pid
, 0);
1993 if (!pi
->status_valid
)
1994 if (!proc_get_status (pi
))
1997 ret
= &pi
->prstatus
.pr_flttrace
;
2000 static fltset_t flttrace
;
2002 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
2007 memcpy (save
, ret
, sizeof (fltset_t
));
2013 * Function: proc_get_traced_sysentry
2015 * returns the set of syscalls that are traced /debugged on entry.
2016 * Will also copy the syscall set if 'save' is non-zero.
2020 proc_get_traced_sysentry (pi
, save
)
2024 sysset_t
*ret
= NULL
;
2027 * We should never have to apply this operation to any procinfo
2028 * except the one for the main process. If that ever changes
2029 * for any reason, then take out the following clause and
2030 * replace it with one that makes sure the ctl_fd is open.
2034 pi
= find_procinfo_or_die (pi
->pid
, 0);
2037 if (!pi
->status_valid
)
2038 if (!proc_get_status (pi
))
2041 ret
= &pi
->prstatus
.pr_sysentry
;
2044 static sysset_t sysentry
;
2046 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
2051 memcpy (save
, ret
, sizeof (sysset_t
));
2057 * Function: proc_get_traced_sysexit
2059 * returns the set of syscalls that are traced /debugged on exit.
2060 * Will also copy the syscall set if 'save' is non-zero.
2064 proc_get_traced_sysexit (pi
, save
)
2068 sysset_t
* ret
= NULL
;
2071 * We should never have to apply this operation to any procinfo
2072 * except the one for the main process. If that ever changes
2073 * for any reason, then take out the following clause and
2074 * replace it with one that makes sure the ctl_fd is open.
2078 pi
= find_procinfo_or_die (pi
->pid
, 0);
2081 if (!pi
->status_valid
)
2082 if (!proc_get_status (pi
))
2085 ret
= &pi
->prstatus
.pr_sysexit
;
2088 static sysset_t sysexit
;
2090 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2095 memcpy (save
, ret
, sizeof (sysset_t
));
2101 * Function: proc_clear_current_fault
2103 * The current fault (if any) is cleared; the associated signal
2104 * will not be sent to the process or LWP when it resumes.
2105 * Returns non-zero for success, zero for failure.
2109 proc_clear_current_fault (pi
)
2115 * We should never have to apply this operation to any procinfo
2116 * except the one for the main process. If that ever changes
2117 * for any reason, then take out the following clause and
2118 * replace it with one that makes sure the ctl_fd is open.
2122 pi
= find_procinfo_or_die (pi
->pid
, 0);
2127 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2130 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2137 * Function: proc_set_current_signal
2139 * Set the "current signal" that will be delivered next to the process.
2140 * NOTE: semantics are different from those of KILL.
2141 * This signal will be delivered to the process or LWP
2142 * immediately when it is resumed (even if the signal is held/blocked);
2143 * it will NOT immediately cause another event of interest, and will NOT
2144 * first trap back to the debugger.
2146 * Returns non-zero for success, zero for failure.
2150 proc_set_current_signal (pi
, signo
)
2157 /* Use char array to avoid alignment issues. */
2158 char sinfo
[sizeof (struct siginfo
)];
2160 struct siginfo
*mysinfo
;
2163 * We should never have to apply this operation to any procinfo
2164 * except the one for the main process. If that ever changes
2165 * for any reason, then take out the following clause and
2166 * replace it with one that makes sure the ctl_fd is open.
2170 pi
= find_procinfo_or_die (pi
->pid
, 0);
2172 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2173 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2174 * receives a PIOCSSIG with a signal identical to the current signal,
2175 * it messes up the current signal. Work around the kernel bug.
2178 signo
== proc_cursig (pi
))
2179 return 1; /* I assume this is a success? */
2182 /* The pointer is just a type alias. */
2183 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2184 mysinfo
->si_signo
= signo
;
2185 mysinfo
->si_code
= 0;
2186 mysinfo
->si_pid
= getpid (); /* ?why? */
2187 mysinfo
->si_uid
= getuid (); /* ?why? */
2191 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2193 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2200 * Function: proc_clear_current_signal
2202 * The current signal (if any) is cleared, and
2203 * is not sent to the process or LWP when it resumes.
2204 * Returns non-zero for success, zero for failure.
2208 proc_clear_current_signal (pi
)
2214 * We should never have to apply this operation to any procinfo
2215 * except the one for the main process. If that ever changes
2216 * for any reason, then take out the following clause and
2217 * replace it with one that makes sure the ctl_fd is open.
2221 pi
= find_procinfo_or_die (pi
->pid
, 0);
2227 /* Use char array to avoid alignment issues. */
2228 char sinfo
[sizeof (struct siginfo
)];
2230 struct siginfo
*mysinfo
;
2233 /* The pointer is just a type alias. */
2234 mysinfo
= (struct siginfo
*) &arg
.sinfo
;
2235 mysinfo
->si_signo
= 0;
2236 mysinfo
->si_code
= 0;
2237 mysinfo
->si_errno
= 0;
2238 mysinfo
->si_pid
= getpid (); /* ?why? */
2239 mysinfo
->si_uid
= getuid (); /* ?why? */
2241 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2244 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2251 * Function: proc_get_gregs
2253 * Get the general registers for the process or LWP.
2254 * Returns non-zero for success, zero for failure.
2261 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2262 if (!proc_get_status (pi
))
2266 * OK, sorry about the ifdef's.
2267 * There's three cases instead of two, because
2268 * in this instance Unixware and Solaris/RW differ.
2272 #ifdef UNIXWARE /* ugh, a true architecture dependency */
2273 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2274 #else /* not Unixware */
2275 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2276 #endif /* Unixware */
2277 #else /* not NEW_PROC_API */
2278 return &pi
->prstatus
.pr_reg
;
2279 #endif /* NEW_PROC_API */
2283 * Function: proc_get_fpregs
2285 * Get the floating point registers for the process or LWP.
2286 * Returns non-zero for success, zero for failure.
2290 proc_get_fpregs (pi
)
2294 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2295 if (!proc_get_status (pi
))
2298 #ifdef UNIXWARE /* a true architecture dependency */
2299 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2301 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2302 #endif /* Unixware */
2304 #else /* not NEW_PROC_API */
2305 if (pi
->fpregs_valid
)
2306 return &pi
->fpregset
; /* already got 'em */
2309 if (pi
->ctl_fd
== 0 &&
2310 open_procinfo_files (pi
, FD_CTL
) == 0)
2319 tid_t pr_error_thread
;
2320 tfpregset_t thread_1
;
2323 thread_fpregs
.pr_count
= 1;
2324 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2327 ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2329 pi
->fpregs_valid
= 1;
2330 return &pi
->fpregset
; /* got 'em now! */
2332 else if (pi
->tid
!= 0 &&
2333 ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2335 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2336 sizeof (pi
->fpregset
));
2337 pi
->fpregs_valid
= 1;
2338 return &pi
->fpregset
; /* got 'em now! */
2345 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2347 pi
->fpregs_valid
= 1;
2348 return &pi
->fpregset
; /* got 'em now! */
2361 * Function: proc_set_gregs
2363 * Write the general registers back to the process or LWP.
2364 * Returns non-zero for success, zero for failure.
2371 gdb_gregset_t
*gregs
;
2374 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2375 return 0; /* get_regs has already warned */
2377 if (pi
->ctl_fd
== 0 &&
2378 open_procinfo_files (pi
, FD_CTL
) == 0)
2387 /* Use char array to avoid alignment issues. */
2388 char gregs
[sizeof (gdb_gregset_t
)];
2392 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2393 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2395 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2399 /* Policy: writing the regs invalidates our cache. */
2400 pi
->gregs_valid
= 0;
2405 * Function: proc_set_fpregs
2407 * Modify the floating point register set of the process or LWP.
2408 * Returns non-zero for success, zero for failure.
2412 proc_set_fpregs (pi
)
2415 gdb_fpregset_t
*fpregs
;
2418 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
2419 return 0; /* get_fpregs has already warned */
2421 if (pi
->ctl_fd
== 0 &&
2422 open_procinfo_files (pi
, FD_CTL
) == 0)
2431 /* Use char array to avoid alignment issues. */
2432 char fpregs
[sizeof (gdb_fpregset_t
)];
2436 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2437 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2441 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2446 tid_t pr_error_thread
;
2447 tfpregset_t thread_1
;
2450 thread_fpregs
.pr_count
= 1;
2451 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2452 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2454 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2457 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2458 #endif /* osf PIOCTSFPREG */
2459 #endif /* NEW_PROC_API */
2462 /* Policy: writing the regs invalidates our cache. */
2463 pi
->fpregs_valid
= 0;
2468 * Function: proc_kill
2470 * Send a signal to the proc or lwp with the semantics of "kill()".
2471 * Returns non-zero for success, zero for failure.
2475 proc_kill (pi
, signo
)
2482 * We might conceivably apply this operation to an LWP, and
2483 * the LWP's ctl file descriptor might not be open.
2486 if (pi
->ctl_fd
== 0 &&
2487 open_procinfo_files (pi
, FD_CTL
) == 0)
2498 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2499 #else /* ioctl method */
2500 /* FIXME: do I need the Alpha OSF fixups present in
2501 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2502 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2510 * Function: proc_parent_pid
2512 * Find the pid of the process that started this one.
2513 * Returns the parent process pid, or zero.
2517 proc_parent_pid (pi
)
2521 * We should never have to apply this operation to any procinfo
2522 * except the one for the main process. If that ever changes
2523 * for any reason, then take out the following clause and
2524 * replace it with one that makes sure the ctl_fd is open.
2528 pi
= find_procinfo_or_die (pi
->pid
, 0);
2530 if (!pi
->status_valid
)
2531 if (!proc_get_status (pi
))
2534 return pi
->prstatus
.pr_ppid
;
2539 * Function: proc_set_watchpoint
2544 proc_set_watchpoint (pi
, addr
, len
, wflags
)
2550 #if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
2553 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
2554 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
2559 char watch
[sizeof (prwatch_t
)];
2563 pwatch
= (prwatch_t
*) &arg
.watch
;
2564 pwatch
->pr_vaddr
= addr
;
2565 pwatch
->pr_size
= len
;
2566 pwatch
->pr_wflags
= wflags
;
2567 #if defined(NEW_PROC_API) && defined (PCWATCH)
2569 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2571 #if defined (PIOCSWATCH)
2572 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, pwatch
) >= 0);
2574 return 0; /* Fail */
2582 * Function: proc_iterate_over_mappings
2584 * Given a pointer to a function, call that function once for every
2585 * mapped address space in the process. The callback function
2586 * receives an open file descriptor for the file corresponding to
2587 * that mapped address space (if there is one), and the base address
2588 * of the mapped space. Quit when the callback function returns a
2589 * nonzero value, or at teh end of the mappings.
2591 * Returns: the first non-zero return value of the callback function,
2595 /* FIXME: it's probably a waste to cache this FD.
2596 It doesn't get called that often... and if I open it
2597 every time, I don't need to lseek it. */
2599 proc_iterate_over_mappings (func
)
2600 int (*func
) PARAMS ((int, CORE_ADDR
));
2607 char pathname
[MAX_PROC_NAME_SIZE
];
2609 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
2613 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
2614 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
2615 proc_error (pi
, "proc_iterate_over_mappings (open)", __LINE__
);
2617 /* Make sure it gets closed again. */
2618 make_cleanup ((make_cleanup_func
) close
, (void *) map_fd
);
2620 /* Allocate space for mapping (lifetime only for this function). */
2621 map
= alloca (sizeof (struct prmap
));
2623 /* Now read the mappings from the file,
2624 open a file descriptor for those that have a name,
2625 and call the callback function. */
2626 while (read (map_fd
,
2628 sizeof (struct prmap
)) == sizeof (struct prmap
))
2630 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
2632 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
2635 if (map
->pr_mapname
[0] == 0)
2637 fd
= -1; /* no map file */
2641 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
2642 /* Note: caller's responsibility to close this fd! */
2643 fd
= open (name
, O_RDONLY
);
2644 /* Note: we don't test the above call for failure;
2645 we just pass the FD on as given. Sometimes there is
2646 no file, so the ioctl may return failure, but that's
2650 /* Stop looping if the callback returns non-zero. */
2651 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
)) != 0)
2655 /* Get the number of mapping entries. */
2656 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmaps
) < 0)
2657 proc_error (pi
, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__
);
2659 /* Allocate space for mappings (lifetime only this function). */
2660 map
= (struct prmap
*) alloca ((nmaps
+ 1) * sizeof (struct prmap
));
2662 /* Read in all the mappings. */
2663 if (ioctl (pi
->ctl_fd
, PIOCMAP
, map
) < 0)
2664 proc_error (pi
, "proc_iterate_over_mappings (PIOCMAP)", __LINE__
);
2666 /* Now loop through the mappings, open an fd for each, and
2667 call the callback function. */
2669 i
< nmaps
&& map
[i
].pr_size
!= 0;
2672 /* Note: caller's responsibility to close this fd! */
2673 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
[i
].pr_vaddr
);
2674 /* Note: we don't test the above call for failure;
2675 we just pass the FD on as given. Sometimes there is
2676 no file, so the ioctl may return failure, but that's
2679 /* Stop looping if the callback returns non-zero. */
2680 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
[i
].pr_vaddr
)) != 0)
2688 #ifdef TM_I386SOL2_H /* Is it hokey to use this? */
2690 #include <sys/sysi86.h>
2693 * Function: proc_get_LDT_entry
2699 * The 'key' is actually the value of the lower 16 bits of
2700 * the GS register for the LWP that we're interested in.
2702 * Return: matching ssh struct (LDT entry).
2706 proc_get_LDT_entry (pi
, key
)
2710 static struct ssd
*ldt_entry
= NULL
;
2712 char pathname
[MAX_PROC_NAME_SIZE
];
2713 struct cleanup
*old_chain
= NULL
;
2716 /* Allocate space for one LDT entry.
2717 This alloc must persist, because we return a pointer to it. */
2718 if (ldt_entry
== NULL
)
2719 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2721 /* Open the file descriptor for the LDT table. */
2722 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2723 if ((fd
= open (pathname
, O_RDONLY
)) < 0)
2725 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2728 /* Make sure it gets closed again! */
2729 old_chain
= make_cleanup ((make_cleanup_func
) close
, (void *) fd
);
2731 /* Now 'read' thru the table, find a match and return it. */
2732 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2734 if (ldt_entry
->sel
== 0 &&
2735 ldt_entry
->bo
== 0 &&
2736 ldt_entry
->acc1
== 0 &&
2737 ldt_entry
->acc2
== 0)
2738 break; /* end of table */
2739 /* If key matches, return this entry. */
2740 if (ldt_entry
->sel
== key
)
2743 /* Loop ended, match not found. */
2747 static int nalloc
= 0;
2749 /* Get the number of LDT entries. */
2750 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2752 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2756 /* Allocate space for the number of LDT entries. */
2757 /* This alloc has to persist, 'cause we return a pointer to it. */
2760 ldt_entry
= (struct ssd
*)
2761 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2765 /* Read the whole table in one gulp. */
2766 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2768 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2772 /* Search the table and return the (first) entry matching 'key'. */
2773 for (i
= 0; i
< nldt
; i
++)
2774 if (ldt_entry
[i
].sel
== key
)
2775 return &ldt_entry
[i
];
2777 /* Loop ended, match not found. */
2782 #endif /* TM_I386SOL2_H */
2784 /* =============== END, non-thread part of /proc "MODULE" =============== */
2786 /* =================== Thread "MODULE" =================== */
2788 /* NOTE: you'll see more ifdefs and duplication of functions here,
2789 since there is a different way to do threads on every OS. */
2792 * Function: proc_get_nthreads
2794 * Return the number of threads for the process
2797 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2802 proc_get_nthreads (pi
)
2807 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2808 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2814 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2816 * Solaris and Unixware version
2819 proc_get_nthreads (pi
)
2822 if (!pi
->status_valid
)
2823 if (!proc_get_status (pi
))
2827 * NEW_PROC_API: only works for the process procinfo,
2828 * because the LWP procinfos do not get prstatus filled in.
2831 if (pi
->tid
!= 0) /* find the parent process procinfo */
2832 pi
= find_procinfo_or_die (pi
->pid
, 0);
2834 return pi
->prstatus
.pr_nlwp
;
2842 proc_get_nthreads (pi
)
2851 * Function: proc_get_current_thread (LWP version)
2853 * Return the ID of the thread that had an event of interest.
2854 * (ie. the one that hit a breakpoint or other traced event).
2855 * All other things being equal, this should be the ID of a
2856 * thread that is currently executing.
2859 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2861 * Solaris and Unixware version
2864 proc_get_current_thread (pi
)
2868 * Note: this should be applied to the root procinfo for the process,
2869 * not to the procinfo for an LWP. If applied to the procinfo for
2870 * an LWP, it will simply return that LWP's ID. In that case,
2871 * find the parent process procinfo.
2875 pi
= find_procinfo_or_die (pi
->pid
, 0);
2877 if (!pi
->status_valid
)
2878 if (!proc_get_status (pi
))
2882 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2884 return pi
->prstatus
.pr_who
;
2889 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2894 proc_get_current_thread (pi
)
2897 #if 0 /* FIXME: not ready for prime time? */
2898 return pi
->prstatus
.pr_tid
;
2909 proc_get_current_thread (pi
)
2919 * Function: proc_update_threads
2921 * Discover the IDs of all the threads within the process, and
2922 * create a procinfo for each of them (chained to the parent).
2924 * This unfortunately requires a different method on every OS.
2926 * Return: non-zero for success, zero for failure.
2930 proc_delete_dead_threads (parent
, thread
, ignore
)
2935 if (thread
&& parent
) /* sanity */
2937 thread
->status_valid
= 0;
2938 if (!proc_get_status (thread
))
2939 destroy_one_procinfo (&parent
->thread_list
, thread
);
2941 return 0; /* keep iterating */
2944 #if defined (PIOCLSTATUS)
2946 * Solaris 2.5 (ioctl) version
2949 proc_update_threads (pi
)
2952 gdb_prstatus_t
*prstatus
;
2953 struct cleanup
*old_chain
= NULL
;
2958 * We should never have to apply this operation to any procinfo
2959 * except the one for the main process. If that ever changes
2960 * for any reason, then take out the following clause and
2961 * replace it with one that makes sure the ctl_fd is open.
2965 pi
= find_procinfo_or_die (pi
->pid
, 0);
2967 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2969 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2970 return 1; /* Process is not multi-threaded; nothing to do. */
2972 if ((prstatus
= (gdb_prstatus_t
*)
2973 malloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1))) == 0)
2974 perror_with_name ("procfs: malloc failed in update_threads");
2976 old_chain
= make_cleanup (free
, prstatus
);
2977 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2978 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2980 /* Skip element zero, which represents the process as a whole. */
2981 for (i
= 1; i
< nlwp
+ 1; i
++)
2983 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
2984 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2986 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
2987 thread
->status_valid
= 1;
2989 pi
->threads_valid
= 1;
2990 do_cleanups (old_chain
);
2996 * Unixware and Solaris 6 (and later) version
2999 proc_update_threads (pi
)
3002 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3003 struct dirent
*direntry
;
3004 struct cleanup
*old_chain
= NULL
;
3010 * We should never have to apply this operation to any procinfo
3011 * except the one for the main process. If that ever changes
3012 * for any reason, then take out the following clause and
3013 * replace it with one that makes sure the ctl_fd is open.
3017 pi
= find_procinfo_or_die (pi
->pid
, 0);
3019 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3024 * Note: this brute-force method is the only way I know of
3025 * to accomplish this task on Unixware. This method will
3026 * also work on Solaris 2.6 and 2.7. There is a much simpler
3027 * and more elegant way to do this on Solaris, but the margins
3028 * of this manuscript are too small to write it here... ;-)
3031 strcpy (pathname
, pi
->pathname
);
3032 strcat (pathname
, "/lwp");
3033 if ((dirp
= opendir (pathname
)) == NULL
)
3034 proc_error (pi
, "update_threads, opendir", __LINE__
);
3036 old_chain
= make_cleanup ((make_cleanup_func
) closedir
, dirp
);
3037 while ((direntry
= readdir (dirp
)) != NULL
)
3038 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3040 lwpid
= atoi (&direntry
->d_name
[0]);
3041 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3042 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3044 pi
->threads_valid
= 1;
3045 do_cleanups (old_chain
);
3054 proc_update_threads (pi
)
3061 * We should never have to apply this operation to any procinfo
3062 * except the one for the main process. If that ever changes
3063 * for any reason, then take out the following clause and
3064 * replace it with one that makes sure the ctl_fd is open.
3068 pi
= find_procinfo_or_die (pi
->pid
, 0);
3070 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3072 nthreads
= proc_get_nthreads (pi
);
3074 return 0; /* nothing to do for 1 or fewer threads */
3076 if ((threads
= malloc (nthreads
* sizeof (tid_t
))) == NULL
)
3077 proc_error (pi
, "update_threads, malloc", __LINE__
);
3079 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3080 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3082 for (i
= 0; i
< nthreads
; i
++)
3084 if (!find_procinfo (pi
->pid
, threads
[i
]))
3085 if (!create_procinfo (pi
->pid
, threads
[i
]))
3086 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3088 pi
->threads_valid
= 1;
3096 proc_update_threads (pi
)
3101 #endif /* OSF PIOCTLIST */
3102 #endif /* NEW_PROC_API */
3103 #endif /* SOL 2.5 PIOCLSTATUS */
3106 * Function: proc_iterate_over_threads
3109 * Given a pointer to a function, call that function once
3110 * for each lwp in the procinfo list, until the function
3111 * returns non-zero, in which event return the value
3112 * returned by the function.
3114 * Note: this function does NOT call update_threads.
3115 * If you want to discover new threads first, you must
3116 * call that function explicitly. This function just makes
3117 * a quick pass over the currently-known procinfos.
3120 * pi - parent process procinfo
3121 * func - per-thread function
3122 * ptr - opaque parameter for function.
3125 * First non-zero return value from the callee, or zero.
3129 proc_iterate_over_threads (pi
, func
, ptr
)
3131 int (*func
) PARAMS ((procinfo
*, procinfo
*, void *));
3134 procinfo
*thread
, *next
;
3138 * We should never have to apply this operation to any procinfo
3139 * except the one for the main process. If that ever changes
3140 * for any reason, then take out the following clause and
3141 * replace it with one that makes sure the ctl_fd is open.
3145 pi
= find_procinfo_or_die (pi
->pid
, 0);
3147 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3149 next
= thread
->next
; /* in case thread is destroyed */
3150 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3157 /* =================== END, Thread "MODULE" =================== */
3159 /* =================== END, /proc "MODULE" =================== */
3161 /* =================== GDB "MODULE" =================== */
3164 * Here are all of the gdb target vector functions and their friends.
3167 static int do_attach
PARAMS ((int pid
));
3168 static void do_detach
PARAMS ((int signo
));
3169 static int register_gdb_signals
PARAMS ((procinfo
*, sigset_t
*));
3172 * Function: procfs_debug_inferior
3174 * Sets up the inferior to be debugged.
3175 * Registers to trace signals, hardware faults, and syscalls.
3176 * Note: does not set RLC flag: caller may want to customize that.
3178 * Returns: zero for success (note! unlike most functions in this module)
3179 * On failure, returns the LINE NUMBER where it failed!
3183 procfs_debug_inferior (pi
)
3186 fltset_t traced_faults
;
3187 sigset_t traced_signals
;
3188 sysset_t traced_syscall_entries
;
3189 sysset_t traced_syscall_exits
;
3191 #ifdef PROCFS_DONT_TRACE_FAULTS
3192 /* On some systems (OSF), we don't trace hardware faults.
3193 Apparently it's enough that we catch them as signals.
3194 Wonder why we don't just do that in general? */
3195 premptyset (&traced_faults
); /* don't trace faults. */
3197 /* Register to trace hardware faults in the child. */
3198 prfillset (&traced_faults
); /* trace all faults... */
3199 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3201 if (!proc_set_traced_faults (pi
, &traced_faults
))
3204 /* Register to trace selected signals in the child. */
3205 premptyset (&traced_signals
);
3206 if (!register_gdb_signals (pi
, &traced_signals
))
3209 /* Register to trace the 'exit' system call (on entry). */
3210 premptyset (&traced_syscall_entries
);
3211 praddset (&traced_syscall_entries
, SYS_exit
);
3213 praddset (&traced_syscall_entries
, SYS_lwpexit
); /* And _lwp_exit... */
3216 praddset (&traced_syscall_entries
, SYS_lwp_exit
);
3219 if (!proc_set_traced_sysentry (pi
, &traced_syscall_entries
))
3222 #ifdef PRFS_STOPEXEC /* defined on OSF */
3223 /* OSF method for tracing exec syscalls. Quoting:
3224 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3225 exits from exec system calls because of the user level loader. */
3226 /* FIXME: make nice and maybe move into an access function. */
3230 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3233 prfs_flags
|= PRFS_STOPEXEC
;
3235 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3238 #else /* not PRFS_STOPEXEC */
3239 /* Everyone else's (except OSF) method for tracing exec syscalls */
3241 Not all systems with /proc have all the exec* syscalls with the same
3242 names. On the SGI, for example, there is no SYS_exec, but there
3243 *is* a SYS_execv. So, we try to account for that. */
3245 premptyset (&traced_syscall_exits
);
3247 praddset (&traced_syscall_exits
, SYS_exec
);
3250 praddset (&traced_syscall_exits
, SYS_execve
);
3253 praddset (&traced_syscall_exits
, SYS_execv
);
3256 #ifdef SYS_lwpcreate
3257 praddset (&traced_syscall_exits
, SYS_lwpcreate
);
3258 praddset (&traced_syscall_exits
, SYS_lwpexit
);
3261 #ifdef SYS_lwp_create /* FIXME: once only, please */
3262 praddset (&traced_syscall_exits
, SYS_lwp_create
);
3263 praddset (&traced_syscall_exits
, SYS_lwp_exit
);
3267 if (!proc_set_traced_sysexit (pi
, &traced_syscall_exits
))
3270 #endif /* PRFS_STOPEXEC */
3275 procfs_attach (args
, from_tty
)
3283 error_no_arg ("process-id to attach");
3286 if (pid
== getpid ())
3287 error ("Attaching GDB to itself is not a good idea...");
3291 exec_file
= get_exec_file (0);
3294 printf_filtered ("Attaching to program `%s', %s\n",
3295 exec_file
, target_pid_to_str (pid
));
3297 printf_filtered ("Attaching to %s\n", target_pid_to_str (pid
));
3301 inferior_pid
= do_attach (pid
);
3302 push_target (&procfs_ops
);
3306 procfs_detach (args
, from_tty
)
3315 exec_file
= get_exec_file (0);
3318 printf_filtered ("Detaching from program: %s %s\n",
3319 exec_file
, target_pid_to_str (inferior_pid
));
3323 signo
= atoi (args
);
3327 unpush_target (&procfs_ops
); /* Pop out of handling an inferior */
3337 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
3338 perror ("procfs: out of memory in 'attach'");
3340 if (!open_procinfo_files (pi
, FD_CTL
))
3342 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3343 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3345 dead_procinfo (pi
, errmsg
, NOKILL
);
3348 /* Stop the process (if it isn't already stopped). */
3349 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3351 pi
->was_stopped
= 1;
3352 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3356 pi
->was_stopped
= 0;
3357 /* Set the process to run again when we close it. */
3358 if (!proc_set_run_on_last_close (pi
))
3359 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3361 /* Now stop the process. */
3362 if (!proc_stop_process (pi
))
3363 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3364 pi
->ignore_next_sigstop
= 1;
3366 /* Save some of the /proc state to be restored if we detach. */
3367 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3368 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3369 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3370 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3371 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
3372 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3374 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
3375 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3377 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3378 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3380 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3381 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3383 /* Let GDB know that the inferior was attached. */
3385 return MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3395 /* Find procinfo for the main process */
3396 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0); /* FIXME: threads */
3398 if (!proc_set_current_signal (pi
, signo
))
3399 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3401 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3402 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3404 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3405 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3407 if (!proc_set_traced_sysentry (pi
, &pi
->saved_entryset
))
3408 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3410 if (!proc_set_traced_sysexit (pi
, &pi
->saved_exitset
))
3411 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3413 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3414 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3416 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3417 if (signo
|| !(pi
->was_stopped
) ||
3418 query ("Was stopped when attached, make it runnable again? "))
3420 /* Clear any pending signal. */
3421 if (!proc_clear_current_fault (pi
))
3422 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3424 if (!proc_set_run_on_last_close (pi
))
3425 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3429 destroy_procinfo (pi
);
3435 * Since the /proc interface cannot give us individual registers,
3436 * we pay no attention to the (regno) argument, and just fetch them all.
3437 * This results in the possibility that we will do unnecessarily many
3438 * fetches, since we may be called repeatedly for individual registers.
3439 * So we cache the results, and mark the cache invalid when the process
3444 procfs_fetch_registers (regno
)
3447 gdb_fpregset_t
*fpregs
;
3448 gdb_gregset_t
*gregs
;
3453 pid
= PIDGET (inferior_pid
);
3454 tid
= TIDGET (inferior_pid
);
3456 /* First look up procinfo for the main process. */
3457 pi
= find_procinfo_or_die (pid
, 0);
3459 /* If the event thread is not the same as GDB's requested thread
3460 (ie. inferior_pid), then look up procinfo for the requested
3463 (tid
!= proc_get_current_thread (pi
)))
3464 pi
= find_procinfo_or_die (pid
, tid
);
3467 error ("procfs: fetch_registers failed to find procinfo for %s",
3468 target_pid_to_str (inferior_pid
));
3470 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3471 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3473 supply_gregset (gregs
);
3475 #if defined (FP0_REGNUM) /* need floating point? */
3476 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3477 regno
== PC_REGNUM
||
3479 regno
== NPC_REGNUM
||
3481 regno
== FP_REGNUM
||
3483 return; /* not a floating point register */
3485 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3486 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3488 supply_fpregset (fpregs
);
3492 /* Get ready to modify the registers array. On machines which store
3493 individual registers, this doesn't need to do anything. On
3494 machines which store all the registers in one fell swoop, such as
3495 /proc, this makes sure that registers contains all the registers
3496 from the program being debugged. */
3499 procfs_prepare_to_store ()
3501 #ifdef CHILD_PREPARE_TO_STORE
3502 CHILD_PREPARE_TO_STORE ();
3509 * Since the /proc interface will not read individual registers,
3510 * we will cache these requests until the process is resumed, and
3511 * only then write them back to the inferior process.
3513 * FIXME: is that a really bad idea? Have to think about cases
3514 * where writing one register might affect the value of others, etc.
3518 procfs_store_registers (regno
)
3521 gdb_fpregset_t
*fpregs
;
3522 gdb_gregset_t
*gregs
;
3527 pid
= PIDGET (inferior_pid
);
3528 tid
= TIDGET (inferior_pid
);
3530 /* First find procinfo for main process */
3531 pi
= find_procinfo_or_die (pid
, 0);
3533 /* If current lwp for process is not the same as requested thread
3534 (ie. inferior_pid), then find procinfo for the requested thread. */
3537 (tid
!= proc_get_current_thread (pi
)))
3538 pi
= find_procinfo_or_die (pid
, tid
);
3541 error ("procfs: store_registers: failed to find procinfo for %s",
3542 target_pid_to_str (inferior_pid
));
3544 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3545 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3547 fill_gregset (gregs
, regno
);
3548 if (!proc_set_gregs (pi
))
3549 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3551 #if defined (FP0_REGNUM) /* need floating point? */
3552 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3553 regno
== PC_REGNUM
||
3555 regno
== NPC_REGNUM
||
3557 regno
== FP_REGNUM
||
3559 return; /* not a floating point register */
3561 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3562 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3564 fill_fpregset (fpregs
, regno
);
3565 if (!proc_set_fpregs (pi
))
3566 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3571 * Function: target_wait
3573 * Retrieve the next stop event from the child process.
3574 * If child has not stopped yet, wait for it to stop.
3575 * Translate /proc eventcodes (or possibly wait eventcodes)
3576 * into gdb internal event codes.
3578 * Return: id of process (and possibly thread) that incurred the event.
3579 * event codes are returned thru a pointer parameter.
3583 procfs_wait (pid
, status
)
3585 struct target_waitstatus
*status
;
3587 /* First cut: loosely based on original version 2.1 */
3591 int why
, what
, flags
;
3600 /* Find procinfo for main process */
3601 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
3604 /* We must assume that the status is stale now... */
3605 pi
->status_valid
= 0;
3606 pi
->gregs_valid
= 0;
3607 pi
->fpregs_valid
= 0;
3609 #if 0 /* just try this out... */
3610 flags
= proc_flags (pi
);
3611 why
= proc_why (pi
);
3612 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3613 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3615 /* If child is not stopped, wait for it to stop. */
3616 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3617 !proc_wait_for_stop (pi
))
3619 /* wait_for_stop failed: has the child terminated? */
3620 if (errno
== ENOENT
)
3622 /* /proc file not found; presumably child has terminated. */
3623 retval
= wait (&wstat
); /* "wait" for the child's exit */
3625 if (retval
!= PIDGET (inferior_pid
)) /* wrong child? */
3626 error ("procfs: couldn't stop process %d: wait returned %d\n",
3627 inferior_pid
, retval
);
3628 /* FIXME: might I not just use waitpid?
3629 Or try find_procinfo to see if I know about this child? */
3633 /* Unknown error from wait_for_stop. */
3634 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3639 /* This long block is reached if either:
3640 a) the child was already stopped, or
3641 b) we successfully waited for the child with wait_for_stop.
3642 This block will analyze the /proc status, and translate it
3643 into a waitstatus for GDB.
3645 If we actually had to call wait because the /proc file
3646 is gone (child terminated), then we skip this block,
3647 because we already have a waitstatus. */
3649 flags
= proc_flags (pi
);
3650 why
= proc_why (pi
);
3651 what
= proc_what (pi
);
3655 int stopped_pc
= read_pc ();
3656 if (stopped_pc
!= 0x10c68 &&
3657 stopped_pc
!= 0x10c6c &&
3658 stopped_pc
!= 0x10c70 &&
3659 stopped_pc
!= 0x22768 &&
3660 stopped_pc
!= 0x10c74)
3661 printf ("%x,%d,%d\n", stopped_pc
, why
, what
);
3665 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3668 /* If it's running async (for single_thread control),
3669 set it back to normal again. */
3670 if (flags
& PR_ASYNC
)
3671 if (!proc_unset_async (pi
))
3672 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3676 proc_prettyprint_why (why
, what
, 1);
3678 /* The 'pid' we will return to GDB is composed of
3679 the process ID plus the lwp ID. */
3680 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3684 wstat
= (what
<< 8) | 0177;
3694 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3695 printf_filtered ("[%s exited]\n",
3696 target_pid_to_str (retval
));
3697 delete_thread (retval
);
3698 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3700 #endif /* _lwp_exit */
3703 /* Handle SYS_exit call only */
3704 /* Stopped at entry to SYS_exit.
3705 Make it runnable, resume it, then use
3706 the wait system call to get its exit code.
3707 Proc_run_process always clears the current
3709 Then return its exit status. */
3710 pi
->status_valid
= 0;
3712 /* FIXME: what we should do is return
3713 TARGET_WAITKIND_SPURIOUS. */
3714 if (!proc_run_process (pi
, 0, 0))
3715 proc_error (pi
, "target_wait, run_process", __LINE__
);
3718 /* Don't call wait: simulate waiting for exit,
3719 return a "success" exit code. Bogus: what if
3720 it returns something else? */
3722 retval
= inferior_pid
; /* ??? */
3726 int temp
= wait (&wstat
);
3728 /* FIXME: shouldn't I make sure I get the right
3729 event from the right process? If (for
3730 instance) I have killed an earlier inferior
3731 process but failed to clean up after it
3732 somehow, I could get its termination event
3735 /* If wait returns -1, that's what we return to GDB. */
3741 printf_filtered ("procfs: trapped on entry to ");
3742 proc_prettyprint_syscall (proc_what (pi
), 0);
3743 printf_filtered ("\n");
3746 long i
, nsysargs
, *sysargs
;
3748 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3749 (sysargs
= proc_sysargs (pi
)) != NULL
)
3751 printf_filtered ("%d syscall arguments:\n", nsysargs
);
3752 for (i
= 0; i
< nsysargs
; i
++)
3753 printf_filtered ("#%d: 0x%08x\n",
3761 /* How to exit gracefully, returning "unknown event" */
3762 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3763 return inferior_pid
;
3767 /* How to keep going without returning to wfi: */
3768 target_resume (pid
, 0, TARGET_SIGNAL_0
);
3785 /* Hopefully this is our own "fork-child" execing
3786 the real child. Hoax this event into a trap, and
3787 GDB will see the child about to execute its start
3789 wstat
= (SIGTRAP
<< 8) | 0177;
3791 #ifdef SYS_lwp_create
3792 case SYS_lwp_create
:
3794 #ifdef SYS_lwpcreate
3797 #if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
3799 * This syscall is somewhat like fork/exec.
3800 * We will get the event twice: once for the parent LWP,
3801 * and once for the child. We should already know about
3802 * the parent LWP, but the child will be new to us. So,
3803 * whenever we get this event, if it represents a new
3804 * thread, simply add the thread to the list.
3807 /* If not in procinfo list, add it. */
3808 temp
= proc_get_current_thread (pi
);
3809 if (!find_procinfo (pi
->pid
, temp
))
3810 create_procinfo (pi
->pid
, temp
);
3812 temp
= MERGEPID (pi
->pid
, temp
);
3813 /* If not in GDB's thread list, add it. */
3814 if (!in_thread_list (temp
))
3816 printf_filtered ("[New %s]\n", target_pid_to_str (temp
));
3819 /* Return to WFI, but tell it to immediately resume. */
3820 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3821 return inferior_pid
;
3822 #endif /* _lwp_create */
3830 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3831 printf_filtered ("[%s exited]\n",
3832 target_pid_to_str (retval
));
3833 delete_thread (retval
);
3834 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3836 #endif /* _lwp_exit */
3840 /* Nothing to do here for now. The old procfs
3841 seemed to use this event to handle threads on
3842 older (non-LWP) systems, where I'm assuming that
3843 threads were actually separate processes. Irix,
3844 maybe? Anyway, low priority for now. */
3848 /* FIXME: do we need to handle this? Investigate. */
3852 /* FIXME: see above. */
3855 printf_filtered ("procfs: trapped on exit from ");
3856 proc_prettyprint_syscall (proc_what (pi
), 0);
3857 printf_filtered ("\n");
3860 long i
, nsysargs
, *sysargs
;
3862 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3863 (sysargs
= proc_sysargs (pi
)) != NULL
)
3865 printf_filtered ("%d syscall arguments:\n", nsysargs
);
3866 for (i
= 0; i
< nsysargs
; i
++)
3867 printf_filtered ("#%d: 0x%08x\n",
3872 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3873 return inferior_pid
;
3878 wstat
= (SIGSTOP
<< 8) | 0177;
3883 printf_filtered ("Retry #%d:\n", retry
);
3884 pi
->status_valid
= 0;
3889 /* If not in procinfo list, add it. */
3890 temp
= proc_get_current_thread (pi
);
3891 if (!find_procinfo (pi
->pid
, temp
))
3892 create_procinfo (pi
->pid
, temp
);
3894 /* If not in GDB's thread list, add it. */
3895 temp
= MERGEPID (pi
->pid
, temp
);
3896 if (!in_thread_list (temp
))
3898 printf_filtered ("[*New %s]\n",
3899 target_pid_to_str (temp
));
3903 status
->kind
= TARGET_WAITKIND_STOPPED
;
3904 status
->value
.sig
= 0;
3909 wstat
= (what
<< 8) | 0177;
3912 switch (what
) { /* FIXME: FAULTED_USE_SIGINFO */
3915 wstat
= (SIGTRAP
<< 8) | 0177;
3920 wstat
= (SIGTRAP
<< 8) | 0177;
3923 /* FIXME: use si_signo where possible. */
3925 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
3928 wstat
= (SIGILL
<< 8) | 0177;
3931 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
3934 wstat
= (SIGTRAP
<< 8) | 0177;
3938 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
3941 wstat
= (SIGSEGV
<< 8) | 0177;
3945 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
3948 wstat
= (SIGFPE
<< 8) | 0177;
3950 case FLTPAGE
: /* Recoverable page fault */
3951 default: /* FIXME: use si_signo if possible for fault */
3953 printf_filtered ("procfs:%d -- ", __LINE__
);
3954 printf_filtered ("child stopped for unknown reason:\n");
3955 proc_prettyprint_why (why
, what
, 1);
3956 error ("... giving up...");
3959 break; /* case PR_FAULTED: */
3960 default: /* switch (why) unmatched */
3961 printf_filtered ("procfs:%d -- ", __LINE__
);
3962 printf_filtered ("child stopped for unknown reason:\n");
3963 proc_prettyprint_why (why
, what
, 1);
3964 error ("... giving up...");
3968 * Got this far without error:
3969 * If retval isn't in the threads database, add it.
3972 retval
!= inferior_pid
&&
3973 !in_thread_list (retval
))
3976 * We have a new thread.
3977 * We need to add it both to GDB's list and to our own.
3978 * If we don't create a procinfo, resume may be unhappy
3981 printf_filtered ("[New %s]\n", target_pid_to_str (retval
));
3982 add_thread (retval
);
3983 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
3984 create_procinfo (PIDGET (retval
), TIDGET (retval
));
3986 /* In addition, it's possible that this is the first
3987 * new thread we've seen, in which case we may not
3988 * have created entries for inferior_pid yet.
3990 if (TIDGET (inferior_pid
) != 0)
3992 if (!in_thread_list (inferior_pid
))
3993 add_thread (inferior_pid
);
3994 if (find_procinfo (PIDGET (inferior_pid
),
3995 TIDGET (inferior_pid
)) == NULL
)
3996 create_procinfo (PIDGET (inferior_pid
),
3997 TIDGET (inferior_pid
));
4001 else /* flags do not indicate STOPPED */
4003 /* surely this can't happen... */
4004 printf_filtered ("procfs:%d -- process not stopped.\n",
4006 proc_prettyprint_flags (flags
, 1);
4007 error ("procfs: ...giving up...");
4012 store_waitstatus (status
, wstat
);
4019 procfs_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
4024 struct target_ops
*target
; /* ignored */
4029 /* Find procinfo for main process */
4030 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4031 if (pi
->as_fd
== 0 &&
4032 open_procinfo_files (pi
, FD_AS
) == 0)
4034 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4038 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4043 PROCFS_NOTE ("write memory: ");
4045 PROCFS_NOTE ("write memory: \n");
4047 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4051 PROCFS_NOTE ("read memory: \n");
4052 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4063 * Function: invalidate_cache
4065 * Called by target_resume before making child runnable.
4066 * Mark cached registers and status's invalid.
4067 * If there are "dirty" caches that need to be written back
4068 * to the child process, do that.
4070 * File descriptors are also cached.
4071 * As they are a limited resource, we cannot hold onto them indefinitely.
4072 * However, as they are expensive to open, we don't want to throw them
4073 * away indescriminately either. As a compromise, we will keep the
4074 * file descriptors for the parent process, but discard any file
4075 * descriptors we may have accumulated for the threads.
4078 * As this function is called by iterate_over_threads, it always
4079 * returns zero (so that iterate_over_threads will keep iterating).
4084 invalidate_cache (parent
, pi
, ptr
)
4090 * About to run the child; invalidate caches and do any other cleanup.
4094 if (pi
->gregs_dirty
)
4095 if (parent
== NULL
||
4096 proc_get_current_thread (parent
) != pi
->tid
)
4097 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4098 proc_warn (pi
, "target_resume, set_gregs",
4101 if (pi
->fpregs_dirty
)
4102 if (parent
== NULL
||
4103 proc_get_current_thread (parent
) != pi
->tid
)
4104 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4105 proc_warn (pi
, "target_resume, set_fpregs",
4112 /* The presence of a parent indicates that this is an LWP.
4113 Close any file descriptors that it might have open.
4114 We don't do this to the master (parent) procinfo. */
4116 close_procinfo_files (pi
);
4118 pi
->gregs_valid
= 0;
4119 pi
->fpregs_valid
= 0;
4121 pi
->gregs_dirty
= 0;
4122 pi
->fpregs_dirty
= 0;
4124 pi
->status_valid
= 0;
4125 pi
->threads_valid
= 0;
4131 * Function: make_signal_thread_runnable
4133 * A callback function for iterate_over_threads.
4134 * Find the asynchronous signal thread, and make it runnable.
4135 * See if that helps matters any.
4139 make_signal_thread_runnable (process
, pi
, ptr
)
4145 if (proc_flags (pi
) & PR_ASLWP
)
4147 if (!proc_run_process (pi
, 0, -1))
4148 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4156 * Function: target_resume
4158 * Make the child process runnable. Normally we will then call
4159 * procfs_wait and wait for it to stop again (unles gdb is async).
4162 * step: if true, then arrange for the child to stop again
4163 * after executing a single instruction.
4164 * signo: if zero, then cancel any pending signal.
4165 * If non-zero, then arrange for the indicated signal
4166 * to be delivered to the child when it runs.
4167 * pid: if -1, then allow any child thread to run.
4168 * if non-zero, then allow only the indicated thread to run.
4169 ******* (not implemented yet)
4173 procfs_resume (pid
, step
, signo
)
4176 enum target_signal signo
;
4178 procinfo
*pi
, *thread
;
4182 prrun.prflags |= PRSVADDR;
4183 prrun.pr_vaddr = $PC; set resume address
4184 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4185 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4186 prrun.prflags |= PRCFAULT; clear current fault.
4188 PRSTRACE and PRSFAULT can be done by other means
4189 (proc_trace_signals, proc_trace_faults)
4190 PRSVADDR is unnecessary.
4191 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4192 This basically leaves PRSTEP and PRCSIG.
4193 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4194 So basically PR_STEP is the sole argument that must be passed
4195 to proc_run_process (for use in the prrun struct by ioctl). */
4197 /* Find procinfo for main process */
4198 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4200 /* First cut: ignore pid argument */
4203 /* Convert signal to host numbering. */
4205 signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
)
4208 native_signo
= target_signal_to_host (signo
);
4210 pi
->ignore_next_sigstop
= 0;
4212 /* Running the process voids all cached registers and status. */
4213 /* Void the threads' caches first */
4214 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4215 /* Void the process procinfo's caches. */
4216 invalidate_cache (NULL
, pi
, NULL
);
4220 /* Resume a specific thread, presumably suppressing the others. */
4221 thread
= find_procinfo (PIDGET (pid
), TIDGET (pid
));
4223 warning ("procfs: resume can't find thread %d -- resuming all.",
4227 if (thread
->tid
!= 0)
4229 /* We're to resume a specific thread, and not the others.
4230 * Set the child process's PR_ASYNC flag.
4233 if (!proc_set_async (pi
))
4234 proc_error (pi
, "target_resume, set_async", __LINE__
);
4237 proc_iterate_over_threads (pi
,
4238 make_signal_thread_runnable
,
4241 pi
= thread
; /* substitute the thread's procinfo for run */
4246 if (!proc_run_process (pi
, step
, native_signo
))
4249 warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
4251 proc_error (pi
, "target_resume", __LINE__
);
4256 * Function: register_gdb_signals
4258 * Traverse the list of signals that GDB knows about
4259 * (see "handle" command), and arrange for the target
4260 * to be stopped or not, according to these settings.
4262 * Returns non-zero for success, zero for failure.
4266 register_gdb_signals (pi
, signals
)
4272 for (signo
= 0; signo
< NSIG
; signo
++)
4273 if (signal_stop_state (target_signal_from_host (signo
)) == 0 &&
4274 signal_print_state (target_signal_from_host (signo
)) == 0 &&
4275 signal_pass_state (target_signal_from_host (signo
)) == 1)
4276 prdelset (signals
, signo
);
4278 praddset (signals
, signo
);
4280 return proc_set_traced_signals (pi
, signals
);
4284 * Function: target_notice_signals
4286 * Set up to trace signals in the child process.
4290 procfs_notice_signals (pid
)
4294 procinfo
*pi
= find_procinfo_or_die (PIDGET (pid
), 0);
4296 if (proc_get_traced_signals (pi
, &signals
) &&
4297 register_gdb_signals (pi
, &signals
))
4300 proc_error (pi
, "notice_signals", __LINE__
);
4304 * Function: target_files_info
4306 * Print status information about the child process.
4310 procfs_files_info (ignore
)
4311 struct target_ops
*ignore
;
4313 printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
4314 attach_flag
? "attached": "child",
4315 target_pid_to_str (inferior_pid
));
4319 * Function: target_open
4321 * A dummy: you don't open procfs.
4325 procfs_open (args
, from_tty
)
4329 error ("Use the \"run\" command to start a Unix child process.");
4333 * Function: target_can_run
4335 * This tells GDB that this target vector can be invoked
4336 * for "run" or "attach".
4339 int procfs_suppress_run
= 0; /* Non-zero if procfs should pretend not to
4340 be a runnable target. Used by targets
4341 that can sit atop procfs, such as solaris
4348 /* This variable is controlled by modules that sit atop procfs that
4349 may layer their own process structure atop that provided here.
4350 sol-thread.c does this because of the Solaris two-level thread
4353 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
4355 return !procfs_suppress_run
;
4359 * Function: target_stop
4361 * Stop the child process asynchronously, as when the
4362 * gdb user types control-c or presses a "stop" button.
4364 * Works by sending kill(SIGINT) to the child's process group.
4370 extern pid_t inferior_process_group
;
4372 kill (-inferior_process_group
, SIGINT
);
4376 * Function: unconditionally_kill_inferior
4378 * Make it die. Wait for it to die. Clean up after it.
4379 * Note: this should only be applied to the real process,
4380 * not to an LWP, because of the check for parent-process.
4381 * If we need this to work for an LWP, it needs some more logic.
4385 unconditionally_kill_inferior (pi
)
4390 parent_pid
= proc_parent_pid (pi
);
4391 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4392 /* FIXME: use access functions */
4393 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4394 before the PIOCKILL, otherwise it might generate a corrupted core
4395 file for the inferior. */
4396 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4398 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4401 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4402 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4403 to kill the inferior, otherwise it might remain stopped with a
4405 We do not check the result of the PIOCSSIG, the inferior might have
4408 struct siginfo newsiginfo
;
4410 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4411 newsiginfo
.si_signo
= SIGKILL
;
4412 newsiginfo
.si_code
= 0;
4413 newsiginfo
.si_errno
= 0;
4414 newsiginfo
.si_pid
= getpid ();
4415 newsiginfo
.si_uid
= getuid ();
4416 /* FIXME: use proc_set_current_signal */
4417 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4419 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4420 if (!proc_kill (pi
, SIGKILL
))
4421 proc_warn (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4422 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4423 destroy_procinfo (pi
);
4425 /* If pi is GDB's child, wait for it to die. */
4426 if (parent_pid
== getpid ())
4427 /* FIXME: should we use waitpid to make sure we get the right event?
4428 Should we check the returned event? */
4433 ret
= waitpid (pi
->pid
, &status
, 0);
4441 * Function: target_kill_inferior
4443 * We're done debugging it, and we want it to go away.
4444 * Then we want GDB to forget all about it.
4448 procfs_kill_inferior ()
4450 if (inferior_pid
!= 0) /* ? */
4452 /* Find procinfo for main process */
4453 procinfo
*pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4456 unconditionally_kill_inferior (pi
);
4457 target_mourn_inferior ();
4462 * Function: target_mourn_inferior
4464 * Forget we ever debugged this thing!
4468 procfs_mourn_inferior ()
4472 if (inferior_pid
!= 0)
4474 /* Find procinfo for main process */
4475 pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4477 destroy_procinfo (pi
);
4479 unpush_target (&procfs_ops
);
4480 generic_mourn_inferior ();
4484 * Function: init_inferior
4486 * When GDB forks to create a runnable inferior process,
4487 * this function is called on the parent side of the fork.
4488 * It's job is to do whatever is necessary to make the child
4489 * ready to be debugged, and then wait for the child to synchronize.
4493 procfs_init_inferior (pid
)
4500 /* This routine called on the parent side (GDB side)
4501 after GDB forks the inferior. */
4503 push_target (&procfs_ops
);
4505 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4506 perror ("procfs: out of memory in 'init_inferior'");
4508 if (!open_procinfo_files (pi
, FD_CTL
))
4509 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4513 open_procinfo_files // done
4516 procfs_notice_signals
4523 /* If not stopped yet, wait for it to stop. */
4524 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4525 !(proc_wait_for_stop (pi
)))
4526 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4528 /* Save some of the /proc state to be restored if we detach. */
4529 /* FIXME: Why? In case another debugger was debugging it?
4530 We're it's parent, for Ghu's sake! */
4531 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4532 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4533 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4534 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4535 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4536 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4537 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
4538 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4539 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
4540 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4542 /* Register to trace selected signals in the child. */
4543 prfillset (&signals
);
4544 if (!register_gdb_signals (pi
, &signals
))
4545 proc_error (pi
, "init_inferior, register_signals", __LINE__
);
4547 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4548 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4550 /* Turn on run-on-last-close flag so that the child
4551 will die if GDB goes away for some reason. */
4552 if (!proc_set_run_on_last_close (pi
))
4553 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4555 /* The 'process ID' we return to GDB is composed of
4556 the actual process ID plus the lwp ID. */
4557 inferior_pid
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
4559 #ifdef START_INFERIOR_TRAPS_EXPECTED
4560 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4562 /* One trap to exec the shell, one to exec the program being debugged. */
4563 startup_inferior (2);
4568 * Function: set_exec_trap
4570 * When GDB forks to create a new process, this function is called
4571 * on the child side of the fork before GDB exec's the user program.
4572 * Its job is to make the child minimally debuggable, so that the
4573 * parent GDB process can connect to the child and take over.
4574 * This function should do only the minimum to make that possible,
4575 * and to synchronize with the parent process. The parent process
4576 * should take care of the details.
4580 procfs_set_exec_trap ()
4582 /* This routine called on the child side (inferior side)
4583 after GDB forks the inferior. It must use only local variables,
4584 because it may be sharing data space with its parent. */
4590 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4591 perror_with_name ("procfs: create_procinfo failed in child.");
4593 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4595 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4596 gdb_flush (gdb_stderr
);
4597 /* no need to call "dead_procinfo", because we're going to exit. */
4601 #ifdef PRFS_STOPEXEC /* defined on OSF */
4602 /* OSF method for tracing exec syscalls. Quoting:
4603 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4604 exits from exec system calls because of the user level loader. */
4605 /* FIXME: make nice and maybe move into an access function. */
4609 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4611 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4612 gdb_flush (gdb_stderr
);
4615 prfs_flags
|= PRFS_STOPEXEC
;
4617 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4619 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4620 gdb_flush (gdb_stderr
);
4624 #else /* not PRFS_STOPEXEC */
4625 /* Everyone else's (except OSF) method for tracing exec syscalls */
4627 Not all systems with /proc have all the exec* syscalls with the same
4628 names. On the SGI, for example, there is no SYS_exec, but there
4629 *is* a SYS_execv. So, we try to account for that. */
4631 premptyset (&exitset
);
4633 praddset (&exitset
, SYS_exec
);
4636 praddset (&exitset
, SYS_execve
);
4639 praddset (&exitset
, SYS_execv
);
4642 if (!proc_set_traced_sysexit (pi
, &exitset
))
4644 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4645 gdb_flush (gdb_stderr
);
4648 #endif /* PRFS_STOPEXEC */
4650 /* FIXME: should this be done in the parent instead? */
4651 /* Turn off inherit on fork flag so that all grand-children
4652 of gdb start with tracing flags cleared. */
4653 if (!proc_unset_inherit_on_fork (pi
))
4654 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4656 /* Turn off run on last close flag, so that the child process
4657 cannot run away just because we close our handle on it.
4658 We want it to wait for the parent to attach. */
4659 if (!proc_unset_run_on_last_close (pi
))
4660 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4662 /* FIXME: No need to destroy the procinfo --
4663 we have our own address space, and we're about to do an exec! */
4664 /*destroy_procinfo (pi);*/
4668 * Function: create_inferior
4670 * This function is called BEFORE gdb forks the inferior process.
4671 * Its only real responsibility is to set things up for the fork,
4672 * and tell GDB which two functions to call after the fork (one
4673 * for the parent, and one for the child).
4675 * This function does a complicated search for a unix shell program,
4676 * which it then uses to parse arguments and environment variables
4677 * to be sent to the child. I wonder whether this code could not
4678 * be abstracted out and shared with other unix targets such as
4683 procfs_create_inferior (exec_file
, allargs
, env
)
4688 char *shell_file
= getenv ("SHELL");
4690 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4693 /* We will be looking down the PATH to find shell_file. If we
4694 just do this the normal way (via execlp, which operates by
4695 attempting an exec for each element of the PATH until it
4696 finds one which succeeds), then there will be an exec for
4697 each failed attempt, each of which will cause a PR_SYSEXIT
4698 stop, and we won't know how to distinguish the PR_SYSEXIT's
4699 for these failed execs with the ones for successful execs
4700 (whether the exec has succeeded is stored at that time in the
4701 carry bit or some such architecture-specific and
4702 non-ABI-specified place).
4704 So I can't think of anything better than to search the PATH
4705 now. This has several disadvantages: (1) There is a race
4706 condition; if we find a file now and it is deleted before we
4707 exec it, we lose, even if the deletion leaves a valid file
4708 further down in the PATH, (2) there is no way to know exactly
4709 what an executable (in the sense of "capable of being
4710 exec'd") file is. Using access() loses because it may lose
4711 if the caller is the superuser; failing to use it loses if
4712 there are ACLs or some such. */
4716 /* FIXME-maybe: might want "set path" command so user can change what
4717 path is used from within GDB. */
4718 char *path
= getenv ("PATH");
4720 struct stat statbuf
;
4723 path
= "/bin:/usr/bin";
4725 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4726 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4728 p1
= strchr (p
, ':');
4733 strncpy (tryname
, p
, len
);
4734 tryname
[len
] = '\0';
4735 strcat (tryname
, "/");
4736 strcat (tryname
, shell_file
);
4737 if (access (tryname
, X_OK
) < 0)
4739 if (stat (tryname
, &statbuf
) < 0)
4741 if (!S_ISREG (statbuf
.st_mode
))
4742 /* We certainly need to reject directories. I'm not quite
4743 as sure about FIFOs, sockets, etc., but I kind of doubt
4744 that people want to exec() these things. */
4749 /* Not found. This must be an error rather than merely passing
4750 the file to execlp(), because execlp() would try all the
4751 exec()s, causing GDB to get confused. */
4752 error ("procfs:%d -- Can't find shell %s in PATH",
4753 __LINE__
, shell_file
);
4755 shell_file
= tryname
;
4758 fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4759 procfs_init_inferior
, NULL
, shell_file
);
4761 /* We are at the first instruction we care about. */
4762 /* Pedal to the metal... */
4764 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
4768 * Function: notice_thread
4770 * Callback for find_new_threads.
4771 * Calls "add_thread".
4775 procfs_notice_thread (pi
, thread
, ptr
)
4780 int gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4782 if (!in_thread_list (gdb_threadid
))
4783 add_thread (gdb_threadid
);
4789 * Function: target_find_new_threads
4791 * Query all the threads that the target knows about,
4792 * and give them back to GDB to add to its list.
4796 procfs_find_new_threads ()
4800 /* Find procinfo for main process */
4801 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4802 proc_update_threads (pi
);
4803 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4807 * Function: target_thread_alive
4809 * Return true if the thread is still 'alive'.
4811 * This guy doesn't really seem to be doing his job.
4812 * Got to investigate how to tell when a thread is really gone.
4816 procfs_thread_alive (pid
)
4822 proc
= PIDGET (pid
);
4823 thread
= TIDGET (pid
);
4824 /* If I don't know it, it ain't alive! */
4825 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4828 /* If I can't get its status, it ain't alive!
4829 What's more, I need to forget about it! */
4830 if (!proc_get_status (pi
))
4832 destroy_procinfo (pi
);
4835 /* I couldn't have got its status if it weren't alive, so it's alive. */
4840 * Function: target_pid_to_str
4842 * Return a string to be used to identify the thread in
4843 * the "info threads" display.
4847 procfs_pid_to_str (pid
)
4850 static char buf
[80];
4854 proc
= PIDGET (pid
);
4855 thread
= TIDGET (pid
);
4856 pi
= find_procinfo (proc
, thread
);
4859 sprintf (buf
, "Process %d", proc
);
4861 sprintf (buf
, "LWP %d", thread
);
4866 * Function: procfs_set_watchpoint
4867 * Insert a watchpoint
4871 procfs_set_watchpoint (pid
, addr
, len
, rwflag
, after
)
4882 pi
= find_procinfo_or_die (pid
== -1 ?
4883 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4885 /* Translate from GDB's flags to /proc's */
4886 if (len
> 0) /* len == 0 means delete watchpoint */
4888 switch (rwflag
) { /* FIXME: need an enum! */
4889 case hw_write
: /* default watchpoint (write) */
4890 pflags
= WRITE_WATCHFLAG
;
4892 case hw_read
: /* read watchpoint */
4893 pflags
= READ_WATCHFLAG
;
4895 case hw_access
: /* access watchpoint */
4896 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
4898 case hw_execute
: /* execution HW breakpoint */
4899 pflags
= EXEC_WATCHFLAG
;
4901 default: /* Something weird. Return error. */
4904 if (after
) /* Stop after r/w access is completed. */
4905 pflags
|= AFTER_WATCHFLAG
;
4908 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
4910 if (errno
== E2BIG
) /* Typical error for no resources */
4911 return -1; /* fail */
4912 /* GDB may try to remove the same watchpoint twice.
4913 If a remove request returns no match, don't error. */
4914 if (errno
== ESRCH
&& len
== 0)
4915 return 0; /* ignore */
4916 proc_error (pi
, "set_watchpoint", __LINE__
);
4923 * Function: stopped_by_watchpoint
4925 * Returns non-zero if process is stopped on a hardware watchpoint fault,
4926 * else returns zero.
4930 procfs_stopped_by_watchpoint (pid
)
4935 pi
= find_procinfo_or_die (pid
== -1 ?
4936 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4937 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
4939 if (proc_why (pi
) == PR_FAULTED
)
4942 if (proc_what (pi
) == FLTWATCH
)
4946 if (proc_what (pi
) == FLTKWATCH
)
4954 #ifdef TM_I386SOL2_H
4956 * Function: procfs_find_LDT_entry
4959 * int pid; // The GDB-style pid-plus-LWP.
4962 * pointer to the corresponding LDT entry.
4966 procfs_find_LDT_entry (pid
)
4969 gdb_gregset_t
*gregs
;
4973 /* Find procinfo for the lwp. */
4974 if ((pi
= find_procinfo (PIDGET (pid
), TIDGET (pid
))) == NULL
)
4976 warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
4980 /* get its general registers. */
4981 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
4983 warning ("procfs_find_LDT_entry: could not read gregs for %d.",
4987 /* Now extract the GS register's lower 16 bits. */
4988 key
= (*gregs
)[GS
] & 0xffff;
4990 /* Find the matching entry and return it. */
4991 return proc_get_LDT_entry (pi
, key
);
4993 #endif /* TM_I386SOL2_H */
4998 info_proc_cmd (args
, from_tty
)
5002 struct cleanup
*old_chain
;
5003 procinfo
*process
= NULL
;
5004 procinfo
*thread
= NULL
;
5010 old_chain
= make_cleanup (null_cleanup
, 0);
5012 if ((argv
= buildargv (args
)) == NULL
)
5015 make_cleanup ((make_cleanup_func
) freeargv
, argv
);
5017 while (argv
!= NULL
&& *argv
!= NULL
)
5019 if (isdigit (argv
[0][0]))
5021 pid
= strtoul (argv
[0], &tmp
, 10);
5023 tid
= strtoul (++tmp
, NULL
, 10);
5025 else if (argv
[0][0] == '/')
5027 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5036 pid
= PIDGET (inferior_pid
);
5038 error ("No current process: you must name one.");
5041 /* Have pid, will travel.
5042 First see if it's a process we're already debugging. */
5043 process
= find_procinfo (pid
, 0);
5044 if (process
== NULL
)
5046 /* No. So open a procinfo for it, but
5047 remember to close it again when finished. */
5048 process
= create_procinfo (pid
, 0);
5049 make_cleanup ((make_cleanup_func
) destroy_procinfo
, process
);
5050 if (!open_procinfo_files (process
, FD_CTL
))
5051 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5055 thread
= create_procinfo (pid
, tid
);
5059 printf_filtered ("process %d flags:\n", process
->pid
);
5060 proc_prettyprint_flags (proc_flags (process
), 1);
5061 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5062 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5063 if (proc_get_nthreads (process
) > 1)
5064 printf_filtered ("Process has %d threads.\n",
5065 proc_get_nthreads (process
));
5069 printf_filtered ("thread %d flags:\n", thread
->tid
);
5070 proc_prettyprint_flags (proc_flags (thread
), 1);
5071 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5072 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5075 do_cleanups (old_chain
);
5079 proc_trace_syscalls (args
, from_tty
, entry_or_exit
, mode
)
5089 if (inferior_pid
<= 0)
5090 error ("you must be debugging a process to use this command.");
5092 if (args
== NULL
|| args
[0] == 0)
5093 error_no_arg ("system call to trace");
5095 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
5096 if (isdigit (args
[0]))
5098 syscallnum
= atoi (args
);
5099 if (entry_or_exit
== PR_SYSENTRY
)
5100 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5102 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5105 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5107 if (mode
== FLAG_SET
)
5108 praddset (sysset
, syscallnum
);
5110 prdelset (sysset
, syscallnum
);
5112 if (entry_or_exit
== PR_SYSENTRY
)
5114 if (!proc_set_traced_sysentry (pi
, sysset
))
5115 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5119 if (!proc_set_traced_sysexit (pi
, sysset
))
5120 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5126 proc_trace_sysentry_cmd (args
, from_tty
)
5130 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5134 proc_trace_sysexit_cmd (args
, from_tty
)
5138 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5142 proc_untrace_sysentry_cmd (args
, from_tty
)
5146 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5150 proc_untrace_sysexit_cmd (args
, from_tty
)
5154 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5159 mapping_test (fd
, core_addr
)
5161 CORE_ADDR core_addr
;
5163 printf ("File descriptor %d, base address 0x%08x\n", fd
, core_addr
);
5170 test_mapping_cmd (args
, from_tty
)
5175 ret
= proc_iterate_over_mappings (mapping_test
);
5176 printf ("iterate_over_mappings returned %d.\n", ret
);
5180 _initialize_procfs ()
5183 add_target (&procfs_ops
);
5184 add_info ("proc", info_proc_cmd
,
5185 "Show /proc process information about any running process.\
5186 Default is the process being debugged.");
5187 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5188 "Give a trace of entries into the syscall.");
5189 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5190 "Give a trace of exits from the syscall.");
5191 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5192 "Cancel a trace of entries into the syscall.");
5193 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5194 "Cancel a trace of exits from the syscall.");
5196 add_com ("test-mapping", no_class
, test_mapping_cmd
,
5197 "test iterate-over-mappings");
5200 /* =================== END, GDB "MODULE" =================== */
5204 /* miscelaneous stubs: */
5205 /* The following satisfy a few random symbols mostly created by */
5206 /* the solaris threads implementation, which I will chase down */
5210 * Return a pid for which we guarantee
5211 * we will be able to find a 'live' procinfo.
5215 procfs_first_available ()
5218 return procinfo_list
->pid
;
5224 procfs_get_pid_fd (pid
)
5229 if (pid
== -1 && inferior_pid
!= 0)
5230 pi
= find_procinfo (PIDGET (inferior_pid
), 0);
5232 pi
= find_procinfo (PIDGET (pid
), 0);