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 PARAMS((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) PARAMS ((procinfo *,
759 void *)), void *ptr);
761 gdb_gregset_t *proc_get_gregs (procinfo * pi);
762 gdb_fpregset_t *proc_get_fpregs (procinfo * pi);
763 sysset_t *proc_get_traced_sysexit (procinfo * pi, sysset_t * save);
764 sysset_t *proc_get_traced_sysentry (procinfo * pi, sysset_t * save);
765 fltset_t *proc_get_traced_faults (procinfo * pi, fltset_t * save);
766 sigset_t *proc_get_traced_signals (procinfo * pi, sigset_t * save);
767 sigset_t *proc_get_held_signals (procinfo * pi, sigset_t * save);
768 sigset_t *proc_get_pending_signals (procinfo * pi, sigset_t * save);
769 struct sigaction *proc_get_signal_actions (procinfo * pi,
770 struct sigaction *save);
772 void proc_warn (procinfo * pi, char *func, int line);
773 void proc_error (procinfo * pi, char *func, int line);
776 proc_warn (pi, func, line)
781 sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
782 print_sys_errmsg (errmsg, errno);
786 proc_error (pi, func, line)
791 sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
792 perror_with_name (errmsg);
796 * Function: proc_get_status
798 * Updates the status struct in the procinfo.
799 * There is a 'valid' flag, to let other functions know when
800 * this function needs to be called (so the status is only
801 * read when it is needed). The status file descriptor is
802 * also only opened when it is needed.
804 * Return: non-zero for success, zero for failure.
811 /* Status file descriptor is opened "lazily" */
812 if (pi->status_fd == 0 &&
813 open_procinfo_files (pi, FD_STATUS) == 0)
815 pi->status_valid = 0;
820 if (lseek (pi->status_fd, 0, SEEK_SET) < 0)
821 pi->status_valid = 0; /* fail */
824 /* Sigh... I have to read a different data structure,
825 depending on whether this is a main process or an LWP. */
827 pi->status_valid = (read (pi->status_fd,
828 (char *) &pi->prstatus.pr_lwp,
829 sizeof (lwpstatus_t))
830 == sizeof (lwpstatus_t));
833 pi->status_valid = (read (pi->status_fd,
834 (char *) &pi->prstatus,
835 sizeof (gdb_prstatus_t))
836 == sizeof (gdb_prstatus_t));
837 #if 0 /*def UNIXWARE*/
838 if (pi->status_valid &&
839 (pi->prstatus.pr_lwp.pr_flags & PR_ISTOP) &&
840 pi->prstatus.pr_lwp.pr_why == PR_REQUESTED)
841 /* Unixware peculiarity -- read the damn thing again! */
842 pi->status_valid = (read (pi->status_fd,
843 (char *) &pi->prstatus,
844 sizeof (gdb_prstatus_t))
845 == sizeof (gdb_prstatus_t));
846 #endif /* UNIXWARE */
849 #else /* ioctl method */
850 #ifdef PIOCTSTATUS /* osf */
851 if (pi->tid == 0) /* main process */
853 /* Just read the danged status. Now isn't that simple? */
855 (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
862 tid_t pr_error_thread;
863 struct prstatus status;
866 thread_status.pr_count = 1;
867 thread_status.status.pr_tid = pi->tid;
868 win = (ioctl (pi->status_fd, PIOCTSTATUS, &thread_status) >= 0);
871 memcpy (&pi->prstatus, &thread_status.status,
872 sizeof (pi->prstatus));
873 pi->status_valid = 1;
877 /* Just read the danged status. Now isn't that simple? */
878 pi->status_valid = (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
882 if (pi->status_valid)
884 PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
887 proc_get_current_thread (pi));
890 /* The status struct includes general regs, so mark them valid too */
891 pi->gregs_valid = pi->status_valid;
893 /* In the read/write multiple-fd model,
894 the status struct includes the fp regs too, so mark them valid too */
895 pi->fpregs_valid = pi->status_valid;
897 return pi->status_valid; /* True if success, false if failure. */
901 * Function: proc_flags
903 * returns the process flags (pr_flags field).
910 if (!pi->status_valid)
911 if (!proc_get_status (pi))
912 return 0; /* FIXME: not a good failure value (but what is?) */
916 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
917 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
918 The two sets of flags don't overlap. */
919 return pi->prstatus.pr_flags | pi->prstatus.pr_lwp.pr_flags;
921 return pi->prstatus.pr_lwp.pr_flags;
924 return pi->prstatus.pr_flags;
931 * returns the pr_why field (why the process stopped).
938 if (!pi->status_valid)
939 if (!proc_get_status (pi))
940 return 0; /* FIXME: not a good failure value (but what is?) */
943 return pi->prstatus.pr_lwp.pr_why;
945 return pi->prstatus.pr_why;
950 * Function: proc_what
952 * returns the pr_what field (details of why the process stopped).
959 if (!pi->status_valid)
960 if (!proc_get_status (pi))
961 return 0; /* FIXME: not a good failure value (but what is?) */
964 return pi->prstatus.pr_lwp.pr_what;
966 return pi->prstatus.pr_what;
970 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
972 * Function: proc_nsysarg
974 * returns the pr_nsysarg field (number of args to the current syscall).
981 if (!pi->status_valid)
982 if (!proc_get_status (pi))
986 return pi->prstatus.pr_lwp.pr_nsysarg;
988 return pi->prstatus.pr_nsysarg;
993 * Function: proc_sysargs
995 * returns the pr_sysarg field (pointer to the arguments of current syscall).
1002 if (!pi->status_valid)
1003 if (!proc_get_status (pi))
1007 return (long *) &pi->prstatus.pr_lwp.pr_sysarg;
1009 return (long *) &pi->prstatus.pr_sysarg;
1014 * Function: proc_syscall
1016 * returns the pr_syscall field (id of current syscall if we are in one).
1023 if (!pi->status_valid)
1024 if (!proc_get_status (pi))
1028 return pi->prstatus.pr_lwp.pr_syscall;
1030 return pi->prstatus.pr_syscall;
1033 #endif /* PIOCSSPCACT */
1036 * Function: proc_cursig:
1038 * returns the pr_cursig field (current signal).
1042 proc_cursig (struct procinfo *pi)
1044 if (!pi->status_valid)
1045 if (!proc_get_status (pi))
1046 return 0; /* FIXME: not a good failure value (but what is?) */
1049 return pi->prstatus.pr_lwp.pr_cursig;
1051 return pi->prstatus.pr_cursig;
1056 * Function: proc_modify_flag
1058 * === I appologize for the messiness of this function.
1059 * === This is an area where the different versions of
1060 * === /proc are more inconsistent than usual. MVS
1062 * Set or reset any of the following process flags:
1063 * PR_FORK -- forked child will inherit trace flags
1064 * PR_RLC -- traced process runs when last /proc file closed.
1065 * PR_KLC -- traced process is killed when last /proc file closed.
1066 * PR_ASYNC -- LWP's get to run/stop independently.
1068 * There are three methods for doing this function:
1069 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1071 * 2) Middle: PIOCSET/PIOCRESET
1073 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1076 * Note: Irix does not define PR_ASYNC.
1077 * Note: OSF does not define PR_KLC.
1078 * Note: OSF is the only one that can ONLY use the oldest method.
1081 * pi -- the procinfo
1082 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1083 * mode -- 1 for set, 0 for reset.
1085 * Returns non-zero for success, zero for failure.
1088 enum { FLAG_RESET, FLAG_SET };
1091 proc_modify_flag (pi, flag, mode)
1096 long win = 0; /* default to fail */
1099 * These operations affect the process as a whole, and applying
1100 * them to an individual LWP has the same meaning as applying them
1101 * to the main process. Therefore, if we're ever called with a
1102 * pointer to an LWP's procinfo, let's substitute the process's
1103 * procinfo and avoid opening the LWP's file descriptor
1108 pi = find_procinfo_or_die (pi->pid, 0);
1110 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
1111 /* First normalize the PCUNSET/PCRESET command opcode
1112 (which for no obvious reason has a different definition
1113 from one operating system to the next...) */
1115 #define GDBRESET PCUNSET
1118 #define GDBRESET PCRESET
1123 if (mode == FLAG_SET) /* Set the flag (RLC, FORK, or ASYNC) */
1125 else /* Reset the flag */
1129 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
1132 #ifdef PIOCSET /* Irix/Sol5 method */
1133 if (mode == FLAG_SET) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
1135 win = (ioctl (pi->ctl_fd, PIOCSET, &flag) >= 0);
1137 else /* Reset the flag */
1139 win = (ioctl (pi->ctl_fd, PIOCRESET, &flag) >= 0);
1143 #ifdef PIOCSRLC /* Oldest method: OSF */
1146 if (mode == FLAG_SET) /* Set run-on-last-close */
1148 win = (ioctl (pi->ctl_fd, PIOCSRLC, NULL) >= 0);
1150 else /* Clear run-on-last-close */
1152 win = (ioctl (pi->ctl_fd, PIOCRRLC, NULL) >= 0);
1156 if (mode == FLAG_SET) /* Set inherit-on-fork */
1158 win = (ioctl (pi->ctl_fd, PIOCSFORK, NULL) >= 0);
1160 else /* Clear inherit-on-fork */
1162 win = (ioctl (pi->ctl_fd, PIOCRFORK, NULL) >= 0);
1166 win = 0; /* fail -- unknown flag (can't do PR_ASYNC) */
1173 /* The above operation renders the procinfo's cached pstatus obsolete. */
1174 pi->status_valid = 0;
1177 warning ("procfs: modify_flag failed to turn %s %s",
1178 flag == PR_FORK ? "PR_FORK" :
1179 flag == PR_RLC ? "PR_RLC" :
1181 flag == PR_ASYNC ? "PR_ASYNC" :
1184 flag == PR_KLC ? "PR_KLC" :
1187 mode == FLAG_RESET ? "off" : "on");
1193 * Function: proc_set_run_on_last_close
1195 * Set the run_on_last_close flag.
1196 * Process with all threads will become runnable
1197 * when debugger closes all /proc fds.
1199 * Returns non-zero for success, zero for failure.
1203 proc_set_run_on_last_close (pi)
1206 return proc_modify_flag (pi, PR_RLC, FLAG_SET);
1210 * Function: proc_unset_run_on_last_close
1212 * Reset the run_on_last_close flag.
1213 * Process will NOT become runnable
1214 * when debugger closes its file handles.
1216 * Returns non-zero for success, zero for failure.
1220 proc_unset_run_on_last_close (pi)
1223 return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
1228 * Function: proc_set_kill_on_last_close
1230 * Set the kill_on_last_close flag.
1231 * Process with all threads will be killed when debugger
1232 * closes all /proc fds (or debugger exits or dies).
1234 * Returns non-zero for success, zero for failure.
1238 proc_set_kill_on_last_close (pi)
1241 return proc_modify_flag (pi, PR_KLC, FLAG_SET);
1245 * Function: proc_unset_kill_on_last_close
1247 * Reset the kill_on_last_close flag.
1248 * Process will NOT be killed when debugger
1249 * closes its file handles (or exits or dies).
1251 * Returns non-zero for success, zero for failure.
1255 proc_unset_kill_on_last_close (pi)
1258 return proc_modify_flag (pi, PR_KLC, FLAG_RESET);
1263 * Function: proc_set_inherit_on_fork
1265 * Set inherit_on_fork flag.
1266 * If the process forks a child while we are registered for events
1267 * in the parent, then we will also recieve events from the child.
1269 * Returns non-zero for success, zero for failure.
1273 proc_set_inherit_on_fork (pi)
1276 return proc_modify_flag (pi, PR_FORK, FLAG_SET);
1280 * Function: proc_unset_inherit_on_fork
1282 * Reset inherit_on_fork flag.
1283 * If the process forks a child while we are registered for events
1284 * in the parent, then we will NOT recieve events from the child.
1286 * Returns non-zero for success, zero for failure.
1290 proc_unset_inherit_on_fork (pi)
1293 return proc_modify_flag (pi, PR_FORK, FLAG_RESET);
1298 * Function: proc_set_async
1300 * Set PR_ASYNC flag.
1301 * If one LWP stops because of a debug event (signal etc.),
1302 * the remaining LWPs will continue to run.
1304 * Returns non-zero for success, zero for failure.
1311 return proc_modify_flag (pi, PR_ASYNC, FLAG_SET);
1315 * Function: proc_unset_async
1317 * Reset PR_ASYNC flag.
1318 * If one LWP stops because of a debug event (signal etc.),
1319 * then all other LWPs will stop as well.
1321 * Returns non-zero for success, zero for failure.
1325 proc_unset_async (pi)
1328 return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET);
1330 #endif /* PR_ASYNC */
1333 * Function: proc_stop_process
1335 * Request the process/LWP to stop. Does not wait.
1336 * Returns non-zero for success, zero for failure.
1340 proc_stop_process (pi)
1346 * We might conceivably apply this operation to an LWP, and
1347 * the LWP's ctl file descriptor might not be open.
1350 if (pi->ctl_fd == 0 &&
1351 open_procinfo_files (pi, FD_CTL) == 0)
1357 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1358 #else /* ioctl method */
1359 win = (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) >= 0);
1360 /* Note: the call also reads the prstatus. */
1363 pi->status_valid = 1;
1364 PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
1367 proc_get_current_thread (pi));
1376 * Function: proc_wait_for_stop
1378 * Wait for the process or LWP to stop (block until it does).
1379 * Returns non-zero for success, zero for failure.
1383 proc_wait_for_stop (pi)
1389 * We should never have to apply this operation to any procinfo
1390 * except the one for the main process. If that ever changes
1391 * for any reason, then take out the following clause and
1392 * replace it with one that makes sure the ctl_fd is open.
1396 pi = find_procinfo_or_die (pi->pid, 0);
1401 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1402 /* We been runnin' and we stopped -- need to update status. */
1403 pi->status_valid = 0;
1405 #else /* ioctl method */
1406 win = (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) >= 0);
1407 /* Above call also refreshes the prstatus. */
1410 pi->status_valid = 1;
1411 PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
1414 proc_get_current_thread (pi));
1422 * Function: proc_run_process
1424 * Make the process or LWP runnable.
1425 * Options (not all are implemented):
1427 * - clear current fault
1428 * - clear current signal
1429 * - abort the current system call
1430 * - stop as soon as finished with system call
1431 * - (ioctl): set traced signal set
1432 * - (ioctl): set held signal set
1433 * - (ioctl): set traced fault set
1434 * - (ioctl): set start pc (vaddr)
1435 * Always clear the current fault.
1436 * Clear the current signal if 'signo' is zero.
1439 * pi the process or LWP to operate on.
1440 * step if true, set the process or LWP to trap after one instr.
1441 * signo if zero, clear the current signal if any.
1442 * if non-zero, set the current signal to this one.
1444 * Returns non-zero for success, zero for failure.
1448 proc_run_process (pi, step, signo)
1457 * We will probably have to apply this operation to individual threads,
1458 * so make sure the control file descriptor is open.
1461 if (pi->ctl_fd == 0 &&
1462 open_procinfo_files (pi, FD_CTL) == 0)
1467 runflags = PRCFAULT; /* always clear current fault */
1472 else if (signo != -1) /* -1 means do nothing W.R.T. signals */
1473 proc_set_current_signal (pi, signo);
1481 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1483 #else /* ioctl method */
1487 memset (&prrun, 0, sizeof (prrun));
1488 prrun.pr_flags = runflags;
1489 win = (ioctl (pi->ctl_fd, PIOCRUN, &prrun) >= 0);
1497 * Function: proc_set_traced_signals
1499 * Register to trace signals in the process or LWP.
1500 * Returns non-zero for success, zero for failure.
1504 proc_set_traced_signals (pi, sigset)
1511 * We should never have to apply this operation to any procinfo
1512 * except the one for the main process. If that ever changes
1513 * for any reason, then take out the following clause and
1514 * replace it with one that makes sure the ctl_fd is open.
1518 pi = find_procinfo_or_die (pi->pid, 0);
1524 /* Use char array to avoid alignment issues. */
1525 char sigset[sizeof (sigset_t)];
1529 memcpy (&arg.sigset, sigset, sizeof (sigset_t));
1531 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
1533 #else /* ioctl method */
1534 win = (ioctl (pi->ctl_fd, PIOCSTRACE, sigset) >= 0);
1536 /* The above operation renders the procinfo's cached pstatus obsolete. */
1537 pi->status_valid = 0;
1540 warning ("procfs: set_traced_signals failed");
1545 * Function: proc_set_traced_faults
1547 * Register to trace hardware faults in the process or LWP.
1548 * Returns non-zero for success, zero for failure.
1552 proc_set_traced_faults (pi, fltset)
1559 * We should never have to apply this operation to any procinfo
1560 * except the one for the main process. If that ever changes
1561 * for any reason, then take out the following clause and
1562 * replace it with one that makes sure the ctl_fd is open.
1566 pi = find_procinfo_or_die (pi->pid, 0);
1572 /* Use char array to avoid alignment issues. */
1573 char fltset[sizeof (fltset_t)];
1577 memcpy (&arg.fltset, fltset, sizeof (fltset_t));
1579 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
1581 #else /* ioctl method */
1582 win = (ioctl (pi->ctl_fd, PIOCSFAULT, fltset) >= 0);
1584 /* The above operation renders the procinfo's cached pstatus obsolete. */
1585 pi->status_valid = 0;
1591 * Function: proc_set_traced_sysentry
1593 * Register to trace entry to system calls in the process or LWP.
1594 * Returns non-zero for success, zero for failure.
1598 proc_set_traced_sysentry (pi, sysset)
1605 * We should never have to apply this operation to any procinfo
1606 * except the one for the main process. If that ever changes
1607 * for any reason, then take out the following clause and
1608 * replace it with one that makes sure the ctl_fd is open.
1612 pi = find_procinfo_or_die (pi->pid, 0);
1618 /* Use char array to avoid alignment issues. */
1619 char sysset[sizeof (sysset_t)];
1623 memcpy (&arg.sysset, sysset, sizeof (sysset_t));
1625 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
1627 #else /* ioctl method */
1628 win = (ioctl (pi->ctl_fd, PIOCSENTRY, sysset) >= 0);
1630 /* The above operation renders the procinfo's cached pstatus obsolete. */
1631 pi->status_valid = 0;
1637 * Function: proc_set_traced_sysexit
1639 * Register to trace exit from system calls in the process or LWP.
1640 * Returns non-zero for success, zero for failure.
1644 proc_set_traced_sysexit (pi, sysset)
1651 * We should never have to apply this operation to any procinfo
1652 * except the one for the main process. If that ever changes
1653 * for any reason, then take out the following clause and
1654 * replace it with one that makes sure the ctl_fd is open.
1658 pi = find_procinfo_or_die (pi->pid, 0);
1664 /* Use char array to avoid alignment issues. */
1665 char sysset[sizeof (sysset_t)];
1669 memcpy (&arg.sysset, sysset, sizeof (sysset_t));
1671 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
1673 #else /* ioctl method */
1674 win = (ioctl (pi->ctl_fd, PIOCSEXIT, sysset) >= 0);
1676 /* The above operation renders the procinfo's cached pstatus obsolete. */
1677 pi->status_valid = 0;
1683 * Function: proc_set_held_signals
1685 * Specify the set of blocked / held signals in the process or LWP.
1686 * Returns non-zero for success, zero for failure.
1690 proc_set_held_signals (pi, sighold)
1697 * We should never have to apply this operation to any procinfo
1698 * except the one for the main process. If that ever changes
1699 * for any reason, then take out the following clause and
1700 * replace it with one that makes sure the ctl_fd is open.
1704 pi = find_procinfo_or_die (pi->pid, 0);
1710 /* Use char array to avoid alignment issues. */
1711 char hold[sizeof (sigset_t)];
1715 memcpy (&arg.hold, sighold, sizeof (sigset_t));
1716 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
1719 win = (ioctl (pi->ctl_fd, PIOCSHOLD, sighold) >= 0);
1721 /* The above operation renders the procinfo's cached pstatus obsolete. */
1722 pi->status_valid = 0;
1728 * Function: proc_get_pending_signals
1730 * returns the set of signals that are pending in the process or LWP.
1731 * Will also copy the sigset if 'save' is non-zero.
1735 proc_get_pending_signals (pi, save)
1739 sigset_t *ret = NULL;
1742 * We should never have to apply this operation to any procinfo
1743 * except the one for the main process. If that ever changes
1744 * for any reason, then take out the following clause and
1745 * replace it with one that makes sure the ctl_fd is open.
1749 pi = find_procinfo_or_die (pi->pid, 0);
1751 if (!pi->status_valid)
1752 if (!proc_get_status (pi))
1756 ret = &pi->prstatus.pr_lwp.pr_lwppend;
1758 ret = &pi->prstatus.pr_sigpend;
1761 memcpy (save, ret, sizeof (sigset_t));
1767 * Function: proc_get_signal_actions
1769 * returns the set of signal actions.
1770 * Will also copy the sigactionset if 'save' is non-zero.
1774 proc_get_signal_actions (pi, save)
1776 struct sigaction *save;
1778 struct sigaction *ret = NULL;
1781 * We should never have to apply this operation to any procinfo
1782 * except the one for the main process. If that ever changes
1783 * for any reason, then take out the following clause and
1784 * replace it with one that makes sure the ctl_fd is open.
1788 pi = find_procinfo_or_die (pi->pid, 0);
1790 if (!pi->status_valid)
1791 if (!proc_get_status (pi))
1795 ret = &pi->prstatus.pr_lwp.pr_action;
1797 ret = &pi->prstatus.pr_action;
1800 memcpy (save, ret, sizeof (struct sigaction));
1806 * Function: proc_get_held_signals
1808 * returns the set of signals that are held / blocked.
1809 * Will also copy the sigset if 'save' is non-zero.
1813 proc_get_held_signals (pi, save)
1817 sigset_t *ret = NULL;
1820 * We should never have to apply this operation to any procinfo
1821 * except the one for the main process. If that ever changes
1822 * for any reason, then take out the following clause and
1823 * replace it with one that makes sure the ctl_fd is open.
1827 pi = find_procinfo_or_die (pi->pid, 0);
1830 if (!pi->status_valid)
1831 if (!proc_get_status (pi))
1835 ret = &pi->prstatus.pr_lwp.pr_context.uc_sigmask;
1837 ret = &pi->prstatus.pr_lwp.pr_lwphold;
1838 #endif /* UNIXWARE */
1839 #else /* not NEW_PROC_API */
1841 static sigset_t sigheld;
1843 if (ioctl (pi->ctl_fd, PIOCGHOLD, &sigheld) >= 0)
1846 #endif /* NEW_PROC_API */
1848 memcpy (save, ret, sizeof (sigset_t));
1854 * Function: proc_get_traced_signals
1856 * returns the set of signals that are traced / debugged.
1857 * Will also copy the sigset if 'save' is non-zero.
1861 proc_get_traced_signals (pi, save)
1865 sigset_t *ret = NULL;
1868 * We should never have to apply this operation to any procinfo
1869 * except the one for the main process. If that ever changes
1870 * for any reason, then take out the following clause and
1871 * replace it with one that makes sure the ctl_fd is open.
1875 pi = find_procinfo_or_die (pi->pid, 0);
1878 if (!pi->status_valid)
1879 if (!proc_get_status (pi))
1882 ret = &pi->prstatus.pr_sigtrace;
1885 static sigset_t sigtrace;
1887 if (ioctl (pi->ctl_fd, PIOCGTRACE, &sigtrace) >= 0)
1892 memcpy (save, ret, sizeof (sigset_t));
1898 * Function: proc_trace_signal
1900 * Add 'signo' to the set of signals that are traced.
1901 * Returns non-zero for success, zero for failure.
1905 proc_trace_signal (pi, signo)
1912 * We should never have to apply this operation to any procinfo
1913 * except the one for the main process. If that ever changes
1914 * for any reason, then take out the following clause and
1915 * replace it with one that makes sure the ctl_fd is open.
1919 pi = find_procinfo_or_die (pi->pid, 0);
1923 if (proc_get_traced_signals (pi, &temp))
1925 praddset (&temp, signo);
1926 return proc_set_traced_signals (pi, &temp);
1930 return 0; /* failure */
1934 * Function: proc_ignore_signal
1936 * Remove 'signo' from the set of signals that are traced.
1937 * Returns non-zero for success, zero for failure.
1941 proc_ignore_signal (pi, signo)
1948 * We should never have to apply this operation to any procinfo
1949 * except the one for the main process. If that ever changes
1950 * for any reason, then take out the following clause and
1951 * replace it with one that makes sure the ctl_fd is open.
1955 pi = find_procinfo_or_die (pi->pid, 0);
1959 if (proc_get_traced_signals (pi, &temp))
1961 prdelset (&temp, signo);
1962 return proc_set_traced_signals (pi, &temp);
1966 return 0; /* failure */
1970 * Function: proc_get_traced_faults
1972 * returns the set of hardware faults that are traced /debugged.
1973 * Will also copy the faultset if 'save' is non-zero.
1977 proc_get_traced_faults (pi, save)
1981 fltset_t *ret = NULL;
1984 * We should never have to apply this operation to any procinfo
1985 * except the one for the main process. If that ever changes
1986 * for any reason, then take out the following clause and
1987 * replace it with one that makes sure the ctl_fd is open.
1991 pi = find_procinfo_or_die (pi->pid, 0);
1994 if (!pi->status_valid)
1995 if (!proc_get_status (pi))
1998 ret = &pi->prstatus.pr_flttrace;
2001 static fltset_t flttrace;
2003 if (ioctl (pi->ctl_fd, PIOCGFAULT, &flttrace) >= 0)
2008 memcpy (save, ret, sizeof (fltset_t));
2014 * Function: proc_get_traced_sysentry
2016 * returns the set of syscalls that are traced /debugged on entry.
2017 * Will also copy the syscall set if 'save' is non-zero.
2021 proc_get_traced_sysentry (pi, save)
2025 sysset_t *ret = NULL;
2028 * We should never have to apply this operation to any procinfo
2029 * except the one for the main process. If that ever changes
2030 * for any reason, then take out the following clause and
2031 * replace it with one that makes sure the ctl_fd is open.
2035 pi = find_procinfo_or_die (pi->pid, 0);
2038 if (!pi->status_valid)
2039 if (!proc_get_status (pi))
2042 ret = &pi->prstatus.pr_sysentry;
2045 static sysset_t sysentry;
2047 if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysentry) >= 0)
2052 memcpy (save, ret, sizeof (sysset_t));
2058 * Function: proc_get_traced_sysexit
2060 * returns the set of syscalls that are traced /debugged on exit.
2061 * Will also copy the syscall set if 'save' is non-zero.
2065 proc_get_traced_sysexit (pi, save)
2069 sysset_t * ret = NULL;
2072 * We should never have to apply this operation to any procinfo
2073 * except the one for the main process. If that ever changes
2074 * for any reason, then take out the following clause and
2075 * replace it with one that makes sure the ctl_fd is open.
2079 pi = find_procinfo_or_die (pi->pid, 0);
2082 if (!pi->status_valid)
2083 if (!proc_get_status (pi))
2086 ret = &pi->prstatus.pr_sysexit;
2089 static sysset_t sysexit;
2091 if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysexit) >= 0)
2096 memcpy (save, ret, sizeof (sysset_t));
2102 * Function: proc_clear_current_fault
2104 * The current fault (if any) is cleared; the associated signal
2105 * will not be sent to the process or LWP when it resumes.
2106 * Returns non-zero for success, zero for failure.
2110 proc_clear_current_fault (pi)
2116 * We should never have to apply this operation to any procinfo
2117 * except the one for the main process. If that ever changes
2118 * for any reason, then take out the following clause and
2119 * replace it with one that makes sure the ctl_fd is open.
2123 pi = find_procinfo_or_die (pi->pid, 0);
2127 long cmd = PCCFAULT;
2128 win = (write (pi->ctl_fd, (void *) &cmd, sizeof (cmd)) == sizeof (cmd));
2131 win = (ioctl (pi->ctl_fd, PIOCCFAULT, 0) >= 0);
2138 * Function: proc_set_current_signal
2140 * Set the "current signal" that will be delivered next to the process.
2141 * NOTE: semantics are different from those of KILL.
2142 * This signal will be delivered to the process or LWP
2143 * immediately when it is resumed (even if the signal is held/blocked);
2144 * it will NOT immediately cause another event of interest, and will NOT
2145 * first trap back to the debugger.
2147 * Returns non-zero for success, zero for failure.
2151 proc_set_current_signal (pi, signo)
2158 /* Use char array to avoid alignment issues. */
2159 char sinfo[sizeof (struct siginfo)];
2161 struct siginfo *mysinfo;
2164 * We should never have to apply this operation to any procinfo
2165 * except the one for the main process. If that ever changes
2166 * for any reason, then take out the following clause and
2167 * replace it with one that makes sure the ctl_fd is open.
2171 pi = find_procinfo_or_die (pi->pid, 0);
2173 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2174 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2175 * receives a PIOCSSIG with a signal identical to the current signal,
2176 * it messes up the current signal. Work around the kernel bug.
2179 signo == proc_cursig (pi))
2180 return 1; /* I assume this is a success? */
2183 /* The pointer is just a type alias. */
2184 mysinfo = (struct siginfo *) &arg.sinfo;
2185 mysinfo->si_signo = signo;
2186 mysinfo->si_code = 0;
2187 mysinfo->si_pid = getpid (); /* ?why? */
2188 mysinfo->si_uid = getuid (); /* ?why? */
2192 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2194 win = (ioctl (pi->ctl_fd, PIOCSSIG, (void *) &arg.sinfo) >= 0);
2201 * Function: proc_clear_current_signal
2203 * The current signal (if any) is cleared, and
2204 * is not sent to the process or LWP when it resumes.
2205 * Returns non-zero for success, zero for failure.
2209 proc_clear_current_signal (pi)
2215 * We should never have to apply this operation to any procinfo
2216 * except the one for the main process. If that ever changes
2217 * for any reason, then take out the following clause and
2218 * replace it with one that makes sure the ctl_fd is open.
2222 pi = find_procinfo_or_die (pi->pid, 0);
2228 /* Use char array to avoid alignment issues. */
2229 char sinfo[sizeof (struct siginfo)];
2231 struct siginfo *mysinfo;
2234 /* The pointer is just a type alias. */
2235 mysinfo = (struct siginfo *) &arg.sinfo;
2236 mysinfo->si_signo = 0;
2237 mysinfo->si_code = 0;
2238 mysinfo->si_errno = 0;
2239 mysinfo->si_pid = getpid (); /* ?why? */
2240 mysinfo->si_uid = getuid (); /* ?why? */
2242 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2245 win = (ioctl (pi->ctl_fd, PIOCSSIG, 0) >= 0);
2252 * Function: proc_get_gregs
2254 * Get the general registers for the process or LWP.
2255 * Returns non-zero for success, zero for failure.
2262 if (!pi->status_valid || !pi->gregs_valid)
2263 if (!proc_get_status (pi))
2267 * OK, sorry about the ifdef's.
2268 * There's three cases instead of two, because
2269 * in this instance Unixware and Solaris/RW differ.
2273 #ifdef UNIXWARE /* ugh, a true architecture dependency */
2274 return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs;
2275 #else /* not Unixware */
2276 return &pi->prstatus.pr_lwp.pr_reg;
2277 #endif /* Unixware */
2278 #else /* not NEW_PROC_API */
2279 return &pi->prstatus.pr_reg;
2280 #endif /* NEW_PROC_API */
2284 * Function: proc_get_fpregs
2286 * Get the floating point registers for the process or LWP.
2287 * Returns non-zero for success, zero for failure.
2291 proc_get_fpregs (pi)
2295 if (!pi->status_valid || !pi->fpregs_valid)
2296 if (!proc_get_status (pi))
2299 #ifdef UNIXWARE /* a true architecture dependency */
2300 return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs;
2302 return &pi->prstatus.pr_lwp.pr_fpreg;
2303 #endif /* Unixware */
2305 #else /* not NEW_PROC_API */
2306 if (pi->fpregs_valid)
2307 return &pi->fpregset; /* already got 'em */
2310 if (pi->ctl_fd == 0 &&
2311 open_procinfo_files (pi, FD_CTL) == 0)
2320 tid_t pr_error_thread;
2321 tfpregset_t thread_1;
2324 thread_fpregs.pr_count = 1;
2325 thread_fpregs.thread_1.tid = pi->tid;
2328 ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
2330 pi->fpregs_valid = 1;
2331 return &pi->fpregset; /* got 'em now! */
2333 else if (pi->tid != 0 &&
2334 ioctl (pi->ctl_fd, PIOCTGFPREG, &thread_fpregs) >= 0)
2336 memcpy (&pi->fpregset, &thread_fpregs.thread_1.pr_fpregs,
2337 sizeof (pi->fpregset));
2338 pi->fpregs_valid = 1;
2339 return &pi->fpregset; /* got 'em now! */
2346 if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
2348 pi->fpregs_valid = 1;
2349 return &pi->fpregset; /* got 'em now! */
2362 * Function: proc_set_gregs
2364 * Write the general registers back to the process or LWP.
2365 * Returns non-zero for success, zero for failure.
2372 gdb_gregset_t *gregs;
2375 if ((gregs = proc_get_gregs (pi)) == NULL)
2376 return 0; /* get_regs has already warned */
2378 if (pi->ctl_fd == 0 &&
2379 open_procinfo_files (pi, FD_CTL) == 0)
2388 /* Use char array to avoid alignment issues. */
2389 char gregs[sizeof (gdb_gregset_t)];
2393 memcpy (&arg.gregs, gregs, sizeof (arg.gregs));
2394 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2396 win = (ioctl (pi->ctl_fd, PIOCSREG, gregs) >= 0);
2400 /* Policy: writing the regs invalidates our cache. */
2401 pi->gregs_valid = 0;
2406 * Function: proc_set_fpregs
2408 * Modify the floating point register set of the process or LWP.
2409 * Returns non-zero for success, zero for failure.
2413 proc_set_fpregs (pi)
2416 gdb_fpregset_t *fpregs;
2419 if ((fpregs = proc_get_fpregs (pi)) == NULL)
2420 return 0; /* get_fpregs has already warned */
2422 if (pi->ctl_fd == 0 &&
2423 open_procinfo_files (pi, FD_CTL) == 0)
2432 /* Use char array to avoid alignment issues. */
2433 char fpregs[sizeof (gdb_fpregset_t)];
2437 memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs));
2438 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2442 win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
2447 tid_t pr_error_thread;
2448 tfpregset_t thread_1;
2451 thread_fpregs.pr_count = 1;
2452 thread_fpregs.thread_1.tid = pi->tid;
2453 memcpy (&thread_fpregs.thread_1.pr_fpregs, fpregs,
2455 win = (ioctl (pi->ctl_fd, PIOCTSFPREG, &thread_fpregs) >= 0);
2458 win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
2459 #endif /* osf PIOCTSFPREG */
2460 #endif /* NEW_PROC_API */
2463 /* Policy: writing the regs invalidates our cache. */
2464 pi->fpregs_valid = 0;
2469 * Function: proc_kill
2471 * Send a signal to the proc or lwp with the semantics of "kill()".
2472 * Returns non-zero for success, zero for failure.
2476 proc_kill (pi, signo)
2483 * We might conceivably apply this operation to an LWP, and
2484 * the LWP's ctl file descriptor might not be open.
2487 if (pi->ctl_fd == 0 &&
2488 open_procinfo_files (pi, FD_CTL) == 0)
2499 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
2500 #else /* ioctl method */
2501 /* FIXME: do I need the Alpha OSF fixups present in
2502 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2503 win = (ioctl (pi->ctl_fd, PIOCKILL, &signo) >= 0);
2511 * Function: proc_parent_pid
2513 * Find the pid of the process that started this one.
2514 * Returns the parent process pid, or zero.
2518 proc_parent_pid (pi)
2522 * We should never have to apply this operation to any procinfo
2523 * except the one for the main process. If that ever changes
2524 * for any reason, then take out the following clause and
2525 * replace it with one that makes sure the ctl_fd is open.
2529 pi = find_procinfo_or_die (pi->pid, 0);
2531 if (!pi->status_valid)
2532 if (!proc_get_status (pi))
2535 return pi->prstatus.pr_ppid;
2540 * Function: proc_set_watchpoint
2545 proc_set_watchpoint (pi, addr, len, wflags)
2551 #if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
2554 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
2555 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
2560 char watch[sizeof (prwatch_t)];
2564 pwatch = (prwatch_t *) &arg.watch;
2565 pwatch->pr_vaddr = address_to_host_pointer (addr);
2566 pwatch->pr_size = len;
2567 pwatch->pr_wflags = wflags;
2568 #if defined(NEW_PROC_API) && defined (PCWATCH)
2570 return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg));
2572 #if defined (PIOCSWATCH)
2573 return (ioctl (pi->ctl_fd, PIOCSWATCH, pwatch) >= 0);
2575 return 0; /* Fail */
2583 * Function: proc_iterate_over_mappings
2585 * Given a pointer to a function, call that function once for every
2586 * mapped address space in the process. The callback function
2587 * receives an open file descriptor for the file corresponding to
2588 * that mapped address space (if there is one), and the base address
2589 * of the mapped space. Quit when the callback function returns a
2590 * nonzero value, or at teh end of the mappings.
2592 * Returns: the first non-zero return value of the callback function,
2596 /* FIXME: it's probably a waste to cache this FD.
2597 It doesn't get called that often... and if I open it
2598 every time, I don't need to lseek it. */
2600 proc_iterate_over_mappings (func)
2601 int (*func) (int, CORE_ADDR);
2605 #ifndef NEW_PROC_API /* avoid compiler warning */
2610 char pathname[MAX_PROC_NAME_SIZE];
2615 pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
2619 sprintf (pathname, "/proc/%d/map", pi->pid);
2620 if ((map_fd = open (pathname, O_RDONLY)) < 0)
2621 proc_error (pi, "proc_iterate_over_mappings (open)", __LINE__);
2623 /* Make sure it gets closed again. */
2624 make_cleanup_close (map_fd);
2626 /* Allocate space for mapping (lifetime only for this function). */
2627 map = alloca (sizeof (struct prmap));
2629 /* Now read the mappings from the file,
2630 open a file descriptor for those that have a name,
2631 and call the callback function. */
2632 while (read (map_fd,
2634 sizeof (struct prmap)) == sizeof (struct prmap))
2636 char name[MAX_PROC_NAME_SIZE + sizeof (map->pr_mapname)];
2638 if (map->pr_vaddr == 0 && map->pr_size == 0)
2641 if (map->pr_mapname[0] == 0)
2643 fd = -1; /* no map file */
2647 sprintf (name, "/proc/%d/object/%s", pi->pid, map->pr_mapname);
2648 /* Note: caller's responsibility to close this fd! */
2649 fd = open (name, O_RDONLY);
2650 /* Note: we don't test the above call for failure;
2651 we just pass the FD on as given. Sometimes there is
2652 no file, so the ioctl may return failure, but that's
2656 /* Stop looping if the callback returns non-zero. */
2657 if ((funcstat = (*func) (fd, (CORE_ADDR) map->pr_vaddr)) != 0)
2661 /* Get the number of mapping entries. */
2662 if (ioctl (pi->ctl_fd, PIOCNMAP, &nmaps) < 0)
2663 proc_error (pi, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__);
2665 /* Allocate space for mappings (lifetime only this function). */
2666 map = (struct prmap *) alloca ((nmaps + 1) * sizeof (struct prmap));
2668 /* Read in all the mappings. */
2669 if (ioctl (pi->ctl_fd, PIOCMAP, map) < 0)
2670 proc_error (pi, "proc_iterate_over_mappings (PIOCMAP)", __LINE__);
2672 /* Now loop through the mappings, open an fd for each, and
2673 call the callback function. */
2675 i < nmaps && map[i].pr_size != 0;
2678 /* Note: caller's responsibility to close this fd! */
2679 fd = ioctl (pi->ctl_fd, PIOCOPENM, &map[i].pr_vaddr);
2680 /* Note: we don't test the above call for failure;
2681 we just pass the FD on as given. Sometimes there is
2682 no file, so the ioctl may return failure, but that's
2685 /* Stop looping if the callback returns non-zero. */
2686 funcstat = (*func) (fd, host_pointer_to_address (map[i].pr_vaddr));
2695 #ifdef TM_I386SOL2_H /* Is it hokey to use this? */
2697 #include <sys/sysi86.h>
2700 * Function: proc_get_LDT_entry
2706 * The 'key' is actually the value of the lower 16 bits of
2707 * the GS register for the LWP that we're interested in.
2709 * Return: matching ssh struct (LDT entry).
2713 proc_get_LDT_entry (pi, key)
2717 static struct ssd *ldt_entry = NULL;
2719 char pathname[MAX_PROC_NAME_SIZE];
2720 struct cleanup *old_chain = NULL;
2723 /* Allocate space for one LDT entry.
2724 This alloc must persist, because we return a pointer to it. */
2725 if (ldt_entry == NULL)
2726 ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd));
2728 /* Open the file descriptor for the LDT table. */
2729 sprintf (pathname, "/proc/%d/ldt", pi->pid);
2730 if ((fd = open (pathname, O_RDONLY)) < 0)
2732 proc_warn (pi, "proc_get_LDT_entry (open)", __LINE__);
2735 /* Make sure it gets closed again! */
2736 old_chain = make_cleanup_close (fd);
2738 /* Now 'read' thru the table, find a match and return it. */
2739 while (read (fd, ldt_entry, sizeof (struct ssd)) == sizeof (struct ssd))
2741 if (ldt_entry->sel == 0 &&
2742 ldt_entry->bo == 0 &&
2743 ldt_entry->acc1 == 0 &&
2744 ldt_entry->acc2 == 0)
2745 break; /* end of table */
2746 /* If key matches, return this entry. */
2747 if (ldt_entry->sel == key)
2750 /* Loop ended, match not found. */
2754 static int nalloc = 0;
2756 /* Get the number of LDT entries. */
2757 if (ioctl (pi->ctl_fd, PIOCNLDT, &nldt) < 0)
2759 proc_warn (pi, "proc_get_LDT_entry (PIOCNLDT)", __LINE__);
2763 /* Allocate space for the number of LDT entries. */
2764 /* This alloc has to persist, 'cause we return a pointer to it. */
2767 ldt_entry = (struct ssd *)
2768 xrealloc (ldt_entry, (nldt + 1) * sizeof (struct ssd));
2772 /* Read the whole table in one gulp. */
2773 if (ioctl (pi->ctl_fd, PIOCLDT, ldt_entry) < 0)
2775 proc_warn (pi, "proc_get_LDT_entry (PIOCLDT)", __LINE__);
2779 /* Search the table and return the (first) entry matching 'key'. */
2780 for (i = 0; i < nldt; i++)
2781 if (ldt_entry[i].sel == key)
2782 return &ldt_entry[i];
2784 /* Loop ended, match not found. */
2789 #endif /* TM_I386SOL2_H */
2791 /* =============== END, non-thread part of /proc "MODULE" =============== */
2793 /* =================== Thread "MODULE" =================== */
2795 /* NOTE: you'll see more ifdefs and duplication of functions here,
2796 since there is a different way to do threads on every OS. */
2799 * Function: proc_get_nthreads
2801 * Return the number of threads for the process
2804 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2809 proc_get_nthreads (pi)
2814 if (ioctl (pi->ctl_fd, PIOCNTHR, &nthreads) < 0)
2815 proc_warn (pi, "procfs: PIOCNTHR failed", __LINE__);
2821 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2823 * Solaris and Unixware version
2826 proc_get_nthreads (pi)
2829 if (!pi->status_valid)
2830 if (!proc_get_status (pi))
2834 * NEW_PROC_API: only works for the process procinfo,
2835 * because the LWP procinfos do not get prstatus filled in.
2838 if (pi->tid != 0) /* find the parent process procinfo */
2839 pi = find_procinfo_or_die (pi->pid, 0);
2841 return pi->prstatus.pr_nlwp;
2849 proc_get_nthreads (pi)
2858 * Function: proc_get_current_thread (LWP version)
2860 * Return the ID of the thread that had an event of interest.
2861 * (ie. the one that hit a breakpoint or other traced event).
2862 * All other things being equal, this should be the ID of a
2863 * thread that is currently executing.
2866 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2868 * Solaris and Unixware version
2871 proc_get_current_thread (pi)
2875 * Note: this should be applied to the root procinfo for the process,
2876 * not to the procinfo for an LWP. If applied to the procinfo for
2877 * an LWP, it will simply return that LWP's ID. In that case,
2878 * find the parent process procinfo.
2882 pi = find_procinfo_or_die (pi->pid, 0);
2884 if (!pi->status_valid)
2885 if (!proc_get_status (pi))
2889 return pi->prstatus.pr_lwp.pr_lwpid;
2891 return pi->prstatus.pr_who;
2896 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2901 proc_get_current_thread (pi)
2904 #if 0 /* FIXME: not ready for prime time? */
2905 return pi->prstatus.pr_tid;
2916 proc_get_current_thread (pi)
2926 * Function: proc_update_threads
2928 * Discover the IDs of all the threads within the process, and
2929 * create a procinfo for each of them (chained to the parent).
2931 * This unfortunately requires a different method on every OS.
2933 * Return: non-zero for success, zero for failure.
2937 proc_delete_dead_threads (parent, thread, ignore)
2942 if (thread && parent) /* sanity */
2944 thread->status_valid = 0;
2945 if (!proc_get_status (thread))
2946 destroy_one_procinfo (&parent->thread_list, thread);
2948 return 0; /* keep iterating */
2951 #if defined (PIOCLSTATUS)
2953 * Solaris 2.5 (ioctl) version
2956 proc_update_threads (pi)
2959 gdb_prstatus_t *prstatus;
2960 struct cleanup *old_chain = NULL;
2965 * We should never have to apply this operation to any procinfo
2966 * except the one for the main process. If that ever changes
2967 * for any reason, then take out the following clause and
2968 * replace it with one that makes sure the ctl_fd is open.
2972 pi = find_procinfo_or_die (pi->pid, 0);
2974 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
2976 if ((nlwp = proc_get_nthreads (pi)) <= 1)
2977 return 1; /* Process is not multi-threaded; nothing to do. */
2979 if ((prstatus = (gdb_prstatus_t *)
2980 malloc (sizeof (gdb_prstatus_t) * (nlwp + 1))) == 0)
2981 perror_with_name ("procfs: malloc failed in update_threads");
2983 old_chain = make_cleanup (free, prstatus);
2984 if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0)
2985 proc_error (pi, "update_threads (PIOCLSTATUS)", __LINE__);
2987 /* Skip element zero, which represents the process as a whole. */
2988 for (i = 1; i < nlwp + 1; i++)
2990 if ((thread = create_procinfo (pi->pid, prstatus[i].pr_who)) == NULL)
2991 proc_error (pi, "update_threads, create_procinfo", __LINE__);
2993 memcpy (&thread->prstatus, &prstatus[i], sizeof (*prstatus));
2994 thread->status_valid = 1;
2996 pi->threads_valid = 1;
2997 do_cleanups (old_chain);
3003 * Unixware and Solaris 6 (and later) version
3006 do_closedir_cleanup (void *dir)
3012 proc_update_threads (pi)
3015 char pathname[MAX_PROC_NAME_SIZE + 16];
3016 struct dirent *direntry;
3017 struct cleanup *old_chain = NULL;
3023 * We should never have to apply this operation to any procinfo
3024 * except the one for the main process. If that ever changes
3025 * for any reason, then take out the following clause and
3026 * replace it with one that makes sure the ctl_fd is open.
3030 pi = find_procinfo_or_die (pi->pid, 0);
3032 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
3037 * Note: this brute-force method is the only way I know of
3038 * to accomplish this task on Unixware. This method will
3039 * also work on Solaris 2.6 and 2.7. There is a much simpler
3040 * and more elegant way to do this on Solaris, but the margins
3041 * of this manuscript are too small to write it here... ;-)
3044 strcpy (pathname, pi->pathname);
3045 strcat (pathname, "/lwp");
3046 if ((dirp = opendir (pathname)) == NULL)
3047 proc_error (pi, "update_threads, opendir", __LINE__);
3049 old_chain = make_cleanup (do_closedir_cleanup, dirp);
3050 while ((direntry = readdir (dirp)) != NULL)
3051 if (direntry->d_name[0] != '.') /* skip '.' and '..' */
3053 lwpid = atoi (&direntry->d_name[0]);
3054 if ((thread = create_procinfo (pi->pid, lwpid)) == NULL)
3055 proc_error (pi, "update_threads, create_procinfo", __LINE__);
3057 pi->threads_valid = 1;
3058 do_cleanups (old_chain);
3067 proc_update_threads (pi)
3074 * We should never have to apply this operation to any procinfo
3075 * except the one for the main process. If that ever changes
3076 * for any reason, then take out the following clause and
3077 * replace it with one that makes sure the ctl_fd is open.
3081 pi = find_procinfo_or_die (pi->pid, 0);
3083 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
3085 nthreads = proc_get_nthreads (pi);
3087 return 0; /* nothing to do for 1 or fewer threads */
3089 if ((threads = malloc (nthreads * sizeof (tid_t))) == NULL)
3090 proc_error (pi, "update_threads, malloc", __LINE__);
3092 if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0)
3093 proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__);
3095 for (i = 0; i < nthreads; i++)
3097 if (!find_procinfo (pi->pid, threads[i]))
3098 if (!create_procinfo (pi->pid, threads[i]))
3099 proc_error (pi, "update_threads, create_procinfo", __LINE__);
3101 pi->threads_valid = 1;
3109 proc_update_threads (pi)
3114 #endif /* OSF PIOCTLIST */
3115 #endif /* NEW_PROC_API */
3116 #endif /* SOL 2.5 PIOCLSTATUS */
3119 * Function: proc_iterate_over_threads
3122 * Given a pointer to a function, call that function once
3123 * for each lwp in the procinfo list, until the function
3124 * returns non-zero, in which event return the value
3125 * returned by the function.
3127 * Note: this function does NOT call update_threads.
3128 * If you want to discover new threads first, you must
3129 * call that function explicitly. This function just makes
3130 * a quick pass over the currently-known procinfos.
3133 * pi - parent process procinfo
3134 * func - per-thread function
3135 * ptr - opaque parameter for function.
3138 * First non-zero return value from the callee, or zero.
3142 proc_iterate_over_threads (pi, func, ptr)
3144 int (*func) (procinfo *, procinfo *, void *);
3147 procinfo *thread, *next;
3151 * We should never have to apply this operation to any procinfo
3152 * except the one for the main process. If that ever changes
3153 * for any reason, then take out the following clause and
3154 * replace it with one that makes sure the ctl_fd is open.
3158 pi = find_procinfo_or_die (pi->pid, 0);
3160 for (thread = pi->thread_list; thread != NULL; thread = next)
3162 next = thread->next; /* in case thread is destroyed */
3163 if ((retval = (*func) (pi, thread, ptr)) != 0)
3170 /* =================== END, Thread "MODULE" =================== */
3172 /* =================== END, /proc "MODULE" =================== */
3174 /* =================== GDB "MODULE" =================== */
3177 * Here are all of the gdb target vector functions and their friends.
3180 static int do_attach (int pid);
3181 static void do_detach (int signo);
3182 static int register_gdb_signals (procinfo *, sigset_t *);
3185 * Function: procfs_debug_inferior
3187 * Sets up the inferior to be debugged.
3188 * Registers to trace signals, hardware faults, and syscalls.
3189 * Note: does not set RLC flag: caller may want to customize that.
3191 * Returns: zero for success (note! unlike most functions in this module)
3192 * On failure, returns the LINE NUMBER where it failed!
3196 procfs_debug_inferior (pi)
3199 fltset_t traced_faults;
3200 sigset_t traced_signals;
3201 sysset_t traced_syscall_entries;
3202 sysset_t traced_syscall_exits;
3204 #ifdef PROCFS_DONT_TRACE_FAULTS
3205 /* On some systems (OSF), we don't trace hardware faults.
3206 Apparently it's enough that we catch them as signals.
3207 Wonder why we don't just do that in general? */
3208 premptyset (&traced_faults); /* don't trace faults. */
3210 /* Register to trace hardware faults in the child. */
3211 prfillset (&traced_faults); /* trace all faults... */
3212 prdelset (&traced_faults, FLTPAGE); /* except page fault. */
3214 if (!proc_set_traced_faults (pi, &traced_faults))
3217 /* Register to trace selected signals in the child. */
3218 premptyset (&traced_signals);
3219 if (!register_gdb_signals (pi, &traced_signals))
3222 /* Register to trace the 'exit' system call (on entry). */
3223 premptyset (&traced_syscall_entries);
3224 praddset (&traced_syscall_entries, SYS_exit);
3226 praddset (&traced_syscall_entries, SYS_lwpexit); /* And _lwp_exit... */
3229 praddset (&traced_syscall_entries, SYS_lwp_exit);
3232 if (!proc_set_traced_sysentry (pi, &traced_syscall_entries))
3235 #ifdef PRFS_STOPEXEC /* defined on OSF */
3236 /* OSF method for tracing exec syscalls. Quoting:
3237 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3238 exits from exec system calls because of the user level loader. */
3239 /* FIXME: make nice and maybe move into an access function. */
3243 if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
3246 prfs_flags |= PRFS_STOPEXEC;
3248 if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
3251 #else /* not PRFS_STOPEXEC */
3252 /* Everyone else's (except OSF) method for tracing exec syscalls */
3254 Not all systems with /proc have all the exec* syscalls with the same
3255 names. On the SGI, for example, there is no SYS_exec, but there
3256 *is* a SYS_execv. So, we try to account for that. */
3258 premptyset (&traced_syscall_exits);
3260 praddset (&traced_syscall_exits, SYS_exec);
3263 praddset (&traced_syscall_exits, SYS_execve);
3266 praddset (&traced_syscall_exits, SYS_execv);
3269 #ifdef SYS_lwpcreate
3270 praddset (&traced_syscall_exits, SYS_lwpcreate);
3271 praddset (&traced_syscall_exits, SYS_lwpexit);
3274 #ifdef SYS_lwp_create /* FIXME: once only, please */
3275 praddset (&traced_syscall_exits, SYS_lwp_create);
3276 praddset (&traced_syscall_exits, SYS_lwp_exit);
3280 if (!proc_set_traced_sysexit (pi, &traced_syscall_exits))
3283 #endif /* PRFS_STOPEXEC */
3288 procfs_attach (args, from_tty)
3296 error_no_arg ("process-id to attach");
3299 if (pid == getpid ())
3300 error ("Attaching GDB to itself is not a good idea...");
3304 exec_file = get_exec_file (0);
3307 printf_filtered ("Attaching to program `%s', %s\n",
3308 exec_file, target_pid_to_str (pid));
3310 printf_filtered ("Attaching to %s\n", target_pid_to_str (pid));
3314 inferior_pid = do_attach (pid);
3315 push_target (&procfs_ops);
3319 procfs_detach (args, from_tty)
3328 exec_file = get_exec_file (0);
3331 printf_filtered ("Detaching from program: %s %s\n",
3332 exec_file, target_pid_to_str (inferior_pid));
3336 signo = atoi (args);
3340 unpush_target (&procfs_ops); /* Pop out of handling an inferior */
3350 if ((pi = create_procinfo (pid, 0)) == NULL)
3351 perror ("procfs: out of memory in 'attach'");
3353 if (!open_procinfo_files (pi, FD_CTL))
3355 fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__);
3356 sprintf (errmsg, "do_attach: couldn't open /proc file for process %d",
3358 dead_procinfo (pi, errmsg, NOKILL);
3361 /* Stop the process (if it isn't already stopped). */
3362 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
3364 pi->was_stopped = 1;
3365 proc_prettyprint_why (proc_why (pi), proc_what (pi), 1);
3369 pi->was_stopped = 0;
3370 /* Set the process to run again when we close it. */
3371 if (!proc_set_run_on_last_close (pi))
3372 dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL);
3374 /* Now stop the process. */
3375 if (!proc_stop_process (pi))
3376 dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL);
3377 pi->ignore_next_sigstop = 1;
3379 /* Save some of the /proc state to be restored if we detach. */
3380 if (!proc_get_traced_faults (pi, &pi->saved_fltset))
3381 dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL);
3382 if (!proc_get_traced_signals (pi, &pi->saved_sigset))
3383 dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL);
3384 if (!proc_get_traced_sysentry (pi, &pi->saved_entryset))
3385 dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.",
3387 if (!proc_get_traced_sysexit (pi, &pi->saved_exitset))
3388 dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.",
3390 if (!proc_get_held_signals (pi, &pi->saved_sighold))
3391 dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL);
3393 if ((fail = procfs_debug_inferior (pi)) != 0)
3394 dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL);
3396 /* Let GDB know that the inferior was attached. */
3398 return MERGEPID (pi->pid, proc_get_current_thread (pi));
3407 /* Find procinfo for the main process */
3408 pi = find_procinfo_or_die (PIDGET (inferior_pid), 0); /* FIXME: threads */
3410 if (!proc_set_current_signal (pi, signo))
3411 proc_warn (pi, "do_detach, set_current_signal", __LINE__);
3413 if (!proc_set_traced_signals (pi, &pi->saved_sigset))
3414 proc_warn (pi, "do_detach, set_traced_signal", __LINE__);
3416 if (!proc_set_traced_faults (pi, &pi->saved_fltset))
3417 proc_warn (pi, "do_detach, set_traced_faults", __LINE__);
3419 if (!proc_set_traced_sysentry (pi, &pi->saved_entryset))
3420 proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__);
3422 if (!proc_set_traced_sysexit (pi, &pi->saved_exitset))
3423 proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__);
3425 if (!proc_set_held_signals (pi, &pi->saved_sighold))
3426 proc_warn (pi, "do_detach, set_held_signals", __LINE__);
3428 if (signo || (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)))
3429 if (signo || !(pi->was_stopped) ||
3430 query ("Was stopped when attached, make it runnable again? "))
3432 /* Clear any pending signal. */
3433 if (!proc_clear_current_fault (pi))
3434 proc_warn (pi, "do_detach, clear_current_fault", __LINE__);
3436 if (!proc_set_run_on_last_close (pi))
3437 proc_warn (pi, "do_detach, set_rlc", __LINE__);
3441 destroy_procinfo (pi);
3447 * Since the /proc interface cannot give us individual registers,
3448 * we pay no attention to the (regno) argument, and just fetch them all.
3449 * This results in the possibility that we will do unnecessarily many
3450 * fetches, since we may be called repeatedly for individual registers.
3451 * So we cache the results, and mark the cache invalid when the process
3456 procfs_fetch_registers (regno)
3459 gdb_fpregset_t *fpregs;
3460 gdb_gregset_t *gregs;
3465 pid = PIDGET (inferior_pid);
3466 tid = TIDGET (inferior_pid);
3468 /* First look up procinfo for the main process. */
3469 pi = find_procinfo_or_die (pid, 0);
3471 /* If the event thread is not the same as GDB's requested thread
3472 (ie. inferior_pid), then look up procinfo for the requested
3475 (tid != proc_get_current_thread (pi)))
3476 pi = find_procinfo_or_die (pid, tid);
3479 error ("procfs: fetch_registers failed to find procinfo for %s",
3480 target_pid_to_str (inferior_pid));
3482 if ((gregs = proc_get_gregs (pi)) == NULL)
3483 proc_error (pi, "fetch_registers, get_gregs", __LINE__);
3485 supply_gregset (gregs);
3487 if (FP0_REGNUM >= 0) /* need floating point? */
3489 if ((regno >= 0 && regno < FP0_REGNUM) ||
3490 regno == PC_REGNUM ||
3491 (NPC_REGNUM >= 0 && regno == NPC_REGNUM) ||
3492 regno == FP_REGNUM ||
3494 return; /* not a floating point register */
3496 if ((fpregs = proc_get_fpregs (pi)) == NULL)
3497 proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
3499 supply_fpregset (fpregs);
3503 /* Get ready to modify the registers array. On machines which store
3504 individual registers, this doesn't need to do anything. On
3505 machines which store all the registers in one fell swoop, such as
3506 /proc, this makes sure that registers contains all the registers
3507 from the program being debugged. */
3510 procfs_prepare_to_store ()
3512 #ifdef CHILD_PREPARE_TO_STORE
3513 CHILD_PREPARE_TO_STORE ();
3520 * Since the /proc interface will not read individual registers,
3521 * we will cache these requests until the process is resumed, and
3522 * only then write them back to the inferior process.
3524 * FIXME: is that a really bad idea? Have to think about cases
3525 * where writing one register might affect the value of others, etc.
3529 procfs_store_registers (regno)
3532 gdb_fpregset_t *fpregs;
3533 gdb_gregset_t *gregs;
3538 pid = PIDGET (inferior_pid);
3539 tid = TIDGET (inferior_pid);
3541 /* First find procinfo for main process */
3542 pi = find_procinfo_or_die (pid, 0);
3544 /* If current lwp for process is not the same as requested thread
3545 (ie. inferior_pid), then find procinfo for the requested thread. */
3548 (tid != proc_get_current_thread (pi)))
3549 pi = find_procinfo_or_die (pid, tid);
3552 error ("procfs: store_registers: failed to find procinfo for %s",
3553 target_pid_to_str (inferior_pid));
3555 if ((gregs = proc_get_gregs (pi)) == NULL)
3556 proc_error (pi, "store_registers, get_gregs", __LINE__);
3558 fill_gregset (gregs, regno);
3559 if (!proc_set_gregs (pi))
3560 proc_error (pi, "store_registers, set_gregs", __LINE__);
3562 if (FP0_REGNUM >= 0) /* need floating point? */
3564 if ((regno >= 0 && regno < FP0_REGNUM) ||
3565 regno == PC_REGNUM ||
3566 (NPC_REGNUM >= 0 && regno == NPC_REGNUM) ||
3567 regno == FP_REGNUM ||
3569 return; /* not a floating point register */
3571 if ((fpregs = proc_get_fpregs (pi)) == NULL)
3572 proc_error (pi, "store_registers, get_fpregs", __LINE__);
3574 fill_fpregset (fpregs, regno);
3575 if (!proc_set_fpregs (pi))
3576 proc_error (pi, "store_registers, set_fpregs", __LINE__);
3581 * Function: target_wait
3583 * Retrieve the next stop event from the child process.
3584 * If child has not stopped yet, wait for it to stop.
3585 * Translate /proc eventcodes (or possibly wait eventcodes)
3586 * into gdb internal event codes.
3588 * Return: id of process (and possibly thread) that incurred the event.
3589 * event codes are returned thru a pointer parameter.
3593 procfs_wait (pid, status)
3595 struct target_waitstatus *status;
3597 /* First cut: loosely based on original version 2.1 */
3601 int why, what, flags;
3610 /* Find procinfo for main process */
3611 pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
3614 /* We must assume that the status is stale now... */
3615 pi->status_valid = 0;
3616 pi->gregs_valid = 0;
3617 pi->fpregs_valid = 0;
3619 #if 0 /* just try this out... */
3620 flags = proc_flags (pi);
3621 why = proc_why (pi);
3622 if ((flags & PR_STOPPED) && (why == PR_REQUESTED))
3623 pi->status_valid = 0; /* re-read again, IMMEDIATELY... */
3625 /* If child is not stopped, wait for it to stop. */
3626 if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) &&
3627 !proc_wait_for_stop (pi))
3629 /* wait_for_stop failed: has the child terminated? */
3630 if (errno == ENOENT)
3632 /* /proc file not found; presumably child has terminated. */
3633 retval = wait (&wstat); /* "wait" for the child's exit */
3635 if (retval != PIDGET (inferior_pid)) /* wrong child? */
3636 error ("procfs: couldn't stop process %d: wait returned %d\n",
3637 inferior_pid, retval);
3638 /* FIXME: might I not just use waitpid?
3639 Or try find_procinfo to see if I know about this child? */
3643 /* Unknown error from wait_for_stop. */
3644 proc_error (pi, "target_wait (wait_for_stop)", __LINE__);
3649 /* This long block is reached if either:
3650 a) the child was already stopped, or
3651 b) we successfully waited for the child with wait_for_stop.
3652 This block will analyze the /proc status, and translate it
3653 into a waitstatus for GDB.
3655 If we actually had to call wait because the /proc file
3656 is gone (child terminated), then we skip this block,
3657 because we already have a waitstatus. */
3659 flags = proc_flags (pi);
3660 why = proc_why (pi);
3661 what = proc_what (pi);
3663 if (flags & (PR_STOPPED | PR_ISTOP))
3666 /* If it's running async (for single_thread control),
3667 set it back to normal again. */
3668 if (flags & PR_ASYNC)
3669 if (!proc_unset_async (pi))
3670 proc_error (pi, "target_wait, unset_async", __LINE__);
3674 proc_prettyprint_why (why, what, 1);
3676 /* The 'pid' we will return to GDB is composed of
3677 the process ID plus the lwp ID. */
3678 retval = MERGEPID (pi->pid, proc_get_current_thread (pi));
3682 wstat = (what << 8) | 0177;
3692 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3693 printf_filtered ("[%s exited]\n",
3694 target_pid_to_str (retval));
3695 delete_thread (retval);
3696 status->kind = TARGET_WAITKIND_SPURIOUS;
3698 #endif /* _lwp_exit */
3701 /* Handle SYS_exit call only */
3702 /* Stopped at entry to SYS_exit.
3703 Make it runnable, resume it, then use
3704 the wait system call to get its exit code.
3705 Proc_run_process always clears the current
3707 Then return its exit status. */
3708 pi->status_valid = 0;
3710 /* FIXME: what we should do is return
3711 TARGET_WAITKIND_SPURIOUS. */
3712 if (!proc_run_process (pi, 0, 0))
3713 proc_error (pi, "target_wait, run_process", __LINE__);
3716 /* Don't call wait: simulate waiting for exit,
3717 return a "success" exit code. Bogus: what if
3718 it returns something else? */
3720 retval = inferior_pid; /* ? ? ? */
3724 int temp = wait (&wstat);
3726 /* FIXME: shouldn't I make sure I get the right
3727 event from the right process? If (for
3728 instance) I have killed an earlier inferior
3729 process but failed to clean up after it
3730 somehow, I could get its termination event
3733 /* If wait returns -1, that's what we return to GDB. */
3739 printf_filtered ("procfs: trapped on entry to ");
3740 proc_prettyprint_syscall (proc_what (pi), 0);
3741 printf_filtered ("\n");
3744 long i, nsysargs, *sysargs;
3746 if ((nsysargs = proc_nsysarg (pi)) > 0 &&
3747 (sysargs = proc_sysargs (pi)) != NULL)
3749 printf_filtered ("%ld syscall arguments:\n", nsysargs);
3750 for (i = 0; i < nsysargs; i++)
3751 printf_filtered ("#%ld: 0x%08lx\n",
3759 /* How to exit gracefully, returning "unknown event" */
3760 status->kind = TARGET_WAITKIND_SPURIOUS;
3761 return inferior_pid;
3765 /* How to keep going without returning to wfi: */
3766 target_resume (pid, 0, TARGET_SIGNAL_0);
3783 /* Hopefully this is our own "fork-child" execing
3784 the real child. Hoax this event into a trap, and
3785 GDB will see the child about to execute its start
3787 wstat = (SIGTRAP << 8) | 0177;
3789 #ifdef SYS_lwp_create
3790 case SYS_lwp_create:
3792 #ifdef SYS_lwpcreate
3795 #if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
3797 * This syscall is somewhat like fork/exec.
3798 * We will get the event twice: once for the parent LWP,
3799 * and once for the child. We should already know about
3800 * the parent LWP, but the child will be new to us. So,
3801 * whenever we get this event, if it represents a new
3802 * thread, simply add the thread to the list.
3805 /* If not in procinfo list, add it. */
3806 temp = proc_get_current_thread (pi);
3807 if (!find_procinfo (pi->pid, temp))
3808 create_procinfo (pi->pid, temp);
3810 temp = MERGEPID (pi->pid, temp);
3811 /* If not in GDB's thread list, add it. */
3812 if (!in_thread_list (temp))
3814 printf_filtered ("[New %s]\n", target_pid_to_str (temp));
3817 /* Return to WFI, but tell it to immediately resume. */
3818 status->kind = TARGET_WAITKIND_SPURIOUS;
3819 return inferior_pid;
3820 #endif /* _lwp_create */
3828 #if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
3829 printf_filtered ("[%s exited]\n",
3830 target_pid_to_str (retval));
3831 delete_thread (retval);
3832 status->kind = TARGET_WAITKIND_SPURIOUS;
3834 #endif /* _lwp_exit */
3838 /* Nothing to do here for now. The old procfs
3839 seemed to use this event to handle threads on
3840 older (non-LWP) systems, where I'm assuming that
3841 threads were actually separate processes. Irix,
3842 maybe? Anyway, low priority for now. */
3846 /* FIXME: do we need to handle this? Investigate. */
3850 /* FIXME: see above. */
3853 printf_filtered ("procfs: trapped on exit from ");
3854 proc_prettyprint_syscall (proc_what (pi), 0);
3855 printf_filtered ("\n");
3858 long i, nsysargs, *sysargs;
3860 if ((nsysargs = proc_nsysarg (pi)) > 0 &&
3861 (sysargs = proc_sysargs (pi)) != NULL)
3863 printf_filtered ("%ld syscall arguments:\n", nsysargs);
3864 for (i = 0; i < nsysargs; i++)
3865 printf_filtered ("#%ld: 0x%08lx\n",
3870 status->kind = TARGET_WAITKIND_SPURIOUS;
3871 return inferior_pid;
3876 wstat = (SIGSTOP << 8) | 0177;
3881 printf_filtered ("Retry #%d:\n", retry);
3882 pi->status_valid = 0;
3887 /* If not in procinfo list, add it. */
3888 temp = proc_get_current_thread (pi);
3889 if (!find_procinfo (pi->pid, temp))
3890 create_procinfo (pi->pid, temp);
3892 /* If not in GDB's thread list, add it. */
3893 temp = MERGEPID (pi->pid, temp);
3894 if (!in_thread_list (temp))
3896 printf_filtered ("[New %s]\n",
3897 target_pid_to_str (temp));
3901 status->kind = TARGET_WAITKIND_STOPPED;
3902 status->value.sig = 0;
3907 wstat = (what << 8) | 0177;
3910 switch (what) { /* FIXME: FAULTED_USE_SIGINFO */
3913 wstat = (SIGTRAP << 8) | 0177;
3918 wstat = (SIGTRAP << 8) | 0177;
3921 /* FIXME: use si_signo where possible. */
3923 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
3926 wstat = (SIGILL << 8) | 0177;
3929 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
3932 wstat = (SIGTRAP << 8) | 0177;
3936 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
3939 wstat = (SIGSEGV << 8) | 0177;
3943 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
3946 wstat = (SIGFPE << 8) | 0177;
3948 case FLTPAGE: /* Recoverable page fault */
3949 default: /* FIXME: use si_signo if possible for fault */
3951 printf_filtered ("procfs:%d -- ", __LINE__);
3952 printf_filtered ("child stopped for unknown reason:\n");
3953 proc_prettyprint_why (why, what, 1);
3954 error ("... giving up...");
3957 break; /* case PR_FAULTED: */
3958 default: /* switch (why) unmatched */
3959 printf_filtered ("procfs:%d -- ", __LINE__);
3960 printf_filtered ("child stopped for unknown reason:\n");
3961 proc_prettyprint_why (why, what, 1);
3962 error ("... giving up...");
3966 * Got this far without error:
3967 * If retval isn't in the threads database, add it.
3970 retval != inferior_pid &&
3971 !in_thread_list (retval))
3974 * We have a new thread.
3975 * We need to add it both to GDB's list and to our own.
3976 * If we don't create a procinfo, resume may be unhappy
3979 printf_filtered ("[New %s]\n", target_pid_to_str (retval));
3980 add_thread (retval);
3981 if (find_procinfo (PIDGET (retval), TIDGET (retval)) == NULL)
3982 create_procinfo (PIDGET (retval), TIDGET (retval));
3984 /* In addition, it's possible that this is the first
3985 * new thread we've seen, in which case we may not
3986 * have created entries for inferior_pid yet.
3988 if (TIDGET (inferior_pid) != 0)
3990 if (!in_thread_list (inferior_pid))
3991 add_thread (inferior_pid);
3992 if (find_procinfo (PIDGET (inferior_pid),
3993 TIDGET (inferior_pid)) == NULL)
3994 create_procinfo (PIDGET (inferior_pid),
3995 TIDGET (inferior_pid));
3999 else /* flags do not indicate STOPPED */
4001 /* surely this can't happen... */
4002 printf_filtered ("procfs:%d -- process not stopped.\n",
4004 proc_prettyprint_flags (flags, 1);
4005 error ("procfs: ...giving up...");
4010 store_waitstatus (status, wstat);
4017 procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
4022 struct target_ops *target; /* ignored */
4027 /* Find procinfo for main process */
4028 pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
4029 if (pi->as_fd == 0 &&
4030 open_procinfo_files (pi, FD_AS) == 0)
4032 proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);
4036 if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
4041 PROCFS_NOTE ("write memory: ");
4043 PROCFS_NOTE ("write memory: \n");
4045 nbytes = write (pi->as_fd, myaddr, len);
4049 PROCFS_NOTE ("read memory: \n");
4050 nbytes = read (pi->as_fd, myaddr, len);
4061 * Function: invalidate_cache
4063 * Called by target_resume before making child runnable.
4064 * Mark cached registers and status's invalid.
4065 * If there are "dirty" caches that need to be written back
4066 * to the child process, do that.
4068 * File descriptors are also cached.
4069 * As they are a limited resource, we cannot hold onto them indefinitely.
4070 * However, as they are expensive to open, we don't want to throw them
4071 * away indescriminately either. As a compromise, we will keep the
4072 * file descriptors for the parent process, but discard any file
4073 * descriptors we may have accumulated for the threads.
4076 * As this function is called by iterate_over_threads, it always
4077 * returns zero (so that iterate_over_threads will keep iterating).
4082 invalidate_cache (parent, pi, ptr)
4088 * About to run the child; invalidate caches and do any other cleanup.
4092 if (pi->gregs_dirty)
4093 if (parent == NULL ||
4094 proc_get_current_thread (parent) != pi->tid)
4095 if (!proc_set_gregs (pi)) /* flush gregs cache */
4096 proc_warn (pi, "target_resume, set_gregs",
4098 if (FP0_REGNUM >= 0)
4099 if (pi->fpregs_dirty)
4100 if (parent == NULL ||
4101 proc_get_current_thread (parent) != pi->tid)
4102 if (!proc_set_fpregs (pi)) /* flush fpregs cache */
4103 proc_warn (pi, "target_resume, set_fpregs",
4109 /* The presence of a parent indicates that this is an LWP.
4110 Close any file descriptors that it might have open.
4111 We don't do this to the master (parent) procinfo. */
4113 close_procinfo_files (pi);
4115 pi->gregs_valid = 0;
4116 pi->fpregs_valid = 0;
4118 pi->gregs_dirty = 0;
4119 pi->fpregs_dirty = 0;
4121 pi->status_valid = 0;
4122 pi->threads_valid = 0;
4129 * Function: make_signal_thread_runnable
4131 * A callback function for iterate_over_threads.
4132 * Find the asynchronous signal thread, and make it runnable.
4133 * See if that helps matters any.
4137 make_signal_thread_runnable (process, pi, ptr)
4143 if (proc_flags (pi) & PR_ASLWP)
4145 if (!proc_run_process (pi, 0, -1))
4146 proc_error (pi, "make_signal_thread_runnable", __LINE__);
4155 * Function: target_resume
4157 * Make the child process runnable. Normally we will then call
4158 * procfs_wait and wait for it to stop again (unles gdb is async).
4161 * step: if true, then arrange for the child to stop again
4162 * after executing a single instruction.
4163 * signo: if zero, then cancel any pending signal.
4164 * If non-zero, then arrange for the indicated signal
4165 * to be delivered to the child when it runs.
4166 * pid: if -1, then allow any child thread to run.
4167 * if non-zero, then allow only the indicated thread to run.
4168 ******* (not implemented yet)
4172 procfs_resume (pid, step, signo)
4175 enum target_signal signo;
4177 procinfo *pi, *thread;
4181 prrun.prflags |= PRSVADDR;
4182 prrun.pr_vaddr = $PC; set resume address
4183 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4184 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4185 prrun.prflags |= PRCFAULT; clear current fault.
4187 PRSTRACE and PRSFAULT can be done by other means
4188 (proc_trace_signals, proc_trace_faults)
4189 PRSVADDR is unnecessary.
4190 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4191 This basically leaves PRSTEP and PRCSIG.
4192 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4193 So basically PR_STEP is the sole argument that must be passed
4194 to proc_run_process (for use in the prrun struct by ioctl). */
4196 /* Find procinfo for main process */
4197 pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
4199 /* First cut: ignore pid argument */
4202 /* Convert signal to host numbering. */
4204 (signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop))
4207 native_signo = target_signal_to_host (signo);
4209 pi->ignore_next_sigstop = 0;
4211 /* Running the process voids all cached registers and status. */
4212 /* Void the threads' caches first */
4213 proc_iterate_over_threads (pi, invalidate_cache, NULL);
4214 /* Void the process procinfo's caches. */
4215 invalidate_cache (NULL, pi, NULL);
4219 /* Resume a specific thread, presumably suppressing the others. */
4220 thread = find_procinfo (PIDGET (pid), TIDGET (pid));
4222 warning ("procfs: resume can't find thread %d -- resuming all.",
4226 if (thread->tid != 0)
4228 /* We're to resume a specific thread, and not the others.
4229 * Set the child process's PR_ASYNC flag.
4232 if (!proc_set_async (pi))
4233 proc_error (pi, "target_resume, set_async", __LINE__);
4236 proc_iterate_over_threads (pi,
4237 make_signal_thread_runnable,
4240 pi = thread; /* substitute the thread's procinfo for run */
4245 if (!proc_run_process (pi, step, native_signo))
4248 warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
4250 proc_error (pi, "target_resume", __LINE__);
4255 * Function: register_gdb_signals
4257 * Traverse the list of signals that GDB knows about
4258 * (see "handle" command), and arrange for the target
4259 * to be stopped or not, according to these settings.
4261 * Returns non-zero for success, zero for failure.
4265 register_gdb_signals (pi, signals)
4271 for (signo = 0; signo < NSIG; signo ++)
4272 if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
4273 signal_print_state (target_signal_from_host (signo)) == 0 &&
4274 signal_pass_state (target_signal_from_host (signo)) == 1)
4275 prdelset (signals, signo);
4277 praddset (signals, signo);
4279 return proc_set_traced_signals (pi, signals);
4283 * Function: target_notice_signals
4285 * Set up to trace signals in the child process.
4289 procfs_notice_signals (pid)
4293 procinfo *pi = find_procinfo_or_die (PIDGET (pid), 0);
4295 if (proc_get_traced_signals (pi, &signals) &&
4296 register_gdb_signals (pi, &signals))
4299 proc_error (pi, "notice_signals", __LINE__);
4303 * Function: target_files_info
4305 * Print status information about the child process.
4309 procfs_files_info (ignore)
4310 struct target_ops *ignore;
4312 printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
4313 attach_flag? "attached": "child",
4314 target_pid_to_str (inferior_pid));
4318 * Function: target_open
4320 * A dummy: you don't open procfs.
4324 procfs_open (args, from_tty)
4328 error ("Use the \"run\" command to start a Unix child process.");
4332 * Function: target_can_run
4334 * This tells GDB that this target vector can be invoked
4335 * for "run" or "attach".
4338 int procfs_suppress_run = 0; /* Non-zero if procfs should pretend not to
4339 be a runnable target. Used by targets
4340 that can sit atop procfs, such as solaris
4347 /* This variable is controlled by modules that sit atop procfs that
4348 may layer their own process structure atop that provided here.
4349 sol-thread.c does this because of the Solaris two-level thread
4352 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
4354 return !procfs_suppress_run;
4358 * Function: target_stop
4360 * Stop the child process asynchronously, as when the
4361 * gdb user types control-c or presses a "stop" button.
4363 * Works by sending kill(SIGINT) to the child's process group.
4369 extern pid_t inferior_process_group;
4371 kill (-inferior_process_group, SIGINT);
4375 * Function: unconditionally_kill_inferior
4377 * Make it die. Wait for it to die. Clean up after it.
4378 * Note: this should only be applied to the real process,
4379 * not to an LWP, because of the check for parent-process.
4380 * If we need this to work for an LWP, it needs some more logic.
4384 unconditionally_kill_inferior (pi)
4389 parent_pid = proc_parent_pid (pi);
4390 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4391 /* FIXME: use access functions */
4392 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4393 before the PIOCKILL, otherwise it might generate a corrupted core
4394 file for the inferior. */
4395 if (ioctl (pi->ctl_fd, PIOCSSIG, NULL) < 0)
4397 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4400 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4401 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4402 to kill the inferior, otherwise it might remain stopped with a
4404 We do not check the result of the PIOCSSIG, the inferior might have
4407 struct siginfo newsiginfo;
4409 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
4410 newsiginfo.si_signo = SIGKILL;
4411 newsiginfo.si_code = 0;
4412 newsiginfo.si_errno = 0;
4413 newsiginfo.si_pid = getpid ();
4414 newsiginfo.si_uid = getuid ();
4415 /* FIXME: use proc_set_current_signal */
4416 ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo);
4418 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4419 if (!proc_kill (pi, SIGKILL))
4420 proc_error (pi, "unconditionally_kill, proc_kill", __LINE__);
4421 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4422 destroy_procinfo (pi);
4424 /* If pi is GDB's child, wait for it to die. */
4425 if (parent_pid == getpid ())
4426 /* FIXME: should we use waitpid to make sure we get the right event?
4427 Should we check the returned event? */
4432 ret = waitpid (pi->pid, &status, 0);
4440 * Function: target_kill_inferior
4442 * We're done debugging it, and we want it to go away.
4443 * Then we want GDB to forget all about it.
4447 procfs_kill_inferior ()
4449 if (inferior_pid != 0) /* ? */
4451 /* Find procinfo for main process */
4452 procinfo *pi = find_procinfo (PIDGET (inferior_pid), 0);
4455 unconditionally_kill_inferior (pi);
4456 target_mourn_inferior ();
4461 * Function: target_mourn_inferior
4463 * Forget we ever debugged this thing!
4467 procfs_mourn_inferior ()
4471 if (inferior_pid != 0)
4473 /* Find procinfo for main process */
4474 pi = find_procinfo (PIDGET (inferior_pid), 0);
4476 destroy_procinfo (pi);
4478 unpush_target (&procfs_ops);
4479 generic_mourn_inferior ();
4483 * Function: init_inferior
4485 * When GDB forks to create a runnable inferior process,
4486 * this function is called on the parent side of the fork.
4487 * It's job is to do whatever is necessary to make the child
4488 * ready to be debugged, and then wait for the child to synchronize.
4492 procfs_init_inferior (pid)
4499 /* This routine called on the parent side (GDB side)
4500 after GDB forks the inferior. */
4502 push_target (&procfs_ops);
4504 if ((pi = create_procinfo (pid, 0)) == NULL)
4505 perror ("procfs: out of memory in 'init_inferior'");
4507 if (!open_procinfo_files (pi, FD_CTL))
4508 proc_error (pi, "init_inferior, open_proc_files", __LINE__);
4512 open_procinfo_files // done
4515 procfs_notice_signals
4522 /* If not stopped yet, wait for it to stop. */
4523 if (!(proc_flags (pi) & PR_STOPPED) &&
4524 !(proc_wait_for_stop (pi)))
4525 dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL);
4527 /* Save some of the /proc state to be restored if we detach. */
4528 /* FIXME: Why? In case another debugger was debugging it?
4529 We're it's parent, for Ghu's sake! */
4530 if (!proc_get_traced_signals (pi, &pi->saved_sigset))
4531 proc_error (pi, "init_inferior, get_traced_signals", __LINE__);
4532 if (!proc_get_held_signals (pi, &pi->saved_sighold))
4533 proc_error (pi, "init_inferior, get_held_signals", __LINE__);
4534 if (!proc_get_traced_faults (pi, &pi->saved_fltset))
4535 proc_error (pi, "init_inferior, get_traced_faults", __LINE__);
4536 if (!proc_get_traced_sysentry (pi, &pi->saved_entryset))
4537 proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__);
4538 if (!proc_get_traced_sysexit (pi, &pi->saved_exitset))
4539 proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__);
4541 /* Register to trace selected signals in the child. */
4542 prfillset (&signals);
4543 if (!register_gdb_signals (pi, &signals))
4544 proc_error (pi, "init_inferior, register_signals", __LINE__);
4546 if ((fail = procfs_debug_inferior (pi)) != 0)
4547 proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
4549 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4550 and possibly even turning ON kill-on-last-close at this point. But
4551 I can't make that change without careful testing which I don't have
4552 time to do right now... */
4553 /* Turn on run-on-last-close flag so that the child
4554 will die if GDB goes away for some reason. */
4555 if (!proc_set_run_on_last_close (pi))
4556 proc_error (pi, "init_inferior, set_RLC", __LINE__);
4558 /* The 'process ID' we return to GDB is composed of
4559 the actual process ID plus the lwp ID. */
4560 inferior_pid = MERGEPID (pi->pid, proc_get_current_thread (pi));
4562 #ifdef START_INFERIOR_TRAPS_EXPECTED
4563 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
4565 /* One trap to exec the shell, one to exec the program being debugged. */
4566 startup_inferior (2);
4567 #endif /* START_INFERIOR_TRAPS_EXPECTED */
4571 * Function: set_exec_trap
4573 * When GDB forks to create a new process, this function is called
4574 * on the child side of the fork before GDB exec's the user program.
4575 * Its job is to make the child minimally debuggable, so that the
4576 * parent GDB process can connect to the child and take over.
4577 * This function should do only the minimum to make that possible,
4578 * and to synchronize with the parent process. The parent process
4579 * should take care of the details.
4583 procfs_set_exec_trap ()
4585 /* This routine called on the child side (inferior side)
4586 after GDB forks the inferior. It must use only local variables,
4587 because it may be sharing data space with its parent. */
4592 if ((pi = create_procinfo (getpid (), 0)) == NULL)
4593 perror_with_name ("procfs: create_procinfo failed in child.");
4595 if (open_procinfo_files (pi, FD_CTL) == 0)
4597 proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__);
4598 gdb_flush (gdb_stderr);
4599 /* no need to call "dead_procinfo", because we're going to exit. */
4603 #ifdef PRFS_STOPEXEC /* defined on OSF */
4604 /* OSF method for tracing exec syscalls. Quoting:
4605 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4606 exits from exec system calls because of the user level loader. */
4607 /* FIXME: make nice and maybe move into an access function. */
4611 if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
4613 proc_warn (pi, "set_exec_trap (PIOCGSPCACT)", __LINE__);
4614 gdb_flush (gdb_stderr);
4617 prfs_flags |= PRFS_STOPEXEC;
4619 if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
4621 proc_warn (pi, "set_exec_trap (PIOCSSPCACT)", __LINE__);
4622 gdb_flush (gdb_stderr);
4626 #else /* not PRFS_STOPEXEC */
4627 /* Everyone else's (except OSF) method for tracing exec syscalls */
4629 Not all systems with /proc have all the exec* syscalls with the same
4630 names. On the SGI, for example, there is no SYS_exec, but there
4631 *is* a SYS_execv. So, we try to account for that. */
4633 premptyset (&exitset);
4635 praddset (&exitset, SYS_exec);
4638 praddset (&exitset, SYS_execve);
4641 praddset (&exitset, SYS_execv);
4644 if (!proc_set_traced_sysexit (pi, &exitset))
4646 proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__);
4647 gdb_flush (gdb_stderr);
4650 #endif /* PRFS_STOPEXEC */
4652 /* FIXME: should this be done in the parent instead? */
4653 /* Turn off inherit on fork flag so that all grand-children
4654 of gdb start with tracing flags cleared. */
4655 if (!proc_unset_inherit_on_fork (pi))
4656 proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__);
4658 /* Turn off run on last close flag, so that the child process
4659 cannot run away just because we close our handle on it.
4660 We want it to wait for the parent to attach. */
4661 if (!proc_unset_run_on_last_close (pi))
4662 proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__);
4664 /* FIXME: No need to destroy the procinfo --
4665 we have our own address space, and we're about to do an exec! */
4666 /*destroy_procinfo (pi);*/
4670 * Function: create_inferior
4672 * This function is called BEFORE gdb forks the inferior process.
4673 * Its only real responsibility is to set things up for the fork,
4674 * and tell GDB which two functions to call after the fork (one
4675 * for the parent, and one for the child).
4677 * This function does a complicated search for a unix shell program,
4678 * which it then uses to parse arguments and environment variables
4679 * to be sent to the child. I wonder whether this code could not
4680 * be abstracted out and shared with other unix targets such as
4685 procfs_create_inferior (exec_file, allargs, env)
4690 char *shell_file = getenv ("SHELL");
4692 if (shell_file != NULL && strchr (shell_file, '/') == NULL)
4695 /* We will be looking down the PATH to find shell_file. If we
4696 just do this the normal way (via execlp, which operates by
4697 attempting an exec for each element of the PATH until it
4698 finds one which succeeds), then there will be an exec for
4699 each failed attempt, each of which will cause a PR_SYSEXIT
4700 stop, and we won't know how to distinguish the PR_SYSEXIT's
4701 for these failed execs with the ones for successful execs
4702 (whether the exec has succeeded is stored at that time in the
4703 carry bit or some such architecture-specific and
4704 non-ABI-specified place).
4706 So I can't think of anything better than to search the PATH
4707 now. This has several disadvantages: (1) There is a race
4708 condition; if we find a file now and it is deleted before we
4709 exec it, we lose, even if the deletion leaves a valid file
4710 further down in the PATH, (2) there is no way to know exactly
4711 what an executable (in the sense of "capable of being
4712 exec'd") file is. Using access() loses because it may lose
4713 if the caller is the superuser; failing to use it loses if
4714 there are ACLs or some such. */
4718 /* FIXME-maybe: might want "set path" command so user can change what
4719 path is used from within GDB. */
4720 char *path = getenv ("PATH");
4722 struct stat statbuf;
4725 path = "/bin:/usr/bin";
4727 tryname = alloca (strlen (path) + strlen (shell_file) + 2);
4728 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
4730 p1 = strchr (p, ':');
4735 strncpy (tryname, p, len);
4736 tryname[len] = '\0';
4737 strcat (tryname, "/");
4738 strcat (tryname, shell_file);
4739 if (access (tryname, X_OK) < 0)
4741 if (stat (tryname, &statbuf) < 0)
4743 if (!S_ISREG (statbuf.st_mode))
4744 /* We certainly need to reject directories. I'm not quite
4745 as sure about FIFOs, sockets, etc., but I kind of doubt
4746 that people want to exec() these things. */
4751 /* Not found. This must be an error rather than merely passing
4752 the file to execlp(), because execlp() would try all the
4753 exec()s, causing GDB to get confused. */
4754 error ("procfs:%d -- Can't find shell %s in PATH",
4755 __LINE__, shell_file);
4757 shell_file = tryname;
4760 fork_inferior (exec_file, allargs, env, procfs_set_exec_trap,
4761 procfs_init_inferior, NULL, shell_file);
4763 /* We are at the first instruction we care about. */
4764 /* Pedal to the metal... */
4766 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
4770 * Function: notice_thread
4772 * Callback for find_new_threads.
4773 * Calls "add_thread".
4777 procfs_notice_thread (pi, thread, ptr)
4782 int gdb_threadid = MERGEPID (pi->pid, thread->tid);
4784 if (!in_thread_list (gdb_threadid))
4785 add_thread (gdb_threadid);
4791 * Function: target_find_new_threads
4793 * Query all the threads that the target knows about,
4794 * and give them back to GDB to add to its list.
4798 procfs_find_new_threads ()
4802 /* Find procinfo for main process */
4803 pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
4804 proc_update_threads (pi);
4805 proc_iterate_over_threads (pi, procfs_notice_thread, NULL);
4809 * Function: target_thread_alive
4811 * Return true if the thread is still 'alive'.
4813 * This guy doesn't really seem to be doing his job.
4814 * Got to investigate how to tell when a thread is really gone.
4818 procfs_thread_alive (pid)
4824 proc = PIDGET (pid);
4825 thread = TIDGET (pid);
4826 /* If I don't know it, it ain't alive! */
4827 if ((pi = find_procinfo (proc, thread)) == NULL)
4830 /* If I can't get its status, it ain't alive!
4831 What's more, I need to forget about it! */
4832 if (!proc_get_status (pi))
4834 destroy_procinfo (pi);
4837 /* I couldn't have got its status if it weren't alive, so it's alive. */
4842 * Function: target_pid_to_str
4844 * Return a string to be used to identify the thread in
4845 * the "info threads" display.
4849 procfs_pid_to_str (pid)
4852 static char buf[80];
4856 proc = PIDGET (pid);
4857 thread = TIDGET (pid);
4858 pi = find_procinfo (proc, thread);
4861 sprintf (buf, "Process %d", proc);
4863 sprintf (buf, "LWP %d", thread);
4868 * Function: procfs_set_watchpoint
4869 * Insert a watchpoint
4873 procfs_set_watchpoint (pid, addr, len, rwflag, after)
4884 pi = find_procinfo_or_die (pid == -1 ?
4885 PIDGET (inferior_pid) : PIDGET (pid), 0);
4887 /* Translate from GDB's flags to /proc's */
4888 if (len > 0) /* len == 0 means delete watchpoint */
4890 switch (rwflag) { /* FIXME: need an enum! */
4891 case hw_write: /* default watchpoint (write) */
4892 pflags = WRITE_WATCHFLAG;
4894 case hw_read: /* read watchpoint */
4895 pflags = READ_WATCHFLAG;
4897 case hw_access: /* access watchpoint */
4898 pflags = READ_WATCHFLAG | WRITE_WATCHFLAG;
4900 case hw_execute: /* execution HW breakpoint */
4901 pflags = EXEC_WATCHFLAG;
4903 default: /* Something weird. Return error. */
4906 if (after) /* Stop after r/w access is completed. */
4907 pflags |= AFTER_WATCHFLAG;
4910 if (!proc_set_watchpoint (pi, addr, len, pflags))
4912 if (errno == E2BIG) /* Typical error for no resources */
4913 return -1; /* fail */
4914 /* GDB may try to remove the same watchpoint twice.
4915 If a remove request returns no match, don't error. */
4916 if (errno == ESRCH && len == 0)
4917 return 0; /* ignore */
4918 proc_error (pi, "set_watchpoint", __LINE__);
4925 * Function: stopped_by_watchpoint
4927 * Returns non-zero if process is stopped on a hardware watchpoint fault,
4928 * else returns zero.
4932 procfs_stopped_by_watchpoint (pid)
4937 pi = find_procinfo_or_die (pid == -1 ?
4938 PIDGET (inferior_pid) : PIDGET (pid), 0);
4939 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
4941 if (proc_why (pi) == PR_FAULTED)
4944 if (proc_what (pi) == FLTWATCH)
4948 if (proc_what (pi) == FLTKWATCH)
4956 #ifdef TM_I386SOL2_H
4958 * Function: procfs_find_LDT_entry
4961 * int pid; // The GDB-style pid-plus-LWP.
4964 * pointer to the corresponding LDT entry.
4968 procfs_find_LDT_entry (pid)
4971 gdb_gregset_t *gregs;
4975 /* Find procinfo for the lwp. */
4976 if ((pi = find_procinfo (PIDGET (pid), TIDGET (pid))) == NULL)
4978 warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
4982 /* get its general registers. */
4983 if ((gregs = proc_get_gregs (pi)) == NULL)
4985 warning ("procfs_find_LDT_entry: could not read gregs for %d.",
4989 /* Now extract the GS register's lower 16 bits. */
4990 key = (*gregs)[GS] & 0xffff;
4992 /* Find the matching entry and return it. */
4993 return proc_get_LDT_entry (pi, key);
4995 #endif /* TM_I386SOL2_H */
5000 info_proc_cmd (args, from_tty)
5004 struct cleanup *old_chain;
5005 procinfo *process = NULL;
5006 procinfo *thread = NULL;
5012 old_chain = make_cleanup (null_cleanup, 0);
5015 if ((argv = buildargv (args)) == NULL)
5018 make_cleanup_freeargv (argv);
5020 while (argv != NULL && *argv != NULL)
5022 if (isdigit (argv[0][0]))
5024 pid = strtoul (argv[0], &tmp, 10);
5026 tid = strtoul (++tmp, NULL, 10);
5028 else if (argv[0][0] == '/')
5030 tid = strtoul (argv[0] + 1, NULL, 10);
5039 pid = PIDGET (inferior_pid);
5041 error ("No current process: you must name one.");
5044 /* Have pid, will travel.
5045 First see if it's a process we're already debugging. */
5046 process = find_procinfo (pid, 0);
5047 if (process == NULL)
5049 /* No. So open a procinfo for it, but
5050 remember to close it again when finished. */
5051 process = create_procinfo (pid, 0);
5052 make_cleanup (do_destroy_procinfo_cleanup, process);
5053 if (!open_procinfo_files (process, FD_CTL))
5054 proc_error (process, "info proc, open_procinfo_files", __LINE__);
5058 thread = create_procinfo (pid, tid);
5062 printf_filtered ("process %d flags:\n", process->pid);
5063 proc_prettyprint_flags (proc_flags (process), 1);
5064 if (proc_flags (process) & (PR_STOPPED | PR_ISTOP))
5065 proc_prettyprint_why (proc_why (process), proc_what (process), 1);
5066 if (proc_get_nthreads (process) > 1)
5067 printf_filtered ("Process has %d threads.\n",
5068 proc_get_nthreads (process));
5072 printf_filtered ("thread %d flags:\n", thread->tid);
5073 proc_prettyprint_flags (proc_flags (thread), 1);
5074 if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP))
5075 proc_prettyprint_why (proc_why (thread), proc_what (thread), 1);
5078 do_cleanups (old_chain);
5082 proc_trace_syscalls (args, from_tty, entry_or_exit, mode)
5092 if (inferior_pid <= 0)
5093 error ("you must be debugging a process to use this command.");
5095 if (args == NULL || args[0] == 0)
5096 error_no_arg ("system call to trace");
5098 pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
5099 if (isdigit (args[0]))
5101 syscallnum = atoi (args);
5102 if (entry_or_exit == PR_SYSENTRY)
5103 sysset = proc_get_traced_sysentry (pi, NULL);
5105 sysset = proc_get_traced_sysexit (pi, NULL);
5108 proc_error (pi, "proc-trace, get_traced_sysset", __LINE__);
5110 if (mode == FLAG_SET)
5111 praddset (sysset, syscallnum);
5113 prdelset (sysset, syscallnum);
5115 if (entry_or_exit == PR_SYSENTRY)
5117 if (!proc_set_traced_sysentry (pi, sysset))
5118 proc_error (pi, "proc-trace, set_traced_sysentry", __LINE__);
5122 if (!proc_set_traced_sysexit (pi, sysset))
5123 proc_error (pi, "proc-trace, set_traced_sysexit", __LINE__);
5129 proc_trace_sysentry_cmd (args, from_tty)
5133 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_SET);
5137 proc_trace_sysexit_cmd (args, from_tty)
5141 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_SET);
5145 proc_untrace_sysentry_cmd (args, from_tty)
5149 proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET);
5153 proc_untrace_sysexit_cmd (args, from_tty)
5157 proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET);
5162 _initialize_procfs ()
5165 add_target (&procfs_ops);
5166 add_info ("proc", info_proc_cmd,
5167 "Show /proc process information about any running process.\
5168 Default is the process being debugged.");
5169 add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
5170 "Give a trace of entries into the syscall.");
5171 add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd,
5172 "Give a trace of exits from the syscall.");
5173 add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd,
5174 "Cancel a trace of entries into the syscall.");
5175 add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd,
5176 "Cancel a trace of exits from the syscall.");
5179 /* =================== END, GDB "MODULE" =================== */
5183 /* miscelaneous stubs: */
5184 /* The following satisfy a few random symbols mostly created by */
5185 /* the solaris threads implementation, which I will chase down */
5189 * Return a pid for which we guarantee
5190 * we will be able to find a 'live' procinfo.
5194 procfs_first_available ()
5197 return procinfo_list->pid;