1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 Written by Michael Snyder at Cygnus Solutions.
7 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "elf-bfd.h" /* for elfcore_write_* */
30 #include "gdbthread.h"
33 #if defined (NEW_PROC_API)
34 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
37 #include <sys/procfs.h>
38 #ifdef HAVE_SYS_FAULT_H
39 #include <sys/fault.h>
41 #ifdef HAVE_SYS_SYSCALL_H
42 #include <sys/syscall.h>
44 #include <sys/errno.h>
48 #include "gdb_string.h"
49 #include "gdb_assert.h"
56 * This module provides the interface between GDB and the
57 * /proc file system, which is used on many versions of Unix
58 * as a means for debuggers to control other processes.
59 * Examples of the systems that use this interface are:
66 * /proc works by imitating a file system: you open a simulated file
67 * that represents the process you wish to interact with, and
68 * perform operations on that "file" in order to examine or change
69 * the state of the other process.
71 * The most important thing to know about /proc and this module
72 * is that there are two very different interfaces to /proc:
73 * One that uses the ioctl system call, and
74 * another that uses read and write system calls.
75 * This module has to support both /proc interfaces. This means
76 * that there are two different ways of doing every basic operation.
78 * In order to keep most of the code simple and clean, I have
79 * defined an interface "layer" which hides all these system calls.
80 * An ifdef (NEW_PROC_API) determines which interface we are using,
81 * and most or all occurrances of this ifdef should be confined to
82 * this interface layer.
86 /* Determine which /proc API we are using:
87 The ioctl API defines PIOCSTATUS, while
88 the read/write (multiple fd) API never does. */
91 #include <sys/types.h>
92 #include "gdb_dirent.h" /* opendir/readdir, for listing the LWP's */
95 #include <fcntl.h> /* for O_RDONLY */
96 #include <unistd.h> /* for "X_OK" */
97 #include "gdb_stat.h" /* for struct stat */
99 /* Note: procfs-utils.h must be included after the above system header
100 files, because it redefines various system calls using macros.
101 This may be incompatible with the prototype declarations. */
103 #include "proc-utils.h"
105 /* Prototypes for supply_gregset etc. */
108 /* =================== TARGET_OPS "MODULE" =================== */
111 * This module defines the GDB target vector and its methods.
114 static void procfs_open (char *, int);
115 static void procfs_attach (char *, int);
116 static void procfs_detach (char *, int);
117 static void procfs_resume (ptid_t
, int, enum target_signal
);
118 static int procfs_can_run (void);
119 static void procfs_stop (void);
120 static void procfs_files_info (struct target_ops
*);
121 static void procfs_fetch_registers (struct regcache
*, int);
122 static void procfs_store_registers (struct regcache
*, int);
123 static void procfs_notice_signals (ptid_t
);
124 static void procfs_prepare_to_store (struct regcache
*);
125 static void procfs_kill_inferior (void);
126 static void procfs_mourn_inferior (void);
127 static void procfs_create_inferior (char *, char *, char **, int);
128 static ptid_t
procfs_wait (ptid_t
, struct target_waitstatus
*);
129 static int procfs_xfer_memory (CORE_ADDR
, char *, int, int,
130 struct mem_attrib
*attrib
,
131 struct target_ops
*);
132 static LONGEST
procfs_xfer_partial (struct target_ops
*ops
,
133 enum target_object object
,
135 void *readbuf
, const void *writebuf
,
136 ULONGEST offset
, LONGEST len
);
138 static int procfs_thread_alive (ptid_t
);
140 void procfs_find_new_threads (void);
141 char *procfs_pid_to_str (ptid_t
);
143 static int proc_find_memory_regions (int (*) (CORE_ADDR
,
149 static char * procfs_make_note_section (bfd
*, int *);
151 static int procfs_can_use_hw_breakpoint (int, int, int);
153 struct target_ops procfs_ops
; /* the target vector */
156 init_procfs_ops (void)
158 procfs_ops
.to_shortname
= "procfs";
159 procfs_ops
.to_longname
= "Unix /proc child process";
161 "Unix /proc child process (started by the \"run\" command).";
162 procfs_ops
.to_open
= procfs_open
;
163 procfs_ops
.to_can_run
= procfs_can_run
;
164 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
165 procfs_ops
.to_kill
= procfs_kill_inferior
;
166 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
167 procfs_ops
.to_attach
= procfs_attach
;
168 procfs_ops
.to_detach
= procfs_detach
;
169 procfs_ops
.to_wait
= procfs_wait
;
170 procfs_ops
.to_resume
= procfs_resume
;
171 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
172 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
173 procfs_ops
.to_store_registers
= procfs_store_registers
;
174 procfs_ops
.to_xfer_partial
= procfs_xfer_partial
;
175 procfs_ops
.deprecated_xfer_memory
= procfs_xfer_memory
;
176 procfs_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
177 procfs_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
178 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
179 procfs_ops
.to_files_info
= procfs_files_info
;
180 procfs_ops
.to_stop
= procfs_stop
;
182 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
183 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
184 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
185 procfs_ops
.to_terminal_ours
= terminal_ours
;
186 procfs_ops
.to_terminal_save_ours
= terminal_save_ours
;
187 procfs_ops
.to_terminal_info
= child_terminal_info
;
189 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
190 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
191 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
193 procfs_ops
.to_has_all_memory
= 1;
194 procfs_ops
.to_has_memory
= 1;
195 procfs_ops
.to_has_execution
= 1;
196 procfs_ops
.to_has_stack
= 1;
197 procfs_ops
.to_has_registers
= 1;
198 procfs_ops
.to_stratum
= process_stratum
;
199 procfs_ops
.to_has_thread_control
= tc_schedlock
;
200 procfs_ops
.to_find_memory_regions
= proc_find_memory_regions
;
201 procfs_ops
.to_make_corefile_notes
= procfs_make_note_section
;
202 procfs_ops
.to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
203 procfs_ops
.to_magic
= OPS_MAGIC
;
206 /* =================== END, TARGET_OPS "MODULE" =================== */
211 * Put any typedefs, defines etc. here that are required for
212 * the unification of code that handles different versions of /proc.
215 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
217 enum { READ_WATCHFLAG
= WA_READ
,
218 WRITE_WATCHFLAG
= WA_WRITE
,
219 EXEC_WATCHFLAG
= WA_EXEC
,
220 AFTER_WATCHFLAG
= WA_TRAPAFTER
223 #else /* Irix method for watchpoints */
224 enum { READ_WATCHFLAG
= MA_READ
,
225 WRITE_WATCHFLAG
= MA_WRITE
,
226 EXEC_WATCHFLAG
= MA_EXEC
,
227 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
232 #ifdef HAVE_PR_SIGSET_T
233 typedef pr_sigset_t gdb_sigset_t
;
235 typedef sigset_t gdb_sigset_t
;
239 #ifdef HAVE_PR_SIGACTION64_T
240 typedef pr_sigaction64_t gdb_sigaction_t
;
242 typedef struct sigaction gdb_sigaction_t
;
246 #ifdef HAVE_PR_SIGINFO64_T
247 typedef pr_siginfo64_t gdb_siginfo_t
;
249 typedef struct siginfo gdb_siginfo_t
;
252 /* gdb_premptysysset */
254 #define gdb_premptysysset premptysysset
256 #define gdb_premptysysset premptyset
261 #define gdb_praddsysset praddsysset
263 #define gdb_praddsysset praddset
268 #define gdb_prdelsysset prdelsysset
270 #define gdb_prdelsysset prdelset
273 /* prissyssetmember */
274 #ifdef prissyssetmember
275 #define gdb_pr_issyssetmember prissyssetmember
277 #define gdb_pr_issyssetmember prismember
280 /* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't
281 as intuitively descriptive as it could be, so we'll define
282 DYNAMIC_SYSCALLS to mean the same thing. Anyway, at the time of
283 this writing, this feature is only found on AIX5 systems and
284 basically means that the set of syscalls is not fixed. I.e,
285 there's no nice table that one can #include to get all of the
286 syscall numbers. Instead, they're stored in /proc/PID/sysent
287 for each process. We are at least guaranteed that they won't
288 change over the lifetime of the process. But each process could
289 (in theory) have different syscall numbers.
291 #ifdef HAVE_PRSYSENT_T
292 #define DYNAMIC_SYSCALLS
297 /* =================== STRUCT PROCINFO "MODULE" =================== */
299 /* FIXME: this comment will soon be out of date W.R.T. threads. */
301 /* The procinfo struct is a wrapper to hold all the state information
302 concerning a /proc process. There should be exactly one procinfo
303 for each process, and since GDB currently can debug only one
304 process at a time, that means there should be only one procinfo.
305 All of the LWP's of a process can be accessed indirectly thru the
306 single process procinfo.
308 However, against the day when GDB may debug more than one process,
309 this data structure is kept in a list (which for now will hold no
310 more than one member), and many functions will have a pointer to a
311 procinfo as an argument.
313 There will be a separate procinfo structure for use by the (not yet
314 implemented) "info proc" command, so that we can print useful
315 information about any random process without interfering with the
316 inferior's procinfo information. */
319 /* format strings for /proc paths */
320 # ifndef CTL_PROC_NAME_FMT
321 # define MAIN_PROC_NAME_FMT "/proc/%d"
322 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
323 # define AS_PROC_NAME_FMT "/proc/%d/as"
324 # define MAP_PROC_NAME_FMT "/proc/%d/map"
325 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
326 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
328 /* the name of the proc status struct depends on the implementation */
329 typedef pstatus_t gdb_prstatus_t
;
330 typedef lwpstatus_t gdb_lwpstatus_t
;
331 #else /* ! NEW_PROC_API */
332 /* format strings for /proc paths */
333 # ifndef CTL_PROC_NAME_FMT
334 # define MAIN_PROC_NAME_FMT "/proc/%05d"
335 # define CTL_PROC_NAME_FMT "/proc/%05d"
336 # define AS_PROC_NAME_FMT "/proc/%05d"
337 # define MAP_PROC_NAME_FMT "/proc/%05d"
338 # define STATUS_PROC_NAME_FMT "/proc/%05d"
339 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
341 /* the name of the proc status struct depends on the implementation */
342 typedef prstatus_t gdb_prstatus_t
;
343 typedef prstatus_t gdb_lwpstatus_t
;
344 #endif /* NEW_PROC_API */
346 typedef struct procinfo
{
347 struct procinfo
*next
;
348 int pid
; /* Process ID */
349 int tid
; /* Thread/LWP id */
353 int ignore_next_sigstop
;
355 /* The following four fd fields may be identical, or may contain
356 several different fd's, depending on the version of /proc
357 (old ioctl or new read/write). */
359 int ctl_fd
; /* File descriptor for /proc control file */
361 * The next three file descriptors are actually only needed in the
362 * read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
363 * However, to avoid a bunch of #ifdefs in the code, we will use
364 * them uniformly by (in the case of the ioctl single-file-descriptor
365 * implementation) filling them with copies of the control fd.
367 int status_fd
; /* File descriptor for /proc status file */
368 int as_fd
; /* File descriptor for /proc as file */
370 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
372 fltset_t saved_fltset
; /* Saved traced hardware fault set */
373 gdb_sigset_t saved_sigset
; /* Saved traced signal set */
374 gdb_sigset_t saved_sighold
; /* Saved held signal set */
375 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
376 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
378 gdb_prstatus_t prstatus
; /* Current process status info */
381 gdb_fpregset_t fpregset
; /* Current floating point registers */
384 #ifdef DYNAMIC_SYSCALLS
385 int num_syscalls
; /* Total number of syscalls */
386 char **syscall_names
; /* Syscall number to name map */
389 struct procinfo
*thread_list
;
391 int status_valid
: 1;
393 int fpregs_valid
: 1;
394 int threads_valid
: 1;
397 static char errmsg
[128]; /* shared error msg buffer */
399 /* Function prototypes for procinfo module: */
401 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
402 static procinfo
*find_procinfo (int pid
, int tid
);
403 static procinfo
*create_procinfo (int pid
, int tid
);
404 static void destroy_procinfo (procinfo
* p
);
405 static void do_destroy_procinfo_cleanup (void *);
406 static void dead_procinfo (procinfo
* p
, char *msg
, int killp
);
407 static int open_procinfo_files (procinfo
* p
, int which
);
408 static void close_procinfo_files (procinfo
* p
);
409 static int sysset_t_size (procinfo
*p
);
410 static sysset_t
*sysset_t_alloc (procinfo
* pi
);
411 #ifdef DYNAMIC_SYSCALLS
412 static void load_syscalls (procinfo
*pi
);
413 static void free_syscalls (procinfo
*pi
);
414 static int find_syscall (procinfo
*pi
, char *name
);
415 #endif /* DYNAMIC_SYSCALLS */
417 /* The head of the procinfo list: */
418 static procinfo
* procinfo_list
;
421 * Function: find_procinfo
423 * Search the procinfo list.
425 * Returns: pointer to procinfo, or NULL if not found.
429 find_procinfo (int pid
, int tid
)
433 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
440 /* Don't check threads_valid. If we're updating the
441 thread_list, we want to find whatever threads are already
442 here. This means that in general it is the caller's
443 responsibility to check threads_valid and update before
444 calling find_procinfo, if the caller wants to find a new
447 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
456 * Function: find_procinfo_or_die
458 * Calls find_procinfo, but errors on failure.
462 find_procinfo_or_die (int pid
, int tid
)
464 procinfo
*pi
= find_procinfo (pid
, tid
);
469 error (_("procfs: couldn't find pid %d (kernel thread %d) in procinfo list."),
472 error (_("procfs: couldn't find pid %d in procinfo list."), pid
);
477 /* open_with_retry() is a wrapper for open(). The appropriate
478 open() call is attempted; if unsuccessful, it will be retried as
479 many times as needed for the EAGAIN and EINTR conditions.
481 For other conditions, open_with_retry() will retry the open() a
482 limited number of times. In addition, a short sleep is imposed
483 prior to retrying the open(). The reason for this sleep is to give
484 the kernel a chance to catch up and create the file in question in
485 the event that GDB "wins" the race to open a file before the kernel
489 open_with_retry (const char *pathname
, int flags
)
491 int retries_remaining
, status
;
493 retries_remaining
= 2;
497 status
= open (pathname
, flags
);
499 if (status
>= 0 || retries_remaining
== 0)
501 else if (errno
!= EINTR
&& errno
!= EAGAIN
)
512 * Function: open_procinfo_files
514 * Open the file descriptor for the process or LWP.
515 * ifdef NEW_PROC_API, we only open the control file descriptor;
516 * the others are opened lazily as needed.
517 * else (if not NEW_PROC_API), there is only one real
518 * file descriptor, but we keep multiple copies of it so that
519 * the code that uses them does not have to be #ifdef'd.
521 * Return: file descriptor, or zero for failure.
524 enum { FD_CTL
, FD_STATUS
, FD_AS
};
527 open_procinfo_files (procinfo
*pi
, int which
)
530 char tmp
[MAX_PROC_NAME_SIZE
];
535 * This function is getting ALMOST long enough to break up into several.
536 * Here is some rationale:
538 * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
539 * There are several file descriptors that may need to be open
540 * for any given process or LWP. The ones we're intereted in are:
541 * - control (ctl) write-only change the state
542 * - status (status) read-only query the state
543 * - address space (as) read/write access memory
544 * - map (map) read-only virtual addr map
545 * Most of these are opened lazily as they are needed.
546 * The pathnames for the 'files' for an LWP look slightly
547 * different from those of a first-class process:
548 * Pathnames for a process (<proc-id>):
549 * /proc/<proc-id>/ctl
550 * /proc/<proc-id>/status
552 * /proc/<proc-id>/map
553 * Pathnames for an LWP (lwp-id):
554 * /proc/<proc-id>/lwp/<lwp-id>/lwpctl
555 * /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
556 * An LWP has no map or address space file descriptor, since
557 * the memory map and address space are shared by all LWPs.
559 * Everyone else (Solaris 2.5, Irix, OSF)
560 * There is only one file descriptor for each process or LWP.
561 * For convenience, we copy the same file descriptor into all
562 * three fields of the procinfo struct (ctl_fd, status_fd, and
563 * as_fd, see NEW_PROC_API above) so that code that uses them
564 * doesn't need any #ifdef's.
569 * Each LWP has an independent file descriptor, but these
570 * are not obtained via the 'open' system call like the rest:
571 * instead, they're obtained thru an ioctl call (PIOCOPENLWP)
572 * to the file descriptor of the parent process.
575 * These do not even have their own independent file descriptor.
576 * All operations are carried out on the file descriptor of the
577 * parent process. Therefore we just call open again for each
578 * thread, getting a new handle for the same 'file'.
583 * In this case, there are several different file descriptors that
584 * we might be asked to open. The control file descriptor will be
585 * opened early, but the others will be opened lazily as they are
589 strcpy (tmp
, pi
->pathname
);
590 switch (which
) { /* which file descriptor to open? */
593 strcat (tmp
, "/lwpctl");
595 strcat (tmp
, "/ctl");
596 fd
= open_with_retry (tmp
, O_WRONLY
);
603 return 0; /* there is no 'as' file descriptor for an lwp */
605 fd
= open_with_retry (tmp
, O_RDWR
);
612 strcat (tmp
, "/lwpstatus");
614 strcat (tmp
, "/status");
615 fd
= open_with_retry (tmp
, O_RDONLY
);
621 return 0; /* unknown file descriptor */
623 #else /* not NEW_PROC_API */
625 * In this case, there is only one file descriptor for each procinfo
626 * (ie. each process or LWP). In fact, only the file descriptor for
627 * the process can actually be opened by an 'open' system call.
628 * The ones for the LWPs have to be obtained thru an IOCTL call
629 * on the process's file descriptor.
631 * For convenience, we copy each procinfo's single file descriptor
632 * into all of the fields occupied by the several file descriptors
633 * of the NEW_PROC_API implementation. That way, the code that uses
634 * them can be written without ifdefs.
638 #ifdef PIOCTSTATUS /* OSF */
639 /* Only one FD; just open it. */
640 if ((fd
= open_with_retry (pi
->pathname
, O_RDWR
)) == 0)
642 #else /* Sol 2.5, Irix, other? */
643 if (pi
->tid
== 0) /* Master procinfo for the process */
645 fd
= open_with_retry (pi
->pathname
, O_RDWR
);
649 else /* LWP thread procinfo */
651 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
655 /* Find the procinfo for the entire process. */
656 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
659 /* Now obtain the file descriptor for the LWP. */
660 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) <= 0)
662 #else /* Irix, other? */
663 return 0; /* Don't know how to open threads */
664 #endif /* Sol 2.5 PIOCOPENLWP */
666 #endif /* OSF PIOCTSTATUS */
667 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
668 #endif /* NEW_PROC_API */
670 return 1; /* success */
674 * Function: create_procinfo
676 * Allocate a data structure and link it into the procinfo list.
677 * (First tries to find a pre-existing one (FIXME: why?)
679 * Return: pointer to new procinfo struct.
683 create_procinfo (int pid
, int tid
)
685 procinfo
*pi
, *parent
;
687 if ((pi
= find_procinfo (pid
, tid
)))
688 return pi
; /* Already exists, nothing to do. */
690 /* find parent before doing malloc, to save having to cleanup */
692 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
694 doesn't exist yet? */
696 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
697 memset (pi
, 0, sizeof (procinfo
));
701 #ifdef DYNAMIC_SYSCALLS
705 pi
->saved_entryset
= sysset_t_alloc (pi
);
706 pi
->saved_exitset
= sysset_t_alloc (pi
);
708 /* Chain into list. */
711 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
712 pi
->next
= procinfo_list
;
718 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
720 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
722 pi
->next
= parent
->thread_list
;
723 parent
->thread_list
= pi
;
729 * Function: close_procinfo_files
731 * Close all file descriptors associated with the procinfo
735 close_procinfo_files (procinfo
*pi
)
742 if (pi
->status_fd
> 0)
743 close (pi
->status_fd
);
745 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
749 * Function: destroy_procinfo
751 * Destructor function. Close, unlink and deallocate the object.
755 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
759 /* Step one: unlink the procinfo from its list */
763 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
766 ptr
->next
= pi
->next
;
770 /* Step two: close any open file descriptors */
771 close_procinfo_files (pi
);
773 /* Step three: free the memory. */
774 #ifdef DYNAMIC_SYSCALLS
777 xfree (pi
->saved_entryset
);
778 xfree (pi
->saved_exitset
);
783 destroy_procinfo (procinfo
*pi
)
787 if (pi
->tid
!= 0) /* destroy a thread procinfo */
789 tmp
= find_procinfo (pi
->pid
, 0); /* find the parent process */
790 destroy_one_procinfo (&tmp
->thread_list
, pi
);
792 else /* destroy a process procinfo and all its threads */
794 /* First destroy the children, if any; */
795 while (pi
->thread_list
!= NULL
)
796 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
797 /* Then destroy the parent. Genocide!!! */
798 destroy_one_procinfo (&procinfo_list
, pi
);
803 do_destroy_procinfo_cleanup (void *pi
)
805 destroy_procinfo (pi
);
808 enum { NOKILL
, KILL
};
811 * Function: dead_procinfo
813 * To be called on a non_recoverable error for a procinfo.
814 * Prints error messages, optionally sends a SIGKILL to the process,
815 * then destroys the data structure.
819 dead_procinfo (procinfo
*pi
, char *msg
, int kill_p
)
825 print_sys_errmsg (pi
->pathname
, errno
);
829 sprintf (procfile
, "process %d", pi
->pid
);
830 print_sys_errmsg (procfile
, errno
);
833 kill (pi
->pid
, SIGKILL
);
835 destroy_procinfo (pi
);
840 * Function: sysset_t_size
842 * Returns the (complete) size of a sysset_t struct. Normally, this
843 * is just sizeof (syset_t), but in the case of Monterey/64, the actual
844 * size of sysset_t isn't known until runtime.
848 sysset_t_size (procinfo
* pi
)
850 #ifndef DYNAMIC_SYSCALLS
851 return sizeof (sysset_t
);
853 return sizeof (sysset_t
) - sizeof (uint64_t)
854 + sizeof (uint64_t) * ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
855 / (8 * sizeof (uint64_t)));
859 /* Function: sysset_t_alloc
861 Allocate and (partially) initialize a sysset_t struct. */
864 sysset_t_alloc (procinfo
* pi
)
867 int size
= sysset_t_size (pi
);
868 ret
= xmalloc (size
);
869 #ifdef DYNAMIC_SYSCALLS
870 ret
->pr_size
= (pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
871 / (8 * sizeof (uint64_t));
876 #ifdef DYNAMIC_SYSCALLS
878 /* Function: load_syscalls
880 Extract syscall numbers and names from /proc/<pid>/sysent. Initialize
881 pi->num_syscalls with the number of syscalls and pi->syscall_names
882 with the names. (Certain numbers may be skipped in which case the
883 names for these numbers will be left as NULL.) */
885 #define MAX_SYSCALL_NAME_LENGTH 256
886 #define MAX_SYSCALLS 65536
889 load_syscalls (procinfo
*pi
)
891 char pathname
[MAX_PROC_NAME_SIZE
];
894 prsyscall_t
*syscalls
;
895 int i
, size
, maxcall
;
897 pi
->num_syscalls
= 0;
898 pi
->syscall_names
= 0;
900 /* Open the file descriptor for the sysent file */
901 sprintf (pathname
, "/proc/%d/sysent", pi
->pid
);
902 sysent_fd
= open_with_retry (pathname
, O_RDONLY
);
905 error (_("load_syscalls: Can't open /proc/%d/sysent"), pi
->pid
);
908 size
= sizeof header
- sizeof (prsyscall_t
);
909 if (read (sysent_fd
, &header
, size
) != size
)
911 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
914 if (header
.pr_nsyscalls
== 0)
916 error (_("load_syscalls: /proc/%d/sysent contains no syscalls!"), pi
->pid
);
919 size
= header
.pr_nsyscalls
* sizeof (prsyscall_t
);
920 syscalls
= xmalloc (size
);
922 if (read (sysent_fd
, syscalls
, size
) != size
)
925 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
928 /* Find maximum syscall number. This may not be the same as
929 pr_nsyscalls since that value refers to the number of entries
930 in the table. (Also, the docs indicate that some system
931 call numbers may be skipped.) */
933 maxcall
= syscalls
[0].pr_number
;
935 for (i
= 1; i
< header
.pr_nsyscalls
; i
++)
936 if (syscalls
[i
].pr_number
> maxcall
937 && syscalls
[i
].pr_nameoff
> 0
938 && syscalls
[i
].pr_number
< MAX_SYSCALLS
)
939 maxcall
= syscalls
[i
].pr_number
;
941 pi
->num_syscalls
= maxcall
+1;
942 pi
->syscall_names
= xmalloc (pi
->num_syscalls
* sizeof (char *));
944 for (i
= 0; i
< pi
->num_syscalls
; i
++)
945 pi
->syscall_names
[i
] = NULL
;
947 /* Read the syscall names in */
948 for (i
= 0; i
< header
.pr_nsyscalls
; i
++)
950 char namebuf
[MAX_SYSCALL_NAME_LENGTH
];
954 if (syscalls
[i
].pr_number
>= MAX_SYSCALLS
955 || syscalls
[i
].pr_number
< 0
956 || syscalls
[i
].pr_nameoff
<= 0
957 || (lseek (sysent_fd
, (off_t
) syscalls
[i
].pr_nameoff
, SEEK_SET
)
958 != (off_t
) syscalls
[i
].pr_nameoff
))
961 nread
= read (sysent_fd
, namebuf
, sizeof namebuf
);
965 callnum
= syscalls
[i
].pr_number
;
967 if (pi
->syscall_names
[callnum
] != NULL
)
969 /* FIXME: Generate warning */
973 namebuf
[nread
-1] = '\0';
974 size
= strlen (namebuf
) + 1;
975 pi
->syscall_names
[callnum
] = xmalloc (size
);
976 strncpy (pi
->syscall_names
[callnum
], namebuf
, size
-1);
977 pi
->syscall_names
[callnum
][size
-1] = '\0';
984 /* Function: free_syscalls
986 Free the space allocated for the syscall names from the procinfo
990 free_syscalls (procinfo
*pi
)
992 if (pi
->syscall_names
)
996 for (i
= 0; i
< pi
->num_syscalls
; i
++)
997 if (pi
->syscall_names
[i
] != NULL
)
998 xfree (pi
->syscall_names
[i
]);
1000 xfree (pi
->syscall_names
);
1001 pi
->syscall_names
= 0;
1005 /* Function: find_syscall
1007 Given a name, look up (and return) the corresponding syscall number.
1008 If no match is found, return -1. */
1011 find_syscall (procinfo
*pi
, char *name
)
1014 for (i
= 0; i
< pi
->num_syscalls
; i
++)
1016 if (pi
->syscall_names
[i
] && strcmp (name
, pi
->syscall_names
[i
]) == 0)
1023 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
1025 /* =================== /proc "MODULE" =================== */
1028 * This "module" is the interface layer between the /proc system API
1029 * and the gdb target vector functions. This layer consists of
1030 * access functions that encapsulate each of the basic operations
1031 * that we need to use from the /proc API.
1033 * The main motivation for this layer is to hide the fact that
1034 * there are two very different implementations of the /proc API.
1035 * Rather than have a bunch of #ifdefs all thru the gdb target vector
1036 * functions, we do our best to hide them all in here.
1039 int proc_get_status (procinfo
* pi
);
1040 long proc_flags (procinfo
* pi
);
1041 int proc_why (procinfo
* pi
);
1042 int proc_what (procinfo
* pi
);
1043 int proc_set_run_on_last_close (procinfo
* pi
);
1044 int proc_unset_run_on_last_close (procinfo
* pi
);
1045 int proc_set_inherit_on_fork (procinfo
* pi
);
1046 int proc_unset_inherit_on_fork (procinfo
* pi
);
1047 int proc_set_async (procinfo
* pi
);
1048 int proc_unset_async (procinfo
* pi
);
1049 int proc_stop_process (procinfo
* pi
);
1050 int proc_trace_signal (procinfo
* pi
, int signo
);
1051 int proc_ignore_signal (procinfo
* pi
, int signo
);
1052 int proc_clear_current_fault (procinfo
* pi
);
1053 int proc_set_current_signal (procinfo
* pi
, int signo
);
1054 int proc_clear_current_signal (procinfo
* pi
);
1055 int proc_set_gregs (procinfo
* pi
);
1056 int proc_set_fpregs (procinfo
* pi
);
1057 int proc_wait_for_stop (procinfo
* pi
);
1058 int proc_run_process (procinfo
* pi
, int step
, int signo
);
1059 int proc_kill (procinfo
* pi
, int signo
);
1060 int proc_parent_pid (procinfo
* pi
);
1061 int proc_get_nthreads (procinfo
* pi
);
1062 int proc_get_current_thread (procinfo
* pi
);
1063 int proc_set_held_signals (procinfo
* pi
, gdb_sigset_t
* sighold
);
1064 int proc_set_traced_sysexit (procinfo
* pi
, sysset_t
* sysset
);
1065 int proc_set_traced_sysentry (procinfo
* pi
, sysset_t
* sysset
);
1066 int proc_set_traced_faults (procinfo
* pi
, fltset_t
* fltset
);
1067 int proc_set_traced_signals (procinfo
* pi
, gdb_sigset_t
* sigset
);
1069 int proc_update_threads (procinfo
* pi
);
1070 int proc_iterate_over_threads (procinfo
* pi
,
1071 int (*func
) (procinfo
*, procinfo
*, void *),
1074 gdb_gregset_t
*proc_get_gregs (procinfo
* pi
);
1075 gdb_fpregset_t
*proc_get_fpregs (procinfo
* pi
);
1076 sysset_t
*proc_get_traced_sysexit (procinfo
* pi
, sysset_t
* save
);
1077 sysset_t
*proc_get_traced_sysentry (procinfo
* pi
, sysset_t
* save
);
1078 fltset_t
*proc_get_traced_faults (procinfo
* pi
, fltset_t
* save
);
1079 gdb_sigset_t
*proc_get_traced_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1080 gdb_sigset_t
*proc_get_held_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1081 gdb_sigset_t
*proc_get_pending_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1082 gdb_sigaction_t
*proc_get_signal_actions (procinfo
* pi
, gdb_sigaction_t
*save
);
1084 void proc_warn (procinfo
* pi
, char *func
, int line
);
1085 void proc_error (procinfo
* pi
, char *func
, int line
);
1088 proc_warn (procinfo
*pi
, char *func
, int line
)
1090 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1091 print_sys_errmsg (errmsg
, errno
);
1095 proc_error (procinfo
*pi
, char *func
, int line
)
1097 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1098 perror_with_name (errmsg
);
1102 * Function: proc_get_status
1104 * Updates the status struct in the procinfo.
1105 * There is a 'valid' flag, to let other functions know when
1106 * this function needs to be called (so the status is only
1107 * read when it is needed). The status file descriptor is
1108 * also only opened when it is needed.
1110 * Return: non-zero for success, zero for failure.
1114 proc_get_status (procinfo
*pi
)
1116 /* Status file descriptor is opened "lazily" */
1117 if (pi
->status_fd
== 0 &&
1118 open_procinfo_files (pi
, FD_STATUS
) == 0)
1120 pi
->status_valid
= 0;
1125 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
1126 pi
->status_valid
= 0; /* fail */
1129 /* Sigh... I have to read a different data structure,
1130 depending on whether this is a main process or an LWP. */
1132 pi
->status_valid
= (read (pi
->status_fd
,
1133 (char *) &pi
->prstatus
.pr_lwp
,
1134 sizeof (lwpstatus_t
))
1135 == sizeof (lwpstatus_t
));
1138 pi
->status_valid
= (read (pi
->status_fd
,
1139 (char *) &pi
->prstatus
,
1140 sizeof (gdb_prstatus_t
))
1141 == sizeof (gdb_prstatus_t
));
1142 #if 0 /*def UNIXWARE*/
1143 if (pi
->status_valid
&&
1144 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
1145 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
1146 /* Unixware peculiarity -- read the damn thing again! */
1147 pi
->status_valid
= (read (pi
->status_fd
,
1148 (char *) &pi
->prstatus
,
1149 sizeof (gdb_prstatus_t
))
1150 == sizeof (gdb_prstatus_t
));
1151 #endif /* UNIXWARE */
1154 #else /* ioctl method */
1155 #ifdef PIOCTSTATUS /* osf */
1156 if (pi
->tid
== 0) /* main process */
1158 /* Just read the danged status. Now isn't that simple? */
1160 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1167 tid_t pr_error_thread
;
1168 struct prstatus status
;
1171 thread_status
.pr_count
= 1;
1172 thread_status
.status
.pr_tid
= pi
->tid
;
1173 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
1176 memcpy (&pi
->prstatus
, &thread_status
.status
,
1177 sizeof (pi
->prstatus
));
1178 pi
->status_valid
= 1;
1182 /* Just read the danged status. Now isn't that simple? */
1183 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1187 if (pi
->status_valid
)
1189 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1192 proc_get_current_thread (pi
));
1195 /* The status struct includes general regs, so mark them valid too */
1196 pi
->gregs_valid
= pi
->status_valid
;
1198 /* In the read/write multiple-fd model,
1199 the status struct includes the fp regs too, so mark them valid too */
1200 pi
->fpregs_valid
= pi
->status_valid
;
1202 return pi
->status_valid
; /* True if success, false if failure. */
1206 * Function: proc_flags
1208 * returns the process flags (pr_flags field).
1212 proc_flags (procinfo
*pi
)
1214 if (!pi
->status_valid
)
1215 if (!proc_get_status (pi
))
1216 return 0; /* FIXME: not a good failure value (but what is?) */
1220 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
1221 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
1222 The two sets of flags don't overlap. */
1223 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
1225 return pi
->prstatus
.pr_lwp
.pr_flags
;
1228 return pi
->prstatus
.pr_flags
;
1233 * Function: proc_why
1235 * returns the pr_why field (why the process stopped).
1239 proc_why (procinfo
*pi
)
1241 if (!pi
->status_valid
)
1242 if (!proc_get_status (pi
))
1243 return 0; /* FIXME: not a good failure value (but what is?) */
1246 return pi
->prstatus
.pr_lwp
.pr_why
;
1248 return pi
->prstatus
.pr_why
;
1253 * Function: proc_what
1255 * returns the pr_what field (details of why the process stopped).
1259 proc_what (procinfo
*pi
)
1261 if (!pi
->status_valid
)
1262 if (!proc_get_status (pi
))
1263 return 0; /* FIXME: not a good failure value (but what is?) */
1266 return pi
->prstatus
.pr_lwp
.pr_what
;
1268 return pi
->prstatus
.pr_what
;
1272 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1274 * Function: proc_nsysarg
1276 * returns the pr_nsysarg field (number of args to the current syscall).
1280 proc_nsysarg (procinfo
*pi
)
1282 if (!pi
->status_valid
)
1283 if (!proc_get_status (pi
))
1287 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1289 return pi
->prstatus
.pr_nsysarg
;
1294 * Function: proc_sysargs
1296 * returns the pr_sysarg field (pointer to the arguments of current syscall).
1300 proc_sysargs (procinfo
*pi
)
1302 if (!pi
->status_valid
)
1303 if (!proc_get_status (pi
))
1307 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1309 return (long *) &pi
->prstatus
.pr_sysarg
;
1314 * Function: proc_syscall
1316 * returns the pr_syscall field (id of current syscall if we are in one).
1320 proc_syscall (procinfo
*pi
)
1322 if (!pi
->status_valid
)
1323 if (!proc_get_status (pi
))
1327 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1329 return pi
->prstatus
.pr_syscall
;
1332 #endif /* PIOCSSPCACT */
1335 * Function: proc_cursig:
1337 * returns the pr_cursig field (current signal).
1341 proc_cursig (struct procinfo
*pi
)
1343 if (!pi
->status_valid
)
1344 if (!proc_get_status (pi
))
1345 return 0; /* FIXME: not a good failure value (but what is?) */
1348 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1350 return pi
->prstatus
.pr_cursig
;
1355 * Function: proc_modify_flag
1357 * === I appologize for the messiness of this function.
1358 * === This is an area where the different versions of
1359 * === /proc are more inconsistent than usual. MVS
1361 * Set or reset any of the following process flags:
1362 * PR_FORK -- forked child will inherit trace flags
1363 * PR_RLC -- traced process runs when last /proc file closed.
1364 * PR_KLC -- traced process is killed when last /proc file closed.
1365 * PR_ASYNC -- LWP's get to run/stop independently.
1367 * There are three methods for doing this function:
1368 * 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1370 * 2) Middle: PIOCSET/PIOCRESET
1372 * 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1375 * Note: Irix does not define PR_ASYNC.
1376 * Note: OSF does not define PR_KLC.
1377 * Note: OSF is the only one that can ONLY use the oldest method.
1380 * pi -- the procinfo
1381 * flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1382 * mode -- 1 for set, 0 for reset.
1384 * Returns non-zero for success, zero for failure.
1387 enum { FLAG_RESET
, FLAG_SET
};
1390 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
1392 long win
= 0; /* default to fail */
1395 * These operations affect the process as a whole, and applying
1396 * them to an individual LWP has the same meaning as applying them
1397 * to the main process. Therefore, if we're ever called with a
1398 * pointer to an LWP's procinfo, let's substitute the process's
1399 * procinfo and avoid opening the LWP's file descriptor
1404 pi
= find_procinfo_or_die (pi
->pid
, 0);
1406 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
1407 /* First normalize the PCUNSET/PCRESET command opcode
1408 (which for no obvious reason has a different definition
1409 from one operating system to the next...) */
1411 #define GDBRESET PCUNSET
1414 #define GDBRESET PCRESET
1418 procfs_ctl_t arg
[2];
1420 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC) */
1422 else /* Reset the flag */
1426 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1429 #ifdef PIOCSET /* Irix/Sol5 method */
1430 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
1432 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1434 else /* Reset the flag */
1436 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1440 #ifdef PIOCSRLC /* Oldest method: OSF */
1443 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1445 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1447 else /* Clear run-on-last-close */
1449 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1453 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1455 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1457 else /* Clear inherit-on-fork */
1459 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1463 win
= 0; /* fail -- unknown flag (can't do PR_ASYNC) */
1470 /* The above operation renders the procinfo's cached pstatus obsolete. */
1471 pi
->status_valid
= 0;
1474 warning (_("procfs: modify_flag failed to turn %s %s"),
1475 flag
== PR_FORK
? "PR_FORK" :
1476 flag
== PR_RLC
? "PR_RLC" :
1478 flag
== PR_ASYNC
? "PR_ASYNC" :
1481 flag
== PR_KLC
? "PR_KLC" :
1484 mode
== FLAG_RESET
? "off" : "on");
1490 * Function: proc_set_run_on_last_close
1492 * Set the run_on_last_close flag.
1493 * Process with all threads will become runnable
1494 * when debugger closes all /proc fds.
1496 * Returns non-zero for success, zero for failure.
1500 proc_set_run_on_last_close (procinfo
*pi
)
1502 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1506 * Function: proc_unset_run_on_last_close
1508 * Reset the run_on_last_close flag.
1509 * Process will NOT become runnable
1510 * when debugger closes its file handles.
1512 * Returns non-zero for success, zero for failure.
1516 proc_unset_run_on_last_close (procinfo
*pi
)
1518 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1523 * Function: proc_set_kill_on_last_close
1525 * Set the kill_on_last_close flag.
1526 * Process with all threads will be killed when debugger
1527 * closes all /proc fds (or debugger exits or dies).
1529 * Returns non-zero for success, zero for failure.
1533 proc_set_kill_on_last_close (procinfo
*pi
)
1535 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1539 * Function: proc_unset_kill_on_last_close
1541 * Reset the kill_on_last_close flag.
1542 * Process will NOT be killed when debugger
1543 * closes its file handles (or exits or dies).
1545 * Returns non-zero for success, zero for failure.
1549 proc_unset_kill_on_last_close (procinfo
*pi
)
1551 return proc_modify_flag (pi
, PR_KLC
, FLAG_RESET
);
1556 * Function: proc_set_inherit_on_fork
1558 * Set inherit_on_fork flag.
1559 * If the process forks a child while we are registered for events
1560 * in the parent, then we will also recieve events from the child.
1562 * Returns non-zero for success, zero for failure.
1566 proc_set_inherit_on_fork (procinfo
*pi
)
1568 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1572 * Function: proc_unset_inherit_on_fork
1574 * Reset inherit_on_fork flag.
1575 * If the process forks a child while we are registered for events
1576 * in the parent, then we will NOT recieve events from the child.
1578 * Returns non-zero for success, zero for failure.
1582 proc_unset_inherit_on_fork (procinfo
*pi
)
1584 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1589 * Function: proc_set_async
1591 * Set PR_ASYNC flag.
1592 * If one LWP stops because of a debug event (signal etc.),
1593 * the remaining LWPs will continue to run.
1595 * Returns non-zero for success, zero for failure.
1599 proc_set_async (procinfo
*pi
)
1601 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1605 * Function: proc_unset_async
1607 * Reset PR_ASYNC flag.
1608 * If one LWP stops because of a debug event (signal etc.),
1609 * then all other LWPs will stop as well.
1611 * Returns non-zero for success, zero for failure.
1615 proc_unset_async (procinfo
*pi
)
1617 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1619 #endif /* PR_ASYNC */
1622 * Function: proc_stop_process
1624 * Request the process/LWP to stop. Does not wait.
1625 * Returns non-zero for success, zero for failure.
1629 proc_stop_process (procinfo
*pi
)
1634 * We might conceivably apply this operation to an LWP, and
1635 * the LWP's ctl file descriptor might not be open.
1638 if (pi
->ctl_fd
== 0 &&
1639 open_procinfo_files (pi
, FD_CTL
) == 0)
1644 procfs_ctl_t cmd
= PCSTOP
;
1645 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1646 #else /* ioctl method */
1647 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1648 /* Note: the call also reads the prstatus. */
1651 pi
->status_valid
= 1;
1652 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1655 proc_get_current_thread (pi
));
1664 * Function: proc_wait_for_stop
1666 * Wait for the process or LWP to stop (block until it does).
1667 * Returns non-zero for success, zero for failure.
1671 proc_wait_for_stop (procinfo
*pi
)
1676 * We should never have to apply this operation to any procinfo
1677 * except the one for the main process. If that ever changes
1678 * for any reason, then take out the following clause and
1679 * replace it with one that makes sure the ctl_fd is open.
1683 pi
= find_procinfo_or_die (pi
->pid
, 0);
1687 procfs_ctl_t cmd
= PCWSTOP
;
1688 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1689 /* We been runnin' and we stopped -- need to update status. */
1690 pi
->status_valid
= 0;
1692 #else /* ioctl method */
1693 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1694 /* Above call also refreshes the prstatus. */
1697 pi
->status_valid
= 1;
1698 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1701 proc_get_current_thread (pi
));
1709 * Function: proc_run_process
1711 * Make the process or LWP runnable.
1712 * Options (not all are implemented):
1714 * - clear current fault
1715 * - clear current signal
1716 * - abort the current system call
1717 * - stop as soon as finished with system call
1718 * - (ioctl): set traced signal set
1719 * - (ioctl): set held signal set
1720 * - (ioctl): set traced fault set
1721 * - (ioctl): set start pc (vaddr)
1722 * Always clear the current fault.
1723 * Clear the current signal if 'signo' is zero.
1726 * pi the process or LWP to operate on.
1727 * step if true, set the process or LWP to trap after one instr.
1728 * signo if zero, clear the current signal if any.
1729 * if non-zero, set the current signal to this one.
1731 * Returns non-zero for success, zero for failure.
1735 proc_run_process (procinfo
*pi
, int step
, int signo
)
1741 * We will probably have to apply this operation to individual threads,
1742 * so make sure the control file descriptor is open.
1745 if (pi
->ctl_fd
== 0 &&
1746 open_procinfo_files (pi
, FD_CTL
) == 0)
1751 runflags
= PRCFAULT
; /* always clear current fault */
1756 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals */
1757 proc_set_current_signal (pi
, signo
);
1761 procfs_ctl_t cmd
[2];
1765 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1767 #else /* ioctl method */
1771 memset (&prrun
, 0, sizeof (prrun
));
1772 prrun
.pr_flags
= runflags
;
1773 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1781 * Function: proc_set_traced_signals
1783 * Register to trace signals in the process or LWP.
1784 * Returns non-zero for success, zero for failure.
1788 proc_set_traced_signals (procinfo
*pi
, gdb_sigset_t
*sigset
)
1793 * We should never have to apply this operation to any procinfo
1794 * except the one for the main process. If that ever changes
1795 * for any reason, then take out the following clause and
1796 * replace it with one that makes sure the ctl_fd is open.
1800 pi
= find_procinfo_or_die (pi
->pid
, 0);
1806 /* Use char array to avoid alignment issues. */
1807 char sigset
[sizeof (gdb_sigset_t
)];
1811 memcpy (&arg
.sigset
, sigset
, sizeof (gdb_sigset_t
));
1813 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1815 #else /* ioctl method */
1816 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1818 /* The above operation renders the procinfo's cached pstatus obsolete. */
1819 pi
->status_valid
= 0;
1822 warning (_("procfs: set_traced_signals failed"));
1827 * Function: proc_set_traced_faults
1829 * Register to trace hardware faults in the process or LWP.
1830 * Returns non-zero for success, zero for failure.
1834 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1839 * We should never have to apply this operation to any procinfo
1840 * except the one for the main process. If that ever changes
1841 * for any reason, then take out the following clause and
1842 * replace it with one that makes sure the ctl_fd is open.
1846 pi
= find_procinfo_or_die (pi
->pid
, 0);
1852 /* Use char array to avoid alignment issues. */
1853 char fltset
[sizeof (fltset_t
)];
1857 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1859 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1861 #else /* ioctl method */
1862 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1864 /* The above operation renders the procinfo's cached pstatus obsolete. */
1865 pi
->status_valid
= 0;
1871 * Function: proc_set_traced_sysentry
1873 * Register to trace entry to system calls in the process or LWP.
1874 * Returns non-zero for success, zero for failure.
1878 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1883 * We should never have to apply this operation to any procinfo
1884 * except the one for the main process. If that ever changes
1885 * for any reason, then take out the following clause and
1886 * replace it with one that makes sure the ctl_fd is open.
1890 pi
= find_procinfo_or_die (pi
->pid
, 0);
1894 struct gdb_proc_ctl_pcsentry
{
1896 /* Use char array to avoid alignment issues. */
1897 char sysset
[sizeof (sysset_t
)];
1899 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
)
1901 + sysset_t_size (pi
);
1903 argp
= xmalloc (argp_size
);
1905 argp
->cmd
= PCSENTRY
;
1906 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1908 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1911 #else /* ioctl method */
1912 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1914 /* The above operation renders the procinfo's cached pstatus obsolete. */
1915 pi
->status_valid
= 0;
1921 * Function: proc_set_traced_sysexit
1923 * Register to trace exit from system calls in the process or LWP.
1924 * Returns non-zero for success, zero for failure.
1928 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1933 * We should never have to apply this operation to any procinfo
1934 * except the one for the main process. If that ever changes
1935 * for any reason, then take out the following clause and
1936 * replace it with one that makes sure the ctl_fd is open.
1940 pi
= find_procinfo_or_die (pi
->pid
, 0);
1944 struct gdb_proc_ctl_pcsexit
{
1946 /* Use char array to avoid alignment issues. */
1947 char sysset
[sizeof (sysset_t
)];
1949 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
)
1951 + sysset_t_size (pi
);
1953 argp
= xmalloc (argp_size
);
1955 argp
->cmd
= PCSEXIT
;
1956 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1958 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1961 #else /* ioctl method */
1962 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1964 /* The above operation renders the procinfo's cached pstatus obsolete. */
1965 pi
->status_valid
= 0;
1971 * Function: proc_set_held_signals
1973 * Specify the set of blocked / held signals in the process or LWP.
1974 * Returns non-zero for success, zero for failure.
1978 proc_set_held_signals (procinfo
*pi
, gdb_sigset_t
*sighold
)
1983 * We should never have to apply this operation to any procinfo
1984 * except the one for the main process. If that ever changes
1985 * for any reason, then take out the following clause and
1986 * replace it with one that makes sure the ctl_fd is open.
1990 pi
= find_procinfo_or_die (pi
->pid
, 0);
1996 /* Use char array to avoid alignment issues. */
1997 char hold
[sizeof (gdb_sigset_t
)];
2001 memcpy (&arg
.hold
, sighold
, sizeof (gdb_sigset_t
));
2002 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2005 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
2007 /* The above operation renders the procinfo's cached pstatus obsolete. */
2008 pi
->status_valid
= 0;
2014 * Function: proc_get_pending_signals
2016 * returns the set of signals that are pending in the process or LWP.
2017 * Will also copy the sigset if 'save' is non-zero.
2021 proc_get_pending_signals (procinfo
*pi
, gdb_sigset_t
*save
)
2023 gdb_sigset_t
*ret
= NULL
;
2026 * We should never have to apply this operation to any procinfo
2027 * except the one for the main process. If that ever changes
2028 * for any reason, then take out the following clause and
2029 * replace it with one that makes sure the ctl_fd is open.
2033 pi
= find_procinfo_or_die (pi
->pid
, 0);
2035 if (!pi
->status_valid
)
2036 if (!proc_get_status (pi
))
2040 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
2042 ret
= &pi
->prstatus
.pr_sigpend
;
2045 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
2051 * Function: proc_get_signal_actions
2053 * returns the set of signal actions.
2054 * Will also copy the sigactionset if 'save' is non-zero.
2058 proc_get_signal_actions (procinfo
*pi
, gdb_sigaction_t
*save
)
2060 gdb_sigaction_t
*ret
= NULL
;
2063 * We should never have to apply this operation to any procinfo
2064 * except the one for the main process. If that ever changes
2065 * for any reason, then take out the following clause and
2066 * replace it with one that makes sure the ctl_fd is open.
2070 pi
= find_procinfo_or_die (pi
->pid
, 0);
2072 if (!pi
->status_valid
)
2073 if (!proc_get_status (pi
))
2077 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
2079 ret
= &pi
->prstatus
.pr_action
;
2082 memcpy (save
, ret
, sizeof (gdb_sigaction_t
));
2088 * Function: proc_get_held_signals
2090 * returns the set of signals that are held / blocked.
2091 * Will also copy the sigset if 'save' is non-zero.
2095 proc_get_held_signals (procinfo
*pi
, gdb_sigset_t
*save
)
2097 gdb_sigset_t
*ret
= NULL
;
2100 * We should never have to apply this operation to any procinfo
2101 * except the one for the main process. If that ever changes
2102 * for any reason, then take out the following clause and
2103 * replace it with one that makes sure the ctl_fd is open.
2107 pi
= find_procinfo_or_die (pi
->pid
, 0);
2110 if (!pi
->status_valid
)
2111 if (!proc_get_status (pi
))
2115 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
2117 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
2118 #endif /* UNIXWARE */
2119 #else /* not NEW_PROC_API */
2121 static gdb_sigset_t sigheld
;
2123 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
2126 #endif /* NEW_PROC_API */
2128 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
2134 * Function: proc_get_traced_signals
2136 * returns the set of signals that are traced / debugged.
2137 * Will also copy the sigset if 'save' is non-zero.
2141 proc_get_traced_signals (procinfo
*pi
, gdb_sigset_t
*save
)
2143 gdb_sigset_t
*ret
= NULL
;
2146 * We should never have to apply this operation to any procinfo
2147 * except the one for the main process. If that ever changes
2148 * for any reason, then take out the following clause and
2149 * replace it with one that makes sure the ctl_fd is open.
2153 pi
= find_procinfo_or_die (pi
->pid
, 0);
2156 if (!pi
->status_valid
)
2157 if (!proc_get_status (pi
))
2160 ret
= &pi
->prstatus
.pr_sigtrace
;
2163 static gdb_sigset_t sigtrace
;
2165 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
2170 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
2176 * Function: proc_trace_signal
2178 * Add 'signo' to the set of signals that are traced.
2179 * Returns non-zero for success, zero for failure.
2183 proc_trace_signal (procinfo
*pi
, int signo
)
2188 * We should never have to apply this operation to any procinfo
2189 * except the one for the main process. If that ever changes
2190 * for any reason, then take out the following clause and
2191 * replace it with one that makes sure the ctl_fd is open.
2195 pi
= find_procinfo_or_die (pi
->pid
, 0);
2199 if (proc_get_traced_signals (pi
, &temp
))
2201 praddset (&temp
, signo
);
2202 return proc_set_traced_signals (pi
, &temp
);
2206 return 0; /* failure */
2210 * Function: proc_ignore_signal
2212 * Remove 'signo' from the set of signals that are traced.
2213 * Returns non-zero for success, zero for failure.
2217 proc_ignore_signal (procinfo
*pi
, int signo
)
2222 * We should never have to apply this operation to any procinfo
2223 * except the one for the main process. If that ever changes
2224 * for any reason, then take out the following clause and
2225 * replace it with one that makes sure the ctl_fd is open.
2229 pi
= find_procinfo_or_die (pi
->pid
, 0);
2233 if (proc_get_traced_signals (pi
, &temp
))
2235 prdelset (&temp
, signo
);
2236 return proc_set_traced_signals (pi
, &temp
);
2240 return 0; /* failure */
2244 * Function: proc_get_traced_faults
2246 * returns the set of hardware faults that are traced /debugged.
2247 * Will also copy the faultset if 'save' is non-zero.
2251 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
2253 fltset_t
*ret
= NULL
;
2256 * We should never have to apply this operation to any procinfo
2257 * except the one for the main process. If that ever changes
2258 * for any reason, then take out the following clause and
2259 * replace it with one that makes sure the ctl_fd is open.
2263 pi
= find_procinfo_or_die (pi
->pid
, 0);
2266 if (!pi
->status_valid
)
2267 if (!proc_get_status (pi
))
2270 ret
= &pi
->prstatus
.pr_flttrace
;
2273 static fltset_t flttrace
;
2275 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
2280 memcpy (save
, ret
, sizeof (fltset_t
));
2286 * Function: proc_get_traced_sysentry
2288 * returns the set of syscalls that are traced /debugged on entry.
2289 * Will also copy the syscall set if 'save' is non-zero.
2293 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
2295 sysset_t
*ret
= NULL
;
2298 * We should never have to apply this operation to any procinfo
2299 * except the one for the main process. If that ever changes
2300 * for any reason, then take out the following clause and
2301 * replace it with one that makes sure the ctl_fd is open.
2305 pi
= find_procinfo_or_die (pi
->pid
, 0);
2308 if (!pi
->status_valid
)
2309 if (!proc_get_status (pi
))
2312 #ifndef DYNAMIC_SYSCALLS
2313 ret
= &pi
->prstatus
.pr_sysentry
;
2314 #else /* DYNAMIC_SYSCALLS */
2316 static sysset_t
*sysentry
;
2320 sysentry
= sysset_t_alloc (pi
);
2322 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2324 if (pi
->prstatus
.pr_sysentry_offset
== 0)
2326 gdb_premptysysset (sysentry
);
2332 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysentry_offset
,
2334 != (off_t
) pi
->prstatus
.pr_sysentry_offset
)
2336 size
= sysset_t_size (pi
);
2337 gdb_premptysysset (sysentry
);
2338 rsize
= read (pi
->status_fd
, sysentry
, size
);
2343 #endif /* DYNAMIC_SYSCALLS */
2344 #else /* !NEW_PROC_API */
2346 static sysset_t sysentry
;
2348 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
2351 #endif /* NEW_PROC_API */
2353 memcpy (save
, ret
, sysset_t_size (pi
));
2359 * Function: proc_get_traced_sysexit
2361 * returns the set of syscalls that are traced /debugged on exit.
2362 * Will also copy the syscall set if 'save' is non-zero.
2366 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
2368 sysset_t
* ret
= NULL
;
2371 * We should never have to apply this operation to any procinfo
2372 * except the one for the main process. If that ever changes
2373 * for any reason, then take out the following clause and
2374 * replace it with one that makes sure the ctl_fd is open.
2378 pi
= find_procinfo_or_die (pi
->pid
, 0);
2381 if (!pi
->status_valid
)
2382 if (!proc_get_status (pi
))
2385 #ifndef DYNAMIC_SYSCALLS
2386 ret
= &pi
->prstatus
.pr_sysexit
;
2387 #else /* DYNAMIC_SYSCALLS */
2389 static sysset_t
*sysexit
;
2393 sysexit
= sysset_t_alloc (pi
);
2395 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2397 if (pi
->prstatus
.pr_sysexit_offset
== 0)
2399 gdb_premptysysset (sysexit
);
2405 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysexit_offset
, SEEK_SET
)
2406 != (off_t
) pi
->prstatus
.pr_sysexit_offset
)
2408 size
= sysset_t_size (pi
);
2409 gdb_premptysysset (sysexit
);
2410 rsize
= read (pi
->status_fd
, sysexit
, size
);
2415 #endif /* DYNAMIC_SYSCALLS */
2418 static sysset_t sysexit
;
2420 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2425 memcpy (save
, ret
, sysset_t_size (pi
));
2431 * Function: proc_clear_current_fault
2433 * The current fault (if any) is cleared; the associated signal
2434 * will not be sent to the process or LWP when it resumes.
2435 * Returns non-zero for success, zero for failure.
2439 proc_clear_current_fault (procinfo
*pi
)
2444 * We should never have to apply this operation to any procinfo
2445 * except the one for the main process. If that ever changes
2446 * for any reason, then take out the following clause and
2447 * replace it with one that makes sure the ctl_fd is open.
2451 pi
= find_procinfo_or_die (pi
->pid
, 0);
2455 procfs_ctl_t cmd
= PCCFAULT
;
2456 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2459 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2466 * Function: proc_set_current_signal
2468 * Set the "current signal" that will be delivered next to the process.
2469 * NOTE: semantics are different from those of KILL.
2470 * This signal will be delivered to the process or LWP
2471 * immediately when it is resumed (even if the signal is held/blocked);
2472 * it will NOT immediately cause another event of interest, and will NOT
2473 * first trap back to the debugger.
2475 * Returns non-zero for success, zero for failure.
2479 proc_set_current_signal (procinfo
*pi
, int signo
)
2484 /* Use char array to avoid alignment issues. */
2485 char sinfo
[sizeof (gdb_siginfo_t
)];
2487 gdb_siginfo_t
*mysinfo
;
2489 struct target_waitstatus wait_status
;
2492 * We should never have to apply this operation to any procinfo
2493 * except the one for the main process. If that ever changes
2494 * for any reason, then take out the following clause and
2495 * replace it with one that makes sure the ctl_fd is open.
2499 pi
= find_procinfo_or_die (pi
->pid
, 0);
2501 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2502 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2503 * receives a PIOCSSIG with a signal identical to the current signal,
2504 * it messes up the current signal. Work around the kernel bug.
2507 signo
== proc_cursig (pi
))
2508 return 1; /* I assume this is a success? */
2511 /* The pointer is just a type alias. */
2512 mysinfo
= (gdb_siginfo_t
*) &arg
.sinfo
;
2513 get_last_target_status (&wait_ptid
, &wait_status
);
2514 if (ptid_equal (wait_ptid
, inferior_ptid
)
2515 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
2516 && wait_status
.value
.sig
== target_signal_from_host (signo
)
2517 && proc_get_status (pi
)
2519 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
2521 && pi
->prstatus
.pr_info
.si_signo
== signo
2524 /* Use the siginfo associated with the signal being
2527 memcpy (mysinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (gdb_siginfo_t
));
2529 memcpy (mysinfo
, &pi
->prstatus
.pr_info
, sizeof (gdb_siginfo_t
));
2533 mysinfo
->si_signo
= signo
;
2534 mysinfo
->si_code
= 0;
2535 mysinfo
->si_pid
= getpid (); /* ?why? */
2536 mysinfo
->si_uid
= getuid (); /* ?why? */
2541 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2543 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2550 * Function: proc_clear_current_signal
2552 * The current signal (if any) is cleared, and
2553 * is not sent to the process or LWP when it resumes.
2554 * Returns non-zero for success, zero for failure.
2558 proc_clear_current_signal (procinfo
*pi
)
2563 * We should never have to apply this operation to any procinfo
2564 * except the one for the main process. If that ever changes
2565 * for any reason, then take out the following clause and
2566 * replace it with one that makes sure the ctl_fd is open.
2570 pi
= find_procinfo_or_die (pi
->pid
, 0);
2576 /* Use char array to avoid alignment issues. */
2577 char sinfo
[sizeof (gdb_siginfo_t
)];
2579 gdb_siginfo_t
*mysinfo
;
2582 /* The pointer is just a type alias. */
2583 mysinfo
= (gdb_siginfo_t
*) &arg
.sinfo
;
2584 mysinfo
->si_signo
= 0;
2585 mysinfo
->si_code
= 0;
2586 mysinfo
->si_errno
= 0;
2587 mysinfo
->si_pid
= getpid (); /* ?why? */
2588 mysinfo
->si_uid
= getuid (); /* ?why? */
2590 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2593 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2599 /* Return the general-purpose registers for the process or LWP
2600 corresponding to PI. Upon failure, return NULL. */
2603 proc_get_gregs (procinfo
*pi
)
2605 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2606 if (!proc_get_status (pi
))
2609 /* OK, sorry about the ifdef's. There's three cases instead of two,
2610 because in this case Unixware and Solaris/RW differ. */
2613 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2614 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2616 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2619 return &pi
->prstatus
.pr_reg
;
2623 /* Return the general-purpose registers for the process or LWP
2624 corresponding to PI. Upon failure, return NULL. */
2627 proc_get_fpregs (procinfo
*pi
)
2630 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2631 if (!proc_get_status (pi
))
2634 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2635 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2637 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2640 #else /* not NEW_PROC_API */
2641 if (pi
->fpregs_valid
)
2642 return &pi
->fpregset
; /* Already got 'em. */
2645 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2654 tid_t pr_error_thread
;
2655 tfpregset_t thread_1
;
2658 thread_fpregs
.pr_count
= 1;
2659 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2662 && ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2664 pi
->fpregs_valid
= 1;
2665 return &pi
->fpregset
; /* Got 'em now! */
2667 else if (pi
->tid
!= 0
2668 && ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2670 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2671 sizeof (pi
->fpregset
));
2672 pi
->fpregs_valid
= 1;
2673 return &pi
->fpregset
; /* Got 'em now! */
2680 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2682 pi
->fpregs_valid
= 1;
2683 return &pi
->fpregset
; /* Got 'em now! */
2692 #endif /* NEW_PROC_API */
2695 /* Write the general-purpose registers back to the process or LWP
2696 corresponding to PI. Return non-zero for success, zero for
2700 proc_set_gregs (procinfo
*pi
)
2702 gdb_gregset_t
*gregs
;
2705 gregs
= proc_get_gregs (pi
);
2707 return 0; /* proc_get_regs has already warned. */
2709 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2718 /* Use char array to avoid alignment issues. */
2719 char gregs
[sizeof (gdb_gregset_t
)];
2723 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2724 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2726 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2730 /* Policy: writing the registers invalidates our cache. */
2731 pi
->gregs_valid
= 0;
2735 /* Write the floating-pointer registers back to the process or LWP
2736 corresponding to PI. Return non-zero for success, zero for
2740 proc_set_fpregs (procinfo
*pi
)
2742 gdb_fpregset_t
*fpregs
;
2745 fpregs
= proc_get_fpregs (pi
);
2747 return 0; /* proc_get_fpregs has already warned. */
2749 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2758 /* Use char array to avoid alignment issues. */
2759 char fpregs
[sizeof (gdb_fpregset_t
)];
2763 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2764 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2768 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2773 tid_t pr_error_thread
;
2774 tfpregset_t thread_1
;
2777 thread_fpregs
.pr_count
= 1;
2778 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2779 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2781 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2784 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2786 #endif /* NEW_PROC_API */
2789 /* Policy: writing the registers invalidates our cache. */
2790 pi
->fpregs_valid
= 0;
2795 * Function: proc_kill
2797 * Send a signal to the proc or lwp with the semantics of "kill()".
2798 * Returns non-zero for success, zero for failure.
2802 proc_kill (procinfo
*pi
, int signo
)
2807 * We might conceivably apply this operation to an LWP, and
2808 * the LWP's ctl file descriptor might not be open.
2811 if (pi
->ctl_fd
== 0 &&
2812 open_procinfo_files (pi
, FD_CTL
) == 0)
2819 procfs_ctl_t cmd
[2];
2823 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2824 #else /* ioctl method */
2825 /* FIXME: do I need the Alpha OSF fixups present in
2826 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2827 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2835 * Function: proc_parent_pid
2837 * Find the pid of the process that started this one.
2838 * Returns the parent process pid, or zero.
2842 proc_parent_pid (procinfo
*pi
)
2845 * We should never have to apply this operation to any procinfo
2846 * except the one for the main process. If that ever changes
2847 * for any reason, then take out the following clause and
2848 * replace it with one that makes sure the ctl_fd is open.
2852 pi
= find_procinfo_or_die (pi
->pid
, 0);
2854 if (!pi
->status_valid
)
2855 if (!proc_get_status (pi
))
2858 return pi
->prstatus
.pr_ppid
;
2862 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
2863 (a.k.a void pointer)! */
2866 procfs_address_to_host_pointer (CORE_ADDR addr
)
2870 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2871 gdbarch_address_to_pointer (current_gdbarch
, builtin_type_void_data_ptr
,
2877 * Function: proc_set_watchpoint
2882 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
2884 #if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
2887 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
2888 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
2893 char watch
[sizeof (prwatch_t
)];
2897 pwatch
= (prwatch_t
*) &arg
.watch
;
2898 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
2899 convert a target address into something that can be stored in a
2900 native data structure. */
2901 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
2902 pwatch
->pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
2904 pwatch
->pr_vaddr
= (caddr_t
) procfs_address_to_host_pointer (addr
);
2906 pwatch
->pr_size
= len
;
2907 pwatch
->pr_wflags
= wflags
;
2908 #if defined(NEW_PROC_API) && defined (PCWATCH)
2910 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2912 #if defined (PIOCSWATCH)
2913 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, pwatch
) >= 0);
2915 return 0; /* Fail */
2922 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
2924 #include <sys/sysi86.h>
2927 * Function: proc_get_LDT_entry
2933 * The 'key' is actually the value of the lower 16 bits of
2934 * the GS register for the LWP that we're interested in.
2936 * Return: matching ssh struct (LDT entry).
2940 proc_get_LDT_entry (procinfo
*pi
, int key
)
2942 static struct ssd
*ldt_entry
= NULL
;
2944 char pathname
[MAX_PROC_NAME_SIZE
];
2945 struct cleanup
*old_chain
= NULL
;
2948 /* Allocate space for one LDT entry.
2949 This alloc must persist, because we return a pointer to it. */
2950 if (ldt_entry
== NULL
)
2951 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2953 /* Open the file descriptor for the LDT table. */
2954 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2955 if ((fd
= open_with_retry (pathname
, O_RDONLY
)) < 0)
2957 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2960 /* Make sure it gets closed again! */
2961 old_chain
= make_cleanup_close (fd
);
2963 /* Now 'read' thru the table, find a match and return it. */
2964 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2966 if (ldt_entry
->sel
== 0 &&
2967 ldt_entry
->bo
== 0 &&
2968 ldt_entry
->acc1
== 0 &&
2969 ldt_entry
->acc2
== 0)
2970 break; /* end of table */
2971 /* If key matches, return this entry. */
2972 if (ldt_entry
->sel
== key
)
2975 /* Loop ended, match not found. */
2979 static int nalloc
= 0;
2981 /* Get the number of LDT entries. */
2982 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2984 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2988 /* Allocate space for the number of LDT entries. */
2989 /* This alloc has to persist, 'cause we return a pointer to it. */
2992 ldt_entry
= (struct ssd
*)
2993 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2997 /* Read the whole table in one gulp. */
2998 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
3000 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
3004 /* Search the table and return the (first) entry matching 'key'. */
3005 for (i
= 0; i
< nldt
; i
++)
3006 if (ldt_entry
[i
].sel
== key
)
3007 return &ldt_entry
[i
];
3009 /* Loop ended, match not found. */
3015 * Function: procfs_find_LDT_entry
3018 * ptid_t ptid; // The GDB-style pid-plus-LWP.
3021 * pointer to the corresponding LDT entry.
3025 procfs_find_LDT_entry (ptid_t ptid
)
3027 gdb_gregset_t
*gregs
;
3031 /* Find procinfo for the lwp. */
3032 if ((pi
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
))) == NULL
)
3034 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%d."),
3035 PIDGET (ptid
), TIDGET (ptid
));
3038 /* get its general registers. */
3039 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
3041 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%d."),
3042 PIDGET (ptid
), TIDGET (ptid
));
3045 /* Now extract the GS register's lower 16 bits. */
3046 key
= (*gregs
)[GS
] & 0xffff;
3048 /* Find the matching entry and return it. */
3049 return proc_get_LDT_entry (pi
, key
);
3054 /* =============== END, non-thread part of /proc "MODULE" =============== */
3056 /* =================== Thread "MODULE" =================== */
3058 /* NOTE: you'll see more ifdefs and duplication of functions here,
3059 since there is a different way to do threads on every OS. */
3062 * Function: proc_get_nthreads
3064 * Return the number of threads for the process
3067 #if defined (PIOCNTHR) && defined (PIOCTLIST)
3072 proc_get_nthreads (procinfo
*pi
)
3076 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
3077 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
3083 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
3085 * Solaris and Unixware version
3088 proc_get_nthreads (procinfo
*pi
)
3090 if (!pi
->status_valid
)
3091 if (!proc_get_status (pi
))
3095 * NEW_PROC_API: only works for the process procinfo,
3096 * because the LWP procinfos do not get prstatus filled in.
3099 if (pi
->tid
!= 0) /* find the parent process procinfo */
3100 pi
= find_procinfo_or_die (pi
->pid
, 0);
3102 return pi
->prstatus
.pr_nlwp
;
3110 proc_get_nthreads (procinfo
*pi
)
3118 * Function: proc_get_current_thread (LWP version)
3120 * Return the ID of the thread that had an event of interest.
3121 * (ie. the one that hit a breakpoint or other traced event).
3122 * All other things being equal, this should be the ID of a
3123 * thread that is currently executing.
3126 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
3128 * Solaris and Unixware version
3131 proc_get_current_thread (procinfo
*pi
)
3134 * Note: this should be applied to the root procinfo for the process,
3135 * not to the procinfo for an LWP. If applied to the procinfo for
3136 * an LWP, it will simply return that LWP's ID. In that case,
3137 * find the parent process procinfo.
3141 pi
= find_procinfo_or_die (pi
->pid
, 0);
3143 if (!pi
->status_valid
)
3144 if (!proc_get_status (pi
))
3148 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
3150 return pi
->prstatus
.pr_who
;
3155 #if defined (PIOCNTHR) && defined (PIOCTLIST)
3160 proc_get_current_thread (procinfo
*pi
)
3162 #if 0 /* FIXME: not ready for prime time? */
3163 return pi
->prstatus
.pr_tid
;
3174 proc_get_current_thread (procinfo
*pi
)
3183 * Function: proc_update_threads
3185 * Discover the IDs of all the threads within the process, and
3186 * create a procinfo for each of them (chained to the parent).
3188 * This unfortunately requires a different method on every OS.
3190 * Return: non-zero for success, zero for failure.
3194 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
3196 if (thread
&& parent
) /* sanity */
3198 thread
->status_valid
= 0;
3199 if (!proc_get_status (thread
))
3200 destroy_one_procinfo (&parent
->thread_list
, thread
);
3202 return 0; /* keep iterating */
3205 #if defined (PIOCLSTATUS)
3207 * Solaris 2.5 (ioctl) version
3210 proc_update_threads (procinfo
*pi
)
3212 gdb_prstatus_t
*prstatus
;
3213 struct cleanup
*old_chain
= NULL
;
3218 * We should never have to apply this operation to any procinfo
3219 * except the one for the main process. If that ever changes
3220 * for any reason, then take out the following clause and
3221 * replace it with one that makes sure the ctl_fd is open.
3225 pi
= find_procinfo_or_die (pi
->pid
, 0);
3227 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3229 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
3230 return 1; /* Process is not multi-threaded; nothing to do. */
3232 prstatus
= xmalloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1));
3234 old_chain
= make_cleanup (xfree
, prstatus
);
3235 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
3236 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
3238 /* Skip element zero, which represents the process as a whole. */
3239 for (i
= 1; i
< nlwp
+ 1; i
++)
3241 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
3242 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3244 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
3245 thread
->status_valid
= 1;
3247 pi
->threads_valid
= 1;
3248 do_cleanups (old_chain
);
3254 * Unixware and Solaris 6 (and later) version
3257 do_closedir_cleanup (void *dir
)
3263 proc_update_threads (procinfo
*pi
)
3265 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3266 struct dirent
*direntry
;
3267 struct cleanup
*old_chain
= NULL
;
3273 * We should never have to apply this operation to any procinfo
3274 * except the one for the main process. If that ever changes
3275 * for any reason, then take out the following clause and
3276 * replace it with one that makes sure the ctl_fd is open.
3280 pi
= find_procinfo_or_die (pi
->pid
, 0);
3282 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3287 * Note: this brute-force method is the only way I know of
3288 * to accomplish this task on Unixware. This method will
3289 * also work on Solaris 2.6 and 2.7. There is a much simpler
3290 * and more elegant way to do this on Solaris, but the margins
3291 * of this manuscript are too small to write it here... ;-)
3294 strcpy (pathname
, pi
->pathname
);
3295 strcat (pathname
, "/lwp");
3296 if ((dirp
= opendir (pathname
)) == NULL
)
3297 proc_error (pi
, "update_threads, opendir", __LINE__
);
3299 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
3300 while ((direntry
= readdir (dirp
)) != NULL
)
3301 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3303 lwpid
= atoi (&direntry
->d_name
[0]);
3304 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3305 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3307 pi
->threads_valid
= 1;
3308 do_cleanups (old_chain
);
3317 proc_update_threads (procinfo
*pi
)
3323 * We should never have to apply this operation to any procinfo
3324 * except the one for the main process. If that ever changes
3325 * for any reason, then take out the following clause and
3326 * replace it with one that makes sure the ctl_fd is open.
3330 pi
= find_procinfo_or_die (pi
->pid
, 0);
3332 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3334 nthreads
= proc_get_nthreads (pi
);
3336 return 0; /* nothing to do for 1 or fewer threads */
3338 threads
= xmalloc (nthreads
* sizeof (tid_t
));
3340 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3341 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3343 for (i
= 0; i
< nthreads
; i
++)
3345 if (!find_procinfo (pi
->pid
, threads
[i
]))
3346 if (!create_procinfo (pi
->pid
, threads
[i
]))
3347 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3349 pi
->threads_valid
= 1;
3357 proc_update_threads (procinfo
*pi
)
3361 #endif /* OSF PIOCTLIST */
3362 #endif /* NEW_PROC_API */
3363 #endif /* SOL 2.5 PIOCLSTATUS */
3366 * Function: proc_iterate_over_threads
3369 * Given a pointer to a function, call that function once
3370 * for each lwp in the procinfo list, until the function
3371 * returns non-zero, in which event return the value
3372 * returned by the function.
3374 * Note: this function does NOT call update_threads.
3375 * If you want to discover new threads first, you must
3376 * call that function explicitly. This function just makes
3377 * a quick pass over the currently-known procinfos.
3380 * pi - parent process procinfo
3381 * func - per-thread function
3382 * ptr - opaque parameter for function.
3385 * First non-zero return value from the callee, or zero.
3389 proc_iterate_over_threads (procinfo
*pi
,
3390 int (*func
) (procinfo
*, procinfo
*, void *),
3393 procinfo
*thread
, *next
;
3397 * We should never have to apply this operation to any procinfo
3398 * except the one for the main process. If that ever changes
3399 * for any reason, then take out the following clause and
3400 * replace it with one that makes sure the ctl_fd is open.
3404 pi
= find_procinfo_or_die (pi
->pid
, 0);
3406 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3408 next
= thread
->next
; /* in case thread is destroyed */
3409 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3416 /* =================== END, Thread "MODULE" =================== */
3418 /* =================== END, /proc "MODULE" =================== */
3420 /* =================== GDB "MODULE" =================== */
3423 * Here are all of the gdb target vector functions and their friends.
3426 static ptid_t
do_attach (ptid_t ptid
);
3427 static void do_detach (int signo
);
3428 static int register_gdb_signals (procinfo
*, gdb_sigset_t
*);
3429 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
3430 int entry_or_exit
, int mode
, int from_tty
);
3431 static int insert_dbx_link_breakpoint (procinfo
*pi
);
3432 static void remove_dbx_link_breakpoint (void);
3434 /* On mips-irix, we need to insert a breakpoint at __dbx_link during
3435 the startup phase. The following two variables are used to record
3436 the address of the breakpoint, and the code that was replaced by
3438 static int dbx_link_bpt_addr
= 0;
3439 static void *dbx_link_bpt
;
3442 * Function: procfs_debug_inferior
3444 * Sets up the inferior to be debugged.
3445 * Registers to trace signals, hardware faults, and syscalls.
3446 * Note: does not set RLC flag: caller may want to customize that.
3448 * Returns: zero for success (note! unlike most functions in this module)
3449 * On failure, returns the LINE NUMBER where it failed!
3453 procfs_debug_inferior (procinfo
*pi
)
3455 fltset_t traced_faults
;
3456 gdb_sigset_t traced_signals
;
3457 sysset_t
*traced_syscall_entries
;
3458 sysset_t
*traced_syscall_exits
;
3461 #ifdef PROCFS_DONT_TRACE_FAULTS
3462 /* On some systems (OSF), we don't trace hardware faults.
3463 Apparently it's enough that we catch them as signals.
3464 Wonder why we don't just do that in general? */
3465 premptyset (&traced_faults
); /* don't trace faults. */
3467 /* Register to trace hardware faults in the child. */
3468 prfillset (&traced_faults
); /* trace all faults... */
3469 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3471 if (!proc_set_traced_faults (pi
, &traced_faults
))
3474 /* Register to trace selected signals in the child. */
3475 premptyset (&traced_signals
);
3476 if (!register_gdb_signals (pi
, &traced_signals
))
3480 /* Register to trace the 'exit' system call (on entry). */
3481 traced_syscall_entries
= sysset_t_alloc (pi
);
3482 gdb_premptysysset (traced_syscall_entries
);
3484 gdb_praddsysset (traced_syscall_entries
, SYS_exit
);
3487 gdb_praddsysset (traced_syscall_entries
, SYS_lwpexit
); /* And _lwp_exit... */
3490 gdb_praddsysset (traced_syscall_entries
, SYS_lwp_exit
);
3492 #ifdef DYNAMIC_SYSCALLS
3494 int callnum
= find_syscall (pi
, "_exit");
3496 gdb_praddsysset (traced_syscall_entries
, callnum
);
3500 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
3501 xfree (traced_syscall_entries
);
3505 #ifdef PRFS_STOPEXEC /* defined on OSF */
3506 /* OSF method for tracing exec syscalls. Quoting:
3507 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3508 exits from exec system calls because of the user level loader. */
3509 /* FIXME: make nice and maybe move into an access function. */
3513 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3516 prfs_flags
|= PRFS_STOPEXEC
;
3518 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3521 #else /* not PRFS_STOPEXEC */
3522 /* Everyone else's (except OSF) method for tracing exec syscalls */
3524 Not all systems with /proc have all the exec* syscalls with the same
3525 names. On the SGI, for example, there is no SYS_exec, but there
3526 *is* a SYS_execv. So, we try to account for that. */
3528 traced_syscall_exits
= sysset_t_alloc (pi
);
3529 gdb_premptysysset (traced_syscall_exits
);
3531 gdb_praddsysset (traced_syscall_exits
, SYS_exec
);
3534 gdb_praddsysset (traced_syscall_exits
, SYS_execve
);
3537 gdb_praddsysset (traced_syscall_exits
, SYS_execv
);
3540 #ifdef SYS_lwpcreate
3541 gdb_praddsysset (traced_syscall_exits
, SYS_lwpcreate
);
3542 gdb_praddsysset (traced_syscall_exits
, SYS_lwpexit
);
3545 #ifdef SYS_lwp_create /* FIXME: once only, please */
3546 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_create
);
3547 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_exit
);
3550 #ifdef DYNAMIC_SYSCALLS
3552 int callnum
= find_syscall (pi
, "execve");
3554 gdb_praddsysset (traced_syscall_exits
, callnum
);
3555 callnum
= find_syscall (pi
, "ra_execve");
3557 gdb_praddsysset (traced_syscall_exits
, callnum
);
3561 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
3562 xfree (traced_syscall_exits
);
3566 #endif /* PRFS_STOPEXEC */
3571 procfs_attach (char *args
, int from_tty
)
3577 error_no_arg (_("process-id to attach"));
3580 if (pid
== getpid ())
3581 error (_("Attaching GDB to itself is not a good idea..."));
3585 exec_file
= get_exec_file (0);
3588 printf_filtered (_("Attaching to program `%s', %s\n"),
3589 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
3591 printf_filtered (_("Attaching to %s\n"),
3592 target_pid_to_str (pid_to_ptid (pid
)));
3596 inferior_ptid
= do_attach (pid_to_ptid (pid
));
3597 push_target (&procfs_ops
);
3601 procfs_detach (char *args
, int from_tty
)
3610 int pid
= PIDGET (inferior_ptid
);
3613 exec_file
= get_exec_file (0);
3614 if (exec_file
== NULL
)
3617 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
3618 target_pid_to_str (pid_to_ptid (pid
)));
3619 gdb_flush (gdb_stdout
);
3624 inferior_ptid
= null_ptid
;
3625 unpush_target (&procfs_ops
);
3629 do_attach (ptid_t ptid
)
3634 if ((pi
= create_procinfo (PIDGET (ptid
), 0)) == NULL
)
3635 perror (_("procfs: out of memory in 'attach'"));
3637 if (!open_procinfo_files (pi
, FD_CTL
))
3639 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3640 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3642 dead_procinfo (pi
, errmsg
, NOKILL
);
3645 /* Stop the process (if it isn't already stopped). */
3646 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3648 pi
->was_stopped
= 1;
3649 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3653 pi
->was_stopped
= 0;
3654 /* Set the process to run again when we close it. */
3655 if (!proc_set_run_on_last_close (pi
))
3656 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3658 /* Now stop the process. */
3659 if (!proc_stop_process (pi
))
3660 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3661 pi
->ignore_next_sigstop
= 1;
3663 /* Save some of the /proc state to be restored if we detach. */
3664 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3665 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3666 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3667 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3668 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
3669 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3671 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
3672 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3674 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3675 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3677 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3678 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3680 /* Let GDB know that the inferior was attached. */
3682 return MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3686 do_detach (int signo
)
3690 /* Find procinfo for the main process */
3691 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0); /* FIXME: threads */
3693 if (!proc_set_current_signal (pi
, signo
))
3694 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3696 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3697 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3699 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3700 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3702 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
3703 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3705 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
3706 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3708 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3709 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3711 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3712 if (signo
|| !(pi
->was_stopped
) ||
3713 query (_("Was stopped when attached, make it runnable again? ")))
3715 /* Clear any pending signal. */
3716 if (!proc_clear_current_fault (pi
))
3717 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3719 if (signo
== 0 && !proc_clear_current_signal (pi
))
3720 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
3722 if (!proc_set_run_on_last_close (pi
))
3723 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3727 destroy_procinfo (pi
);
3730 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
3733 ??? Is the following note still relevant? We can't get individual
3734 registers with the PT_GETREGS ptrace(2) request either, yet we
3735 don't bother with caching at all in that case.
3737 NOTE: Since the /proc interface cannot give us individual
3738 registers, we pay no attention to REGNUM, and just fetch them all.
3739 This results in the possibility that we will do unnecessarily many
3740 fetches, since we may be called repeatedly for individual
3741 registers. So we cache the results, and mark the cache invalid
3742 when the process is resumed. */
3745 procfs_fetch_registers (struct regcache
*regcache
, int regnum
)
3747 gdb_gregset_t
*gregs
;
3749 int pid
= PIDGET (inferior_ptid
);
3750 int tid
= TIDGET (inferior_ptid
);
3751 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3753 /* First look up procinfo for the main process. */
3754 pi
= find_procinfo_or_die (pid
, 0);
3756 /* If the event thread is not the same as GDB's requested thread
3757 (ie. inferior_ptid), then look up procinfo for the requested
3759 if (tid
!= 0 && tid
!= proc_get_current_thread (pi
))
3760 pi
= find_procinfo_or_die (pid
, tid
);
3763 error (_("procfs: fetch_registers failed to find procinfo for %s"),
3764 target_pid_to_str (inferior_ptid
));
3766 gregs
= proc_get_gregs (pi
);
3768 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3770 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
3772 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3774 gdb_fpregset_t
*fpregs
;
3776 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3777 || regnum
== gdbarch_pc_regnum (gdbarch
)
3778 || regnum
== gdbarch_sp_regnum (gdbarch
))
3779 return; /* Not a floating point register. */
3781 fpregs
= proc_get_fpregs (pi
);
3783 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3785 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
3789 /* Get ready to modify the registers array. On machines which store
3790 individual registers, this doesn't need to do anything. On
3791 machines which store all the registers in one fell swoop, such as
3792 /proc, this makes sure that registers contains all the registers
3793 from the program being debugged. */
3796 procfs_prepare_to_store (struct regcache
*regcache
)
3800 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
3801 this for all registers.
3803 NOTE: Since the /proc interface will not read individual registers,
3804 we will cache these requests until the process is resumed, and only
3805 then write them back to the inferior process.
3807 FIXME: is that a really bad idea? Have to think about cases where
3808 writing one register might affect the value of others, etc. */
3811 procfs_store_registers (struct regcache
*regcache
, int regnum
)
3813 gdb_gregset_t
*gregs
;
3815 int pid
= PIDGET (inferior_ptid
);
3816 int tid
= TIDGET (inferior_ptid
);
3817 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3819 /* First find procinfo for main process. */
3820 pi
= find_procinfo_or_die (pid
, 0);
3822 /* If the event thread is not the same as GDB's requested thread
3823 (ie. inferior_ptid), then look up procinfo for the requested
3825 if (tid
!= 0 && tid
!= proc_get_current_thread (pi
))
3826 pi
= find_procinfo_or_die (pid
, tid
);
3829 error (_("procfs: store_registers: failed to find procinfo for %s"),
3830 target_pid_to_str (inferior_ptid
));
3832 gregs
= proc_get_gregs (pi
);
3834 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3836 fill_gregset (regcache
, gregs
, regnum
);
3837 if (!proc_set_gregs (pi
))
3838 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3840 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3842 gdb_fpregset_t
*fpregs
;
3844 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3845 || regnum
== gdbarch_pc_regnum (gdbarch
)
3846 || regnum
== gdbarch_sp_regnum (gdbarch
))
3847 return; /* Not a floating point register. */
3849 fpregs
= proc_get_fpregs (pi
);
3851 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3853 fill_fpregset (regcache
, fpregs
, regnum
);
3854 if (!proc_set_fpregs (pi
))
3855 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3860 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
3864 if (scall
== SYS_lwp_exit
)
3868 if (scall
== SYS_lwpexit
)
3875 syscall_is_exit (procinfo
*pi
, int scall
)
3878 if (scall
== SYS_exit
)
3881 #ifdef DYNAMIC_SYSCALLS
3882 if (find_syscall (pi
, "_exit") == scall
)
3889 syscall_is_exec (procinfo
*pi
, int scall
)
3892 if (scall
== SYS_exec
)
3896 if (scall
== SYS_execv
)
3900 if (scall
== SYS_execve
)
3903 #ifdef DYNAMIC_SYSCALLS
3904 if (find_syscall (pi
, "_execve"))
3906 if (find_syscall (pi
, "ra_execve"))
3913 syscall_is_lwp_create (procinfo
*pi
, int scall
)
3915 #ifdef SYS_lwp_create
3916 if (scall
== SYS_lwp_create
)
3919 #ifdef SYS_lwpcreate
3920 if (scall
== SYS_lwpcreate
)
3927 * Function: target_wait
3929 * Retrieve the next stop event from the child process.
3930 * If child has not stopped yet, wait for it to stop.
3931 * Translate /proc eventcodes (or possibly wait eventcodes)
3932 * into gdb internal event codes.
3934 * Return: id of process (and possibly thread) that incurred the event.
3935 * event codes are returned thru a pointer parameter.
3939 procfs_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3941 /* First cut: loosely based on original version 2.1 */
3945 ptid_t retval
, temp_ptid
;
3946 int why
, what
, flags
;
3953 retval
= pid_to_ptid (-1);
3955 /* Find procinfo for main process */
3956 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
3959 /* We must assume that the status is stale now... */
3960 pi
->status_valid
= 0;
3961 pi
->gregs_valid
= 0;
3962 pi
->fpregs_valid
= 0;
3964 #if 0 /* just try this out... */
3965 flags
= proc_flags (pi
);
3966 why
= proc_why (pi
);
3967 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3968 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3970 /* If child is not stopped, wait for it to stop. */
3971 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3972 !proc_wait_for_stop (pi
))
3974 /* wait_for_stop failed: has the child terminated? */
3975 if (errno
== ENOENT
)
3979 /* /proc file not found; presumably child has terminated. */
3980 wait_retval
= wait (&wstat
); /* "wait" for the child's exit */
3982 if (wait_retval
!= PIDGET (inferior_ptid
)) /* wrong child? */
3983 error (_("procfs: couldn't stop process %d: wait returned %d."),
3984 PIDGET (inferior_ptid
), wait_retval
);
3985 /* FIXME: might I not just use waitpid?
3986 Or try find_procinfo to see if I know about this child? */
3987 retval
= pid_to_ptid (wait_retval
);
3989 else if (errno
== EINTR
)
3993 /* Unknown error from wait_for_stop. */
3994 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3999 /* This long block is reached if either:
4000 a) the child was already stopped, or
4001 b) we successfully waited for the child with wait_for_stop.
4002 This block will analyze the /proc status, and translate it
4003 into a waitstatus for GDB.
4005 If we actually had to call wait because the /proc file
4006 is gone (child terminated), then we skip this block,
4007 because we already have a waitstatus. */
4009 flags
= proc_flags (pi
);
4010 why
= proc_why (pi
);
4011 what
= proc_what (pi
);
4013 if (flags
& (PR_STOPPED
| PR_ISTOP
))
4016 /* If it's running async (for single_thread control),
4017 set it back to normal again. */
4018 if (flags
& PR_ASYNC
)
4019 if (!proc_unset_async (pi
))
4020 proc_error (pi
, "target_wait, unset_async", __LINE__
);
4024 proc_prettyprint_why (why
, what
, 1);
4026 /* The 'pid' we will return to GDB is composed of
4027 the process ID plus the lwp ID. */
4028 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
4032 wstat
= (what
<< 8) | 0177;
4035 if (syscall_is_lwp_exit (pi
, what
))
4037 if (print_thread_events
)
4038 printf_unfiltered (_("[%s exited]\n"),
4039 target_pid_to_str (retval
));
4040 delete_thread (retval
);
4041 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4044 else if (syscall_is_exit (pi
, what
))
4046 /* Handle SYS_exit call only */
4047 /* Stopped at entry to SYS_exit.
4048 Make it runnable, resume it, then use
4049 the wait system call to get its exit code.
4050 Proc_run_process always clears the current
4052 Then return its exit status. */
4053 pi
->status_valid
= 0;
4055 /* FIXME: what we should do is return
4056 TARGET_WAITKIND_SPURIOUS. */
4057 if (!proc_run_process (pi
, 0, 0))
4058 proc_error (pi
, "target_wait, run_process", __LINE__
);
4061 /* Don't call wait: simulate waiting for exit,
4062 return a "success" exit code. Bogus: what if
4063 it returns something else? */
4065 retval
= inferior_ptid
; /* ? ? ? */
4069 int temp
= wait (&wstat
);
4071 /* FIXME: shouldn't I make sure I get the right
4072 event from the right process? If (for
4073 instance) I have killed an earlier inferior
4074 process but failed to clean up after it
4075 somehow, I could get its termination event
4078 /* If wait returns -1, that's what we return to GDB. */
4080 retval
= pid_to_ptid (temp
);
4085 printf_filtered (_("procfs: trapped on entry to "));
4086 proc_prettyprint_syscall (proc_what (pi
), 0);
4087 printf_filtered ("\n");
4090 long i
, nsysargs
, *sysargs
;
4092 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
4093 (sysargs
= proc_sysargs (pi
)) != NULL
)
4095 printf_filtered (_("%ld syscall arguments:\n"), nsysargs
);
4096 for (i
= 0; i
< nsysargs
; i
++)
4097 printf_filtered ("#%ld: 0x%08lx\n",
4105 /* How to exit gracefully, returning "unknown event" */
4106 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4107 return inferior_ptid
;
4111 /* How to keep going without returning to wfi: */
4112 target_resume (ptid
, 0, TARGET_SIGNAL_0
);
4118 if (syscall_is_exec (pi
, what
))
4120 /* Hopefully this is our own "fork-child" execing
4121 the real child. Hoax this event into a trap, and
4122 GDB will see the child about to execute its start
4124 wstat
= (SIGTRAP
<< 8) | 0177;
4127 else if (what
== SYS_syssgi
)
4129 /* see if we can break on dbx_link(). If yes, then
4130 we no longer need the SYS_syssgi notifications. */
4131 if (insert_dbx_link_breakpoint (pi
))
4132 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
,
4135 /* This is an internal event and should be transparent
4136 to wfi, so resume the execution and wait again. See
4137 comment in procfs_init_inferior() for more details. */
4138 target_resume (ptid
, 0, TARGET_SIGNAL_0
);
4142 else if (syscall_is_lwp_create (pi
, what
))
4145 * This syscall is somewhat like fork/exec.
4146 * We will get the event twice: once for the parent LWP,
4147 * and once for the child. We should already know about
4148 * the parent LWP, but the child will be new to us. So,
4149 * whenever we get this event, if it represents a new
4150 * thread, simply add the thread to the list.
4153 /* If not in procinfo list, add it. */
4154 temp_tid
= proc_get_current_thread (pi
);
4155 if (!find_procinfo (pi
->pid
, temp_tid
))
4156 create_procinfo (pi
->pid
, temp_tid
);
4158 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
4159 /* If not in GDB's thread list, add it. */
4160 if (!in_thread_list (temp_ptid
))
4161 add_thread (temp_ptid
);
4163 /* Return to WFI, but tell it to immediately resume. */
4164 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4165 return inferior_ptid
;
4167 else if (syscall_is_lwp_exit (pi
, what
))
4169 if (print_thread_events
)
4170 printf_unfiltered (_("[%s exited]\n"),
4171 target_pid_to_str (retval
));
4172 delete_thread (retval
);
4173 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4178 /* FIXME: Do we need to handle SYS_sproc,
4179 SYS_fork, or SYS_vfork here? The old procfs
4180 seemed to use this event to handle threads on
4181 older (non-LWP) systems, where I'm assuming
4182 that threads were actually separate processes.
4183 Irix, maybe? Anyway, low priority for now. */
4187 printf_filtered (_("procfs: trapped on exit from "));
4188 proc_prettyprint_syscall (proc_what (pi
), 0);
4189 printf_filtered ("\n");
4192 long i
, nsysargs
, *sysargs
;
4194 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
4195 (sysargs
= proc_sysargs (pi
)) != NULL
)
4197 printf_filtered (_("%ld syscall arguments:\n"), nsysargs
);
4198 for (i
= 0; i
< nsysargs
; i
++)
4199 printf_filtered ("#%ld: 0x%08lx\n",
4204 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4205 return inferior_ptid
;
4210 wstat
= (SIGSTOP
<< 8) | 0177;
4215 printf_filtered (_("Retry #%d:\n"), retry
);
4216 pi
->status_valid
= 0;
4221 /* If not in procinfo list, add it. */
4222 temp_tid
= proc_get_current_thread (pi
);
4223 if (!find_procinfo (pi
->pid
, temp_tid
))
4224 create_procinfo (pi
->pid
, temp_tid
);
4226 /* If not in GDB's thread list, add it. */
4227 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
4228 if (!in_thread_list (temp_ptid
))
4229 add_thread (temp_ptid
);
4231 status
->kind
= TARGET_WAITKIND_STOPPED
;
4232 status
->value
.sig
= 0;
4237 wstat
= (what
<< 8) | 0177;
4243 wstat
= (SIGTRAP
<< 8) | 0177;
4248 wstat
= (SIGTRAP
<< 8) | 0177;
4251 /* FIXME: use si_signo where possible. */
4253 #if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
4256 wstat
= (SIGILL
<< 8) | 0177;
4259 #if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
4262 /* If we hit our __dbx_link() internal breakpoint,
4263 then remove it. See comments in procfs_init_inferior()
4264 for more details. */
4265 if (dbx_link_bpt_addr
!= 0
4266 && dbx_link_bpt_addr
== read_pc ())
4267 remove_dbx_link_breakpoint ();
4269 wstat
= (SIGTRAP
<< 8) | 0177;
4273 #if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
4276 wstat
= (SIGSEGV
<< 8) | 0177;
4280 #if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
4283 wstat
= (SIGFPE
<< 8) | 0177;
4285 case FLTPAGE
: /* Recoverable page fault */
4286 default: /* FIXME: use si_signo if possible for fault */
4287 retval
= pid_to_ptid (-1);
4288 printf_filtered ("procfs:%d -- ", __LINE__
);
4289 printf_filtered (_("child stopped for unknown reason:\n"));
4290 proc_prettyprint_why (why
, what
, 1);
4291 error (_("... giving up..."));
4294 break; /* case PR_FAULTED: */
4295 default: /* switch (why) unmatched */
4296 printf_filtered ("procfs:%d -- ", __LINE__
);
4297 printf_filtered (_("child stopped for unknown reason:\n"));
4298 proc_prettyprint_why (why
, what
, 1);
4299 error (_("... giving up..."));
4303 * Got this far without error:
4304 * If retval isn't in the threads database, add it.
4306 if (PIDGET (retval
) > 0 &&
4307 !ptid_equal (retval
, inferior_ptid
) &&
4308 !in_thread_list (retval
))
4311 * We have a new thread.
4312 * We need to add it both to GDB's list and to our own.
4313 * If we don't create a procinfo, resume may be unhappy
4316 add_thread (retval
);
4317 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
4318 create_procinfo (PIDGET (retval
), TIDGET (retval
));
4320 /* In addition, it's possible that this is the first
4321 * new thread we've seen, in which case we may not
4322 * have created entries for inferior_ptid yet.
4324 if (TIDGET (inferior_ptid
) != 0)
4326 if (!in_thread_list (inferior_ptid
))
4327 add_thread (inferior_ptid
);
4328 if (find_procinfo (PIDGET (inferior_ptid
),
4329 TIDGET (inferior_ptid
)) == NULL
)
4330 create_procinfo (PIDGET (inferior_ptid
),
4331 TIDGET (inferior_ptid
));
4335 else /* flags do not indicate STOPPED */
4337 /* surely this can't happen... */
4338 printf_filtered ("procfs:%d -- process not stopped.\n",
4340 proc_prettyprint_flags (flags
, 1);
4341 error (_("procfs: ...giving up..."));
4346 store_waitstatus (status
, wstat
);
4352 /* Perform a partial transfer to/from the specified object. For
4353 memory transfers, fall back to the old memory xfer functions. */
4356 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4357 const char *annex
, void *readbuf
,
4358 const void *writebuf
, ULONGEST offset
, LONGEST len
)
4362 case TARGET_OBJECT_MEMORY
:
4364 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
, len
,
4365 0/*read*/, NULL
, ops
);
4367 return (*ops
->deprecated_xfer_memory
) (offset
, writebuf
, len
,
4368 1/*write*/, NULL
, ops
);
4372 case TARGET_OBJECT_AUXV
:
4373 return procfs_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
4378 if (ops
->beneath
!= NULL
)
4379 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
4380 readbuf
, writebuf
, offset
, len
);
4386 /* Transfer LEN bytes between GDB address MYADDR and target address
4387 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
4388 otherwise transfer them from the target. TARGET is unused.
4390 The return value is 0 if an error occurred or no bytes were
4391 transferred. Otherwise, it will be a positive value which
4392 indicates the number of bytes transferred between gdb and the
4393 target. (Note that the interface also makes provisions for
4394 negative values, but this capability isn't implemented here.) */
4397 procfs_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
4398 struct mem_attrib
*attrib
, struct target_ops
*target
)
4403 /* Find procinfo for main process */
4404 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4405 if (pi
->as_fd
== 0 &&
4406 open_procinfo_files (pi
, FD_AS
) == 0)
4408 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4412 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4417 PROCFS_NOTE ("write memory: ");
4419 PROCFS_NOTE ("write memory: \n");
4421 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4425 PROCFS_NOTE ("read memory: \n");
4426 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4437 * Function: invalidate_cache
4439 * Called by target_resume before making child runnable.
4440 * Mark cached registers and status's invalid.
4441 * If there are "dirty" caches that need to be written back
4442 * to the child process, do that.
4444 * File descriptors are also cached.
4445 * As they are a limited resource, we cannot hold onto them indefinitely.
4446 * However, as they are expensive to open, we don't want to throw them
4447 * away indescriminately either. As a compromise, we will keep the
4448 * file descriptors for the parent process, but discard any file
4449 * descriptors we may have accumulated for the threads.
4452 * As this function is called by iterate_over_threads, it always
4453 * returns zero (so that iterate_over_threads will keep iterating).
4458 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
4461 * About to run the child; invalidate caches and do any other cleanup.
4465 if (pi
->gregs_dirty
)
4466 if (parent
== NULL
||
4467 proc_get_current_thread (parent
) != pi
->tid
)
4468 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4469 proc_warn (pi
, "target_resume, set_gregs",
4471 if (gdbarch_fp0_regnum (current_gdbarch
) >= 0)
4472 if (pi
->fpregs_dirty
)
4473 if (parent
== NULL
||
4474 proc_get_current_thread (parent
) != pi
->tid
)
4475 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4476 proc_warn (pi
, "target_resume, set_fpregs",
4482 /* The presence of a parent indicates that this is an LWP.
4483 Close any file descriptors that it might have open.
4484 We don't do this to the master (parent) procinfo. */
4486 close_procinfo_files (pi
);
4488 pi
->gregs_valid
= 0;
4489 pi
->fpregs_valid
= 0;
4491 pi
->gregs_dirty
= 0;
4492 pi
->fpregs_dirty
= 0;
4494 pi
->status_valid
= 0;
4495 pi
->threads_valid
= 0;
4502 * Function: make_signal_thread_runnable
4504 * A callback function for iterate_over_threads.
4505 * Find the asynchronous signal thread, and make it runnable.
4506 * See if that helps matters any.
4510 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
4513 if (proc_flags (pi
) & PR_ASLWP
)
4515 if (!proc_run_process (pi
, 0, -1))
4516 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4525 * Function: target_resume
4527 * Make the child process runnable. Normally we will then call
4528 * procfs_wait and wait for it to stop again (unles gdb is async).
4531 * step: if true, then arrange for the child to stop again
4532 * after executing a single instruction.
4533 * signo: if zero, then cancel any pending signal.
4534 * If non-zero, then arrange for the indicated signal
4535 * to be delivered to the child when it runs.
4536 * pid: if -1, then allow any child thread to run.
4537 * if non-zero, then allow only the indicated thread to run.
4538 ******* (not implemented yet)
4542 procfs_resume (ptid_t ptid
, int step
, enum target_signal signo
)
4544 procinfo
*pi
, *thread
;
4548 prrun.prflags |= PRSVADDR;
4549 prrun.pr_vaddr = $PC; set resume address
4550 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4551 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4552 prrun.prflags |= PRCFAULT; clear current fault.
4554 PRSTRACE and PRSFAULT can be done by other means
4555 (proc_trace_signals, proc_trace_faults)
4556 PRSVADDR is unnecessary.
4557 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4558 This basically leaves PRSTEP and PRCSIG.
4559 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4560 So basically PR_STEP is the sole argument that must be passed
4561 to proc_run_process (for use in the prrun struct by ioctl). */
4563 /* Find procinfo for main process */
4564 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4566 /* First cut: ignore pid argument */
4569 /* Convert signal to host numbering. */
4571 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4574 native_signo
= target_signal_to_host (signo
);
4576 pi
->ignore_next_sigstop
= 0;
4578 /* Running the process voids all cached registers and status. */
4579 /* Void the threads' caches first */
4580 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4581 /* Void the process procinfo's caches. */
4582 invalidate_cache (NULL
, pi
, NULL
);
4584 if (PIDGET (ptid
) != -1)
4586 /* Resume a specific thread, presumably suppressing the others. */
4587 thread
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
));
4590 if (thread
->tid
!= 0)
4592 /* We're to resume a specific thread, and not the others.
4593 * Set the child process's PR_ASYNC flag.
4596 if (!proc_set_async (pi
))
4597 proc_error (pi
, "target_resume, set_async", __LINE__
);
4600 proc_iterate_over_threads (pi
,
4601 make_signal_thread_runnable
,
4604 pi
= thread
; /* substitute the thread's procinfo for run */
4609 if (!proc_run_process (pi
, step
, native_signo
))
4612 warning (_("resume: target already running. Pretend to resume, and hope for the best!"));
4614 proc_error (pi
, "target_resume", __LINE__
);
4619 * Function: register_gdb_signals
4621 * Traverse the list of signals that GDB knows about
4622 * (see "handle" command), and arrange for the target
4623 * to be stopped or not, according to these settings.
4625 * Returns non-zero for success, zero for failure.
4629 register_gdb_signals (procinfo
*pi
, gdb_sigset_t
*signals
)
4633 for (signo
= 0; signo
< NSIG
; signo
++)
4634 if (signal_stop_state (target_signal_from_host (signo
)) == 0 &&
4635 signal_print_state (target_signal_from_host (signo
)) == 0 &&
4636 signal_pass_state (target_signal_from_host (signo
)) == 1)
4637 prdelset (signals
, signo
);
4639 praddset (signals
, signo
);
4641 return proc_set_traced_signals (pi
, signals
);
4645 * Function: target_notice_signals
4647 * Set up to trace signals in the child process.
4651 procfs_notice_signals (ptid_t ptid
)
4653 gdb_sigset_t signals
;
4654 procinfo
*pi
= find_procinfo_or_die (PIDGET (ptid
), 0);
4656 if (proc_get_traced_signals (pi
, &signals
) &&
4657 register_gdb_signals (pi
, &signals
))
4660 proc_error (pi
, "notice_signals", __LINE__
);
4664 * Function: target_files_info
4666 * Print status information about the child process.
4670 procfs_files_info (struct target_ops
*ignore
)
4672 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
4673 attach_flag
? "attached": "child",
4674 target_pid_to_str (inferior_ptid
));
4678 * Function: target_open
4680 * A dummy: you don't open procfs.
4684 procfs_open (char *args
, int from_tty
)
4686 error (_("Use the \"run\" command to start a Unix child process."));
4690 * Function: target_can_run
4692 * This tells GDB that this target vector can be invoked
4693 * for "run" or "attach".
4696 int procfs_suppress_run
= 0; /* Non-zero if procfs should pretend not to
4697 be a runnable target. Used by targets
4698 that can sit atop procfs, such as solaris
4703 procfs_can_run (void)
4705 /* This variable is controlled by modules that sit atop procfs that
4706 may layer their own process structure atop that provided here.
4707 sol-thread.c does this because of the Solaris two-level thread
4710 /* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
4712 return !procfs_suppress_run
;
4716 * Function: target_stop
4718 * Stop the child process asynchronously, as when the
4719 * gdb user types control-c or presses a "stop" button.
4721 * Works by sending kill(SIGINT) to the child's process group.
4727 kill (-inferior_process_group
, SIGINT
);
4731 * Function: unconditionally_kill_inferior
4733 * Make it die. Wait for it to die. Clean up after it.
4734 * Note: this should only be applied to the real process,
4735 * not to an LWP, because of the check for parent-process.
4736 * If we need this to work for an LWP, it needs some more logic.
4740 unconditionally_kill_inferior (procinfo
*pi
)
4744 parent_pid
= proc_parent_pid (pi
);
4745 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4746 /* FIXME: use access functions */
4747 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4748 before the PIOCKILL, otherwise it might generate a corrupted core
4749 file for the inferior. */
4750 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4752 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4755 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4756 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4757 to kill the inferior, otherwise it might remain stopped with a
4759 We do not check the result of the PIOCSSIG, the inferior might have
4762 gdb_siginfo_t newsiginfo
;
4764 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4765 newsiginfo
.si_signo
= SIGKILL
;
4766 newsiginfo
.si_code
= 0;
4767 newsiginfo
.si_errno
= 0;
4768 newsiginfo
.si_pid
= getpid ();
4769 newsiginfo
.si_uid
= getuid ();
4770 /* FIXME: use proc_set_current_signal */
4771 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4773 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4774 if (!proc_kill (pi
, SIGKILL
))
4775 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4776 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4777 destroy_procinfo (pi
);
4779 /* If pi is GDB's child, wait for it to die. */
4780 if (parent_pid
== getpid ())
4781 /* FIXME: should we use waitpid to make sure we get the right event?
4782 Should we check the returned event? */
4787 ret
= waitpid (pi
->pid
, &status
, 0);
4795 * Function: target_kill_inferior
4797 * We're done debugging it, and we want it to go away.
4798 * Then we want GDB to forget all about it.
4802 procfs_kill_inferior (void)
4804 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
4806 /* Find procinfo for main process */
4807 procinfo
*pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4810 unconditionally_kill_inferior (pi
);
4811 target_mourn_inferior ();
4816 * Function: target_mourn_inferior
4818 * Forget we ever debugged this thing!
4822 procfs_mourn_inferior (void)
4826 if (!ptid_equal (inferior_ptid
, null_ptid
))
4828 /* Find procinfo for main process */
4829 pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4831 destroy_procinfo (pi
);
4833 unpush_target (&procfs_ops
);
4835 if (dbx_link_bpt
!= NULL
)
4837 deprecated_remove_raw_breakpoint (dbx_link_bpt
);
4838 dbx_link_bpt_addr
= 0;
4839 dbx_link_bpt
= NULL
;
4842 generic_mourn_inferior ();
4846 * Function: init_inferior
4848 * When GDB forks to create a runnable inferior process,
4849 * this function is called on the parent side of the fork.
4850 * It's job is to do whatever is necessary to make the child
4851 * ready to be debugged, and then wait for the child to synchronize.
4855 procfs_init_inferior (int pid
)
4858 gdb_sigset_t signals
;
4861 /* This routine called on the parent side (GDB side)
4862 after GDB forks the inferior. */
4864 push_target (&procfs_ops
);
4866 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4867 perror ("procfs: out of memory in 'init_inferior'");
4869 if (!open_procinfo_files (pi
, FD_CTL
))
4870 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4874 open_procinfo_files // done
4877 procfs_notice_signals
4884 /* If not stopped yet, wait for it to stop. */
4885 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4886 !(proc_wait_for_stop (pi
)))
4887 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4889 /* Save some of the /proc state to be restored if we detach. */
4890 /* FIXME: Why? In case another debugger was debugging it?
4891 We're it's parent, for Ghu's sake! */
4892 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4893 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4894 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4895 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4896 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4897 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4898 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
4899 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4900 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
4901 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4903 /* Register to trace selected signals in the child. */
4904 prfillset (&signals
);
4905 if (!register_gdb_signals (pi
, &signals
))
4906 proc_error (pi
, "init_inferior, register_signals", __LINE__
);
4908 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4909 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4911 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4912 and possibly even turning ON kill-on-last-close at this point. But
4913 I can't make that change without careful testing which I don't have
4914 time to do right now... */
4915 /* Turn on run-on-last-close flag so that the child
4916 will die if GDB goes away for some reason. */
4917 if (!proc_set_run_on_last_close (pi
))
4918 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4920 /* The 'process ID' we return to GDB is composed of
4921 the actual process ID plus the lwp ID. */
4922 inferior_ptid
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
4924 /* Typically two, one trap to exec the shell, one to exec the
4925 program being debugged. Defined by "inferior.h". */
4926 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4929 /* On mips-irix, we need to stop the inferior early enough during
4930 the startup phase in order to be able to load the shared library
4931 symbols and insert the breakpoints that are located in these shared
4932 libraries. Stopping at the program entry point is not good enough
4933 because the -init code is executed before the execution reaches
4936 So what we need to do is to insert a breakpoint in the runtime
4937 loader (rld), more precisely in __dbx_link(). This procedure is
4938 called by rld once all shared libraries have been mapped, but before
4939 the -init code is executed. Unfortuantely, this is not straightforward,
4940 as rld is not part of the executable we are running, and thus we need
4941 the inferior to run until rld itself has been mapped in memory.
4943 For this, we trace all syssgi() syscall exit events. Each time
4944 we detect such an event, we iterate over each text memory maps,
4945 get its associated fd, and scan the symbol table for __dbx_link().
4946 When found, we know that rld has been mapped, and that we can insert
4947 the breakpoint at the symbol address. Once the dbx_link() breakpoint
4948 has been inserted, the syssgi() notifications are no longer necessary,
4949 so they should be canceled. */
4950 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
, FLAG_SET
, 0);
4955 * Function: set_exec_trap
4957 * When GDB forks to create a new process, this function is called
4958 * on the child side of the fork before GDB exec's the user program.
4959 * Its job is to make the child minimally debuggable, so that the
4960 * parent GDB process can connect to the child and take over.
4961 * This function should do only the minimum to make that possible,
4962 * and to synchronize with the parent process. The parent process
4963 * should take care of the details.
4967 procfs_set_exec_trap (void)
4969 /* This routine called on the child side (inferior side)
4970 after GDB forks the inferior. It must use only local variables,
4971 because it may be sharing data space with its parent. */
4976 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4977 perror_with_name (_("procfs: create_procinfo failed in child."));
4979 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4981 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4982 gdb_flush (gdb_stderr
);
4983 /* no need to call "dead_procinfo", because we're going to exit. */
4987 #ifdef PRFS_STOPEXEC /* defined on OSF */
4988 /* OSF method for tracing exec syscalls. Quoting:
4989 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4990 exits from exec system calls because of the user level loader. */
4991 /* FIXME: make nice and maybe move into an access function. */
4995 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4997 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4998 gdb_flush (gdb_stderr
);
5001 prfs_flags
|= PRFS_STOPEXEC
;
5003 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
5005 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
5006 gdb_flush (gdb_stderr
);
5010 #else /* not PRFS_STOPEXEC */
5011 /* Everyone else's (except OSF) method for tracing exec syscalls */
5013 Not all systems with /proc have all the exec* syscalls with the same
5014 names. On the SGI, for example, there is no SYS_exec, but there
5015 *is* a SYS_execv. So, we try to account for that. */
5017 exitset
= sysset_t_alloc (pi
);
5018 gdb_premptysysset (exitset
);
5020 gdb_praddsysset (exitset
, SYS_exec
);
5023 gdb_praddsysset (exitset
, SYS_execve
);
5026 gdb_praddsysset (exitset
, SYS_execv
);
5028 #ifdef DYNAMIC_SYSCALLS
5030 int callnum
= find_syscall (pi
, "execve");
5033 gdb_praddsysset (exitset
, callnum
);
5035 callnum
= find_syscall (pi
, "ra_execve");
5037 gdb_praddsysset (exitset
, callnum
);
5039 #endif /* DYNAMIC_SYSCALLS */
5041 if (!proc_set_traced_sysexit (pi
, exitset
))
5043 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
5044 gdb_flush (gdb_stderr
);
5047 #endif /* PRFS_STOPEXEC */
5049 /* FIXME: should this be done in the parent instead? */
5050 /* Turn off inherit on fork flag so that all grand-children
5051 of gdb start with tracing flags cleared. */
5052 if (!proc_unset_inherit_on_fork (pi
))
5053 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
5055 /* Turn off run on last close flag, so that the child process
5056 cannot run away just because we close our handle on it.
5057 We want it to wait for the parent to attach. */
5058 if (!proc_unset_run_on_last_close (pi
))
5059 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
5061 /* FIXME: No need to destroy the procinfo --
5062 we have our own address space, and we're about to do an exec! */
5063 /*destroy_procinfo (pi);*/
5067 * Function: create_inferior
5069 * This function is called BEFORE gdb forks the inferior process.
5070 * Its only real responsibility is to set things up for the fork,
5071 * and tell GDB which two functions to call after the fork (one
5072 * for the parent, and one for the child).
5074 * This function does a complicated search for a unix shell program,
5075 * which it then uses to parse arguments and environment variables
5076 * to be sent to the child. I wonder whether this code could not
5077 * be abstracted out and shared with other unix targets such as
5082 procfs_create_inferior (char *exec_file
, char *allargs
, char **env
,
5085 char *shell_file
= getenv ("SHELL");
5087 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
5090 /* We will be looking down the PATH to find shell_file. If we
5091 just do this the normal way (via execlp, which operates by
5092 attempting an exec for each element of the PATH until it
5093 finds one which succeeds), then there will be an exec for
5094 each failed attempt, each of which will cause a PR_SYSEXIT
5095 stop, and we won't know how to distinguish the PR_SYSEXIT's
5096 for these failed execs with the ones for successful execs
5097 (whether the exec has succeeded is stored at that time in the
5098 carry bit or some such architecture-specific and
5099 non-ABI-specified place).
5101 So I can't think of anything better than to search the PATH
5102 now. This has several disadvantages: (1) There is a race
5103 condition; if we find a file now and it is deleted before we
5104 exec it, we lose, even if the deletion leaves a valid file
5105 further down in the PATH, (2) there is no way to know exactly
5106 what an executable (in the sense of "capable of being
5107 exec'd") file is. Using access() loses because it may lose
5108 if the caller is the superuser; failing to use it loses if
5109 there are ACLs or some such. */
5113 /* FIXME-maybe: might want "set path" command so user can change what
5114 path is used from within GDB. */
5115 char *path
= getenv ("PATH");
5117 struct stat statbuf
;
5120 path
= "/bin:/usr/bin";
5122 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
5123 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
5125 p1
= strchr (p
, ':');
5130 strncpy (tryname
, p
, len
);
5131 tryname
[len
] = '\0';
5132 strcat (tryname
, "/");
5133 strcat (tryname
, shell_file
);
5134 if (access (tryname
, X_OK
) < 0)
5136 if (stat (tryname
, &statbuf
) < 0)
5138 if (!S_ISREG (statbuf
.st_mode
))
5139 /* We certainly need to reject directories. I'm not quite
5140 as sure about FIFOs, sockets, etc., but I kind of doubt
5141 that people want to exec() these things. */
5146 /* Not found. This must be an error rather than merely passing
5147 the file to execlp(), because execlp() would try all the
5148 exec()s, causing GDB to get confused. */
5149 error (_("procfs:%d -- Can't find shell %s in PATH"),
5150 __LINE__
, shell_file
);
5152 shell_file
= tryname
;
5155 fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
5156 procfs_init_inferior
, NULL
, shell_file
);
5159 /* Make sure to cancel the syssgi() syscall-exit notifications.
5160 They should normally have been removed by now, but they may still
5161 be activated if the inferior doesn't use shared libraries, or if
5162 we didn't locate __dbx_link, or if we never stopped in __dbx_link.
5163 See procfs_init_inferior() for more details. */
5164 proc_trace_syscalls_1 (find_procinfo_or_die (PIDGET (inferior_ptid
), 0),
5165 SYS_syssgi
, PR_SYSEXIT
, FLAG_RESET
, 0);
5170 * Function: notice_thread
5172 * Callback for find_new_threads.
5173 * Calls "add_thread".
5177 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
5179 ptid_t gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
5181 if (!in_thread_list (gdb_threadid
))
5182 add_thread (gdb_threadid
);
5188 * Function: target_find_new_threads
5190 * Query all the threads that the target knows about,
5191 * and give them back to GDB to add to its list.
5195 procfs_find_new_threads (void)
5199 /* Find procinfo for main process */
5200 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5201 proc_update_threads (pi
);
5202 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
5206 * Function: target_thread_alive
5208 * Return true if the thread is still 'alive'.
5210 * This guy doesn't really seem to be doing his job.
5211 * Got to investigate how to tell when a thread is really gone.
5215 procfs_thread_alive (ptid_t ptid
)
5220 proc
= PIDGET (ptid
);
5221 thread
= TIDGET (ptid
);
5222 /* If I don't know it, it ain't alive! */
5223 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
5226 /* If I can't get its status, it ain't alive!
5227 What's more, I need to forget about it! */
5228 if (!proc_get_status (pi
))
5230 destroy_procinfo (pi
);
5233 /* I couldn't have got its status if it weren't alive, so it's alive. */
5237 /* Convert PTID to a string. Returns the string in a static buffer. */
5240 procfs_pid_to_str (ptid_t ptid
)
5242 static char buf
[80];
5244 if (TIDGET (ptid
) == 0)
5245 sprintf (buf
, "process %d", PIDGET (ptid
));
5247 sprintf (buf
, "LWP %ld", TIDGET (ptid
));
5253 * Function: procfs_set_watchpoint
5254 * Insert a watchpoint
5258 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
5266 pi
= find_procinfo_or_die (PIDGET (ptid
) == -1 ?
5267 PIDGET (inferior_ptid
) : PIDGET (ptid
), 0);
5269 /* Translate from GDB's flags to /proc's */
5270 if (len
> 0) /* len == 0 means delete watchpoint */
5272 switch (rwflag
) { /* FIXME: need an enum! */
5273 case hw_write
: /* default watchpoint (write) */
5274 pflags
= WRITE_WATCHFLAG
;
5276 case hw_read
: /* read watchpoint */
5277 pflags
= READ_WATCHFLAG
;
5279 case hw_access
: /* access watchpoint */
5280 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
5282 case hw_execute
: /* execution HW breakpoint */
5283 pflags
= EXEC_WATCHFLAG
;
5285 default: /* Something weird. Return error. */
5288 if (after
) /* Stop after r/w access is completed. */
5289 pflags
|= AFTER_WATCHFLAG
;
5292 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
5294 if (errno
== E2BIG
) /* Typical error for no resources */
5295 return -1; /* fail */
5296 /* GDB may try to remove the same watchpoint twice.
5297 If a remove request returns no match, don't error. */
5298 if (errno
== ESRCH
&& len
== 0)
5299 return 0; /* ignore */
5300 proc_error (pi
, "set_watchpoint", __LINE__
);
5303 #endif /* UNIXWARE */
5307 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
5308 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
5309 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
5312 Note: procfs_can_use_hw_breakpoint() is not yet used by all
5313 procfs.c targets due to the fact that some of them still define
5314 TARGET_CAN_USE_HARDWARE_WATCHPOINT. */
5317 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
5319 #ifndef TARGET_HAS_HARDWARE_WATCHPOINTS
5322 /* Due to the way that proc_set_watchpoint() is implemented, host
5323 and target pointers must be of the same size. If they are not,
5324 we can't use hardware watchpoints. This limitation is due to the
5325 fact that proc_set_watchpoint() calls
5326 procfs_address_to_host_pointer(); a close inspection of
5327 procfs_address_to_host_pointer will reveal that an internal error
5328 will be generated when the host and target pointer sizes are
5330 if (sizeof (void *) != TYPE_LENGTH (builtin_type_void_data_ptr
))
5333 /* Other tests here??? */
5340 * Function: stopped_by_watchpoint
5342 * Returns non-zero if process is stopped on a hardware watchpoint fault,
5343 * else returns zero.
5347 procfs_stopped_by_watchpoint (ptid_t ptid
)
5351 pi
= find_procinfo_or_die (PIDGET (ptid
) == -1 ?
5352 PIDGET (inferior_ptid
) : PIDGET (ptid
), 0);
5354 if (!pi
) /* If no process, then not stopped by watchpoint! */
5357 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
5359 if (proc_why (pi
) == PR_FAULTED
)
5362 if (proc_what (pi
) == FLTWATCH
)
5366 if (proc_what (pi
) == FLTKWATCH
)
5375 * Memory Mappings Functions:
5379 * Function: iterate_over_mappings
5381 * Call a callback function once for each mapping, passing it the mapping,
5382 * an optional secondary callback function, and some optional opaque data.
5383 * Quit and return the first non-zero value returned from the callback.
5386 * pi -- procinfo struct for the process to be mapped.
5387 * func -- callback function to be called by this iterator.
5388 * data -- optional opaque data to be passed to the callback function.
5389 * child_func -- optional secondary function pointer to be passed
5390 * to the child function.
5392 * Return: First non-zero return value from the callback function,
5397 iterate_over_mappings (procinfo
*pi
, int (*child_func
) (), void *data
,
5398 int (*func
) (struct prmap
*map
,
5399 int (*child_func
) (),
5402 char pathname
[MAX_PROC_NAME_SIZE
];
5403 struct prmap
*prmaps
;
5404 struct prmap
*prmap
;
5412 /* Get the number of mappings, allocate space,
5413 and read the mappings into prmaps. */
5416 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
5417 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
5418 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
5420 /* Make sure it gets closed again. */
5421 make_cleanup_close (map_fd
);
5423 /* Use stat to determine the file size, and compute
5424 the number of prmap_t objects it contains. */
5425 if (fstat (map_fd
, &sbuf
) != 0)
5426 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
5428 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
5429 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5430 if (read (map_fd
, (char *) prmaps
, nmap
* sizeof (*prmaps
))
5431 != (nmap
* sizeof (*prmaps
)))
5432 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
5434 /* Use ioctl command PIOCNMAP to get number of mappings. */
5435 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmap
) != 0)
5436 proc_error (pi
, "iterate_over_mappings (PIOCNMAP)", __LINE__
);
5438 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5439 if (ioctl (pi
->ctl_fd
, PIOCMAP
, prmaps
) != 0)
5440 proc_error (pi
, "iterate_over_mappings (PIOCMAP)", __LINE__
);
5443 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
5444 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
5451 * Function: solib_mappings_callback
5453 * Calls the supplied callback function once for each mapped address
5454 * space in the process. The callback function receives an open
5455 * file descriptor for the file corresponding to that mapped
5456 * address space (if there is one), and the base address of the
5457 * mapped space. Quit when the callback function returns a
5458 * nonzero value, or at teh end of the mappings.
5460 * Returns: the first non-zero return value of the callback function,
5464 int solib_mappings_callback (struct prmap
*map
,
5465 int (*func
) (int, CORE_ADDR
),
5468 procinfo
*pi
= data
;
5472 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
5474 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
5475 return -1; /* sanity */
5477 if (map
->pr_mapname
[0] == 0)
5479 fd
= -1; /* no map file */
5483 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
5484 /* Note: caller's responsibility to close this fd! */
5485 fd
= open_with_retry (name
, O_RDONLY
);
5486 /* Note: we don't test the above call for failure;
5487 we just pass the FD on as given. Sometimes there is
5488 no file, so the open may return failure, but that's
5492 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
->pr_vaddr
);
5493 /* Note: we don't test the above call for failure;
5494 we just pass the FD on as given. Sometimes there is
5495 no file, so the ioctl may return failure, but that's
5498 return (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
);
5502 * Function: proc_iterate_over_mappings
5504 * Uses the unified "iterate_over_mappings" function
5505 * to implement the exported interface to solib-svr4.c.
5507 * Given a pointer to a function, call that function once for every
5508 * mapped address space in the process. The callback function
5509 * receives an open file descriptor for the file corresponding to
5510 * that mapped address space (if there is one), and the base address
5511 * of the mapped space. Quit when the callback function returns a
5512 * nonzero value, or at teh end of the mappings.
5514 * Returns: the first non-zero return value of the callback function,
5519 proc_iterate_over_mappings (int (*func
) (int, CORE_ADDR
))
5521 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5523 return iterate_over_mappings (pi
, func
, pi
, solib_mappings_callback
);
5527 * Function: find_memory_regions_callback
5529 * Implements the to_find_memory_regions method.
5530 * Calls an external function for each memory region.
5531 * External function will have the signiture:
5533 * int callback (CORE_ADDR vaddr,
5534 * unsigned long size,
5535 * int read, int write, int execute,
5538 * Returns the integer value returned by the callback.
5542 find_memory_regions_callback (struct prmap
*map
,
5543 int (*func
) (CORE_ADDR
,
5549 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
5551 (map
->pr_mflags
& MA_READ
) != 0,
5552 (map
->pr_mflags
& MA_WRITE
) != 0,
5553 (map
->pr_mflags
& MA_EXEC
) != 0,
5558 * Function: proc_find_memory_regions
5560 * External interface. Calls a callback function once for each
5561 * mapped memory region in the child process, passing as arguments
5562 * CORE_ADDR virtual_address,
5563 * unsigned long size,
5564 * int read, TRUE if region is readable by the child
5565 * int write, TRUE if region is writable by the child
5566 * int execute TRUE if region is executable by the child.
5568 * Stops iterating and returns the first non-zero value
5569 * returned by the callback.
5573 proc_find_memory_regions (int (*func
) (CORE_ADDR
,
5579 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5581 return iterate_over_mappings (pi
, func
, data
,
5582 find_memory_regions_callback
);
5585 /* Remove the breakpoint that we inserted in __dbx_link().
5586 Does nothing if the breakpoint hasn't been inserted or has already
5590 remove_dbx_link_breakpoint (void)
5592 if (dbx_link_bpt_addr
== 0)
5595 if (deprecated_remove_raw_breakpoint (dbx_link_bpt
) != 0)
5596 warning (_("Unable to remove __dbx_link breakpoint."));
5598 dbx_link_bpt_addr
= 0;
5599 dbx_link_bpt
= NULL
;
5602 /* Return the address of the __dbx_link() function in the file
5603 refernced by ABFD by scanning its symbol table. Return 0 if
5604 the symbol was not found. */
5607 dbx_link_addr (bfd
*abfd
)
5609 long storage_needed
;
5610 asymbol
**symbol_table
;
5611 long number_of_symbols
;
5614 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
5615 if (storage_needed
<= 0)
5618 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
5619 make_cleanup (xfree
, symbol_table
);
5621 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
5623 for (i
= 0; i
< number_of_symbols
; i
++)
5625 asymbol
*sym
= symbol_table
[i
];
5627 if ((sym
->flags
& BSF_GLOBAL
)
5628 && sym
->name
!= NULL
&& strcmp (sym
->name
, "__dbx_link") == 0)
5629 return (sym
->value
+ sym
->section
->vma
);
5632 /* Symbol not found, return NULL. */
5636 /* Search the symbol table of the file referenced by FD for a symbol
5637 named __dbx_link(). If found, then insert a breakpoint at this location,
5638 and return nonzero. Return zero otherwise. */
5641 insert_dbx_link_bpt_in_file (int fd
, CORE_ADDR ignored
)
5644 long storage_needed
;
5647 abfd
= bfd_fdopenr ("unamed", 0, fd
);
5650 warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
5654 if (!bfd_check_format (abfd
, bfd_object
))
5656 /* Not the correct format, so we can not possibly find the dbx_link
5662 sym_addr
= dbx_link_addr (abfd
);
5665 /* Insert the breakpoint. */
5666 dbx_link_bpt_addr
= sym_addr
;
5667 dbx_link_bpt
= deprecated_insert_raw_breakpoint (sym_addr
);
5668 if (dbx_link_bpt
== NULL
)
5670 warning (_("Failed to insert dbx_link breakpoint."));
5682 /* If the given memory region MAP contains a symbol named __dbx_link,
5683 insert a breakpoint at this location and return nonzero. Return
5687 insert_dbx_link_bpt_in_region (struct prmap
*map
,
5688 int (*child_func
) (),
5691 procinfo
*pi
= (procinfo
*) data
;
5693 /* We know the symbol we're looking for is in a text region, so
5694 only look for it if the region is a text one. */
5695 if (map
->pr_mflags
& MA_EXEC
)
5696 return solib_mappings_callback (map
, insert_dbx_link_bpt_in_file
, pi
);
5701 /* Search all memory regions for a symbol named __dbx_link. If found,
5702 insert a breakpoint at its location, and return nonzero. Return zero
5706 insert_dbx_link_breakpoint (procinfo
*pi
)
5708 return iterate_over_mappings (pi
, NULL
, pi
, insert_dbx_link_bpt_in_region
);
5712 * Function: mappingflags
5714 * Returns an ascii representation of a memory mapping's flags.
5718 mappingflags (long flags
)
5720 static char asciiflags
[8];
5722 strcpy (asciiflags
, "-------");
5723 #if defined (MA_PHYS)
5724 if (flags
& MA_PHYS
)
5725 asciiflags
[0] = 'd';
5727 if (flags
& MA_STACK
)
5728 asciiflags
[1] = 's';
5729 if (flags
& MA_BREAK
)
5730 asciiflags
[2] = 'b';
5731 if (flags
& MA_SHARED
)
5732 asciiflags
[3] = 's';
5733 if (flags
& MA_READ
)
5734 asciiflags
[4] = 'r';
5735 if (flags
& MA_WRITE
)
5736 asciiflags
[5] = 'w';
5737 if (flags
& MA_EXEC
)
5738 asciiflags
[6] = 'x';
5739 return (asciiflags
);
5743 * Function: info_mappings_callback
5745 * Callback function, does the actual work for 'info proc mappings'.
5749 info_mappings_callback (struct prmap
*map
, int (*ignore
) (), void *unused
)
5751 char *data_fmt_string
;
5753 if (gdbarch_addr_bit (current_gdbarch
) == 32)
5754 data_fmt_string
= "\t%#10lx %#10lx %#10x %#10x %7s\n";
5756 data_fmt_string
= " %#18lx %#18lx %#10x %#10x %7s\n";
5758 printf_filtered (data_fmt_string
,
5759 (unsigned long) map
->pr_vaddr
,
5760 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5762 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
5763 (unsigned int) map
->pr_offset
,
5767 mappingflags (map
->pr_mflags
));
5773 * Function: info_proc_mappings
5775 * Implement the "info proc mappings" subcommand.
5779 info_proc_mappings (procinfo
*pi
, int summary
)
5781 char *header_fmt_string
;
5783 if (gdbarch_ptr_bit (current_gdbarch
) == 32)
5784 header_fmt_string
= "\t%10s %10s %10s %10s %7s\n";
5786 header_fmt_string
= " %18s %18s %10s %10s %7s\n";
5789 return; /* No output for summary mode. */
5791 printf_filtered (_("Mapped address spaces:\n\n"));
5792 printf_filtered (header_fmt_string
,
5799 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
5800 printf_filtered ("\n");
5804 * Function: info_proc_cmd
5806 * Implement the "info proc" command.
5810 info_proc_cmd (char *args
, int from_tty
)
5812 struct cleanup
*old_chain
;
5813 procinfo
*process
= NULL
;
5814 procinfo
*thread
= NULL
;
5821 old_chain
= make_cleanup (null_cleanup
, 0);
5824 if ((argv
= buildargv (args
)) == NULL
)
5827 make_cleanup_freeargv (argv
);
5829 while (argv
!= NULL
&& *argv
!= NULL
)
5831 if (isdigit (argv
[0][0]))
5833 pid
= strtoul (argv
[0], &tmp
, 10);
5835 tid
= strtoul (++tmp
, NULL
, 10);
5837 else if (argv
[0][0] == '/')
5839 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5841 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
5852 pid
= PIDGET (inferior_ptid
);
5854 error (_("No current process: you must name one."));
5857 /* Have pid, will travel.
5858 First see if it's a process we're already debugging. */
5859 process
= find_procinfo (pid
, 0);
5860 if (process
== NULL
)
5862 /* No. So open a procinfo for it, but
5863 remember to close it again when finished. */
5864 process
= create_procinfo (pid
, 0);
5865 make_cleanup (do_destroy_procinfo_cleanup
, process
);
5866 if (!open_procinfo_files (process
, FD_CTL
))
5867 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5871 thread
= create_procinfo (pid
, tid
);
5875 printf_filtered (_("process %d flags:\n"), process
->pid
);
5876 proc_prettyprint_flags (proc_flags (process
), 1);
5877 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5878 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5879 if (proc_get_nthreads (process
) > 1)
5880 printf_filtered ("Process has %d threads.\n",
5881 proc_get_nthreads (process
));
5885 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
5886 proc_prettyprint_flags (proc_flags (thread
), 1);
5887 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5888 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5893 info_proc_mappings (process
, 0);
5896 do_cleanups (old_chain
);
5899 /* Modify the status of the system call identified by SYSCALLNUM in
5900 the set of syscalls that are currently traced/debugged.
5902 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
5903 will be updated. Otherwise, the exit syscalls set will be updated.
5905 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
5906 will be disabled. */
5909 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
5910 int mode
, int from_tty
)
5914 if (entry_or_exit
== PR_SYSENTRY
)
5915 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5917 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5920 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5922 if (mode
== FLAG_SET
)
5923 gdb_praddsysset (sysset
, syscallnum
);
5925 gdb_prdelsysset (sysset
, syscallnum
);
5927 if (entry_or_exit
== PR_SYSENTRY
)
5929 if (!proc_set_traced_sysentry (pi
, sysset
))
5930 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5934 if (!proc_set_traced_sysexit (pi
, sysset
))
5935 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5940 proc_trace_syscalls (char *args
, int from_tty
, int entry_or_exit
, int mode
)
5944 if (PIDGET (inferior_ptid
) <= 0)
5945 error (_("you must be debugging a process to use this command."));
5947 if (args
== NULL
|| args
[0] == 0)
5948 error_no_arg (_("system call to trace"));
5950 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5951 if (isdigit (args
[0]))
5953 const int syscallnum
= atoi (args
);
5955 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
5960 proc_trace_sysentry_cmd (char *args
, int from_tty
)
5962 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5966 proc_trace_sysexit_cmd (char *args
, int from_tty
)
5968 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5972 proc_untrace_sysentry_cmd (char *args
, int from_tty
)
5974 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5978 proc_untrace_sysexit_cmd (char *args
, int from_tty
)
5980 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5985 _initialize_procfs (void)
5988 add_target (&procfs_ops
);
5989 add_info ("proc", info_proc_cmd
, _("\
5990 Show /proc process information about any running process.\n\
5991 Specify process id, or use the program being debugged by default.\n\
5992 Specify keyword 'mappings' for detailed info on memory mappings."));
5993 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5994 _("Give a trace of entries into the syscall."));
5995 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5996 _("Give a trace of exits from the syscall."));
5997 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5998 _("Cancel a trace of entries into the syscall."));
5999 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
6000 _("Cancel a trace of exits from the syscall."));
6003 /* =================== END, GDB "MODULE" =================== */
6007 /* miscellaneous stubs: */
6008 /* The following satisfy a few random symbols mostly created by */
6009 /* the solaris threads implementation, which I will chase down */
6013 * Return a pid for which we guarantee
6014 * we will be able to find a 'live' procinfo.
6018 procfs_first_available (void)
6020 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
6023 /* =================== GCORE .NOTE "MODULE" =================== */
6024 #if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT)
6025 /* gcore only implemented on solaris and unixware (so far) */
6028 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
6029 char *note_data
, int *note_size
)
6031 struct regcache
*regcache
= get_thread_regcache (ptid
);
6032 gdb_gregset_t gregs
;
6033 gdb_fpregset_t fpregs
;
6034 unsigned long merged_pid
;
6036 merged_pid
= TIDGET (ptid
) << 16 | PIDGET (ptid
);
6038 fill_gregset (regcache
, &gregs
, -1);
6039 #if defined (UNIXWARE)
6040 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
6047 note_data
= (char *) elfcore_write_prstatus (obfd
,
6054 fill_fpregset (regcache
, &fpregs
, -1);
6055 note_data
= (char *) elfcore_write_prfpreg (obfd
,
6063 struct procfs_corefile_thread_data
{
6070 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
6072 struct procfs_corefile_thread_data
*args
= data
;
6074 if (pi
!= NULL
&& thread
->tid
!= 0)
6076 ptid_t saved_ptid
= inferior_ptid
;
6077 inferior_ptid
= MERGEPID (pi
->pid
, thread
->tid
);
6078 args
->note_data
= procfs_do_thread_registers (args
->obfd
, inferior_ptid
,
6081 inferior_ptid
= saved_ptid
;
6087 procfs_make_note_section (bfd
*obfd
, int *note_size
)
6089 struct cleanup
*old_chain
;
6090 gdb_gregset_t gregs
;
6091 gdb_fpregset_t fpregs
;
6092 char fname
[16] = {'\0'};
6093 char psargs
[80] = {'\0'};
6094 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
6095 char *note_data
= NULL
;
6097 struct procfs_corefile_thread_data thread_args
;
6101 if (get_exec_file (0))
6103 strncpy (fname
, strrchr (get_exec_file (0), '/') + 1, sizeof (fname
));
6104 strncpy (psargs
, get_exec_file (0),
6107 inf_args
= get_inferior_args ();
6108 if (inf_args
&& *inf_args
&&
6109 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
6111 strncat (psargs
, " ",
6112 sizeof (psargs
) - strlen (psargs
));
6113 strncat (psargs
, inf_args
,
6114 sizeof (psargs
) - strlen (psargs
));
6118 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
6125 fill_gregset (get_current_regcache (), &gregs
, -1);
6126 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
6127 PIDGET (inferior_ptid
),
6128 stop_signal
, &gregs
);
6131 thread_args
.obfd
= obfd
;
6132 thread_args
.note_data
= note_data
;
6133 thread_args
.note_size
= note_size
;
6134 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
, &thread_args
);
6136 if (thread_args
.note_data
== note_data
)
6138 /* iterate_over_threads didn't come up with any threads;
6139 just use inferior_ptid. */
6140 note_data
= procfs_do_thread_registers (obfd
, inferior_ptid
,
6141 note_data
, note_size
);
6145 note_data
= thread_args
.note_data
;
6148 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
6152 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
6153 "CORE", NT_AUXV
, auxv
, auxv_len
);
6157 make_cleanup (xfree
, note_data
);
6160 #else /* !(Solaris or Unixware) */
6162 procfs_make_note_section (bfd
*obfd
, int *note_size
)
6164 error (_("gcore not implemented for this host."));
6165 return NULL
; /* lint */
6167 #endif /* Solaris or Unixware */
6168 /* =================== END GCORE .NOTE "MODULE" =================== */