1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
2 Copyright 1999-2000 Free Software Foundation, Inc.
3 Written by Michael Snyder at Cygnus Solutions.
4 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software Foundation,
20 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "gdbthread.h"
29 #if defined (NEW_PROC_API)
30 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
33 #include <sys/procfs.h>
34 #include <sys/fault.h>
35 #include <sys/syscall.h>
36 #include <sys/errno.h>
44 * This module provides the interface between GDB and the
45 * /proc file system, which is used on many versions of Unix
46 * as a means for debuggers to control other processes.
47 * Examples of the systems that use this interface are:
53 * /proc works by immitating a file system: you open a simulated file
54 * that represents the process you wish to interact with, and
55 * perform operations on that "file" in order to examine or change
56 * the state of the other process.
58 * The most important thing to know about /proc and this module
59 * is that there are two very different interfaces to /proc:
60 * One that uses the ioctl system call, and
61 * another that uses read and write system calls.
62 * This module has to support both /proc interfaces. This means
63 * that there are two different ways of doing every basic operation.
65 * In order to keep most of the code simple and clean, I have
66 * defined an interface "layer" which hides all these system calls.
67 * An ifdef (NEW_PROC_API) determines which interface we are using,
68 * and most or all occurrances of this ifdef should be confined to
69 * this interface layer.
73 /* Determine which /proc API we are using:
74 The ioctl API defines PIOCSTATUS, while
75 the read/write (multiple fd) API never does. */
78 #include <sys/types.h>
79 #include "gdb_dirent.h" /* opendir/readdir, for listing the LWP's */
82 #include <fcntl.h> /* for O_RDONLY */
83 #include <unistd.h> /* for "X_OK" */
84 #include "gdb_stat.h" /* for struct stat */
86 /* Note: procfs-utils.h must be included after the above system header
87 files, because it redefines various system calls using macros.
88 This may be incompatible with the prototype declarations. */
90 #include "proc-utils.h"
92 /* Prototypes for supply_gregset etc. */
95 /* =================== TARGET_OPS "MODULE" =================== */
98 * This module defines the GDB target vector and its methods.
101 static void procfs_open (char *, int);
102 static void procfs_attach (char *, int);
103 static void procfs_detach (char *, int);
104 static void procfs_resume (int, int, enum target_signal
);
105 static int procfs_can_run (void);
106 static void procfs_stop (void);
107 static void procfs_files_info (struct target_ops
*);
108 static void procfs_fetch_registers (int);
109 static void procfs_store_registers (int);
110 static void procfs_notice_signals (int);
111 static void procfs_prepare_to_store (void);
112 static void procfs_kill_inferior (void);
113 static void procfs_mourn_inferior (void);
114 static void procfs_create_inferior (char *, char *, char **);
115 static int procfs_wait (int, struct target_waitstatus
*);
116 static int procfs_xfer_memory (CORE_ADDR
,
117 char *, int, int, struct target_ops
*);
119 static int procfs_thread_alive (int);
121 void procfs_find_new_threads (void);
122 char *procfs_pid_to_str (int);
124 struct target_ops procfs_ops
; /* the target vector */
129 procfs_ops
.to_shortname
= "procfs";
130 procfs_ops
.to_longname
= "Unix /proc child process";
132 "Unix /proc child process (started by the \"run\" command).";
133 procfs_ops
.to_open
= procfs_open
;
134 procfs_ops
.to_can_run
= procfs_can_run
;
135 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
136 procfs_ops
.to_kill
= procfs_kill_inferior
;
137 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
138 procfs_ops
.to_attach
= procfs_attach
;
139 procfs_ops
.to_detach
= procfs_detach
;
140 procfs_ops
.to_wait
= procfs_wait
;
141 procfs_ops
.to_resume
= procfs_resume
;
142 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
143 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
144 procfs_ops
.to_store_registers
= procfs_store_registers
;
145 procfs_ops
.to_xfer_memory
= procfs_xfer_memory
;
146 procfs_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
147 procfs_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
148 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
149 procfs_ops
.to_files_info
= procfs_files_info
;
150 procfs_ops
.to_stop
= procfs_stop
;
152 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
153 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
154 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
155 procfs_ops
.to_terminal_ours
= terminal_ours
;
156 procfs_ops
.to_terminal_info
= child_terminal_info
;
158 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
159 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
160 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
162 procfs_ops
.to_has_all_memory
= 1;
163 procfs_ops
.to_has_memory
= 1;
164 procfs_ops
.to_has_execution
= 1;
165 procfs_ops
.to_has_stack
= 1;
166 procfs_ops
.to_has_registers
= 1;
167 procfs_ops
.to_stratum
= process_stratum
;
168 procfs_ops
.to_has_thread_control
= tc_schedlock
;
169 procfs_ops
.to_magic
= OPS_MAGIC
;
172 /* =================== END, TARGET_OPS "MODULE" =================== */
177 * Put any typedefs, defines etc. here that are required for
178 * the unification of code that handles different versions of /proc.
181 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
183 enum { READ_WATCHFLAG
= WA_READ
,
184 WRITE_WATCHFLAG
= WA_WRITE
,
185 EXEC_WATCHFLAG
= WA_EXEC
,
186 AFTER_WATCHFLAG
= WA_TRAPAFTER
189 #else /* Irix method for watchpoints */
190 enum { READ_WATCHFLAG
= MA_READ
,
191 WRITE_WATCHFLAG
= MA_WRITE
,
192 EXEC_WATCHFLAG
= MA_EXEC
,
193 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
200 /* =================== STRUCT PROCINFO "MODULE" =================== */
202 /* FIXME: this comment will soon be out of date W.R.T. threads. */
204 /* The procinfo struct is a wrapper to hold all the state information
205 concerning a /proc process. There should be exactly one procinfo
206 for each process, and since GDB currently can debug only one
207 process at a time, that means there should be only one procinfo.
208 All of the LWP's of a process can be accessed indirectly thru the
209 single process procinfo.
211 However, against the day when GDB may debug more than one process,
212 this data structure is kept in a list (which for now will hold no
213 more than one member), and many functions will have a pointer to a
214 procinfo as an argument.
216 There will be a separate procinfo structure for use by the (not yet
217 implemented) "info proc" command, so that we can print useful
218 information about any random process without interfering with the
219 inferior's procinfo information. */
222 /* format strings for /proc paths */
223 # ifndef CTL_PROC_NAME_FMT
224 # define MAIN_PROC_NAME_FMT "/proc/%d"
225 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
226 # define AS_PROC_NAME_FMT "/proc/%d/as"
227 # define MAP_PROC_NAME_FMT "/proc/%d/map"
228 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
229 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
231 /* the name of the proc status struct depends on the implementation */
232 typedef pstatus_t gdb_prstatus_t
;
233 typedef lwpstatus_t gdb_lwpstatus_t
;
234 #else /* ! NEW_PROC_API */
235 /* format strings for /proc paths */
236 # ifndef CTL_PROC_NAME_FMT
237 # define MAIN_PROC_NAME_FMT "/proc/%05d"
238 # define CTL_PROC_NAME_FMT "/proc/%05d"
239 # define AS_PROC_NAME_FMT "/proc/%05d"
240 # define MAP_PROC_NAME_FMT "/proc/%05d"
241 # define STATUS_PROC_NAME_FMT "/proc/%05d"
242 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
244 /* the name of the proc status struct depends on the implementation */
245 typedef prstatus_t gdb_prstatus_t
;
246 typedef prstatus_t gdb_lwpstatus_t
;
247 #endif /* NEW_PROC_API */
249 /* Provide default composite pid manipulation macros for systems that
250 don't have threads. */
253 #define PIDGET(PID) (PID)
254 #define TIDGET(PID) (PID)
257 #define MERGEPID(PID, TID) (PID)
260 typedef struct procinfo
{
261 struct procinfo
*next
;
262 int pid
; /* Process ID */
263 int tid
; /* Thread/LWP id */
267 int ignore_next_sigstop
;
269 /* The following four fd fields may be identical, or may contain
270 several different fd's, depending on the version of /proc
271 (old ioctl or new read/write). */
273 int ctl_fd
; /* File descriptor for /proc control file */
275 * The next three file descriptors are actually only needed in the
276 * read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
277 * However, to avoid a bunch of #ifdefs in the code, we will use
278 * them uniformly by (in the case of the ioctl single-file-descriptor
279 * implementation) filling them with copies of the control fd.
281 int status_fd
; /* File descriptor for /proc status file */
282 int as_fd
; /* File descriptor for /proc as file */
284 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
286 fltset_t saved_fltset
; /* Saved traced hardware fault set */
287 sigset_t saved_sigset
; /* Saved traced signal set */
288 sigset_t saved_sighold
; /* Saved held signal set */
289 sysset_t saved_exitset
; /* Saved traced system call exit set */
290 sysset_t saved_entryset
; /* Saved traced system call entry set */
292 gdb_prstatus_t prstatus
; /* Current process status info */
295 gdb_fpregset_t fpregset
; /* Current floating point registers */
298 struct procinfo
*thread_list
;
300 int status_valid
: 1;
302 int fpregs_valid
: 1;
303 int threads_valid
: 1;
306 static char errmsg
[128]; /* shared error msg buffer */
308 /* Function prototypes for procinfo module: */
310 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
311 static procinfo
*find_procinfo (int pid
, int tid
);
312 static procinfo
*create_procinfo (int pid
, int tid
);
313 static void destroy_procinfo (procinfo
* p
);
314 static void do_destroy_procinfo_cleanup (void *);
315 static void dead_procinfo (procinfo
* p
, char *msg
, int killp
);
316 static int open_procinfo_files (procinfo
* p
, int which
);
317 static void close_procinfo_files (procinfo
* p
);
319 /* The head of the procinfo list: */
320 static procinfo
* procinfo_list
;
323 * Function: find_procinfo
325 * Search the procinfo list.
327 * Returns: pointer to procinfo, or NULL if not found.
331 find_procinfo (pid
, tid
)
337 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
344 /* Don't check threads_valid. If we're updating the
345 thread_list, we want to find whatever threads are already
346 here. This means that in general it is the caller's
347 responsibility to check threads_valid and update before
348 calling find_procinfo, if the caller wants to find a new
351 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
360 * Function: find_procinfo_or_die
362 * Calls find_procinfo, but errors on failure.
366 find_procinfo_or_die (pid
, tid
)
370 procinfo
*pi
= find_procinfo (pid
, tid
);
375 error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",
378 error ("procfs: couldn't find pid %d in procinfo list.", pid
);
384 * Function: open_procinfo_files
386 * Open the file descriptor for the process or LWP.
387 * ifdef NEW_PROC_API, we only open the control file descriptor;
388 * the others are opened lazily as needed.
389 * else (if not NEW_PROC_API), there is only one real
390 * file descriptor, but we keep multiple copies of it so that
391 * the code that uses them does not have to be #ifdef'd.
393 * Return: file descriptor, or zero for failure.
396 enum { FD_CTL
, FD_STATUS
, FD_AS
};
399 open_procinfo_files (pi
, which
)
404 char tmp
[MAX_PROC_NAME_SIZE
];
409 * This function is getting ALMOST long enough to break up into several.
410 * Here is some rationale:
412 * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
413 * There are several file descriptors that may need to be open
414 * for any given process or LWP. The ones we're intereted in are:
415 * - control (ctl) write-only change the state
416 * - status (status) read-only query the state
417 * - address space (as) read/write access memory
418 * - map (map) read-only virtual addr map
419 * Most of these are opened lazily as they are needed.
420 * The pathnames for the 'files' for an LWP look slightly
421 * different from those of a first-class process:
422 * Pathnames for a process (<proc-id>):
423 * /proc/<proc-id>/ctl
424 * /proc/<proc-id>/status
426 * /proc/<proc-id>/map
427 * Pathnames for an LWP (lwp-id):
428 * /proc/<proc-id>/lwp/<lwp-id>/lwpctl
429 * /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
430 * An LWP has no map or address space file descriptor, since
431 * the memory map and address space are shared by all LWPs.
433 * Everyone else (Solaris 2.5, Irix, OSF)
434 * There is only one file descriptor for each process or LWP.
435 * For convenience, we copy the same file descriptor into all
436 * three fields of the procinfo struct (ctl_fd, status_fd, and
437 * as_fd, see NEW_PROC_API above) so that code that uses them
438 * doesn't need any #ifdef's.
443 * Each LWP has an independent file descriptor, but these
444 * are not obtained via the 'open' system call like the rest:
445 * instead, they're obtained thru an ioctl call (PIOCOPENLWP)
446 * to the file descriptor of the parent process.
449 * These do not even have their own independent file descriptor.
450 * All operations are carried out on the file descriptor of the
451 * parent process. Therefore we just call open again for each
452 * thread, getting a new handle for the same 'file'.
457 * In this case, there are several different file descriptors that
458 * we might be asked to open. The control file descriptor will be
459 * opened early, but the others will be opened lazily as they are
463 strcpy (tmp
, pi
->pathname
);
464 switch (which
) { /* which file descriptor to open? */
467 strcat (tmp
, "/lwpctl");
469 strcat (tmp
, "/ctl");
470 fd
= open (tmp
, O_WRONLY
);
477 return 0; /* there is no 'as' file descriptor for an lwp */
479 fd
= open (tmp
, O_RDWR
);
486 strcat (tmp
, "/lwpstatus");
488 strcat (tmp
, "/status");
489 fd
= open (tmp
, O_RDONLY
);
495 return 0; /* unknown file descriptor */
497 #else /* not NEW_PROC_API */
499 * In this case, there is only one file descriptor for each procinfo
500 * (ie. each process or LWP). In fact, only the file descriptor for
501 * the process can actually be opened by an 'open' system call.
502 * The ones for the LWPs have to be obtained thru an IOCTL call
503 * on the process's file descriptor.
505 * For convenience, we copy each procinfo's single file descriptor
506 * into all of the fields occupied by the several file descriptors
507 * of the NEW_PROC_API implementation. That way, the code that uses
508 * them can be written without ifdefs.
512 #ifdef PIOCTSTATUS /* OSF */
513 if ((fd
= open (pi
->pathname
, O_RDWR
)) == 0) /* Only one FD; just open it. */
515 #else /* Sol 2.5, Irix, other? */
516 if (pi
->tid
== 0) /* Master procinfo for the process */
518 fd
= open (pi
->pathname
, O_RDWR
);
522 else /* LWP thread procinfo */
524 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
528 /* Find the procinfo for the entire process. */
529 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
532 /* Now obtain the file descriptor for the LWP. */
533 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) <= 0)
535 #else /* Irix, other? */
536 return 0; /* Don't know how to open threads */
537 #endif /* Sol 2.5 PIOCOPENLWP */
539 #endif /* OSF PIOCTSTATUS */
540 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
541 #endif /* NEW_PROC_API */
543 return 1; /* success */
547 * Function: create_procinfo
549 * Allocate a data structure and link it into the procinfo list.
550 * (First tries to find a pre-existing one (FIXME: why?)
552 * Return: pointer to new procinfo struct.
556 create_procinfo (pid
, tid
)
560 procinfo
*pi
, *parent
;
562 if ((pi
= find_procinfo (pid
, tid
)))
563 return pi
; /* Already exists, nothing to do. */
565 /* find parent before doing malloc, to save having to cleanup */
567 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
569 doesn't exist yet? */
571 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
572 memset (pi
, 0, sizeof (procinfo
));
576 /* Chain into list. */
579 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
580 pi
->next
= procinfo_list
;
586 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
588 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
590 pi
->next
= parent
->thread_list
;
591 parent
->thread_list
= pi
;
597 * Function: close_procinfo_files
599 * Close all file descriptors associated with the procinfo
603 close_procinfo_files (pi
)
611 if (pi
->status_fd
> 0)
612 close (pi
->status_fd
);
614 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
618 * Function: destroy_procinfo
620 * Destructor function. Close, unlink and deallocate the object.
624 destroy_one_procinfo (list
, pi
)
630 /* Step one: unlink the procinfo from its list */
634 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
637 ptr
->next
= pi
->next
;
641 /* Step two: close any open file descriptors */
642 close_procinfo_files (pi
);
644 /* Step three: free the memory. */
649 destroy_procinfo (pi
)
654 if (pi
->tid
!= 0) /* destroy a thread procinfo */
656 tmp
= find_procinfo (pi
->pid
, 0); /* find the parent process */
657 destroy_one_procinfo (&tmp
->thread_list
, pi
);
659 else /* destroy a process procinfo and all its threads */
661 /* First destroy the children, if any; */
662 while (pi
->thread_list
!= NULL
)
663 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
664 /* Then destroy the parent. Genocide!!! */
665 destroy_one_procinfo (&procinfo_list
, pi
);
670 do_destroy_procinfo_cleanup (void *pi
)
672 destroy_procinfo (pi
);
675 enum { NOKILL
, KILL
};
678 * Function: dead_procinfo
680 * To be called on a non_recoverable error for a procinfo.
681 * Prints error messages, optionally sends a SIGKILL to the process,
682 * then destroys the data structure.
686 dead_procinfo (pi
, msg
, kill_p
)
695 print_sys_errmsg (pi
->pathname
, errno
);
699 sprintf (procfile
, "process %d", pi
->pid
);
700 print_sys_errmsg (procfile
, errno
);
703 kill (pi
->pid
, SIGKILL
);
705 destroy_procinfo (pi
);
709 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
711 /* =================== /proc "MODULE" =================== */
714 * This "module" is the interface layer between the /proc system API
715 * and the gdb target vector functions. This layer consists of
716 * access functions that encapsulate each of the basic operations
717 * that we need to use from the /proc API.
719 * The main motivation for this layer is to hide the fact that
720 * there are two very different implementations of the /proc API.
721 * Rather than have a bunch of #ifdefs all thru the gdb target vector
722 * functions, we do our best to hide them all in here.
725 int proc_get_status (procinfo
* pi
);
726 long proc_flags (procinfo
* pi
);
727 int proc_why (procinfo
* pi
);
728 int proc_what (procinfo
* pi
);
729 int proc_set_run_on_last_close (procinfo
* pi
);
730 int proc_unset_run_on_last_close (procinfo
* pi
);
731 int proc_set_inherit_on_fork (procinfo
* pi
);
732 int proc_unset_inherit_on_fork (procinfo
* pi
);
733 int proc_set_async (procinfo
* pi
);
734 int proc_unset_async (procinfo
* pi
);
735 int proc_stop_process (procinfo
* pi
);
736 int proc_trace_signal (procinfo
* pi
, int signo
);
737 int proc_ignore_signal (procinfo
* pi
, int signo
);
738 int proc_clear_current_fault (procinfo
* pi
);
739 int proc_set_current_signal (procinfo
* pi
, int signo
);
740 int proc_clear_current_signal (procinfo
* pi
);
741 int proc_set_gregs (procinfo
* pi
);
742 int proc_set_fpregs (procinfo
* pi
);
743 int proc_wait_for_stop (procinfo
* pi
);
744 int proc_run_process (procinfo
* pi
, int step
, int signo
);
745 int proc_kill (procinfo
* pi
, int signo
);
746 int proc_parent_pid (procinfo
* pi
);
747 int proc_get_nthreads (procinfo
* pi
);
748 int proc_get_current_thread (procinfo
* pi
);
749 int proc_set_held_signals (procinfo
* pi
, sigset_t
* sighold
);
750 int proc_set_traced_sysexit (procinfo
* pi
, sysset_t
* sysset
);
751 int proc_set_traced_sysentry (procinfo
* pi
, sysset_t
* sysset
);
752 int proc_set_traced_faults (procinfo
* pi
, fltset_t
* fltset
);
753 int proc_set_traced_signals (procinfo
* pi
, sigset_t
* sigset
);
755 int proc_update_threads (procinfo
* pi
);
756 int proc_iterate_over_threads (procinfo
* pi
,
757 int (*func
) (procinfo
*, procinfo
*, void *),
760 gdb_gregset_t
*proc_get_gregs (procinfo
* pi
);
761 gdb_fpregset_t
*proc_get_fpregs (procinfo
* pi
);
762 sysset_t
*proc_get_traced_sysexit (procinfo
* pi
, sysset_t
* save
);
763 sysset_t
*proc_get_traced_sysentry (procinfo
* pi
, sysset_t
* save
);
764 fltset_t
*proc_get_traced_faults (procinfo
* pi
, fltset_t
* save
);
765 sigset_t
*proc_get_traced_signals (procinfo
* pi
, sigset_t
* save
);
766 sigset_t
*proc_get_held_signals (procinfo
* pi
, sigset_t
* save
);
767 sigset_t
*proc_get_pending_signals (procinfo
* pi
, sigset_t
* save
);
768 struct sigaction
*proc_get_signal_actions (procinfo
* pi
,
769 struct sigaction
*save
);
771 void proc_warn (procinfo
* pi
, char *func
, int line
);
772 void proc_error (procinfo
* pi
, char *func
, int line
);
775 proc_warn (pi
, func
, line
)
780 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
781 print_sys_errmsg (errmsg
, errno
);
785 proc_error (pi
, func
, line
)
790 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
791 perror_with_name (errmsg
);
795 * Function: proc_get_status
797 * Updates the status struct in the procinfo.
798 * There is a 'valid' flag, to let other functions know when
799 * this function needs to be called (so the status is only
800 * read when it is needed). The status file descriptor is
801 * also only opened when it is needed.
803 * Return: non-zero for success, zero for failure.
810 /* Status file descriptor is opened "lazily" */
811 if (pi
->status_fd
== 0 &&
812 open_procinfo_files (pi
, FD_STATUS
) == 0)
814 pi
->status_valid
= 0;
819 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
820 pi
->status_valid
= 0; /* fail */
823 /* Sigh... I have to read a different data structure,
824 depending on whether this is a main process or an LWP. */
826 pi
->status_valid
= (read (pi
->status_fd
,
827 (char *) &pi
->prstatus
.pr_lwp
,
828 sizeof (lwpstatus_t
))
829 == sizeof (lwpstatus_t
));
832 pi
->status_valid
= (read (pi
->status_fd
,
833 (char *) &pi
->prstatus
,
834 sizeof (gdb_prstatus_t
))
835 == sizeof (gdb_prstatus_t
));
836 #if 0 /*def UNIXWARE*/
837 if (pi
->status_valid
&&
838 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
839 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
840 /* Unixware peculiarity -- read the damn thing again! */
841 pi
->status_valid
= (read (pi
->status_fd
,
842 (char *) &pi
->prstatus
,
843 sizeof (gdb_prstatus_t
))
844 == sizeof (gdb_prstatus_t
));
845 #endif /* UNIXWARE */
848 #else /* ioctl method */
849 #ifdef PIOCTSTATUS /* osf */
850 if (pi
->tid
== 0) /* main process */
852 /* Just read the danged status. Now isn't that simple? */
854 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
861 tid_t pr_error_thread
;
862 struct prstatus status
;
865 thread_status
.pr_count
= 1;
866 thread_status
.status
.pr_tid
= pi
->tid
;
867 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
870 memcpy (&pi
->prstatus
, &thread_status
.status
,
871 sizeof (pi
->prstatus
));
872 pi
->status_valid
= 1;
876 /* Just read the danged status. Now isn't that simple? */
877 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
881 if (pi
->status_valid
)
883 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
886 proc_get_current_thread (pi
));
889 /* The status struct includes general regs, so mark them valid too */
890 pi
->gregs_valid
= pi
->status_valid
;
892 /* In the read/write multiple-fd model,
893 the status struct includes the fp regs too, so mark them valid too */
894 pi
->fpregs_valid
= pi
->status_valid
;
896 return pi
->status_valid
; /* True if success, false if failure. */
900 * Function: proc_flags
902 * returns the process flags (pr_flags field).
909 if (!pi
->status_valid
)
910 if (!proc_get_status (pi
))
911 return 0; /* FIXME: not a good failure value (but what is?) */
915 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
916 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
917 The two sets of flags don't overlap. */
918 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
920 return pi
->prstatus
.pr_lwp
.pr_flags
;
923 return pi
->prstatus
.pr_flags
;
930 * returns the pr_why field (why the process stopped).
937 if (!pi
->status_valid
)
938 if (!proc_get_status (pi
))
939 return 0; /* FIXME: not a good failure value (but what is?) */
942 return pi
->prstatus
.pr_lwp
.pr_why
;
944 return pi
->prstatus
.pr_why
;
949 * Function: proc_what
951 * returns the pr_what field (details of why the process stopped).
958 if (!pi
->status_valid
)
959 if (!proc_get_status (pi
))
960 return 0; /* FIXME: not a good failure value (but what is?) */
963 return pi
->prstatus
.pr_lwp
.pr_what
;
965 return pi
->prstatus
.pr_what
;
969 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
971 * Function: proc_nsysarg
973 * returns the pr_nsysarg field (number of args to the current syscall).
980 if (!pi
->status_valid
)
981 if (!proc_get_status (pi
))
985 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
987 return pi
->prstatus
.pr_nsysarg
;
992 * Function: proc_sysargs
994 * returns the pr_sysarg field (pointer to the arguments of current syscall).
1001 if (!pi
->status_valid
)
1002 if (!proc_get_status (pi
))
1006 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1008 return (long *) &pi
->prstatus
.pr_sysarg
;
1013 * Function: proc_syscall
1015 * returns the pr_syscall field (id of current syscall if we are in one).
1022 if (!pi
->status_valid
)
1023 if (!proc_get_status (pi
))
1027 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1029 return pi
->prstatus
.pr_syscall
;
1032 #endif /* PIOCSSPCACT */
1035 * Function: proc_cursig:
1037 * returns the pr_cursig field (current signal).
1041 proc_cursig (struct procinfo
*pi
)
1043 if (!pi
->status_valid
)
1044 if (!proc_get_status (pi
))
1045 return 0; /* FIXME: not a good failure value (but what is?) */
1048 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1050 return pi
->prstatus
.pr_cursig
;
1055 * Function: proc_modify_flag
1057 * === I appologize for the messiness of this function.
1058 * === This is an area where the different versions of
1059 * === /proc are more inconsistent than usual. MVS
1061 * Set or reset any of the following process flags:
1062 * PR_FORK -- forked child will inherit trace flags
1063 * PR_RLC -- traced process runs when last /proc file closed.
1064 * PR_KLC -- traced process is killed when last /proc file closed.
1065 * PR_ASYNC -- LWP's get to run/stop independently.
1067 * There are three methods for doing this function:
1068 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1070 * 2) Middle: PIOCSET/PIOCRESET
1072 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1075 * Note: Irix does not define PR_ASYNC.
1076 * Note: OSF does not define PR_KLC.
1077 * Note: OSF is the only one that can ONLY use the oldest method.
1080 * pi -- the procinfo
1081 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1082 * mode -- 1 for set, 0 for reset.
1084 * Returns non-zero for success, zero for failure.
1087 enum { FLAG_RESET
, FLAG_SET
};
1090 proc_modify_flag (pi
, flag
, mode
)
1095 long win
= 0; /* default to fail */
1098 * These operations affect the process as a whole, and applying
1099 * them to an individual LWP has the same meaning as applying them
1100 * to the main process. Therefore, if we're ever called with a
1101 * pointer to an LWP's procinfo, let's substitute the process's
1102 * procinfo and avoid opening the LWP's file descriptor
1107 pi
= find_procinfo_or_die (pi
->pid
, 0);
1109 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
1110 /* First normalize the PCUNSET/PCRESET command opcode
1111 (which for no obvious reason has a different definition
1112 from one operating system to the next...) */
1114 #define GDBRESET PCUNSET
1117 #define GDBRESET PCRESET
1122 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC) */
1124 else /* Reset the flag */
1128 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1131 #ifdef PIOCSET /* Irix/Sol5 method */
1132 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
1134 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1136 else /* Reset the flag */
1138 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1142 #ifdef PIOCSRLC /* Oldest method: OSF */
1145 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1147 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1149 else /* Clear run-on-last-close */
1151 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1155 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1157 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1159 else /* Clear inherit-on-fork */
1161 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1165 win
= 0; /* fail -- unknown flag (can't do PR_ASYNC) */
1172 /* The above operation renders the procinfo's cached pstatus obsolete. */
1173 pi
->status_valid
= 0;
1176 warning ("procfs: modify_flag failed to turn %s %s",
1177 flag
== PR_FORK
? "PR_FORK" :
1178 flag
== PR_RLC
? "PR_RLC" :
1180 flag
== PR_ASYNC
? "PR_ASYNC" :
1183 flag
== PR_KLC
? "PR_KLC" :
1186 mode
== FLAG_RESET
? "off" : "on");
1192 * Function: proc_set_run_on_last_close
1194 * Set the run_on_last_close flag.
1195 * Process with all threads will become runnable
1196 * when debugger closes all /proc fds.
1198 * Returns non-zero for success, zero for failure.
1202 proc_set_run_on_last_close (pi
)
1205 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1209 * Function: proc_unset_run_on_last_close
1211 * Reset the run_on_last_close flag.
1212 * Process will NOT become runnable
1213 * when debugger closes its file handles.
1215 * Returns non-zero for success, zero for failure.
1219 proc_unset_run_on_last_close (pi
)
1222 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1227 * Function: proc_set_kill_on_last_close
1229 * Set the kill_on_last_close flag.
1230 * Process with all threads will be killed when debugger
1231 * closes all /proc fds (or debugger exits or dies).
1233 * Returns non-zero for success, zero for failure.
1237 proc_set_kill_on_last_close (pi
)
1240 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1244 * Function: proc_unset_kill_on_last_close
1246 * Reset the kill_on_last_close flag.
1247 * Process will NOT be killed when debugger
1248 * closes its file handles (or exits or dies).
1250 * Returns non-zero for success, zero for failure.
1254 proc_unset_kill_on_last_close (pi
)
1257 return proc_modify_flag (pi
, PR_KLC
, 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);
2126 long cmd
= PCCFAULT
;
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
= address_to_host_pointer (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
) (int, CORE_ADDR
);
2604 #ifndef NEW_PROC_API /* avoid compiler warning */
2609 char pathname
[MAX_PROC_NAME_SIZE
];
2614 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
2618 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
2619 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
2620 proc_error (pi
, "proc_iterate_over_mappings (open)", __LINE__
);
2622 /* Make sure it gets closed again. */
2623 make_cleanup_close (map_fd
);
2625 /* Allocate space for mapping (lifetime only for this function). */
2626 map
= alloca (sizeof (struct prmap
));
2628 /* Now read the mappings from the file,
2629 open a file descriptor for those that have a name,
2630 and call the callback function. */
2631 while (read (map_fd
,
2633 sizeof (struct prmap
)) == sizeof (struct prmap
))
2635 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
2637 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
2640 if (map
->pr_mapname
[0] == 0)
2642 fd
= -1; /* no map file */
2646 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
2647 /* Note: caller's responsibility to close this fd! */
2648 fd
= open (name
, O_RDONLY
);
2649 /* Note: we don't test the above call for failure;
2650 we just pass the FD on as given. Sometimes there is
2651 no file, so the ioctl may return failure, but that's
2655 /* Stop looping if the callback returns non-zero. */
2656 if ((funcstat
= (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
)) != 0)
2660 /* Get the number of mapping entries. */
2661 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmaps
) < 0)
2662 proc_error (pi
, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__
);
2664 /* Allocate space for mappings (lifetime only this function). */
2665 map
= (struct prmap
*) alloca ((nmaps
+ 1) * sizeof (struct prmap
));
2667 /* Read in all the mappings. */
2668 if (ioctl (pi
->ctl_fd
, PIOCMAP
, map
) < 0)
2669 proc_error (pi
, "proc_iterate_over_mappings (PIOCMAP)", __LINE__
);
2671 /* Now loop through the mappings, open an fd for each, and
2672 call the callback function. */
2674 i
< nmaps
&& map
[i
].pr_size
!= 0;
2677 /* Note: caller's responsibility to close this fd! */
2678 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
[i
].pr_vaddr
);
2679 /* Note: we don't test the above call for failure;
2680 we just pass the FD on as given. Sometimes there is
2681 no file, so the ioctl may return failure, but that's
2684 /* Stop looping if the callback returns non-zero. */
2685 funcstat
= (*func
) (fd
, host_pointer_to_address (map
[i
].pr_vaddr
));
2694 #ifdef TM_I386SOL2_H /* Is it hokey to use this? */
2696 #include <sys/sysi86.h>
2699 * Function: proc_get_LDT_entry
2705 * The 'key' is actually the value of the lower 16 bits of
2706 * the GS register for the LWP that we're interested in.
2708 * Return: matching ssh struct (LDT entry).
2712 proc_get_LDT_entry (pi
, key
)
2716 static struct ssd
*ldt_entry
= NULL
;
2718 char pathname
[MAX_PROC_NAME_SIZE
];
2719 struct cleanup
*old_chain
= NULL
;
2722 /* Allocate space for one LDT entry.
2723 This alloc must persist, because we return a pointer to it. */
2724 if (ldt_entry
== NULL
)
2725 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2727 /* Open the file descriptor for the LDT table. */
2728 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2729 if ((fd
= open (pathname
, O_RDONLY
)) < 0)
2731 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2734 /* Make sure it gets closed again! */
2735 old_chain
= make_cleanup_close (fd
);
2737 /* Now 'read' thru the table, find a match and return it. */
2738 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2740 if (ldt_entry
->sel
== 0 &&
2741 ldt_entry
->bo
== 0 &&
2742 ldt_entry
->acc1
== 0 &&
2743 ldt_entry
->acc2
== 0)
2744 break; /* end of table */
2745 /* If key matches, return this entry. */
2746 if (ldt_entry
->sel
== key
)
2749 /* Loop ended, match not found. */
2753 static int nalloc
= 0;
2755 /* Get the number of LDT entries. */
2756 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2758 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2762 /* Allocate space for the number of LDT entries. */
2763 /* This alloc has to persist, 'cause we return a pointer to it. */
2766 ldt_entry
= (struct ssd
*)
2767 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2771 /* Read the whole table in one gulp. */
2772 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2774 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2778 /* Search the table and return the (first) entry matching 'key'. */
2779 for (i
= 0; i
< nldt
; i
++)
2780 if (ldt_entry
[i
].sel
== key
)
2781 return &ldt_entry
[i
];
2783 /* Loop ended, match not found. */
2788 #endif /* TM_I386SOL2_H */
2790 /* =============== END, non-thread part of /proc "MODULE" =============== */
2792 /* =================== Thread "MODULE" =================== */
2794 /* NOTE: you'll see more ifdefs and duplication of functions here,
2795 since there is a different way to do threads on every OS. */
2798 * Function: proc_get_nthreads
2800 * Return the number of threads for the process
2803 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2808 proc_get_nthreads (pi
)
2813 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2814 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2820 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2822 * Solaris and Unixware version
2825 proc_get_nthreads (pi
)
2828 if (!pi
->status_valid
)
2829 if (!proc_get_status (pi
))
2833 * NEW_PROC_API: only works for the process procinfo,
2834 * because the LWP procinfos do not get prstatus filled in.
2837 if (pi
->tid
!= 0) /* find the parent process procinfo */
2838 pi
= find_procinfo_or_die (pi
->pid
, 0);
2840 return pi
->prstatus
.pr_nlwp
;
2848 proc_get_nthreads (pi
)
2857 * Function: proc_get_current_thread (LWP version)
2859 * Return the ID of the thread that had an event of interest.
2860 * (ie. the one that hit a breakpoint or other traced event).
2861 * All other things being equal, this should be the ID of a
2862 * thread that is currently executing.
2865 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2867 * Solaris and Unixware version
2870 proc_get_current_thread (pi
)
2874 * Note: this should be applied to the root procinfo for the process,
2875 * not to the procinfo for an LWP. If applied to the procinfo for
2876 * an LWP, it will simply return that LWP's ID. In that case,
2877 * find the parent process procinfo.
2881 pi
= find_procinfo_or_die (pi
->pid
, 0);
2883 if (!pi
->status_valid
)
2884 if (!proc_get_status (pi
))
2888 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2890 return pi
->prstatus
.pr_who
;
2895 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2900 proc_get_current_thread (pi
)
2903 #if 0 /* FIXME: not ready for prime time? */
2904 return pi
->prstatus
.pr_tid
;
2915 proc_get_current_thread (pi
)
2925 * Function: proc_update_threads
2927 * Discover the IDs of all the threads within the process, and
2928 * create a procinfo for each of them (chained to the parent).
2930 * This unfortunately requires a different method on every OS.
2932 * Return: non-zero for success, zero for failure.
2936 proc_delete_dead_threads (parent
, thread
, ignore
)
2941 if (thread
&& parent
) /* sanity */
2943 thread
->status_valid
= 0;
2944 if (!proc_get_status (thread
))
2945 destroy_one_procinfo (&parent
->thread_list
, thread
);
2947 return 0; /* keep iterating */
2950 #if defined (PIOCLSTATUS)
2952 * Solaris 2.5 (ioctl) version
2955 proc_update_threads (pi
)
2958 gdb_prstatus_t
*prstatus
;
2959 struct cleanup
*old_chain
= NULL
;
2964 * We should never have to apply this operation to any procinfo
2965 * except the one for the main process. If that ever changes
2966 * for any reason, then take out the following clause and
2967 * replace it with one that makes sure the ctl_fd is open.
2971 pi
= find_procinfo_or_die (pi
->pid
, 0);
2973 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2975 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2976 return 1; /* Process is not multi-threaded; nothing to do. */
2978 if ((prstatus
= (gdb_prstatus_t
*)
2979 malloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1))) == 0)
2980 perror_with_name ("procfs: malloc failed in update_threads");
2982 old_chain
= make_cleanup (free
, prstatus
);
2983 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2984 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2986 /* Skip element zero, which represents the process as a whole. */
2987 for (i
= 1; i
< nlwp
+ 1; i
++)
2989 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
2990 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2992 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
2993 thread
->status_valid
= 1;
2995 pi
->threads_valid
= 1;
2996 do_cleanups (old_chain
);
3002 * Unixware and Solaris 6 (and later) version
3005 do_closedir_cleanup (void *dir
)
3011 proc_update_threads (pi
)
3014 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3015 struct dirent
*direntry
;
3016 struct cleanup
*old_chain
= NULL
;
3022 * We should never have to apply this operation to any procinfo
3023 * except the one for the main process. If that ever changes
3024 * for any reason, then take out the following clause and
3025 * replace it with one that makes sure the ctl_fd is open.
3029 pi
= find_procinfo_or_die (pi
->pid
, 0);
3031 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3036 * Note: this brute-force method is the only way I know of
3037 * to accomplish this task on Unixware. This method will
3038 * also work on Solaris 2.6 and 2.7. There is a much simpler
3039 * and more elegant way to do this on Solaris, but the margins
3040 * of this manuscript are too small to write it here... ;-)
3043 strcpy (pathname
, pi
->pathname
);
3044 strcat (pathname
, "/lwp");
3045 if ((dirp
= opendir (pathname
)) == NULL
)
3046 proc_error (pi
, "update_threads, opendir", __LINE__
);
3048 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
3049 while ((direntry
= readdir (dirp
)) != NULL
)
3050 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3052 lwpid
= atoi (&direntry
->d_name
[0]);
3053 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3054 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3056 pi
->threads_valid
= 1;
3057 do_cleanups (old_chain
);
3066 proc_update_threads (pi
)
3073 * We should never have to apply this operation to any procinfo
3074 * except the one for the main process. If that ever changes
3075 * for any reason, then take out the following clause and
3076 * replace it with one that makes sure the ctl_fd is open.
3080 pi
= find_procinfo_or_die (pi
->pid
, 0);
3082 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3084 nthreads
= proc_get_nthreads (pi
);
3086 return 0; /* nothing to do for 1 or fewer threads */
3088 if ((threads
= malloc (nthreads
* sizeof (tid_t
))) == NULL
)
3089 proc_error (pi
, "update_threads, malloc", __LINE__
);
3091 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3092 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3094 for (i
= 0; i
< nthreads
; i
++)
3096 if (!find_procinfo (pi
->pid
, threads
[i
]))
3097 if (!create_procinfo (pi
->pid
, threads
[i
]))
3098 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3100 pi
->threads_valid
= 1;
3108 proc_update_threads (pi
)
3113 #endif /* OSF PIOCTLIST */
3114 #endif /* NEW_PROC_API */
3115 #endif /* SOL 2.5 PIOCLSTATUS */
3118 * Function: proc_iterate_over_threads
3121 * Given a pointer to a function, call that function once
3122 * for each lwp in the procinfo list, until the function
3123 * returns non-zero, in which event return the value
3124 * returned by the function.
3126 * Note: this function does NOT call update_threads.
3127 * If you want to discover new threads first, you must
3128 * call that function explicitly. This function just makes
3129 * a quick pass over the currently-known procinfos.
3132 * pi - parent process procinfo
3133 * func - per-thread function
3134 * ptr - opaque parameter for function.
3137 * First non-zero return value from the callee, or zero.
3141 proc_iterate_over_threads (pi
, func
, ptr
)
3143 int (*func
) (procinfo
*, procinfo
*, void *);
3146 procinfo
*thread
, *next
;
3150 * We should never have to apply this operation to any procinfo
3151 * except the one for the main process. If that ever changes
3152 * for any reason, then take out the following clause and
3153 * replace it with one that makes sure the ctl_fd is open.
3157 pi
= find_procinfo_or_die (pi
->pid
, 0);
3159 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3161 next
= thread
->next
; /* in case thread is destroyed */
3162 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3169 /* =================== END, Thread "MODULE" =================== */
3171 /* =================== END, /proc "MODULE" =================== */
3173 /* =================== GDB "MODULE" =================== */
3176 * Here are all of the gdb target vector functions and their friends.
3179 static int do_attach (int pid
);
3180 static void do_detach (int signo
);
3181 static int register_gdb_signals (procinfo
*, sigset_t
*);
3184 * Function: procfs_debug_inferior
3186 * Sets up the inferior to be debugged.
3187 * Registers to trace signals, hardware faults, and syscalls.
3188 * Note: does not set RLC flag: caller may want to customize that.
3190 * Returns: zero for success (note! unlike most functions in this module)
3191 * On failure, returns the LINE NUMBER where it failed!
3195 procfs_debug_inferior (pi
)
3198 fltset_t traced_faults
;
3199 sigset_t traced_signals
;
3200 sysset_t traced_syscall_entries
;
3201 sysset_t traced_syscall_exits
;
3203 #ifdef PROCFS_DONT_TRACE_FAULTS
3204 /* On some systems (OSF), we don't trace hardware faults.
3205 Apparently it's enough that we catch them as signals.
3206 Wonder why we don't just do that in general? */
3207 premptyset (&traced_faults
); /* don't trace faults. */
3209 /* Register to trace hardware faults in the child. */
3210 prfillset (&traced_faults
); /* trace all faults... */
3211 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3213 if (!proc_set_traced_faults (pi
, &traced_faults
))
3216 /* Register to trace selected signals in the child. */
3217 premptyset (&traced_signals
);
3218 if (!register_gdb_signals (pi
, &traced_signals
))
3221 /* Register to trace the 'exit' system call (on entry). */
3222 premptyset (&traced_syscall_entries
);
3223 praddset (&traced_syscall_entries
, SYS_exit
);
3225 praddset (&traced_syscall_entries
, SYS_lwpexit
); /* And _lwp_exit... */
3228 praddset (&traced_syscall_entries
, SYS_lwp_exit
);
3231 if (!proc_set_traced_sysentry (pi
, &traced_syscall_entries
))
3234 #ifdef PRFS_STOPEXEC /* defined on OSF */
3235 /* OSF method for tracing exec syscalls. Quoting:
3236 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3237 exits from exec system calls because of the user level loader. */
3238 /* FIXME: make nice and maybe move into an access function. */
3242 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3245 prfs_flags
|= PRFS_STOPEXEC
;
3247 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3250 #else /* not PRFS_STOPEXEC */
3251 /* Everyone else's (except OSF) method for tracing exec syscalls */
3253 Not all systems with /proc have all the exec* syscalls with the same
3254 names. On the SGI, for example, there is no SYS_exec, but there
3255 *is* a SYS_execv. So, we try to account for that. */
3257 premptyset (&traced_syscall_exits
);
3259 praddset (&traced_syscall_exits
, SYS_exec
);
3262 praddset (&traced_syscall_exits
, SYS_execve
);
3265 praddset (&traced_syscall_exits
, SYS_execv
);
3268 #ifdef SYS_lwpcreate
3269 praddset (&traced_syscall_exits
, SYS_lwpcreate
);
3270 praddset (&traced_syscall_exits
, SYS_lwpexit
);
3273 #ifdef SYS_lwp_create /* FIXME: once only, please */
3274 praddset (&traced_syscall_exits
, SYS_lwp_create
);
3275 praddset (&traced_syscall_exits
, SYS_lwp_exit
);
3279 if (!proc_set_traced_sysexit (pi
, &traced_syscall_exits
))
3282 #endif /* PRFS_STOPEXEC */
3287 procfs_attach (args
, from_tty
)
3295 error_no_arg ("process-id to attach");
3298 if (pid
== getpid ())
3299 error ("Attaching GDB to itself is not a good idea...");
3303 exec_file
= get_exec_file (0);
3306 printf_filtered ("Attaching to program `%s', %s\n",
3307 exec_file
, target_pid_to_str (pid
));
3309 printf_filtered ("Attaching to %s\n", target_pid_to_str (pid
));
3313 inferior_pid
= do_attach (pid
);
3314 push_target (&procfs_ops
);
3318 procfs_detach (args
, from_tty
)
3327 exec_file
= get_exec_file (0);
3330 printf_filtered ("Detaching from program: %s %s\n",
3331 exec_file
, target_pid_to_str (inferior_pid
));
3335 signo
= atoi (args
);
3339 unpush_target (&procfs_ops
); /* Pop out of handling an inferior */
3349 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
3350 perror ("procfs: out of memory in 'attach'");
3352 if (!open_procinfo_files (pi
, FD_CTL
))
3354 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3355 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3357 dead_procinfo (pi
, errmsg
, NOKILL
);
3360 /* Stop the process (if it isn't already stopped). */
3361 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3363 pi
->was_stopped
= 1;
3364 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3368 pi
->was_stopped
= 0;
3369 /* Set the process to run again when we close it. */
3370 if (!proc_set_run_on_last_close (pi
))
3371 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3373 /* Now stop the process. */
3374 if (!proc_stop_process (pi
))
3375 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3376 pi
->ignore_next_sigstop
= 1;
3378 /* Save some of the /proc state to be restored if we detach. */
3379 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3380 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3381 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3382 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3383 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
3384 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3386 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
3387 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3389 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3390 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3392 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3393 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3395 /* Let GDB know that the inferior was attached. */
3397 return MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3406 /* Find procinfo for the main process */
3407 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0); /* FIXME: threads */
3409 if (!proc_set_current_signal (pi
, signo
))
3410 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3412 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3413 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3415 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3416 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3418 if (!proc_set_traced_sysentry (pi
, &pi
->saved_entryset
))
3419 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3421 if (!proc_set_traced_sysexit (pi
, &pi
->saved_exitset
))
3422 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3424 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3425 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3427 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3428 if (signo
|| !(pi
->was_stopped
) ||
3429 query ("Was stopped when attached, make it runnable again? "))
3431 /* Clear any pending signal. */
3432 if (!proc_clear_current_fault (pi
))
3433 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3435 if (!proc_set_run_on_last_close (pi
))
3436 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3440 destroy_procinfo (pi
);
3446 * Since the /proc interface cannot give us individual registers,
3447 * we pay no attention to the (regno) argument, and just fetch them all.
3448 * This results in the possibility that we will do unnecessarily many
3449 * fetches, since we may be called repeatedly for individual registers.
3450 * So we cache the results, and mark the cache invalid when the process
3455 procfs_fetch_registers (regno
)
3458 gdb_fpregset_t
*fpregs
;
3459 gdb_gregset_t
*gregs
;
3464 pid
= PIDGET (inferior_pid
);
3465 tid
= TIDGET (inferior_pid
);
3467 /* First look up procinfo for the main process. */
3468 pi
= find_procinfo_or_die (pid
, 0);
3470 /* If the event thread is not the same as GDB's requested thread
3471 (ie. inferior_pid), then look up procinfo for the requested
3474 (tid
!= proc_get_current_thread (pi
)))
3475 pi
= find_procinfo_or_die (pid
, tid
);
3478 error ("procfs: fetch_registers failed to find procinfo for %s",
3479 target_pid_to_str (inferior_pid
));
3481 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3482 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3484 supply_gregset (gregs
);
3486 if (FP0_REGNUM
>= 0) /* need floating point? */
3488 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3489 regno
== PC_REGNUM
||
3490 (NPC_REGNUM
>= 0 && regno
== NPC_REGNUM
) ||
3491 regno
== FP_REGNUM
||
3493 return; /* not a floating point register */
3495 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3496 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3498 supply_fpregset (fpregs
);
3502 /* Get ready to modify the registers array. On machines which store
3503 individual registers, this doesn't need to do anything. On
3504 machines which store all the registers in one fell swoop, such as
3505 /proc, this makes sure that registers contains all the registers
3506 from the program being debugged. */
3509 procfs_prepare_to_store ()
3511 #ifdef CHILD_PREPARE_TO_STORE
3512 CHILD_PREPARE_TO_STORE ();
3519 * Since the /proc interface will not read individual registers,
3520 * we will cache these requests until the process is resumed, and
3521 * only then write them back to the inferior process.
3523 * FIXME: is that a really bad idea? Have to think about cases
3524 * where writing one register might affect the value of others, etc.
3528 procfs_store_registers (regno
)
3531 gdb_fpregset_t
*fpregs
;
3532 gdb_gregset_t
*gregs
;
3537 pid
= PIDGET (inferior_pid
);
3538 tid
= TIDGET (inferior_pid
);
3540 /* First find procinfo for main process */
3541 pi
= find_procinfo_or_die (pid
, 0);
3543 /* If current lwp for process is not the same as requested thread
3544 (ie. inferior_pid), then find procinfo for the requested thread. */
3547 (tid
!= proc_get_current_thread (pi
)))
3548 pi
= find_procinfo_or_die (pid
, tid
);
3551 error ("procfs: store_registers: failed to find procinfo for %s",
3552 target_pid_to_str (inferior_pid
));
3554 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3555 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3557 fill_gregset (gregs
, regno
);
3558 if (!proc_set_gregs (pi
))
3559 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3561 if (FP0_REGNUM
>= 0) /* need floating point? */
3563 if ((regno
>= 0 && regno
< FP0_REGNUM
) ||
3564 regno
== PC_REGNUM
||
3565 (NPC_REGNUM
>= 0 && regno
== NPC_REGNUM
) ||
3566 regno
== FP_REGNUM
||
3568 return; /* not a floating point register */
3570 if ((fpregs
= proc_get_fpregs (pi
)) == NULL
)
3571 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3573 fill_fpregset (fpregs
, regno
);
3574 if (!proc_set_fpregs (pi
))
3575 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3580 * Function: target_wait
3582 * Retrieve the next stop event from the child process.
3583 * If child has not stopped yet, wait for it to stop.
3584 * Translate /proc eventcodes (or possibly wait eventcodes)
3585 * into gdb internal event codes.
3587 * Return: id of process (and possibly thread) that incurred the event.
3588 * event codes are returned thru a pointer parameter.
3592 procfs_wait (pid
, status
)
3594 struct target_waitstatus
*status
;
3596 /* First cut: loosely based on original version 2.1 */
3600 int why
, what
, flags
;
3609 /* Find procinfo for main process */
3610 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
3613 /* We must assume that the status is stale now... */
3614 pi
->status_valid
= 0;
3615 pi
->gregs_valid
= 0;
3616 pi
->fpregs_valid
= 0;
3618 #if 0 /* just try this out... */
3619 flags
= proc_flags (pi
);
3620 why
= proc_why (pi
);
3621 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3622 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3624 /* If child is not stopped, wait for it to stop. */
3625 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3626 !proc_wait_for_stop (pi
))
3628 /* wait_for_stop failed: has the child terminated? */
3629 if (errno
== ENOENT
)
3631 /* /proc file not found; presumably child has terminated. */
3632 retval
= wait (&wstat
); /* "wait" for the child's exit */
3634 if (retval
!= PIDGET (inferior_pid
)) /* wrong child? */
3635 error ("procfs: couldn't stop process %d: wait returned %d\n",
3636 inferior_pid
, retval
);
3637 /* FIXME: might I not just use waitpid?
3638 Or try find_procinfo to see if I know about this child? */
3642 /* Unknown error from wait_for_stop. */
3643 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3648 /* This long block is reached if either:
3649 a) the child was already stopped, or
3650 b) we successfully waited for the child with wait_for_stop.
3651 This block will analyze the /proc status, and translate it
3652 into a waitstatus for GDB.
3654 If we actually had to call wait because the /proc file
3655 is gone (child terminated), then we skip this block,
3656 because we already have a waitstatus. */
3658 flags
= proc_flags (pi
);
3659 why
= proc_why (pi
);
3660 what
= proc_what (pi
);
3662 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3665 /* If it's running async (for single_thread control),
3666 set it back to normal again. */
3667 if (flags
& PR_ASYNC
)
3668 if (!proc_unset_async (pi
))
3669 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3673 proc_prettyprint_why (why
, what
, 1);
3675 /* The 'pid' we will return to GDB is composed of
3676 the process ID plus the lwp ID. */
3677 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3681 wstat
= (what
<< 8) | 0177;
3691 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3692 printf_filtered ("[%s exited]\n",
3693 target_pid_to_str (retval
));
3694 delete_thread (retval
);
3695 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3697 #endif /* _lwp_exit */
3700 /* Handle SYS_exit call only */
3701 /* Stopped at entry to SYS_exit.
3702 Make it runnable, resume it, then use
3703 the wait system call to get its exit code.
3704 Proc_run_process always clears the current
3706 Then return its exit status. */
3707 pi
->status_valid
= 0;
3709 /* FIXME: what we should do is return
3710 TARGET_WAITKIND_SPURIOUS. */
3711 if (!proc_run_process (pi
, 0, 0))
3712 proc_error (pi
, "target_wait, run_process", __LINE__
);
3715 /* Don't call wait: simulate waiting for exit,
3716 return a "success" exit code. Bogus: what if
3717 it returns something else? */
3719 retval
= inferior_pid
; /* ? ? ? */
3723 int temp
= wait (&wstat
);
3725 /* FIXME: shouldn't I make sure I get the right
3726 event from the right process? If (for
3727 instance) I have killed an earlier inferior
3728 process but failed to clean up after it
3729 somehow, I could get its termination event
3732 /* If wait returns -1, that's what we return to GDB. */
3738 printf_filtered ("procfs: trapped on entry to ");
3739 proc_prettyprint_syscall (proc_what (pi
), 0);
3740 printf_filtered ("\n");
3743 long i
, nsysargs
, *sysargs
;
3745 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3746 (sysargs
= proc_sysargs (pi
)) != NULL
)
3748 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3749 for (i
= 0; i
< nsysargs
; i
++)
3750 printf_filtered ("#%ld: 0x%08lx\n",
3758 /* How to exit gracefully, returning "unknown event" */
3759 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3760 return inferior_pid
;
3764 /* How to keep going without returning to wfi: */
3765 target_resume (pid
, 0, TARGET_SIGNAL_0
);
3782 /* Hopefully this is our own "fork-child" execing
3783 the real child. Hoax this event into a trap, and
3784 GDB will see the child about to execute its start
3786 wstat
= (SIGTRAP
<< 8) | 0177;
3788 #ifdef SYS_lwp_create
3789 case SYS_lwp_create
:
3791 #ifdef SYS_lwpcreate
3794 #if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
3796 * This syscall is somewhat like fork/exec.
3797 * We will get the event twice: once for the parent LWP,
3798 * and once for the child. We should already know about
3799 * the parent LWP, but the child will be new to us. So,
3800 * whenever we get this event, if it represents a new
3801 * thread, simply add the thread to the list.
3804 /* If not in procinfo list, add it. */
3805 temp
= proc_get_current_thread (pi
);
3806 if (!find_procinfo (pi
->pid
, temp
))
3807 create_procinfo (pi
->pid
, temp
);
3809 temp
= MERGEPID (pi
->pid
, temp
);
3810 /* If not in GDB's thread list, add it. */
3811 if (!in_thread_list (temp
))
3813 printf_filtered ("[New %s]\n", target_pid_to_str (temp
));
3816 /* Return to WFI, but tell it to immediately resume. */
3817 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3818 return inferior_pid
;
3819 #endif /* _lwp_create */
3827 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3828 printf_filtered ("[%s exited]\n",
3829 target_pid_to_str (retval
));
3830 delete_thread (retval
);
3831 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3833 #endif /* _lwp_exit */
3837 /* Nothing to do here for now. The old procfs
3838 seemed to use this event to handle threads on
3839 older (non-LWP) systems, where I'm assuming that
3840 threads were actually separate processes. Irix,
3841 maybe? Anyway, low priority for now. */
3845 /* FIXME: do we need to handle this? Investigate. */
3849 /* FIXME: see above. */
3852 printf_filtered ("procfs: trapped on exit from ");
3853 proc_prettyprint_syscall (proc_what (pi
), 0);
3854 printf_filtered ("\n");
3857 long i
, nsysargs
, *sysargs
;
3859 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3860 (sysargs
= proc_sysargs (pi
)) != NULL
)
3862 printf_filtered ("%ld syscall arguments:\n", nsysargs
);
3863 for (i
= 0; i
< nsysargs
; i
++)
3864 printf_filtered ("#%ld: 0x%08lx\n",
3869 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3870 return inferior_pid
;
3875 wstat
= (SIGSTOP
<< 8) | 0177;
3880 printf_filtered ("Retry #%d:\n", retry
);
3881 pi
->status_valid
= 0;
3886 /* If not in procinfo list, add it. */
3887 temp
= proc_get_current_thread (pi
);
3888 if (!find_procinfo (pi
->pid
, temp
))
3889 create_procinfo (pi
->pid
, temp
);
3891 /* If not in GDB's thread list, add it. */
3892 temp
= MERGEPID (pi
->pid
, temp
);
3893 if (!in_thread_list (temp
))
3895 printf_filtered ("[New %s]\n",
3896 target_pid_to_str (temp
));
3900 status
->kind
= TARGET_WAITKIND_STOPPED
;
3901 status
->value
.sig
= 0;
3906 wstat
= (what
<< 8) | 0177;
3909 switch (what
) { /* FIXME: FAULTED_USE_SIGINFO */
3912 wstat
= (SIGTRAP
<< 8) | 0177;
3917 wstat
= (SIGTRAP
<< 8) | 0177;
3920 /* FIXME: use si_signo where possible. */
3922 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
3925 wstat
= (SIGILL
<< 8) | 0177;
3928 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
3931 wstat
= (SIGTRAP
<< 8) | 0177;
3935 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
3938 wstat
= (SIGSEGV
<< 8) | 0177;
3942 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
3945 wstat
= (SIGFPE
<< 8) | 0177;
3947 case FLTPAGE
: /* Recoverable page fault */
3948 default: /* FIXME: use si_signo if possible for fault */
3950 printf_filtered ("procfs:%d -- ", __LINE__
);
3951 printf_filtered ("child stopped for unknown reason:\n");
3952 proc_prettyprint_why (why
, what
, 1);
3953 error ("... giving up...");
3956 break; /* case PR_FAULTED: */
3957 default: /* switch (why) unmatched */
3958 printf_filtered ("procfs:%d -- ", __LINE__
);
3959 printf_filtered ("child stopped for unknown reason:\n");
3960 proc_prettyprint_why (why
, what
, 1);
3961 error ("... giving up...");
3965 * Got this far without error:
3966 * If retval isn't in the threads database, add it.
3969 retval
!= inferior_pid
&&
3970 !in_thread_list (retval
))
3973 * We have a new thread.
3974 * We need to add it both to GDB's list and to our own.
3975 * If we don't create a procinfo, resume may be unhappy
3978 printf_filtered ("[New %s]\n", target_pid_to_str (retval
));
3979 add_thread (retval
);
3980 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
3981 create_procinfo (PIDGET (retval
), TIDGET (retval
));
3983 /* In addition, it's possible that this is the first
3984 * new thread we've seen, in which case we may not
3985 * have created entries for inferior_pid yet.
3987 if (TIDGET (inferior_pid
) != 0)
3989 if (!in_thread_list (inferior_pid
))
3990 add_thread (inferior_pid
);
3991 if (find_procinfo (PIDGET (inferior_pid
),
3992 TIDGET (inferior_pid
)) == NULL
)
3993 create_procinfo (PIDGET (inferior_pid
),
3994 TIDGET (inferior_pid
));
3998 else /* flags do not indicate STOPPED */
4000 /* surely this can't happen... */
4001 printf_filtered ("procfs:%d -- process not stopped.\n",
4003 proc_prettyprint_flags (flags
, 1);
4004 error ("procfs: ...giving up...");
4009 store_waitstatus (status
, wstat
);
4016 procfs_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
4021 struct target_ops
*target
; /* ignored */
4026 /* Find procinfo for main process */
4027 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4028 if (pi
->as_fd
== 0 &&
4029 open_procinfo_files (pi
, FD_AS
) == 0)
4031 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4035 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4040 PROCFS_NOTE ("write memory: ");
4042 PROCFS_NOTE ("write memory: \n");
4044 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4048 PROCFS_NOTE ("read memory: \n");
4049 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4060 * Function: invalidate_cache
4062 * Called by target_resume before making child runnable.
4063 * Mark cached registers and status's invalid.
4064 * If there are "dirty" caches that need to be written back
4065 * to the child process, do that.
4067 * File descriptors are also cached.
4068 * As they are a limited resource, we cannot hold onto them indefinitely.
4069 * However, as they are expensive to open, we don't want to throw them
4070 * away indescriminately either. As a compromise, we will keep the
4071 * file descriptors for the parent process, but discard any file
4072 * descriptors we may have accumulated for the threads.
4075 * As this function is called by iterate_over_threads, it always
4076 * returns zero (so that iterate_over_threads will keep iterating).
4081 invalidate_cache (parent
, pi
, ptr
)
4087 * About to run the child; invalidate caches and do any other cleanup.
4091 if (pi
->gregs_dirty
)
4092 if (parent
== NULL
||
4093 proc_get_current_thread (parent
) != pi
->tid
)
4094 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4095 proc_warn (pi
, "target_resume, set_gregs",
4097 if (FP0_REGNUM
>= 0)
4098 if (pi
->fpregs_dirty
)
4099 if (parent
== NULL
||
4100 proc_get_current_thread (parent
) != pi
->tid
)
4101 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4102 proc_warn (pi
, "target_resume, set_fpregs",
4108 /* The presence of a parent indicates that this is an LWP.
4109 Close any file descriptors that it might have open.
4110 We don't do this to the master (parent) procinfo. */
4112 close_procinfo_files (pi
);
4114 pi
->gregs_valid
= 0;
4115 pi
->fpregs_valid
= 0;
4117 pi
->gregs_dirty
= 0;
4118 pi
->fpregs_dirty
= 0;
4120 pi
->status_valid
= 0;
4121 pi
->threads_valid
= 0;
4128 * Function: make_signal_thread_runnable
4130 * A callback function for iterate_over_threads.
4131 * Find the asynchronous signal thread, and make it runnable.
4132 * See if that helps matters any.
4136 make_signal_thread_runnable (process
, pi
, ptr
)
4142 if (proc_flags (pi
) & PR_ASLWP
)
4144 if (!proc_run_process (pi
, 0, -1))
4145 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4154 * Function: target_resume
4156 * Make the child process runnable. Normally we will then call
4157 * procfs_wait and wait for it to stop again (unles gdb is async).
4160 * step: if true, then arrange for the child to stop again
4161 * after executing a single instruction.
4162 * signo: if zero, then cancel any pending signal.
4163 * If non-zero, then arrange for the indicated signal
4164 * to be delivered to the child when it runs.
4165 * pid: if -1, then allow any child thread to run.
4166 * if non-zero, then allow only the indicated thread to run.
4167 ******* (not implemented yet)
4171 procfs_resume (pid
, step
, signo
)
4174 enum target_signal signo
;
4176 procinfo
*pi
, *thread
;
4180 prrun.prflags |= PRSVADDR;
4181 prrun.pr_vaddr = $PC; set resume address
4182 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4183 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4184 prrun.prflags |= PRCFAULT; clear current fault.
4186 PRSTRACE and PRSFAULT can be done by other means
4187 (proc_trace_signals, proc_trace_faults)
4188 PRSVADDR is unnecessary.
4189 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4190 This basically leaves PRSTEP and PRCSIG.
4191 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4192 So basically PR_STEP is the sole argument that must be passed
4193 to proc_run_process (for use in the prrun struct by ioctl). */
4195 /* Find procinfo for main process */
4196 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4198 /* First cut: ignore pid argument */
4201 /* Convert signal to host numbering. */
4203 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4206 native_signo
= target_signal_to_host (signo
);
4208 pi
->ignore_next_sigstop
= 0;
4210 /* Running the process voids all cached registers and status. */
4211 /* Void the threads' caches first */
4212 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4213 /* Void the process procinfo's caches. */
4214 invalidate_cache (NULL
, pi
, NULL
);
4218 /* Resume a specific thread, presumably suppressing the others. */
4219 thread
= find_procinfo (PIDGET (pid
), TIDGET (pid
));
4221 warning ("procfs: resume can't find thread %d -- resuming all.",
4225 if (thread
->tid
!= 0)
4227 /* We're to resume a specific thread, and not the others.
4228 * Set the child process's PR_ASYNC flag.
4231 if (!proc_set_async (pi
))
4232 proc_error (pi
, "target_resume, set_async", __LINE__
);
4235 proc_iterate_over_threads (pi
,
4236 make_signal_thread_runnable
,
4239 pi
= thread
; /* substitute the thread's procinfo for run */
4244 if (!proc_run_process (pi
, step
, native_signo
))
4247 warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
4249 proc_error (pi
, "target_resume", __LINE__
);
4254 * Function: register_gdb_signals
4256 * Traverse the list of signals that GDB knows about
4257 * (see "handle" command), and arrange for the target
4258 * to be stopped or not, according to these settings.
4260 * Returns non-zero for success, zero for failure.
4264 register_gdb_signals (pi
, signals
)
4270 for (signo
= 0; signo
< NSIG
; signo
++)
4271 if (signal_stop_state (target_signal_from_host (signo
)) == 0 &&
4272 signal_print_state (target_signal_from_host (signo
)) == 0 &&
4273 signal_pass_state (target_signal_from_host (signo
)) == 1)
4274 prdelset (signals
, signo
);
4276 praddset (signals
, signo
);
4278 return proc_set_traced_signals (pi
, signals
);
4282 * Function: target_notice_signals
4284 * Set up to trace signals in the child process.
4288 procfs_notice_signals (pid
)
4292 procinfo
*pi
= find_procinfo_or_die (PIDGET (pid
), 0);
4294 if (proc_get_traced_signals (pi
, &signals
) &&
4295 register_gdb_signals (pi
, &signals
))
4298 proc_error (pi
, "notice_signals", __LINE__
);
4302 * Function: target_files_info
4304 * Print status information about the child process.
4308 procfs_files_info (ignore
)
4309 struct target_ops
*ignore
;
4311 printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
4312 attach_flag
? "attached": "child",
4313 target_pid_to_str (inferior_pid
));
4317 * Function: target_open
4319 * A dummy: you don't open procfs.
4323 procfs_open (args
, from_tty
)
4327 error ("Use the \"run\" command to start a Unix child process.");
4331 * Function: target_can_run
4333 * This tells GDB that this target vector can be invoked
4334 * for "run" or "attach".
4337 int procfs_suppress_run
= 0; /* Non-zero if procfs should pretend not to
4338 be a runnable target. Used by targets
4339 that can sit atop procfs, such as solaris
4346 /* This variable is controlled by modules that sit atop procfs that
4347 may layer their own process structure atop that provided here.
4348 sol-thread.c does this because of the Solaris two-level thread
4351 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
4353 return !procfs_suppress_run
;
4357 * Function: target_stop
4359 * Stop the child process asynchronously, as when the
4360 * gdb user types control-c or presses a "stop" button.
4362 * Works by sending kill(SIGINT) to the child's process group.
4368 extern pid_t inferior_process_group
;
4370 kill (-inferior_process_group
, SIGINT
);
4374 * Function: unconditionally_kill_inferior
4376 * Make it die. Wait for it to die. Clean up after it.
4377 * Note: this should only be applied to the real process,
4378 * not to an LWP, because of the check for parent-process.
4379 * If we need this to work for an LWP, it needs some more logic.
4383 unconditionally_kill_inferior (pi
)
4388 parent_pid
= proc_parent_pid (pi
);
4389 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4390 /* FIXME: use access functions */
4391 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4392 before the PIOCKILL, otherwise it might generate a corrupted core
4393 file for the inferior. */
4394 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4396 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4399 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4400 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4401 to kill the inferior, otherwise it might remain stopped with a
4403 We do not check the result of the PIOCSSIG, the inferior might have
4406 struct siginfo newsiginfo
;
4408 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4409 newsiginfo
.si_signo
= SIGKILL
;
4410 newsiginfo
.si_code
= 0;
4411 newsiginfo
.si_errno
= 0;
4412 newsiginfo
.si_pid
= getpid ();
4413 newsiginfo
.si_uid
= getuid ();
4414 /* FIXME: use proc_set_current_signal */
4415 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4417 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4418 if (!proc_kill (pi
, SIGKILL
))
4419 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4420 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4421 destroy_procinfo (pi
);
4423 /* If pi is GDB's child, wait for it to die. */
4424 if (parent_pid
== getpid ())
4425 /* FIXME: should we use waitpid to make sure we get the right event?
4426 Should we check the returned event? */
4431 ret
= waitpid (pi
->pid
, &status
, 0);
4439 * Function: target_kill_inferior
4441 * We're done debugging it, and we want it to go away.
4442 * Then we want GDB to forget all about it.
4446 procfs_kill_inferior ()
4448 if (inferior_pid
!= 0) /* ? */
4450 /* Find procinfo for main process */
4451 procinfo
*pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4454 unconditionally_kill_inferior (pi
);
4455 target_mourn_inferior ();
4460 * Function: target_mourn_inferior
4462 * Forget we ever debugged this thing!
4466 procfs_mourn_inferior ()
4470 if (inferior_pid
!= 0)
4472 /* Find procinfo for main process */
4473 pi
= find_procinfo (PIDGET (inferior_pid
), 0);
4475 destroy_procinfo (pi
);
4477 unpush_target (&procfs_ops
);
4478 generic_mourn_inferior ();
4482 * Function: init_inferior
4484 * When GDB forks to create a runnable inferior process,
4485 * this function is called on the parent side of the fork.
4486 * It's job is to do whatever is necessary to make the child
4487 * ready to be debugged, and then wait for the child to synchronize.
4491 procfs_init_inferior (pid
)
4498 /* This routine called on the parent side (GDB side)
4499 after GDB forks the inferior. */
4501 push_target (&procfs_ops
);
4503 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4504 perror ("procfs: out of memory in 'init_inferior'");
4506 if (!open_procinfo_files (pi
, FD_CTL
))
4507 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4511 open_procinfo_files // done
4514 procfs_notice_signals
4521 /* If not stopped yet, wait for it to stop. */
4522 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4523 !(proc_wait_for_stop (pi
)))
4524 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4526 /* Save some of the /proc state to be restored if we detach. */
4527 /* FIXME: Why? In case another debugger was debugging it?
4528 We're it's parent, for Ghu's sake! */
4529 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4530 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4531 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4532 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4533 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4534 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4535 if (!proc_get_traced_sysentry (pi
, &pi
->saved_entryset
))
4536 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4537 if (!proc_get_traced_sysexit (pi
, &pi
->saved_exitset
))
4538 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4540 /* Register to trace selected signals in the child. */
4541 prfillset (&signals
);
4542 if (!register_gdb_signals (pi
, &signals
))
4543 proc_error (pi
, "init_inferior, register_signals", __LINE__
);
4545 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4546 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4548 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4549 and possibly even turning ON kill-on-last-close at this point. But
4550 I can't make that change without careful testing which I don't have
4551 time to do right now... */
4552 /* Turn on run-on-last-close flag so that the child
4553 will die if GDB goes away for some reason. */
4554 if (!proc_set_run_on_last_close (pi
))
4555 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4557 /* The 'process ID' we return to GDB is composed of
4558 the actual process ID plus the lwp ID. */
4559 inferior_pid
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
4561 #ifdef START_INFERIOR_TRAPS_EXPECTED
4562 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4564 /* One trap to exec the shell, one to exec the program being debugged. */
4565 startup_inferior (2);
4566 #endif /* START_INFERIOR_TRAPS_EXPECTED */
4570 * Function: set_exec_trap
4572 * When GDB forks to create a new process, this function is called
4573 * on the child side of the fork before GDB exec's the user program.
4574 * Its job is to make the child minimally debuggable, so that the
4575 * parent GDB process can connect to the child and take over.
4576 * This function should do only the minimum to make that possible,
4577 * and to synchronize with the parent process. The parent process
4578 * should take care of the details.
4582 procfs_set_exec_trap ()
4584 /* This routine called on the child side (inferior side)
4585 after GDB forks the inferior. It must use only local variables,
4586 because it may be sharing data space with its parent. */
4591 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4592 perror_with_name ("procfs: create_procinfo failed in child.");
4594 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4596 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4597 gdb_flush (gdb_stderr
);
4598 /* no need to call "dead_procinfo", because we're going to exit. */
4602 #ifdef PRFS_STOPEXEC /* defined on OSF */
4603 /* OSF method for tracing exec syscalls. Quoting:
4604 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4605 exits from exec system calls because of the user level loader. */
4606 /* FIXME: make nice and maybe move into an access function. */
4610 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4612 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4613 gdb_flush (gdb_stderr
);
4616 prfs_flags
|= PRFS_STOPEXEC
;
4618 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4620 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4621 gdb_flush (gdb_stderr
);
4625 #else /* not PRFS_STOPEXEC */
4626 /* Everyone else's (except OSF) method for tracing exec syscalls */
4628 Not all systems with /proc have all the exec* syscalls with the same
4629 names. On the SGI, for example, there is no SYS_exec, but there
4630 *is* a SYS_execv. So, we try to account for that. */
4632 premptyset (&exitset
);
4634 praddset (&exitset
, SYS_exec
);
4637 praddset (&exitset
, SYS_execve
);
4640 praddset (&exitset
, SYS_execv
);
4643 if (!proc_set_traced_sysexit (pi
, &exitset
))
4645 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4646 gdb_flush (gdb_stderr
);
4649 #endif /* PRFS_STOPEXEC */
4651 /* FIXME: should this be done in the parent instead? */
4652 /* Turn off inherit on fork flag so that all grand-children
4653 of gdb start with tracing flags cleared. */
4654 if (!proc_unset_inherit_on_fork (pi
))
4655 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4657 /* Turn off run on last close flag, so that the child process
4658 cannot run away just because we close our handle on it.
4659 We want it to wait for the parent to attach. */
4660 if (!proc_unset_run_on_last_close (pi
))
4661 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4663 /* FIXME: No need to destroy the procinfo --
4664 we have our own address space, and we're about to do an exec! */
4665 /*destroy_procinfo (pi);*/
4669 * Function: create_inferior
4671 * This function is called BEFORE gdb forks the inferior process.
4672 * Its only real responsibility is to set things up for the fork,
4673 * and tell GDB which two functions to call after the fork (one
4674 * for the parent, and one for the child).
4676 * This function does a complicated search for a unix shell program,
4677 * which it then uses to parse arguments and environment variables
4678 * to be sent to the child. I wonder whether this code could not
4679 * be abstracted out and shared with other unix targets such as
4684 procfs_create_inferior (exec_file
, allargs
, env
)
4689 char *shell_file
= getenv ("SHELL");
4691 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4694 /* We will be looking down the PATH to find shell_file. If we
4695 just do this the normal way (via execlp, which operates by
4696 attempting an exec for each element of the PATH until it
4697 finds one which succeeds), then there will be an exec for
4698 each failed attempt, each of which will cause a PR_SYSEXIT
4699 stop, and we won't know how to distinguish the PR_SYSEXIT's
4700 for these failed execs with the ones for successful execs
4701 (whether the exec has succeeded is stored at that time in the
4702 carry bit or some such architecture-specific and
4703 non-ABI-specified place).
4705 So I can't think of anything better than to search the PATH
4706 now. This has several disadvantages: (1) There is a race
4707 condition; if we find a file now and it is deleted before we
4708 exec it, we lose, even if the deletion leaves a valid file
4709 further down in the PATH, (2) there is no way to know exactly
4710 what an executable (in the sense of "capable of being
4711 exec'd") file is. Using access() loses because it may lose
4712 if the caller is the superuser; failing to use it loses if
4713 there are ACLs or some such. */
4717 /* FIXME-maybe: might want "set path" command so user can change what
4718 path is used from within GDB. */
4719 char *path
= getenv ("PATH");
4721 struct stat statbuf
;
4724 path
= "/bin:/usr/bin";
4726 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4727 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4729 p1
= strchr (p
, ':');
4734 strncpy (tryname
, p
, len
);
4735 tryname
[len
] = '\0';
4736 strcat (tryname
, "/");
4737 strcat (tryname
, shell_file
);
4738 if (access (tryname
, X_OK
) < 0)
4740 if (stat (tryname
, &statbuf
) < 0)
4742 if (!S_ISREG (statbuf
.st_mode
))
4743 /* We certainly need to reject directories. I'm not quite
4744 as sure about FIFOs, sockets, etc., but I kind of doubt
4745 that people want to exec() these things. */
4750 /* Not found. This must be an error rather than merely passing
4751 the file to execlp(), because execlp() would try all the
4752 exec()s, causing GDB to get confused. */
4753 error ("procfs:%d -- Can't find shell %s in PATH",
4754 __LINE__
, shell_file
);
4756 shell_file
= tryname
;
4759 fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4760 procfs_init_inferior
, NULL
, shell_file
);
4762 /* We are at the first instruction we care about. */
4763 /* Pedal to the metal... */
4765 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
4769 * Function: notice_thread
4771 * Callback for find_new_threads.
4772 * Calls "add_thread".
4776 procfs_notice_thread (pi
, thread
, ptr
)
4781 int gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4783 if (!in_thread_list (gdb_threadid
))
4784 add_thread (gdb_threadid
);
4790 * Function: target_find_new_threads
4792 * Query all the threads that the target knows about,
4793 * and give them back to GDB to add to its list.
4797 procfs_find_new_threads ()
4801 /* Find procinfo for main process */
4802 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
4803 proc_update_threads (pi
);
4804 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4808 * Function: target_thread_alive
4810 * Return true if the thread is still 'alive'.
4812 * This guy doesn't really seem to be doing his job.
4813 * Got to investigate how to tell when a thread is really gone.
4817 procfs_thread_alive (pid
)
4823 proc
= PIDGET (pid
);
4824 thread
= TIDGET (pid
);
4825 /* If I don't know it, it ain't alive! */
4826 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4829 /* If I can't get its status, it ain't alive!
4830 What's more, I need to forget about it! */
4831 if (!proc_get_status (pi
))
4833 destroy_procinfo (pi
);
4836 /* I couldn't have got its status if it weren't alive, so it's alive. */
4841 * Function: target_pid_to_str
4843 * Return a string to be used to identify the thread in
4844 * the "info threads" display.
4848 procfs_pid_to_str (pid
)
4851 static char buf
[80];
4855 proc
= PIDGET (pid
);
4856 thread
= TIDGET (pid
);
4857 pi
= find_procinfo (proc
, thread
);
4860 sprintf (buf
, "Process %d", proc
);
4862 sprintf (buf
, "LWP %d", thread
);
4867 * Function: procfs_set_watchpoint
4868 * Insert a watchpoint
4872 procfs_set_watchpoint (pid
, addr
, len
, rwflag
, after
)
4883 pi
= find_procinfo_or_die (pid
== -1 ?
4884 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4886 /* Translate from GDB's flags to /proc's */
4887 if (len
> 0) /* len == 0 means delete watchpoint */
4889 switch (rwflag
) { /* FIXME: need an enum! */
4890 case hw_write
: /* default watchpoint (write) */
4891 pflags
= WRITE_WATCHFLAG
;
4893 case hw_read
: /* read watchpoint */
4894 pflags
= READ_WATCHFLAG
;
4896 case hw_access
: /* access watchpoint */
4897 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
4899 case hw_execute
: /* execution HW breakpoint */
4900 pflags
= EXEC_WATCHFLAG
;
4902 default: /* Something weird. Return error. */
4905 if (after
) /* Stop after r/w access is completed. */
4906 pflags
|= AFTER_WATCHFLAG
;
4909 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
4911 if (errno
== E2BIG
) /* Typical error for no resources */
4912 return -1; /* fail */
4913 /* GDB may try to remove the same watchpoint twice.
4914 If a remove request returns no match, don't error. */
4915 if (errno
== ESRCH
&& len
== 0)
4916 return 0; /* ignore */
4917 proc_error (pi
, "set_watchpoint", __LINE__
);
4924 * Function: stopped_by_watchpoint
4926 * Returns non-zero if process is stopped on a hardware watchpoint fault,
4927 * else returns zero.
4931 procfs_stopped_by_watchpoint (pid
)
4936 pi
= find_procinfo_or_die (pid
== -1 ?
4937 PIDGET (inferior_pid
) : PIDGET (pid
), 0);
4938 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
4940 if (proc_why (pi
) == PR_FAULTED
)
4943 if (proc_what (pi
) == FLTWATCH
)
4947 if (proc_what (pi
) == FLTKWATCH
)
4955 #ifdef TM_I386SOL2_H
4957 * Function: procfs_find_LDT_entry
4960 * int pid; // The GDB-style pid-plus-LWP.
4963 * pointer to the corresponding LDT entry.
4967 procfs_find_LDT_entry (pid
)
4970 gdb_gregset_t
*gregs
;
4974 /* Find procinfo for the lwp. */
4975 if ((pi
= find_procinfo (PIDGET (pid
), TIDGET (pid
))) == NULL
)
4977 warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
4981 /* get its general registers. */
4982 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
4984 warning ("procfs_find_LDT_entry: could not read gregs for %d.",
4988 /* Now extract the GS register's lower 16 bits. */
4989 key
= (*gregs
)[GS
] & 0xffff;
4991 /* Find the matching entry and return it. */
4992 return proc_get_LDT_entry (pi
, key
);
4994 #endif /* TM_I386SOL2_H */
4999 info_proc_cmd (args
, from_tty
)
5003 struct cleanup
*old_chain
;
5004 procinfo
*process
= NULL
;
5005 procinfo
*thread
= NULL
;
5011 old_chain
= make_cleanup (null_cleanup
, 0);
5014 if ((argv
= buildargv (args
)) == NULL
)
5017 make_cleanup_freeargv (argv
);
5019 while (argv
!= NULL
&& *argv
!= NULL
)
5021 if (isdigit (argv
[0][0]))
5023 pid
= strtoul (argv
[0], &tmp
, 10);
5025 tid
= strtoul (++tmp
, NULL
, 10);
5027 else if (argv
[0][0] == '/')
5029 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5038 pid
= PIDGET (inferior_pid
);
5040 error ("No current process: you must name one.");
5043 /* Have pid, will travel.
5044 First see if it's a process we're already debugging. */
5045 process
= find_procinfo (pid
, 0);
5046 if (process
== NULL
)
5048 /* No. So open a procinfo for it, but
5049 remember to close it again when finished. */
5050 process
= create_procinfo (pid
, 0);
5051 make_cleanup (do_destroy_procinfo_cleanup
, process
);
5052 if (!open_procinfo_files (process
, FD_CTL
))
5053 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5057 thread
= create_procinfo (pid
, tid
);
5061 printf_filtered ("process %d flags:\n", process
->pid
);
5062 proc_prettyprint_flags (proc_flags (process
), 1);
5063 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5064 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5065 if (proc_get_nthreads (process
) > 1)
5066 printf_filtered ("Process has %d threads.\n",
5067 proc_get_nthreads (process
));
5071 printf_filtered ("thread %d flags:\n", thread
->tid
);
5072 proc_prettyprint_flags (proc_flags (thread
), 1);
5073 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5074 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5077 do_cleanups (old_chain
);
5081 proc_trace_syscalls (args
, from_tty
, entry_or_exit
, mode
)
5091 if (inferior_pid
<= 0)
5092 error ("you must be debugging a process to use this command.");
5094 if (args
== NULL
|| args
[0] == 0)
5095 error_no_arg ("system call to trace");
5097 pi
= find_procinfo_or_die (PIDGET (inferior_pid
), 0);
5098 if (isdigit (args
[0]))
5100 syscallnum
= atoi (args
);
5101 if (entry_or_exit
== PR_SYSENTRY
)
5102 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5104 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5107 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5109 if (mode
== FLAG_SET
)
5110 praddset (sysset
, syscallnum
);
5112 prdelset (sysset
, syscallnum
);
5114 if (entry_or_exit
== PR_SYSENTRY
)
5116 if (!proc_set_traced_sysentry (pi
, sysset
))
5117 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5121 if (!proc_set_traced_sysexit (pi
, sysset
))
5122 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5128 proc_trace_sysentry_cmd (args
, from_tty
)
5132 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5136 proc_trace_sysexit_cmd (args
, from_tty
)
5140 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5144 proc_untrace_sysentry_cmd (args
, from_tty
)
5148 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5152 proc_untrace_sysexit_cmd (args
, from_tty
)
5156 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5161 _initialize_procfs ()
5164 add_target (&procfs_ops
);
5165 add_info ("proc", info_proc_cmd
,
5166 "Show /proc process information about any running process.\
5167 Default is the process being debugged.");
5168 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5169 "Give a trace of entries into the syscall.");
5170 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5171 "Give a trace of exits from the syscall.");
5172 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5173 "Cancel a trace of entries into the syscall.");
5174 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5175 "Cancel a trace of exits from the syscall.");
5178 /* =================== END, GDB "MODULE" =================== */
5182 /* miscelaneous stubs: */
5183 /* The following satisfy a few random symbols mostly created by */
5184 /* the solaris threads implementation, which I will chase down */
5188 * Return a pid for which we guarantee
5189 * we will be able to find a 'live' procinfo.
5193 procfs_first_available ()
5196 return procinfo_list
->pid
;