1 /* Machine independent support for Solaris /proc (process file system) for GDB.
3 Copyright (C) 1999-2018 Free Software Foundation, Inc.
5 Written by Michael Snyder at Cygnus Solutions.
6 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "elf-bfd.h" /* for elfcore_write_* */
30 #include "gdbthread.h"
32 #include "inf-child.h"
33 #include "nat/fork-inferior.h"
34 #include "filestuff.h"
36 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
38 #include <sys/procfs.h>
39 #include <sys/fault.h>
40 #include <sys/syscall.h>
48 #include "observable.h"
49 #include "common/scoped_fd.h"
51 /* This module provides the interface between GDB and the
52 /proc file system, which is used on many versions of Unix
53 as a means for debuggers to control other processes.
55 /proc works by imitating a file system: you open a simulated file
56 that represents the process you wish to interact with, and perform
57 operations on that "file" in order to examine or change the state
60 The most important thing to know about /proc and this module is
61 that there are two very different interfaces to /proc:
63 One that uses the ioctl system call, and another that uses read
64 and write system calls.
66 This module supports only the Solaris version of the read/write
69 #include <sys/types.h>
70 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
72 #include <fcntl.h> /* for O_RDONLY */
73 #include <unistd.h> /* for "X_OK" */
74 #include <sys/stat.h> /* for struct stat */
76 /* Note: procfs-utils.h must be included after the above system header
77 files, because it redefines various system calls using macros.
78 This may be incompatible with the prototype declarations. */
80 #include "proc-utils.h"
82 /* Prototypes for supply_gregset etc. */
85 /* =================== TARGET_OPS "MODULE" =================== */
87 /* This module defines the GDB target vector and its methods. */
89 static void procfs_attach (struct target_ops
*, const char *, int);
90 static void procfs_detach (struct target_ops
*, inferior
*, int);
91 static void procfs_resume (struct target_ops
*,
92 ptid_t
, int, enum gdb_signal
);
93 static void procfs_files_info (struct target_ops
*);
94 static void procfs_fetch_registers (struct target_ops
*,
95 struct regcache
*, int);
96 static void procfs_store_registers (struct target_ops
*,
97 struct regcache
*, int);
98 static void procfs_pass_signals (struct target_ops
*self
,
99 int, unsigned char *);
100 static void procfs_kill_inferior (struct target_ops
*ops
);
101 static void procfs_mourn_inferior (struct target_ops
*ops
);
102 static void procfs_create_inferior (struct target_ops
*, const char *,
103 const std::string
&, char **, int);
104 static ptid_t
procfs_wait (struct target_ops
*,
105 ptid_t
, struct target_waitstatus
*, int);
106 static enum target_xfer_status
procfs_xfer_memory (gdb_byte
*,
110 static target_xfer_partial_ftype procfs_xfer_partial
;
112 static int procfs_thread_alive (struct target_ops
*ops
, ptid_t
);
114 static void procfs_update_thread_list (struct target_ops
*ops
);
115 static const char *procfs_pid_to_str (struct target_ops
*, ptid_t
);
117 static int proc_find_memory_regions (struct target_ops
*self
,
118 find_memory_region_ftype
, void *);
120 static char *procfs_make_note_section (struct target_ops
*self
,
123 static int procfs_can_use_hw_breakpoint (struct target_ops
*self
,
124 enum bptype
, int, int);
126 static void procfs_info_proc (struct target_ops
*, const char *,
127 enum info_proc_what
);
129 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
130 /* When GDB is built as 64-bit application on Solaris, the auxv data
131 is presented in 64-bit format. We need to provide a custom parser
134 procfs_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
135 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
137 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
138 gdb_byte
*ptr
= *readptr
;
143 if (endptr
- ptr
< 8 * 2)
146 *typep
= extract_unsigned_integer (ptr
, 4, byte_order
);
148 /* The size of data is always 64-bit. If the application is 32-bit,
149 it will be zero extended, as expected. */
150 *valp
= extract_unsigned_integer (ptr
, 8, byte_order
);
161 struct target_ops
*t
= inf_child_target ();
163 t
->to_create_inferior
= procfs_create_inferior
;
164 t
->to_kill
= procfs_kill_inferior
;
165 t
->to_mourn_inferior
= procfs_mourn_inferior
;
166 t
->to_attach
= procfs_attach
;
167 t
->to_detach
= procfs_detach
;
168 t
->to_wait
= procfs_wait
;
169 t
->to_resume
= procfs_resume
;
170 t
->to_fetch_registers
= procfs_fetch_registers
;
171 t
->to_store_registers
= procfs_store_registers
;
172 t
->to_xfer_partial
= procfs_xfer_partial
;
173 t
->to_pass_signals
= procfs_pass_signals
;
174 t
->to_files_info
= procfs_files_info
;
176 t
->to_update_thread_list
= procfs_update_thread_list
;
177 t
->to_thread_alive
= procfs_thread_alive
;
178 t
->to_pid_to_str
= procfs_pid_to_str
;
180 t
->to_has_thread_control
= tc_schedlock
;
181 t
->to_find_memory_regions
= proc_find_memory_regions
;
182 t
->to_make_corefile_notes
= procfs_make_note_section
;
183 t
->to_info_proc
= procfs_info_proc
;
185 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
186 t
->to_auxv_parse
= procfs_auxv_parse
;
189 t
->to_magic
= OPS_MAGIC
;
194 /* =================== END, TARGET_OPS "MODULE" =================== */
196 /* World Unification:
198 Put any typedefs, defines etc. here that are required for the
199 unification of code that handles different versions of /proc. */
201 enum { READ_WATCHFLAG
= WA_READ
,
202 WRITE_WATCHFLAG
= WA_WRITE
,
203 EXEC_WATCHFLAG
= WA_EXEC
,
204 AFTER_WATCHFLAG
= WA_TRAPAFTER
208 /* =================== STRUCT PROCINFO "MODULE" =================== */
210 /* FIXME: this comment will soon be out of date W.R.T. threads. */
212 /* The procinfo struct is a wrapper to hold all the state information
213 concerning a /proc process. There should be exactly one procinfo
214 for each process, and since GDB currently can debug only one
215 process at a time, that means there should be only one procinfo.
216 All of the LWP's of a process can be accessed indirectly thru the
217 single process procinfo.
219 However, against the day when GDB may debug more than one process,
220 this data structure is kept in a list (which for now will hold no
221 more than one member), and many functions will have a pointer to a
222 procinfo as an argument.
224 There will be a separate procinfo structure for use by the (not yet
225 implemented) "info proc" command, so that we can print useful
226 information about any random process without interfering with the
227 inferior's procinfo information. */
229 /* format strings for /proc paths */
230 #define MAIN_PROC_NAME_FMT "/proc/%d"
231 #define CTL_PROC_NAME_FMT "/proc/%d/ctl"
232 #define AS_PROC_NAME_FMT "/proc/%d/as"
233 #define MAP_PROC_NAME_FMT "/proc/%d/map"
234 #define STATUS_PROC_NAME_FMT "/proc/%d/status"
235 #define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
237 typedef struct procinfo
{
238 struct procinfo
*next
;
239 int pid
; /* Process ID */
240 int tid
; /* Thread/LWP id */
244 int ignore_next_sigstop
;
246 int ctl_fd
; /* File descriptor for /proc control file */
247 int status_fd
; /* File descriptor for /proc status file */
248 int as_fd
; /* File descriptor for /proc as file */
250 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
252 fltset_t saved_fltset
; /* Saved traced hardware fault set */
253 sigset_t saved_sigset
; /* Saved traced signal set */
254 sigset_t saved_sighold
; /* Saved held signal set */
255 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
256 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
258 pstatus_t prstatus
; /* Current process status info */
260 struct procinfo
*thread_list
;
262 int status_valid
: 1;
264 int fpregs_valid
: 1;
265 int threads_valid
: 1;
268 static char errmsg
[128]; /* shared error msg buffer */
270 /* Function prototypes for procinfo module: */
272 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
273 static procinfo
*find_procinfo (int pid
, int tid
);
274 static procinfo
*create_procinfo (int pid
, int tid
);
275 static void destroy_procinfo (procinfo
*p
);
276 static void do_destroy_procinfo_cleanup (void *);
277 static void dead_procinfo (procinfo
*p
, const char *msg
, int killp
);
278 static int open_procinfo_files (procinfo
*p
, int which
);
279 static void close_procinfo_files (procinfo
*p
);
280 static sysset_t
*sysset_t_alloc (procinfo
*pi
);
282 static int iterate_over_mappings
283 (procinfo
*pi
, find_memory_region_ftype child_func
, void *data
,
284 int (*func
) (struct prmap
*map
, find_memory_region_ftype child_func
,
287 /* The head of the procinfo list: */
288 static procinfo
*procinfo_list
;
290 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
294 find_procinfo (int pid
, int tid
)
298 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
305 /* Don't check threads_valid. If we're updating the
306 thread_list, we want to find whatever threads are already
307 here. This means that in general it is the caller's
308 responsibility to check threads_valid and update before
309 calling find_procinfo, if the caller wants to find a new
312 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
320 /* Calls find_procinfo, but errors on failure. */
323 find_procinfo_or_die (int pid
, int tid
)
325 procinfo
*pi
= find_procinfo (pid
, tid
);
330 error (_("procfs: couldn't find pid %d "
331 "(kernel thread %d) in procinfo list."),
334 error (_("procfs: couldn't find pid %d in procinfo list."), pid
);
339 /* Wrapper for `open'. The appropriate open call is attempted; if
340 unsuccessful, it will be retried as many times as needed for the
341 EAGAIN and EINTR conditions.
343 For other conditions, retry the open a limited number of times. In
344 addition, a short sleep is imposed prior to retrying the open. The
345 reason for this sleep is to give the kernel a chance to catch up
346 and create the file in question in the event that GDB "wins" the
347 race to open a file before the kernel has created it. */
350 open_with_retry (const char *pathname
, int flags
)
352 int retries_remaining
, status
;
354 retries_remaining
= 2;
358 status
= open (pathname
, flags
);
360 if (status
>= 0 || retries_remaining
== 0)
362 else if (errno
!= EINTR
&& errno
!= EAGAIN
)
372 /* Open the file descriptor for the process or LWP. We only open the
373 control file descriptor; the others are opened lazily as needed.
374 Returns the file descriptor, or zero for failure. */
376 enum { FD_CTL
, FD_STATUS
, FD_AS
};
379 open_procinfo_files (procinfo
*pi
, int which
)
381 char tmp
[MAX_PROC_NAME_SIZE
];
384 /* This function is getting ALMOST long enough to break up into
385 several. Here is some rationale:
387 There are several file descriptors that may need to be open
388 for any given process or LWP. The ones we're intereted in are:
389 - control (ctl) write-only change the state
390 - status (status) read-only query the state
391 - address space (as) read/write access memory
392 - map (map) read-only virtual addr map
393 Most of these are opened lazily as they are needed.
394 The pathnames for the 'files' for an LWP look slightly
395 different from those of a first-class process:
396 Pathnames for a process (<proc-id>):
398 /proc/<proc-id>/status
401 Pathnames for an LWP (lwp-id):
402 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
403 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
404 An LWP has no map or address space file descriptor, since
405 the memory map and address space are shared by all LWPs. */
407 /* In this case, there are several different file descriptors that
408 we might be asked to open. The control file descriptor will be
409 opened early, but the others will be opened lazily as they are
412 strcpy (tmp
, pi
->pathname
);
413 switch (which
) { /* Which file descriptor to open? */
416 strcat (tmp
, "/lwpctl");
418 strcat (tmp
, "/ctl");
419 fd
= open_with_retry (tmp
, O_WRONLY
);
426 return 0; /* There is no 'as' file descriptor for an lwp. */
428 fd
= open_with_retry (tmp
, O_RDWR
);
435 strcat (tmp
, "/lwpstatus");
437 strcat (tmp
, "/status");
438 fd
= open_with_retry (tmp
, O_RDONLY
);
444 return 0; /* unknown file descriptor */
447 return 1; /* success */
450 /* Allocate a data structure and link it into the procinfo list.
451 First tries to find a pre-existing one (FIXME: why?). Returns the
452 pointer to new procinfo struct. */
455 create_procinfo (int pid
, int tid
)
457 procinfo
*pi
, *parent
= NULL
;
459 if ((pi
= find_procinfo (pid
, tid
)))
460 return pi
; /* Already exists, nothing to do. */
462 /* Find parent before doing malloc, to save having to cleanup. */
464 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
466 doesn't exist yet? */
468 pi
= XNEW (procinfo
);
469 memset (pi
, 0, sizeof (procinfo
));
473 pi
->saved_entryset
= sysset_t_alloc (pi
);
474 pi
->saved_exitset
= sysset_t_alloc (pi
);
476 /* Chain into list. */
479 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
480 pi
->next
= procinfo_list
;
485 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
486 pi
->next
= parent
->thread_list
;
487 parent
->thread_list
= pi
;
492 /* Close all file descriptors associated with the procinfo. */
495 close_procinfo_files (procinfo
*pi
)
501 if (pi
->status_fd
> 0)
502 close (pi
->status_fd
);
503 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
506 /* Destructor function. Close, unlink and deallocate the object. */
509 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
513 /* Step one: unlink the procinfo from its list. */
517 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
520 ptr
->next
= pi
->next
;
524 /* Step two: close any open file descriptors. */
525 close_procinfo_files (pi
);
527 /* Step three: free the memory. */
528 xfree (pi
->saved_entryset
);
529 xfree (pi
->saved_exitset
);
534 destroy_procinfo (procinfo
*pi
)
538 if (pi
->tid
!= 0) /* Destroy a thread procinfo. */
540 tmp
= find_procinfo (pi
->pid
, 0); /* Find the parent process. */
541 destroy_one_procinfo (&tmp
->thread_list
, pi
);
543 else /* Destroy a process procinfo and all its threads. */
545 /* First destroy the children, if any; */
546 while (pi
->thread_list
!= NULL
)
547 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
548 /* Then destroy the parent. Genocide!!! */
549 destroy_one_procinfo (&procinfo_list
, pi
);
554 do_destroy_procinfo_cleanup (void *pi
)
556 destroy_procinfo ((procinfo
*) pi
);
559 enum { NOKILL
, KILL
};
561 /* To be called on a non_recoverable error for a procinfo. Prints
562 error messages, optionally sends a SIGKILL to the process, then
563 destroys the data structure. */
566 dead_procinfo (procinfo
*pi
, const char *msg
, int kill_p
)
572 print_sys_errmsg (pi
->pathname
, errno
);
576 sprintf (procfile
, "process %d", pi
->pid
);
577 print_sys_errmsg (procfile
, errno
);
580 kill (pi
->pid
, SIGKILL
);
582 destroy_procinfo (pi
);
586 /* Allocate and (partially) initialize a sysset_t struct. */
589 sysset_t_alloc (procinfo
*pi
)
591 return (sysset_t
*) xmalloc (sizeof (sysset_t
));
594 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
596 /* =================== /proc "MODULE" =================== */
598 /* This "module" is the interface layer between the /proc system API
599 and the gdb target vector functions. This layer consists of access
600 functions that encapsulate each of the basic operations that we
601 need to use from the /proc API.
603 The main motivation for this layer is to hide the fact that there
604 are two very different implementations of the /proc API. Rather
605 than have a bunch of #ifdefs all thru the gdb target vector
606 functions, we do our best to hide them all in here. */
608 static long proc_flags (procinfo
*pi
);
609 static int proc_why (procinfo
*pi
);
610 static int proc_what (procinfo
*pi
);
611 static int proc_set_current_signal (procinfo
*pi
, int signo
);
612 static int proc_get_current_thread (procinfo
*pi
);
613 static int proc_iterate_over_threads
615 int (*func
) (procinfo
*, procinfo
*, void *),
619 proc_warn (procinfo
*pi
, const char *func
, int line
)
621 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
622 print_sys_errmsg (errmsg
, errno
);
626 proc_error (procinfo
*pi
, const char *func
, int line
)
628 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
629 perror_with_name (errmsg
);
632 /* Updates the status struct in the procinfo. There is a 'valid'
633 flag, to let other functions know when this function needs to be
634 called (so the status is only read when it is needed). The status
635 file descriptor is also only opened when it is needed. Returns
636 non-zero for success, zero for failure. */
639 proc_get_status (procinfo
*pi
)
641 /* Status file descriptor is opened "lazily". */
642 if (pi
->status_fd
== 0 &&
643 open_procinfo_files (pi
, FD_STATUS
) == 0)
645 pi
->status_valid
= 0;
649 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
650 pi
->status_valid
= 0; /* fail */
653 /* Sigh... I have to read a different data structure,
654 depending on whether this is a main process or an LWP. */
656 pi
->status_valid
= (read (pi
->status_fd
,
657 (char *) &pi
->prstatus
.pr_lwp
,
658 sizeof (lwpstatus_t
))
659 == sizeof (lwpstatus_t
));
662 pi
->status_valid
= (read (pi
->status_fd
,
663 (char *) &pi
->prstatus
,
665 == sizeof (pstatus_t
));
669 if (pi
->status_valid
)
671 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
674 proc_get_current_thread (pi
));
677 /* The status struct includes general regs, so mark them valid too. */
678 pi
->gregs_valid
= pi
->status_valid
;
679 /* In the read/write multiple-fd model, the status struct includes
680 the fp regs too, so mark them valid too. */
681 pi
->fpregs_valid
= pi
->status_valid
;
682 return pi
->status_valid
; /* True if success, false if failure. */
685 /* Returns the process flags (pr_flags field). */
688 proc_flags (procinfo
*pi
)
690 if (!pi
->status_valid
)
691 if (!proc_get_status (pi
))
692 return 0; /* FIXME: not a good failure value (but what is?) */
694 return pi
->prstatus
.pr_lwp
.pr_flags
;
697 /* Returns the pr_why field (why the process stopped). */
700 proc_why (procinfo
*pi
)
702 if (!pi
->status_valid
)
703 if (!proc_get_status (pi
))
704 return 0; /* FIXME: not a good failure value (but what is?) */
706 return pi
->prstatus
.pr_lwp
.pr_why
;
709 /* Returns the pr_what field (details of why the process stopped). */
712 proc_what (procinfo
*pi
)
714 if (!pi
->status_valid
)
715 if (!proc_get_status (pi
))
716 return 0; /* FIXME: not a good failure value (but what is?) */
718 return pi
->prstatus
.pr_lwp
.pr_what
;
721 /* This function is only called when PI is stopped by a watchpoint.
722 Assuming the OS supports it, write to *ADDR the data address which
723 triggered it and return 1. Return 0 if it is not possible to know
727 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
729 if (!pi
->status_valid
)
730 if (!proc_get_status (pi
))
733 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch (),
734 builtin_type (target_gdbarch ())->builtin_data_ptr
,
735 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
739 /* Returns the pr_nsysarg field (number of args to the current
743 proc_nsysarg (procinfo
*pi
)
745 if (!pi
->status_valid
)
746 if (!proc_get_status (pi
))
749 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
752 /* Returns the pr_sysarg field (pointer to the arguments of current
756 proc_sysargs (procinfo
*pi
)
758 if (!pi
->status_valid
)
759 if (!proc_get_status (pi
))
762 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
765 /* Set or reset any of the following process flags:
766 PR_FORK -- forked child will inherit trace flags
767 PR_RLC -- traced process runs when last /proc file closed.
768 PR_KLC -- traced process is killed when last /proc file closed.
769 PR_ASYNC -- LWP's get to run/stop independently.
771 This function is done using read/write [PCSET/PCRESET/PCUNSET].
775 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
776 mode -- 1 for set, 0 for reset.
778 Returns non-zero for success, zero for failure. */
780 enum { FLAG_RESET
, FLAG_SET
};
783 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
785 long win
= 0; /* default to fail */
787 /* These operations affect the process as a whole, and applying them
788 to an individual LWP has the same meaning as applying them to the
789 main process. Therefore, if we're ever called with a pointer to
790 an LWP's procinfo, let's substitute the process's procinfo and
791 avoid opening the LWP's file descriptor unnecessarily. */
794 pi
= find_procinfo_or_die (pi
->pid
, 0);
798 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
800 else /* Reset the flag. */
804 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
806 /* The above operation renders the procinfo's cached pstatus
808 pi
->status_valid
= 0;
811 warning (_("procfs: modify_flag failed to turn %s %s"),
812 flag
== PR_FORK
? "PR_FORK" :
813 flag
== PR_RLC
? "PR_RLC" :
814 flag
== PR_ASYNC
? "PR_ASYNC" :
815 flag
== PR_KLC
? "PR_KLC" :
817 mode
== FLAG_RESET
? "off" : "on");
822 /* Set the run_on_last_close flag. Process with all threads will
823 become runnable when debugger closes all /proc fds. Returns
824 non-zero for success, zero for failure. */
827 proc_set_run_on_last_close (procinfo
*pi
)
829 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
832 /* Reset the run_on_last_close flag. The process will NOT become
833 runnable when debugger closes its file handles. Returns non-zero
834 for success, zero for failure. */
837 proc_unset_run_on_last_close (procinfo
*pi
)
839 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
842 /* Reset inherit_on_fork flag. If the process forks a child while we
843 are registered for events in the parent, then we will NOT recieve
844 events from the child. Returns non-zero for success, zero for
848 proc_unset_inherit_on_fork (procinfo
*pi
)
850 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
853 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
854 (signal etc.), the remaining LWPs will continue to run. Returns
855 non-zero for success, zero for failure. */
858 proc_set_async (procinfo
*pi
)
860 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
863 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
864 (signal etc.), then all other LWPs will stop as well. Returns
865 non-zero for success, zero for failure. */
868 proc_unset_async (procinfo
*pi
)
870 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
873 /* Request the process/LWP to stop. Does not wait. Returns non-zero
874 for success, zero for failure. */
877 proc_stop_process (procinfo
*pi
)
881 /* We might conceivably apply this operation to an LWP, and the
882 LWP's ctl file descriptor might not be open. */
884 if (pi
->ctl_fd
== 0 &&
885 open_procinfo_files (pi
, FD_CTL
) == 0)
889 procfs_ctl_t cmd
= PCSTOP
;
891 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
897 /* Wait for the process or LWP to stop (block until it does). Returns
898 non-zero for success, zero for failure. */
901 proc_wait_for_stop (procinfo
*pi
)
905 /* We should never have to apply this operation to any procinfo
906 except the one for the main process. If that ever changes for
907 any reason, then take out the following clause and replace it
908 with one that makes sure the ctl_fd is open. */
911 pi
= find_procinfo_or_die (pi
->pid
, 0);
913 procfs_ctl_t cmd
= PCWSTOP
;
915 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
916 /* We been runnin' and we stopped -- need to update status. */
917 pi
->status_valid
= 0;
922 /* Make the process or LWP runnable.
924 Options (not all are implemented):
926 - clear current fault
927 - clear current signal
928 - abort the current system call
929 - stop as soon as finished with system call
930 - (ioctl): set traced signal set
931 - (ioctl): set held signal set
932 - (ioctl): set traced fault set
933 - (ioctl): set start pc (vaddr)
935 Always clears the current fault. PI is the process or LWP to
936 operate on. If STEP is true, set the process or LWP to trap after
937 one instruction. If SIGNO is zero, clear the current signal if
938 any; if non-zero, set the current signal to this one. Returns
939 non-zero for success, zero for failure. */
942 proc_run_process (procinfo
*pi
, int step
, int signo
)
947 /* We will probably have to apply this operation to individual
948 threads, so make sure the control file descriptor is open. */
950 if (pi
->ctl_fd
== 0 &&
951 open_procinfo_files (pi
, FD_CTL
) == 0)
956 runflags
= PRCFAULT
; /* Always clear current fault. */
961 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
962 proc_set_current_signal (pi
, signo
);
968 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
973 /* Register to trace signals in the process or LWP. Returns non-zero
974 for success, zero for failure. */
977 proc_set_traced_signals (procinfo
*pi
, sigset_t
*sigset
)
981 /* We should never have to apply this operation to any procinfo
982 except the one for the main process. If that ever changes for
983 any reason, then take out the following clause and replace it
984 with one that makes sure the ctl_fd is open. */
987 pi
= find_procinfo_or_die (pi
->pid
, 0);
991 /* Use char array to avoid alignment issues. */
992 char sigset
[sizeof (sigset_t
)];
996 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
998 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1000 /* The above operation renders the procinfo's cached pstatus obsolete. */
1001 pi
->status_valid
= 0;
1004 warning (_("procfs: set_traced_signals failed"));
1008 /* Register to trace hardware faults in the process or LWP. Returns
1009 non-zero for success, zero for failure. */
1012 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1016 /* We should never have to apply this operation to any procinfo
1017 except the one for the main process. If that ever changes for
1018 any reason, then take out the following clause and replace it
1019 with one that makes sure the ctl_fd is open. */
1022 pi
= find_procinfo_or_die (pi
->pid
, 0);
1026 /* Use char array to avoid alignment issues. */
1027 char fltset
[sizeof (fltset_t
)];
1031 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1033 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1035 /* The above operation renders the procinfo's cached pstatus obsolete. */
1036 pi
->status_valid
= 0;
1041 /* Register to trace entry to system calls in the process or LWP.
1042 Returns non-zero for success, zero for failure. */
1045 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1049 /* We should never have to apply this operation to any procinfo
1050 except the one for the main process. If that ever changes for
1051 any reason, then take out the following clause and replace it
1052 with one that makes sure the ctl_fd is open. */
1055 pi
= find_procinfo_or_die (pi
->pid
, 0);
1057 struct gdb_proc_ctl_pcsentry
{
1059 /* Use char array to avoid alignment issues. */
1060 char sysset
[sizeof (sysset_t
)];
1062 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
);
1064 argp
= (struct gdb_proc_ctl_pcsentry
*) xmalloc (argp_size
);
1066 argp
->cmd
= PCSENTRY
;
1067 memcpy (&argp
->sysset
, sysset
, sizeof (sysset_t
));
1069 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1072 /* The above operation renders the procinfo's cached pstatus
1074 pi
->status_valid
= 0;
1079 /* Register to trace exit from system calls in the process or LWP.
1080 Returns non-zero for success, zero for failure. */
1083 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1087 /* We should never have to apply this operation to any procinfo
1088 except the one for the main process. If that ever changes for
1089 any reason, then take out the following clause and replace it
1090 with one that makes sure the ctl_fd is open. */
1093 pi
= find_procinfo_or_die (pi
->pid
, 0);
1095 struct gdb_proc_ctl_pcsexit
{
1097 /* Use char array to avoid alignment issues. */
1098 char sysset
[sizeof (sysset_t
)];
1100 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
);
1102 argp
= (struct gdb_proc_ctl_pcsexit
*) xmalloc (argp_size
);
1104 argp
->cmd
= PCSEXIT
;
1105 memcpy (&argp
->sysset
, sysset
, sizeof (sysset_t
));
1107 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1110 /* The above operation renders the procinfo's cached pstatus
1112 pi
->status_valid
= 0;
1117 /* Specify the set of blocked / held signals in the process or LWP.
1118 Returns non-zero for success, zero for failure. */
1121 proc_set_held_signals (procinfo
*pi
, sigset_t
*sighold
)
1125 /* We should never have to apply this operation to any procinfo
1126 except the one for the main process. If that ever changes for
1127 any reason, then take out the following clause and replace it
1128 with one that makes sure the ctl_fd is open. */
1131 pi
= find_procinfo_or_die (pi
->pid
, 0);
1135 /* Use char array to avoid alignment issues. */
1136 char hold
[sizeof (sigset_t
)];
1140 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1141 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1143 /* The above operation renders the procinfo's cached pstatus
1145 pi
->status_valid
= 0;
1150 /* Returns the set of signals that are held / blocked. Will also copy
1151 the sigset if SAVE is non-zero. */
1154 proc_get_held_signals (procinfo
*pi
, sigset_t
*save
)
1156 sigset_t
*ret
= NULL
;
1158 /* We should never have to apply this operation to any procinfo
1159 except the one for the main process. If that ever changes for
1160 any reason, then take out the following clause and replace it
1161 with one that makes sure the ctl_fd is open. */
1164 pi
= find_procinfo_or_die (pi
->pid
, 0);
1166 if (!pi
->status_valid
)
1167 if (!proc_get_status (pi
))
1170 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1172 memcpy (save
, ret
, sizeof (sigset_t
));
1177 /* Returns the set of signals that are traced / debugged. Will also
1178 copy the sigset if SAVE is non-zero. */
1181 proc_get_traced_signals (procinfo
*pi
, sigset_t
*save
)
1183 sigset_t
*ret
= NULL
;
1185 /* We should never have to apply this operation to any procinfo
1186 except the one for the main process. If that ever changes for
1187 any reason, then take out the following clause and replace it
1188 with one that makes sure the ctl_fd is open. */
1191 pi
= find_procinfo_or_die (pi
->pid
, 0);
1193 if (!pi
->status_valid
)
1194 if (!proc_get_status (pi
))
1197 ret
= &pi
->prstatus
.pr_sigtrace
;
1199 memcpy (save
, ret
, sizeof (sigset_t
));
1204 /* Returns the set of hardware faults that are traced /debugged. Will
1205 also copy the faultset if SAVE is non-zero. */
1208 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
1210 fltset_t
*ret
= NULL
;
1212 /* We should never have to apply this operation to any procinfo
1213 except the one for the main process. If that ever changes for
1214 any reason, then take out the following clause and replace it
1215 with one that makes sure the ctl_fd is open. */
1218 pi
= find_procinfo_or_die (pi
->pid
, 0);
1220 if (!pi
->status_valid
)
1221 if (!proc_get_status (pi
))
1224 ret
= &pi
->prstatus
.pr_flttrace
;
1226 memcpy (save
, ret
, sizeof (fltset_t
));
1231 /* Returns the set of syscalls that are traced /debugged on entry.
1232 Will also copy the syscall set if SAVE is non-zero. */
1235 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
1237 sysset_t
*ret
= NULL
;
1239 /* We should never have to apply this operation to any procinfo
1240 except the one for the main process. If that ever changes for
1241 any reason, then take out the following clause and replace it
1242 with one that makes sure the ctl_fd is open. */
1245 pi
= find_procinfo_or_die (pi
->pid
, 0);
1247 if (!pi
->status_valid
)
1248 if (!proc_get_status (pi
))
1251 ret
= &pi
->prstatus
.pr_sysentry
;
1253 memcpy (save
, ret
, sizeof (sysset_t
));
1258 /* Returns the set of syscalls that are traced /debugged on exit.
1259 Will also copy the syscall set if SAVE is non-zero. */
1262 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
1264 sysset_t
*ret
= NULL
;
1266 /* We should never have to apply this operation to any procinfo
1267 except the one for the main process. If that ever changes for
1268 any reason, then take out the following clause and replace it
1269 with one that makes sure the ctl_fd is open. */
1272 pi
= find_procinfo_or_die (pi
->pid
, 0);
1274 if (!pi
->status_valid
)
1275 if (!proc_get_status (pi
))
1278 ret
= &pi
->prstatus
.pr_sysexit
;
1280 memcpy (save
, ret
, sizeof (sysset_t
));
1285 /* The current fault (if any) is cleared; the associated signal will
1286 not be sent to the process or LWP when it resumes. Returns
1287 non-zero for success, zero for failure. */
1290 proc_clear_current_fault (procinfo
*pi
)
1294 /* We should never have to apply this operation to any procinfo
1295 except the one for the main process. If that ever changes for
1296 any reason, then take out the following clause and replace it
1297 with one that makes sure the ctl_fd is open. */
1300 pi
= find_procinfo_or_die (pi
->pid
, 0);
1302 procfs_ctl_t cmd
= PCCFAULT
;
1304 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1309 /* Set the "current signal" that will be delivered next to the
1310 process. NOTE: semantics are different from those of KILL. This
1311 signal will be delivered to the process or LWP immediately when it
1312 is resumed (even if the signal is held/blocked); it will NOT
1313 immediately cause another event of interest, and will NOT first
1314 trap back to the debugger. Returns non-zero for success, zero for
1318 proc_set_current_signal (procinfo
*pi
, int signo
)
1323 /* Use char array to avoid alignment issues. */
1324 char sinfo
[sizeof (siginfo_t
)];
1328 struct target_waitstatus wait_status
;
1330 /* We should never have to apply this operation to any procinfo
1331 except the one for the main process. If that ever changes for
1332 any reason, then take out the following clause and replace it
1333 with one that makes sure the ctl_fd is open. */
1336 pi
= find_procinfo_or_die (pi
->pid
, 0);
1338 /* The pointer is just a type alias. */
1339 get_last_target_status (&wait_ptid
, &wait_status
);
1340 if (ptid_equal (wait_ptid
, inferior_ptid
)
1341 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
1342 && wait_status
.value
.sig
== gdb_signal_from_host (signo
)
1343 && proc_get_status (pi
)
1344 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
1346 /* Use the siginfo associated with the signal being
1348 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (siginfo_t
));
1351 mysinfo
.si_signo
= signo
;
1352 mysinfo
.si_code
= 0;
1353 mysinfo
.si_pid
= getpid (); /* ?why? */
1354 mysinfo
.si_uid
= getuid (); /* ?why? */
1355 memcpy (arg
.sinfo
, &mysinfo
, sizeof (siginfo_t
));
1359 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1364 /* The current signal (if any) is cleared, and is not sent to the
1365 process or LWP when it resumes. Returns non-zero for success, zero
1369 proc_clear_current_signal (procinfo
*pi
)
1373 /* We should never have to apply this operation to any procinfo
1374 except the one for the main process. If that ever changes for
1375 any reason, then take out the following clause and replace it
1376 with one that makes sure the ctl_fd is open. */
1379 pi
= find_procinfo_or_die (pi
->pid
, 0);
1383 /* Use char array to avoid alignment issues. */
1384 char sinfo
[sizeof (siginfo_t
)];
1389 /* The pointer is just a type alias. */
1390 mysinfo
.si_signo
= 0;
1391 mysinfo
.si_code
= 0;
1392 mysinfo
.si_errno
= 0;
1393 mysinfo
.si_pid
= getpid (); /* ?why? */
1394 mysinfo
.si_uid
= getuid (); /* ?why? */
1395 memcpy (arg
.sinfo
, &mysinfo
, sizeof (siginfo_t
));
1397 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1402 /* Return the general-purpose registers for the process or LWP
1403 corresponding to PI. Upon failure, return NULL. */
1405 static gdb_gregset_t
*
1406 proc_get_gregs (procinfo
*pi
)
1408 if (!pi
->status_valid
|| !pi
->gregs_valid
)
1409 if (!proc_get_status (pi
))
1412 return &pi
->prstatus
.pr_lwp
.pr_reg
;
1415 /* Return the general-purpose registers for the process or LWP
1416 corresponding to PI. Upon failure, return NULL. */
1418 static gdb_fpregset_t
*
1419 proc_get_fpregs (procinfo
*pi
)
1421 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
1422 if (!proc_get_status (pi
))
1425 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
1428 /* Write the general-purpose registers back to the process or LWP
1429 corresponding to PI. Return non-zero for success, zero for
1433 proc_set_gregs (procinfo
*pi
)
1435 gdb_gregset_t
*gregs
;
1438 gregs
= proc_get_gregs (pi
);
1440 return 0; /* proc_get_regs has already warned. */
1442 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1450 /* Use char array to avoid alignment issues. */
1451 char gregs
[sizeof (gdb_gregset_t
)];
1455 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
1456 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1459 /* Policy: writing the registers invalidates our cache. */
1460 pi
->gregs_valid
= 0;
1464 /* Write the floating-pointer registers back to the process or LWP
1465 corresponding to PI. Return non-zero for success, zero for
1469 proc_set_fpregs (procinfo
*pi
)
1471 gdb_fpregset_t
*fpregs
;
1474 fpregs
= proc_get_fpregs (pi
);
1476 return 0; /* proc_get_fpregs has already warned. */
1478 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1486 /* Use char array to avoid alignment issues. */
1487 char fpregs
[sizeof (gdb_fpregset_t
)];
1491 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
1492 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1495 /* Policy: writing the registers invalidates our cache. */
1496 pi
->fpregs_valid
= 0;
1500 /* Send a signal to the proc or lwp with the semantics of "kill()".
1501 Returns non-zero for success, zero for failure. */
1504 proc_kill (procinfo
*pi
, int signo
)
1508 /* We might conceivably apply this operation to an LWP, and the
1509 LWP's ctl file descriptor might not be open. */
1511 if (pi
->ctl_fd
== 0 &&
1512 open_procinfo_files (pi
, FD_CTL
) == 0)
1518 procfs_ctl_t cmd
[2];
1522 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1528 /* Find the pid of the process that started this one. Returns the
1529 parent process pid, or zero. */
1532 proc_parent_pid (procinfo
*pi
)
1534 /* We should never have to apply this operation to any procinfo
1535 except the one for the main process. If that ever changes for
1536 any reason, then take out the following clause and replace it
1537 with one that makes sure the ctl_fd is open. */
1540 pi
= find_procinfo_or_die (pi
->pid
, 0);
1542 if (!pi
->status_valid
)
1543 if (!proc_get_status (pi
))
1546 return pi
->prstatus
.pr_ppid
;
1549 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
1550 (a.k.a void pointer)! */
1553 procfs_address_to_host_pointer (CORE_ADDR addr
)
1555 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
1558 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
1559 gdbarch_address_to_pointer (target_gdbarch (), ptr_type
,
1560 (gdb_byte
*) &ptr
, addr
);
1565 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
1569 char watch
[sizeof (prwatch_t
)];
1573 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
1574 convert a target address into something that can be stored in a
1575 native data structure. */
1576 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
1577 pwatch
.pr_size
= len
;
1578 pwatch
.pr_wflags
= wflags
;
1580 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
1581 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
1584 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
1586 #include <sys/sysi86.h>
1588 /* The KEY is actually the value of the lower 16 bits of the GS
1589 register for the LWP that we're interested in. Returns the
1590 matching ssh struct (LDT entry). */
1593 proc_get_LDT_entry (procinfo
*pi
, int key
)
1595 static struct ssd
*ldt_entry
= NULL
;
1596 char pathname
[MAX_PROC_NAME_SIZE
];
1598 /* Allocate space for one LDT entry.
1599 This alloc must persist, because we return a pointer to it. */
1600 if (ldt_entry
== NULL
)
1601 ldt_entry
= XNEW (struct ssd
);
1603 /* Open the file descriptor for the LDT table. */
1604 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
1605 scoped_fd
fd (open_with_retry (pathname
, O_RDONLY
));
1608 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
1612 /* Now 'read' thru the table, find a match and return it. */
1613 while (read (fd
.get (), ldt_entry
, sizeof (struct ssd
))
1614 == sizeof (struct ssd
))
1616 if (ldt_entry
->sel
== 0 &&
1617 ldt_entry
->bo
== 0 &&
1618 ldt_entry
->acc1
== 0 &&
1619 ldt_entry
->acc2
== 0)
1620 break; /* end of table */
1621 /* If key matches, return this entry. */
1622 if (ldt_entry
->sel
== key
)
1625 /* Loop ended, match not found. */
1629 /* Returns the pointer to the LDT entry of PTID. */
1632 procfs_find_LDT_entry (ptid_t ptid
)
1634 gdb_gregset_t
*gregs
;
1638 /* Find procinfo for the lwp. */
1639 if ((pi
= find_procinfo (ptid_get_pid (ptid
), ptid_get_lwp (ptid
))) == NULL
)
1641 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
1642 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
1645 /* get its general registers. */
1646 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
1648 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
1649 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
1652 /* Now extract the GS register's lower 16 bits. */
1653 key
= (*gregs
)[GS
] & 0xffff;
1655 /* Find the matching entry and return it. */
1656 return proc_get_LDT_entry (pi
, key
);
1661 /* =============== END, non-thread part of /proc "MODULE" =============== */
1663 /* =================== Thread "MODULE" =================== */
1665 /* NOTE: you'll see more ifdefs and duplication of functions here,
1666 since there is a different way to do threads on every OS. */
1668 /* Returns the number of threads for the process. */
1671 proc_get_nthreads (procinfo
*pi
)
1673 if (!pi
->status_valid
)
1674 if (!proc_get_status (pi
))
1677 /* Only works for the process procinfo, because the LWP procinfos do not
1678 get prstatus filled in. */
1679 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
1680 pi
= find_procinfo_or_die (pi
->pid
, 0);
1681 return pi
->prstatus
.pr_nlwp
;
1686 Return the ID of the thread that had an event of interest.
1687 (ie. the one that hit a breakpoint or other traced event). All
1688 other things being equal, this should be the ID of a thread that is
1689 currently executing. */
1692 proc_get_current_thread (procinfo
*pi
)
1694 /* Note: this should be applied to the root procinfo for the
1695 process, not to the procinfo for an LWP. If applied to the
1696 procinfo for an LWP, it will simply return that LWP's ID. In
1697 that case, find the parent process procinfo. */
1700 pi
= find_procinfo_or_die (pi
->pid
, 0);
1702 if (!pi
->status_valid
)
1703 if (!proc_get_status (pi
))
1706 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
1709 /* Discover the IDs of all the threads within the process, and create
1710 a procinfo for each of them (chained to the parent). This
1711 unfortunately requires a different method on every OS. Returns
1712 non-zero for success, zero for failure. */
1715 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
1717 if (thread
&& parent
) /* sanity */
1719 thread
->status_valid
= 0;
1720 if (!proc_get_status (thread
))
1721 destroy_one_procinfo (&parent
->thread_list
, thread
);
1723 return 0; /* keep iterating */
1727 do_closedir_cleanup (void *dir
)
1729 closedir ((DIR *) dir
);
1733 proc_update_threads (procinfo
*pi
)
1735 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
1736 struct dirent
*direntry
;
1737 struct cleanup
*old_chain
= NULL
;
1742 /* We should never have to apply this operation to any procinfo
1743 except the one for the main process. If that ever changes for
1744 any reason, then take out the following clause and replace it
1745 with one that makes sure the ctl_fd is open. */
1748 pi
= find_procinfo_or_die (pi
->pid
, 0);
1750 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
1752 /* Note: this brute-force method was originally devised for Unixware
1753 (support removed since), and will also work on Solaris 2.6 and
1754 2.7. The original comment mentioned the existence of a much
1755 simpler and more elegant way to do this on Solaris, but didn't
1756 point out what that was. */
1758 strcpy (pathname
, pi
->pathname
);
1759 strcat (pathname
, "/lwp");
1760 if ((dirp
= opendir (pathname
)) == NULL
)
1761 proc_error (pi
, "update_threads, opendir", __LINE__
);
1763 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
1764 while ((direntry
= readdir (dirp
)) != NULL
)
1765 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
1767 lwpid
= atoi (&direntry
->d_name
[0]);
1768 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
1769 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
1771 pi
->threads_valid
= 1;
1772 do_cleanups (old_chain
);
1776 /* Given a pointer to a function, call that function once for each lwp
1777 in the procinfo list, until the function returns non-zero, in which
1778 event return the value returned by the function.
1780 Note: this function does NOT call update_threads. If you want to
1781 discover new threads first, you must call that function explicitly.
1782 This function just makes a quick pass over the currently-known
1785 PI is the parent process procinfo. FUNC is the per-thread
1786 function. PTR is an opaque parameter for function. Returns the
1787 first non-zero return value from the callee, or zero. */
1790 proc_iterate_over_threads (procinfo
*pi
,
1791 int (*func
) (procinfo
*, procinfo
*, void *),
1794 procinfo
*thread
, *next
;
1797 /* We should never have to apply this operation to any procinfo
1798 except the one for the main process. If that ever changes for
1799 any reason, then take out the following clause and replace it
1800 with one that makes sure the ctl_fd is open. */
1803 pi
= find_procinfo_or_die (pi
->pid
, 0);
1805 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
1807 next
= thread
->next
; /* In case thread is destroyed. */
1808 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
1815 /* =================== END, Thread "MODULE" =================== */
1817 /* =================== END, /proc "MODULE" =================== */
1819 /* =================== GDB "MODULE" =================== */
1821 /* Here are all of the gdb target vector functions and their
1824 static ptid_t
do_attach (ptid_t ptid
);
1825 static void do_detach ();
1826 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
1827 int entry_or_exit
, int mode
, int from_tty
);
1829 /* Sets up the inferior to be debugged. Registers to trace signals,
1830 hardware faults, and syscalls. Note: does not set RLC flag: caller
1831 may want to customize that. Returns zero for success (note!
1832 unlike most functions in this module); on failure, returns the LINE
1833 NUMBER where it failed! */
1836 procfs_debug_inferior (procinfo
*pi
)
1838 fltset_t traced_faults
;
1839 sigset_t traced_signals
;
1840 sysset_t
*traced_syscall_entries
;
1841 sysset_t
*traced_syscall_exits
;
1844 /* Register to trace hardware faults in the child. */
1845 prfillset (&traced_faults
); /* trace all faults... */
1846 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
1847 if (!proc_set_traced_faults (pi
, &traced_faults
))
1850 /* Initially, register to trace all signals in the child. */
1851 prfillset (&traced_signals
);
1852 if (!proc_set_traced_signals (pi
, &traced_signals
))
1856 /* Register to trace the 'exit' system call (on entry). */
1857 traced_syscall_entries
= sysset_t_alloc (pi
);
1858 premptyset (traced_syscall_entries
);
1859 praddset (traced_syscall_entries
, SYS_exit
);
1860 praddset (traced_syscall_entries
, SYS_lwp_exit
);
1862 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
1863 xfree (traced_syscall_entries
);
1867 /* Method for tracing exec syscalls. */
1869 Not all systems with /proc have all the exec* syscalls with the same
1870 names. On the SGI, for example, there is no SYS_exec, but there
1871 *is* a SYS_execv. So, we try to account for that. */
1873 traced_syscall_exits
= sysset_t_alloc (pi
);
1874 premptyset (traced_syscall_exits
);
1876 praddset (traced_syscall_exits
, SYS_exec
);
1878 praddset (traced_syscall_exits
, SYS_execve
);
1879 praddset (traced_syscall_exits
, SYS_lwp_create
);
1880 praddset (traced_syscall_exits
, SYS_lwp_exit
);
1882 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
1883 xfree (traced_syscall_exits
);
1891 procfs_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1896 pid
= parse_pid_to_attach (args
);
1898 if (pid
== getpid ())
1899 error (_("Attaching GDB to itself is not a good idea..."));
1903 exec_file
= get_exec_file (0);
1906 printf_filtered (_("Attaching to program `%s', %s\n"),
1907 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
1909 printf_filtered (_("Attaching to %s\n"),
1910 target_pid_to_str (pid_to_ptid (pid
)));
1914 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1915 if (!target_is_pushed (ops
))
1920 procfs_detach (struct target_ops
*ops
, inferior
*inf
, int from_tty
)
1922 int pid
= ptid_get_pid (inferior_ptid
);
1926 const char *exec_file
;
1928 exec_file
= get_exec_file (0);
1929 if (exec_file
== NULL
)
1932 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
1933 target_pid_to_str (pid_to_ptid (pid
)));
1934 gdb_flush (gdb_stdout
);
1939 inferior_ptid
= null_ptid
;
1940 detach_inferior (pid
);
1941 inf_child_maybe_unpush_target (ops
);
1945 do_attach (ptid_t ptid
)
1948 struct inferior
*inf
;
1952 if ((pi
= create_procinfo (ptid_get_pid (ptid
), 0)) == NULL
)
1953 perror (_("procfs: out of memory in 'attach'"));
1955 if (!open_procinfo_files (pi
, FD_CTL
))
1957 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
1958 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
1959 ptid_get_pid (ptid
));
1960 dead_procinfo (pi
, errmsg
, NOKILL
);
1963 /* Stop the process (if it isn't already stopped). */
1964 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
1966 pi
->was_stopped
= 1;
1967 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
1971 pi
->was_stopped
= 0;
1972 /* Set the process to run again when we close it. */
1973 if (!proc_set_run_on_last_close (pi
))
1974 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
1976 /* Now stop the process. */
1977 if (!proc_stop_process (pi
))
1978 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
1979 pi
->ignore_next_sigstop
= 1;
1981 /* Save some of the /proc state to be restored if we detach. */
1982 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
1983 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
1984 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
1985 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
1986 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
1987 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
1989 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
1990 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
1992 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
1993 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
1995 if ((fail
= procfs_debug_inferior (pi
)) != 0)
1996 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
1998 inf
= current_inferior ();
1999 inferior_appeared (inf
, pi
->pid
);
2000 /* Let GDB know that the inferior was attached. */
2001 inf
->attach_flag
= 1;
2003 /* Create a procinfo for the current lwp. */
2004 lwpid
= proc_get_current_thread (pi
);
2005 create_procinfo (pi
->pid
, lwpid
);
2007 /* Add it to gdb's thread list. */
2008 ptid
= ptid_build (pi
->pid
, lwpid
, 0);
2019 /* Find procinfo for the main process. */
2020 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
),
2021 0); /* FIXME: threads */
2023 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
2024 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
2026 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
2027 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
2029 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
2030 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
2032 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
2033 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
2035 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
2036 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
2038 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
2039 if (!(pi
->was_stopped
)
2040 || query (_("Was stopped when attached, make it runnable again? ")))
2042 /* Clear any pending signal. */
2043 if (!proc_clear_current_fault (pi
))
2044 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
2046 if (!proc_clear_current_signal (pi
))
2047 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
2049 if (!proc_set_run_on_last_close (pi
))
2050 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
2053 destroy_procinfo (pi
);
2056 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
2059 ??? Is the following note still relevant? We can't get individual
2060 registers with the PT_GETREGS ptrace(2) request either, yet we
2061 don't bother with caching at all in that case.
2063 NOTE: Since the /proc interface cannot give us individual
2064 registers, we pay no attention to REGNUM, and just fetch them all.
2065 This results in the possibility that we will do unnecessarily many
2066 fetches, since we may be called repeatedly for individual
2067 registers. So we cache the results, and mark the cache invalid
2068 when the process is resumed. */
2071 procfs_fetch_registers (struct target_ops
*ops
,
2072 struct regcache
*regcache
, int regnum
)
2074 gdb_gregset_t
*gregs
;
2076 ptid_t ptid
= regcache_get_ptid (regcache
);
2077 int pid
= ptid_get_pid (ptid
);
2078 int tid
= ptid_get_lwp (ptid
);
2079 struct gdbarch
*gdbarch
= regcache
->arch ();
2081 pi
= find_procinfo_or_die (pid
, tid
);
2084 error (_("procfs: fetch_registers failed to find procinfo for %s"),
2085 target_pid_to_str (ptid
));
2087 gregs
= proc_get_gregs (pi
);
2089 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
2091 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
2093 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2095 gdb_fpregset_t
*fpregs
;
2097 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2098 || regnum
== gdbarch_pc_regnum (gdbarch
)
2099 || regnum
== gdbarch_sp_regnum (gdbarch
))
2100 return; /* Not a floating point register. */
2102 fpregs
= proc_get_fpregs (pi
);
2104 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
2106 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
2110 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
2111 this for all registers.
2113 NOTE: Since the /proc interface will not read individual registers,
2114 we will cache these requests until the process is resumed, and only
2115 then write them back to the inferior process.
2117 FIXME: is that a really bad idea? Have to think about cases where
2118 writing one register might affect the value of others, etc. */
2121 procfs_store_registers (struct target_ops
*ops
,
2122 struct regcache
*regcache
, int regnum
)
2124 gdb_gregset_t
*gregs
;
2126 ptid_t ptid
= regcache_get_ptid (regcache
);
2127 int pid
= ptid_get_pid (ptid
);
2128 int tid
= ptid_get_lwp (ptid
);
2129 struct gdbarch
*gdbarch
= regcache
->arch ();
2131 pi
= find_procinfo_or_die (pid
, tid
);
2134 error (_("procfs: store_registers: failed to find procinfo for %s"),
2135 target_pid_to_str (ptid
));
2137 gregs
= proc_get_gregs (pi
);
2139 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
2141 fill_gregset (regcache
, gregs
, regnum
);
2142 if (!proc_set_gregs (pi
))
2143 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
2145 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2147 gdb_fpregset_t
*fpregs
;
2149 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2150 || regnum
== gdbarch_pc_regnum (gdbarch
)
2151 || regnum
== gdbarch_sp_regnum (gdbarch
))
2152 return; /* Not a floating point register. */
2154 fpregs
= proc_get_fpregs (pi
);
2156 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
2158 fill_fpregset (regcache
, fpregs
, regnum
);
2159 if (!proc_set_fpregs (pi
))
2160 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
2165 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
2167 if (scall
== SYS_lwp_exit
)
2173 syscall_is_exit (procinfo
*pi
, int scall
)
2175 if (scall
== SYS_exit
)
2181 syscall_is_exec (procinfo
*pi
, int scall
)
2184 if (scall
== SYS_exec
)
2187 if (scall
== SYS_execve
)
2193 syscall_is_lwp_create (procinfo
*pi
, int scall
)
2195 if (scall
== SYS_lwp_create
)
2200 /* Retrieve the next stop event from the child process. If child has
2201 not stopped yet, wait for it to stop. Translate /proc eventcodes
2202 (or possibly wait eventcodes) into gdb internal event codes.
2203 Returns the id of process (and possibly thread) that incurred the
2204 event. Event codes are returned through a pointer parameter. */
2207 procfs_wait (struct target_ops
*ops
,
2208 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2210 /* First cut: loosely based on original version 2.1. */
2214 ptid_t retval
, temp_ptid
;
2215 int why
, what
, flags
;
2222 retval
= pid_to_ptid (-1);
2224 /* Find procinfo for main process. */
2225 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2228 /* We must assume that the status is stale now... */
2229 pi
->status_valid
= 0;
2230 pi
->gregs_valid
= 0;
2231 pi
->fpregs_valid
= 0;
2233 #if 0 /* just try this out... */
2234 flags
= proc_flags (pi
);
2235 why
= proc_why (pi
);
2236 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
2237 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
2239 /* If child is not stopped, wait for it to stop. */
2240 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
2241 !proc_wait_for_stop (pi
))
2243 /* wait_for_stop failed: has the child terminated? */
2244 if (errno
== ENOENT
)
2248 /* /proc file not found; presumably child has terminated. */
2249 wait_retval
= wait (&wstat
); /* "wait" for the child's exit. */
2252 if (wait_retval
!= ptid_get_pid (inferior_ptid
))
2253 error (_("procfs: couldn't stop "
2254 "process %d: wait returned %d."),
2255 ptid_get_pid (inferior_ptid
), wait_retval
);
2256 /* FIXME: might I not just use waitpid?
2257 Or try find_procinfo to see if I know about this child? */
2258 retval
= pid_to_ptid (wait_retval
);
2260 else if (errno
== EINTR
)
2264 /* Unknown error from wait_for_stop. */
2265 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
2270 /* This long block is reached if either:
2271 a) the child was already stopped, or
2272 b) we successfully waited for the child with wait_for_stop.
2273 This block will analyze the /proc status, and translate it
2274 into a waitstatus for GDB.
2276 If we actually had to call wait because the /proc file
2277 is gone (child terminated), then we skip this block,
2278 because we already have a waitstatus. */
2280 flags
= proc_flags (pi
);
2281 why
= proc_why (pi
);
2282 what
= proc_what (pi
);
2284 if (flags
& (PR_STOPPED
| PR_ISTOP
))
2286 /* If it's running async (for single_thread control),
2287 set it back to normal again. */
2288 if (flags
& PR_ASYNC
)
2289 if (!proc_unset_async (pi
))
2290 proc_error (pi
, "target_wait, unset_async", __LINE__
);
2293 proc_prettyprint_why (why
, what
, 1);
2295 /* The 'pid' we will return to GDB is composed of
2296 the process ID plus the lwp ID. */
2297 retval
= ptid_build (pi
->pid
, proc_get_current_thread (pi
), 0);
2301 wstat
= (what
<< 8) | 0177;
2304 if (syscall_is_lwp_exit (pi
, what
))
2306 if (print_thread_events
)
2307 printf_unfiltered (_("[%s exited]\n"),
2308 target_pid_to_str (retval
));
2309 delete_thread (retval
);
2310 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2313 else if (syscall_is_exit (pi
, what
))
2315 struct inferior
*inf
;
2317 /* Handle SYS_exit call only. */
2318 /* Stopped at entry to SYS_exit.
2319 Make it runnable, resume it, then use
2320 the wait system call to get its exit code.
2321 Proc_run_process always clears the current
2323 Then return its exit status. */
2324 pi
->status_valid
= 0;
2326 /* FIXME: what we should do is return
2327 TARGET_WAITKIND_SPURIOUS. */
2328 if (!proc_run_process (pi
, 0, 0))
2329 proc_error (pi
, "target_wait, run_process", __LINE__
);
2331 inf
= find_inferior_pid (pi
->pid
);
2332 if (inf
->attach_flag
)
2334 /* Don't call wait: simulate waiting for exit,
2335 return a "success" exit code. Bogus: what if
2336 it returns something else? */
2338 retval
= inferior_ptid
; /* ? ? ? */
2342 int temp
= wait (&wstat
);
2344 /* FIXME: shouldn't I make sure I get the right
2345 event from the right process? If (for
2346 instance) I have killed an earlier inferior
2347 process but failed to clean up after it
2348 somehow, I could get its termination event
2351 /* If wait returns -1, that's what we return
2354 retval
= pid_to_ptid (temp
);
2359 printf_filtered (_("procfs: trapped on entry to "));
2360 proc_prettyprint_syscall (proc_what (pi
), 0);
2361 printf_filtered ("\n");
2363 long i
, nsysargs
, *sysargs
;
2365 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
2366 (sysargs
= proc_sysargs (pi
)) != NULL
)
2368 printf_filtered (_("%ld syscall arguments:\n"),
2370 for (i
= 0; i
< nsysargs
; i
++)
2371 printf_filtered ("#%ld: 0x%08lx\n",
2377 /* How to exit gracefully, returning "unknown
2379 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2380 return inferior_ptid
;
2384 /* How to keep going without returning to wfi: */
2385 target_continue_no_signal (ptid
);
2391 if (syscall_is_exec (pi
, what
))
2393 /* Hopefully this is our own "fork-child" execing
2394 the real child. Hoax this event into a trap, and
2395 GDB will see the child about to execute its start
2397 wstat
= (SIGTRAP
<< 8) | 0177;
2399 else if (syscall_is_lwp_create (pi
, what
))
2401 /* This syscall is somewhat like fork/exec. We
2402 will get the event twice: once for the parent
2403 LWP, and once for the child. We should already
2404 know about the parent LWP, but the child will
2405 be new to us. So, whenever we get this event,
2406 if it represents a new thread, simply add the
2407 thread to the list. */
2409 /* If not in procinfo list, add it. */
2410 temp_tid
= proc_get_current_thread (pi
);
2411 if (!find_procinfo (pi
->pid
, temp_tid
))
2412 create_procinfo (pi
->pid
, temp_tid
);
2414 temp_ptid
= ptid_build (pi
->pid
, temp_tid
, 0);
2415 /* If not in GDB's thread list, add it. */
2416 if (!in_thread_list (temp_ptid
))
2417 add_thread (temp_ptid
);
2419 /* Return to WFI, but tell it to immediately resume. */
2420 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2421 return inferior_ptid
;
2423 else if (syscall_is_lwp_exit (pi
, what
))
2425 if (print_thread_events
)
2426 printf_unfiltered (_("[%s exited]\n"),
2427 target_pid_to_str (retval
));
2428 delete_thread (retval
);
2429 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2434 /* FIXME: Do we need to handle SYS_sproc,
2435 SYS_fork, or SYS_vfork here? The old procfs
2436 seemed to use this event to handle threads on
2437 older (non-LWP) systems, where I'm assuming
2438 that threads were actually separate processes.
2439 Irix, maybe? Anyway, low priority for now. */
2443 printf_filtered (_("procfs: trapped on exit from "));
2444 proc_prettyprint_syscall (proc_what (pi
), 0);
2445 printf_filtered ("\n");
2447 long i
, nsysargs
, *sysargs
;
2449 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
2450 (sysargs
= proc_sysargs (pi
)) != NULL
)
2452 printf_filtered (_("%ld syscall arguments:\n"),
2454 for (i
= 0; i
< nsysargs
; i
++)
2455 printf_filtered ("#%ld: 0x%08lx\n",
2459 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2460 return inferior_ptid
;
2465 wstat
= (SIGSTOP
<< 8) | 0177;
2470 printf_filtered (_("Retry #%d:\n"), retry
);
2471 pi
->status_valid
= 0;
2476 /* If not in procinfo list, add it. */
2477 temp_tid
= proc_get_current_thread (pi
);
2478 if (!find_procinfo (pi
->pid
, temp_tid
))
2479 create_procinfo (pi
->pid
, temp_tid
);
2481 /* If not in GDB's thread list, add it. */
2482 temp_ptid
= ptid_build (pi
->pid
, temp_tid
, 0);
2483 if (!in_thread_list (temp_ptid
))
2484 add_thread (temp_ptid
);
2486 status
->kind
= TARGET_WAITKIND_STOPPED
;
2487 status
->value
.sig
= GDB_SIGNAL_0
;
2492 wstat
= (what
<< 8) | 0177;
2497 wstat
= (SIGTRAP
<< 8) | 0177;
2499 /* FIXME: use si_signo where possible. */
2502 wstat
= (SIGILL
<< 8) | 0177;
2506 wstat
= (SIGTRAP
<< 8) | 0177;
2511 wstat
= (SIGSEGV
<< 8) | 0177;
2516 wstat
= (SIGFPE
<< 8) | 0177;
2518 case FLTPAGE
: /* Recoverable page fault */
2519 default: /* FIXME: use si_signo if possible for
2521 retval
= pid_to_ptid (-1);
2522 printf_filtered ("procfs:%d -- ", __LINE__
);
2523 printf_filtered (_("child stopped for unknown reason:\n"));
2524 proc_prettyprint_why (why
, what
, 1);
2525 error (_("... giving up..."));
2528 break; /* case PR_FAULTED: */
2529 default: /* switch (why) unmatched */
2530 printf_filtered ("procfs:%d -- ", __LINE__
);
2531 printf_filtered (_("child stopped for unknown reason:\n"));
2532 proc_prettyprint_why (why
, what
, 1);
2533 error (_("... giving up..."));
2536 /* Got this far without error: If retval isn't in the
2537 threads database, add it. */
2538 if (ptid_get_pid (retval
) > 0 &&
2539 !ptid_equal (retval
, inferior_ptid
) &&
2540 !in_thread_list (retval
))
2542 /* We have a new thread. We need to add it both to
2543 GDB's list and to our own. If we don't create a
2544 procinfo, resume may be unhappy later. */
2545 add_thread (retval
);
2546 if (find_procinfo (ptid_get_pid (retval
),
2547 ptid_get_lwp (retval
)) == NULL
)
2548 create_procinfo (ptid_get_pid (retval
),
2549 ptid_get_lwp (retval
));
2552 else /* Flags do not indicate STOPPED. */
2554 /* surely this can't happen... */
2555 printf_filtered ("procfs:%d -- process not stopped.\n",
2557 proc_prettyprint_flags (flags
, 1);
2558 error (_("procfs: ...giving up..."));
2563 store_waitstatus (status
, wstat
);
2569 /* Perform a partial transfer to/from the specified object. For
2570 memory transfers, fall back to the old memory xfer functions. */
2572 static enum target_xfer_status
2573 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2574 const char *annex
, gdb_byte
*readbuf
,
2575 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2576 ULONGEST
*xfered_len
)
2580 case TARGET_OBJECT_MEMORY
:
2581 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2583 case TARGET_OBJECT_AUXV
:
2584 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
2585 offset
, len
, xfered_len
);
2588 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2589 readbuf
, writebuf
, offset
, len
,
2594 /* Helper for procfs_xfer_partial that handles memory transfers.
2595 Arguments are like target_xfer_partial. */
2597 static enum target_xfer_status
2598 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2599 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2604 /* Find procinfo for main process. */
2605 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2606 if (pi
->as_fd
== 0 &&
2607 open_procinfo_files (pi
, FD_AS
) == 0)
2609 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
2610 return TARGET_XFER_E_IO
;
2613 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
2614 return TARGET_XFER_E_IO
;
2616 if (writebuf
!= NULL
)
2618 PROCFS_NOTE ("write memory:\n");
2619 nbytes
= write (pi
->as_fd
, writebuf
, len
);
2623 PROCFS_NOTE ("read memory:\n");
2624 nbytes
= read (pi
->as_fd
, readbuf
, len
);
2627 return TARGET_XFER_E_IO
;
2628 *xfered_len
= nbytes
;
2629 return TARGET_XFER_OK
;
2632 /* Called by target_resume before making child runnable. Mark cached
2633 registers and status's invalid. If there are "dirty" caches that
2634 need to be written back to the child process, do that.
2636 File descriptors are also cached. As they are a limited resource,
2637 we cannot hold onto them indefinitely. However, as they are
2638 expensive to open, we don't want to throw them away
2639 indescriminately either. As a compromise, we will keep the file
2640 descriptors for the parent process, but discard any file
2641 descriptors we may have accumulated for the threads.
2643 As this function is called by iterate_over_threads, it always
2644 returns zero (so that iterate_over_threads will keep
2648 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
2650 /* About to run the child; invalidate caches and do any other
2654 if (pi
->gregs_dirty
)
2655 if (parent
== NULL
||
2656 proc_get_current_thread (parent
) != pi
->tid
)
2657 if (!proc_set_gregs (pi
)) /* flush gregs cache */
2658 proc_warn (pi
, "target_resume, set_gregs",
2660 if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
2661 if (pi
->fpregs_dirty
)
2662 if (parent
== NULL
||
2663 proc_get_current_thread (parent
) != pi
->tid
)
2664 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
2665 proc_warn (pi
, "target_resume, set_fpregs",
2671 /* The presence of a parent indicates that this is an LWP.
2672 Close any file descriptors that it might have open.
2673 We don't do this to the master (parent) procinfo. */
2675 close_procinfo_files (pi
);
2677 pi
->gregs_valid
= 0;
2678 pi
->fpregs_valid
= 0;
2680 pi
->gregs_dirty
= 0;
2681 pi
->fpregs_dirty
= 0;
2683 pi
->status_valid
= 0;
2684 pi
->threads_valid
= 0;
2690 /* A callback function for iterate_over_threads. Find the
2691 asynchronous signal thread, and make it runnable. See if that
2692 helps matters any. */
2695 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
2698 if (proc_flags (pi
) & PR_ASLWP
)
2700 if (!proc_run_process (pi
, 0, -1))
2701 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
2709 /* Make the child process runnable. Normally we will then call
2710 procfs_wait and wait for it to stop again (unless gdb is async).
2712 If STEP is true, then arrange for the child to stop again after
2713 executing a single instruction. If SIGNO is zero, then cancel any
2714 pending signal; if non-zero, then arrange for the indicated signal
2715 to be delivered to the child when it runs. If PID is -1, then
2716 allow any child thread to run; if non-zero, then allow only the
2717 indicated thread to run. (not implemented yet). */
2720 procfs_resume (struct target_ops
*ops
,
2721 ptid_t ptid
, int step
, enum gdb_signal signo
)
2723 procinfo
*pi
, *thread
;
2727 prrun.prflags |= PRSVADDR;
2728 prrun.pr_vaddr = $PC; set resume address
2729 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
2730 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
2731 prrun.prflags |= PRCFAULT; clear current fault.
2733 PRSTRACE and PRSFAULT can be done by other means
2734 (proc_trace_signals, proc_trace_faults)
2735 PRSVADDR is unnecessary.
2736 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
2737 This basically leaves PRSTEP and PRCSIG.
2738 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
2739 So basically PR_STEP is the sole argument that must be passed
2740 to proc_run_process (for use in the prrun struct by ioctl). */
2742 /* Find procinfo for main process. */
2743 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2745 /* First cut: ignore pid argument. */
2748 /* Convert signal to host numbering. */
2750 (signo
== GDB_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
2753 native_signo
= gdb_signal_to_host (signo
);
2755 pi
->ignore_next_sigstop
= 0;
2757 /* Running the process voids all cached registers and status. */
2758 /* Void the threads' caches first. */
2759 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
2760 /* Void the process procinfo's caches. */
2761 invalidate_cache (NULL
, pi
, NULL
);
2763 if (ptid_get_pid (ptid
) != -1)
2765 /* Resume a specific thread, presumably suppressing the
2767 thread
= find_procinfo (ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
2770 if (thread
->tid
!= 0)
2772 /* We're to resume a specific thread, and not the
2773 others. Set the child process's PR_ASYNC flag. */
2774 if (!proc_set_async (pi
))
2775 proc_error (pi
, "target_resume, set_async", __LINE__
);
2777 proc_iterate_over_threads (pi
,
2778 make_signal_thread_runnable
,
2781 pi
= thread
; /* Substitute the thread's procinfo
2787 if (!proc_run_process (pi
, step
, native_signo
))
2790 warning (_("resume: target already running. "
2791 "Pretend to resume, and hope for the best!"));
2793 proc_error (pi
, "target_resume", __LINE__
);
2797 /* Set up to trace signals in the child process. */
2800 procfs_pass_signals (struct target_ops
*self
,
2801 int numsigs
, unsigned char *pass_signals
)
2804 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2807 prfillset (&signals
);
2809 for (signo
= 0; signo
< NSIG
; signo
++)
2811 int target_signo
= gdb_signal_from_host (signo
);
2812 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
2813 prdelset (&signals
, signo
);
2816 if (!proc_set_traced_signals (pi
, &signals
))
2817 proc_error (pi
, "pass_signals", __LINE__
);
2820 /* Print status information about the child process. */
2823 procfs_files_info (struct target_ops
*ignore
)
2825 struct inferior
*inf
= current_inferior ();
2827 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
2828 inf
->attach_flag
? "attached": "child",
2829 target_pid_to_str (inferior_ptid
));
2832 /* Make it die. Wait for it to die. Clean up after it. Note: this
2833 should only be applied to the real process, not to an LWP, because
2834 of the check for parent-process. If we need this to work for an
2835 LWP, it needs some more logic. */
2838 unconditionally_kill_inferior (procinfo
*pi
)
2842 parent_pid
= proc_parent_pid (pi
);
2843 if (!proc_kill (pi
, SIGKILL
))
2844 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
2845 destroy_procinfo (pi
);
2847 /* If pi is GDB's child, wait for it to die. */
2848 if (parent_pid
== getpid ())
2849 /* FIXME: should we use waitpid to make sure we get the right event?
2850 Should we check the returned event? */
2855 ret
= waitpid (pi
->pid
, &status
, 0);
2862 /* We're done debugging it, and we want it to go away. Then we want
2863 GDB to forget all about it. */
2866 procfs_kill_inferior (struct target_ops
*ops
)
2868 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
2870 /* Find procinfo for main process. */
2871 procinfo
*pi
= find_procinfo (ptid_get_pid (inferior_ptid
), 0);
2874 unconditionally_kill_inferior (pi
);
2875 target_mourn_inferior (inferior_ptid
);
2879 /* Forget we ever debugged this thing! */
2882 procfs_mourn_inferior (struct target_ops
*ops
)
2886 if (!ptid_equal (inferior_ptid
, null_ptid
))
2888 /* Find procinfo for main process. */
2889 pi
= find_procinfo (ptid_get_pid (inferior_ptid
), 0);
2891 destroy_procinfo (pi
);
2894 generic_mourn_inferior ();
2896 inf_child_maybe_unpush_target (ops
);
2899 /* When GDB forks to create a runnable inferior process, this function
2900 is called on the parent side of the fork. It's job is to do
2901 whatever is necessary to make the child ready to be debugged, and
2902 then wait for the child to synchronize. */
2905 procfs_init_inferior (struct target_ops
*ops
, int pid
)
2912 /* This routine called on the parent side (GDB side)
2913 after GDB forks the inferior. */
2914 if (!target_is_pushed (ops
))
2917 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
2918 perror (_("procfs: out of memory in 'init_inferior'"));
2920 if (!open_procinfo_files (pi
, FD_CTL
))
2921 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
2925 open_procinfo_files // done
2928 procfs_notice_signals
2935 /* If not stopped yet, wait for it to stop. */
2936 if (!(proc_flags (pi
) & PR_STOPPED
) &&
2937 !(proc_wait_for_stop (pi
)))
2938 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
2940 /* Save some of the /proc state to be restored if we detach. */
2941 /* FIXME: Why? In case another debugger was debugging it?
2942 We're it's parent, for Ghu's sake! */
2943 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
2944 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
2945 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
2946 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
2947 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
2948 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
2949 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
2950 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
2951 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
2952 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
2954 if ((fail
= procfs_debug_inferior (pi
)) != 0)
2955 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
2957 /* FIXME: logically, we should really be turning OFF run-on-last-close,
2958 and possibly even turning ON kill-on-last-close at this point. But
2959 I can't make that change without careful testing which I don't have
2960 time to do right now... */
2961 /* Turn on run-on-last-close flag so that the child
2962 will die if GDB goes away for some reason. */
2963 if (!proc_set_run_on_last_close (pi
))
2964 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
2966 /* We now have have access to the lwpid of the main thread/lwp. */
2967 lwpid
= proc_get_current_thread (pi
);
2969 /* Create a procinfo for the main lwp. */
2970 create_procinfo (pid
, lwpid
);
2972 /* We already have a main thread registered in the thread table at
2973 this point, but it didn't have any lwp info yet. Notify the core
2974 about it. This changes inferior_ptid as well. */
2975 thread_change_ptid (pid_to_ptid (pid
),
2976 ptid_build (pid
, lwpid
, 0));
2978 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2981 /* When GDB forks to create a new process, this function is called on
2982 the child side of the fork before GDB exec's the user program. Its
2983 job is to make the child minimally debuggable, so that the parent
2984 GDB process can connect to the child and take over. This function
2985 should do only the minimum to make that possible, and to
2986 synchronize with the parent process. The parent process should
2987 take care of the details. */
2990 procfs_set_exec_trap (void)
2992 /* This routine called on the child side (inferior side)
2993 after GDB forks the inferior. It must use only local variables,
2994 because it may be sharing data space with its parent. */
2999 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
3000 perror_with_name (_("procfs: create_procinfo failed in child."));
3002 if (open_procinfo_files (pi
, FD_CTL
) == 0)
3004 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
3005 gdb_flush (gdb_stderr
);
3006 /* No need to call "dead_procinfo", because we're going to
3011 /* Method for tracing exec syscalls. */
3013 Not all systems with /proc have all the exec* syscalls with the same
3014 names. On the SGI, for example, there is no SYS_exec, but there
3015 *is* a SYS_execv. So, we try to account for that. */
3017 exitset
= sysset_t_alloc (pi
);
3018 premptyset (exitset
);
3020 praddset (exitset
, SYS_exec
);
3022 praddset (exitset
, SYS_execve
);
3024 if (!proc_set_traced_sysexit (pi
, exitset
))
3026 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
3027 gdb_flush (gdb_stderr
);
3031 /* FIXME: should this be done in the parent instead? */
3032 /* Turn off inherit on fork flag so that all grand-children
3033 of gdb start with tracing flags cleared. */
3034 if (!proc_unset_inherit_on_fork (pi
))
3035 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
3037 /* Turn off run on last close flag, so that the child process
3038 cannot run away just because we close our handle on it.
3039 We want it to wait for the parent to attach. */
3040 if (!proc_unset_run_on_last_close (pi
))
3041 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
3043 /* FIXME: No need to destroy the procinfo --
3044 we have our own address space, and we're about to do an exec! */
3045 /*destroy_procinfo (pi);*/
3048 /* This function is called BEFORE gdb forks the inferior process. Its
3049 only real responsibility is to set things up for the fork, and tell
3050 GDB which two functions to call after the fork (one for the parent,
3051 and one for the child).
3053 This function does a complicated search for a unix shell program,
3054 which it then uses to parse arguments and environment variables to
3055 be sent to the child. I wonder whether this code could not be
3056 abstracted out and shared with other unix targets such as
3060 procfs_create_inferior (struct target_ops
*ops
, const char *exec_file
,
3061 const std::string
&allargs
, char **env
, int from_tty
)
3063 char *shell_file
= getenv ("SHELL");
3067 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
3070 /* We will be looking down the PATH to find shell_file. If we
3071 just do this the normal way (via execlp, which operates by
3072 attempting an exec for each element of the PATH until it
3073 finds one which succeeds), then there will be an exec for
3074 each failed attempt, each of which will cause a PR_SYSEXIT
3075 stop, and we won't know how to distinguish the PR_SYSEXIT's
3076 for these failed execs with the ones for successful execs
3077 (whether the exec has succeeded is stored at that time in the
3078 carry bit or some such architecture-specific and
3079 non-ABI-specified place).
3081 So I can't think of anything better than to search the PATH
3082 now. This has several disadvantages: (1) There is a race
3083 condition; if we find a file now and it is deleted before we
3084 exec it, we lose, even if the deletion leaves a valid file
3085 further down in the PATH, (2) there is no way to know exactly
3086 what an executable (in the sense of "capable of being
3087 exec'd") file is. Using access() loses because it may lose
3088 if the caller is the superuser; failing to use it loses if
3089 there are ACLs or some such. */
3093 /* FIXME-maybe: might want "set path" command so user can change what
3094 path is used from within GDB. */
3095 const char *path
= getenv ("PATH");
3097 struct stat statbuf
;
3100 path
= "/bin:/usr/bin";
3102 tryname
= (char *) alloca (strlen (path
) + strlen (shell_file
) + 2);
3103 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
3105 p1
= strchr (p
, ':');
3110 strncpy (tryname
, p
, len
);
3111 tryname
[len
] = '\0';
3112 strcat (tryname
, "/");
3113 strcat (tryname
, shell_file
);
3114 if (access (tryname
, X_OK
) < 0)
3116 if (stat (tryname
, &statbuf
) < 0)
3118 if (!S_ISREG (statbuf
.st_mode
))
3119 /* We certainly need to reject directories. I'm not quite
3120 as sure about FIFOs, sockets, etc., but I kind of doubt
3121 that people want to exec() these things. */
3126 /* Not found. This must be an error rather than merely passing
3127 the file to execlp(), because execlp() would try all the
3128 exec()s, causing GDB to get confused. */
3129 error (_("procfs:%d -- Can't find shell %s in PATH"),
3130 __LINE__
, shell_file
);
3132 shell_file
= tryname
;
3135 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
3136 NULL
, NULL
, shell_file
, NULL
);
3138 /* We have something that executes now. We'll be running through
3139 the shell at this point (if startup-with-shell is true), but the
3140 pid shouldn't change. */
3141 add_thread_silent (pid_to_ptid (pid
));
3143 procfs_init_inferior (ops
, pid
);
3146 /* An observer for the "inferior_created" event. */
3149 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
3153 /* Callback for update_thread_list. Calls "add_thread". */
3156 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
3158 ptid_t gdb_threadid
= ptid_build (pi
->pid
, thread
->tid
, 0);
3160 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
3161 add_thread (gdb_threadid
);
3166 /* Query all the threads that the target knows about, and give them
3167 back to GDB to add to its list. */
3170 procfs_update_thread_list (struct target_ops
*ops
)
3176 /* Find procinfo for main process. */
3177 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3178 proc_update_threads (pi
);
3179 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
3182 /* Return true if the thread is still 'alive'. This guy doesn't
3183 really seem to be doing his job. Got to investigate how to tell
3184 when a thread is really gone. */
3187 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
3192 proc
= ptid_get_pid (ptid
);
3193 thread
= ptid_get_lwp (ptid
);
3194 /* If I don't know it, it ain't alive! */
3195 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
3198 /* If I can't get its status, it ain't alive!
3199 What's more, I need to forget about it! */
3200 if (!proc_get_status (pi
))
3202 destroy_procinfo (pi
);
3205 /* I couldn't have got its status if it weren't alive, so it's
3210 /* Convert PTID to a string. Returns the string in a static
3214 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3216 static char buf
[80];
3218 if (ptid_get_lwp (ptid
) == 0)
3219 sprintf (buf
, "process %d", ptid_get_pid (ptid
));
3221 sprintf (buf
, "LWP %ld", ptid_get_lwp (ptid
));
3226 /* Insert a watchpoint. */
3229 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
3235 pi
= find_procinfo_or_die (ptid_get_pid (ptid
) == -1 ?
3236 ptid_get_pid (inferior_ptid
) : ptid_get_pid (ptid
),
3239 /* Translate from GDB's flags to /proc's. */
3240 if (len
> 0) /* len == 0 means delete watchpoint. */
3242 switch (rwflag
) { /* FIXME: need an enum! */
3243 case hw_write
: /* default watchpoint (write) */
3244 pflags
= WRITE_WATCHFLAG
;
3246 case hw_read
: /* read watchpoint */
3247 pflags
= READ_WATCHFLAG
;
3249 case hw_access
: /* access watchpoint */
3250 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
3252 case hw_execute
: /* execution HW breakpoint */
3253 pflags
= EXEC_WATCHFLAG
;
3255 default: /* Something weird. Return error. */
3258 if (after
) /* Stop after r/w access is completed. */
3259 pflags
|= AFTER_WATCHFLAG
;
3262 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
3264 if (errno
== E2BIG
) /* Typical error for no resources. */
3265 return -1; /* fail */
3266 /* GDB may try to remove the same watchpoint twice.
3267 If a remove request returns no match, don't error. */
3268 if (errno
== ESRCH
&& len
== 0)
3269 return 0; /* ignore */
3270 proc_error (pi
, "set_watchpoint", __LINE__
);
3275 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
3276 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
3277 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
3280 Note: procfs_can_use_hw_breakpoint() is not yet used by all
3281 procfs.c targets due to the fact that some of them still define
3282 target_can_use_hardware_watchpoint. */
3285 procfs_can_use_hw_breakpoint (struct target_ops
*self
,
3287 int cnt
, int othertype
)
3289 /* Due to the way that proc_set_watchpoint() is implemented, host
3290 and target pointers must be of the same size. If they are not,
3291 we can't use hardware watchpoints. This limitation is due to the
3292 fact that proc_set_watchpoint() calls
3293 procfs_address_to_host_pointer(); a close inspection of
3294 procfs_address_to_host_pointer will reveal that an internal error
3295 will be generated when the host and target pointer sizes are
3297 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
3299 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
3302 /* Other tests here??? */
3307 /* Returns non-zero if process is stopped on a hardware watchpoint
3308 fault, else returns zero. */
3311 procfs_stopped_by_watchpoint (struct target_ops
*ops
)
3315 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3317 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3319 if (proc_why (pi
) == PR_FAULTED
)
3321 if (proc_what (pi
) == FLTWATCH
)
3328 /* Returns 1 if the OS knows the position of the triggered watchpoint,
3329 and sets *ADDR to that address. Returns 0 if OS cannot report that
3330 address. This function is only called if
3331 procfs_stopped_by_watchpoint returned 1, thus no further checks are
3332 done. The function also assumes that ADDR is not NULL. */
3335 procfs_stopped_data_address (struct target_ops
*targ
, CORE_ADDR
*addr
)
3339 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3340 return proc_watchpoint_address (pi
, addr
);
3344 procfs_insert_watchpoint (struct target_ops
*self
,
3345 CORE_ADDR addr
, int len
,
3346 enum target_hw_bp_type type
,
3347 struct expression
*cond
)
3349 if (!target_have_steppable_watchpoint
3350 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
3352 /* When a hardware watchpoint fires off the PC will be left at
3353 the instruction following the one which caused the
3354 watchpoint. It will *NOT* be necessary for GDB to step over
3356 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
3360 /* When a hardware watchpoint fires off the PC will be left at
3361 the instruction which caused the watchpoint. It will be
3362 necessary for GDB to step over the watchpoint. */
3363 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
3368 procfs_remove_watchpoint (struct target_ops
*self
,
3369 CORE_ADDR addr
, int len
,
3370 enum target_hw_bp_type type
,
3371 struct expression
*cond
)
3373 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
3377 procfs_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3378 CORE_ADDR addr
, int len
)
3380 /* The man page for proc(4) on Solaris 2.6 and up says that the
3381 system can support "thousands" of hardware watchpoints, but gives
3382 no method for finding out how many; It doesn't say anything about
3383 the allowed size for the watched area either. So we just tell
3389 procfs_use_watchpoints (struct target_ops
*t
)
3391 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
3392 t
->to_insert_watchpoint
= procfs_insert_watchpoint
;
3393 t
->to_remove_watchpoint
= procfs_remove_watchpoint
;
3394 t
->to_region_ok_for_hw_watchpoint
= procfs_region_ok_for_hw_watchpoint
;
3395 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
3396 t
->to_stopped_data_address
= procfs_stopped_data_address
;
3399 /* Memory Mappings Functions: */
3401 /* Call a callback function once for each mapping, passing it the
3402 mapping, an optional secondary callback function, and some optional
3403 opaque data. Quit and return the first non-zero value returned
3406 PI is the procinfo struct for the process to be mapped. FUNC is
3407 the callback function to be called by this iterator. DATA is the
3408 optional opaque data to be passed to the callback function.
3409 CHILD_FUNC is the optional secondary function pointer to be passed
3410 to the child function. Returns the first non-zero return value
3411 from the callback function, or zero. */
3414 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
3416 int (*func
) (struct prmap
*map
,
3417 find_memory_region_ftype child_func
,
3420 char pathname
[MAX_PROC_NAME_SIZE
];
3421 struct prmap
*prmaps
;
3422 struct prmap
*prmap
;
3427 /* Get the number of mappings, allocate space,
3428 and read the mappings into prmaps. */
3430 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
3432 scoped_fd
map_fd (open (pathname
, O_RDONLY
));
3433 if (map_fd
.get () < 0)
3434 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
3436 /* Use stat to determine the file size, and compute
3437 the number of prmap_t objects it contains. */
3438 if (fstat (map_fd
.get (), &sbuf
) != 0)
3439 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
3441 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
3442 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
3443 if (read (map_fd
.get (), (char *) prmaps
, nmap
* sizeof (*prmaps
))
3444 != (nmap
* sizeof (*prmaps
)))
3445 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
3447 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
3448 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
3454 /* Implements the to_find_memory_regions method. Calls an external
3455 function for each memory region.
3456 Returns the integer value returned by the callback. */
3459 find_memory_regions_callback (struct prmap
*map
,
3460 find_memory_region_ftype func
, void *data
)
3462 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
3464 (map
->pr_mflags
& MA_READ
) != 0,
3465 (map
->pr_mflags
& MA_WRITE
) != 0,
3466 (map
->pr_mflags
& MA_EXEC
) != 0,
3467 1, /* MODIFIED is unknown, pass it as true. */
3471 /* External interface. Calls a callback function once for each
3472 mapped memory region in the child process, passing as arguments:
3474 CORE_ADDR virtual_address,
3476 int read, TRUE if region is readable by the child
3477 int write, TRUE if region is writable by the child
3478 int execute TRUE if region is executable by the child.
3480 Stops iterating and returns the first non-zero value returned by
3484 proc_find_memory_regions (struct target_ops
*self
,
3485 find_memory_region_ftype func
, void *data
)
3487 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3489 return iterate_over_mappings (pi
, func
, data
,
3490 find_memory_regions_callback
);
3493 /* Returns an ascii representation of a memory mapping's flags. */
3496 mappingflags (long flags
)
3498 static char asciiflags
[8];
3500 strcpy (asciiflags
, "-------");
3501 if (flags
& MA_STACK
)
3502 asciiflags
[1] = 's';
3503 if (flags
& MA_BREAK
)
3504 asciiflags
[2] = 'b';
3505 if (flags
& MA_SHARED
)
3506 asciiflags
[3] = 's';
3507 if (flags
& MA_READ
)
3508 asciiflags
[4] = 'r';
3509 if (flags
& MA_WRITE
)
3510 asciiflags
[5] = 'w';
3511 if (flags
& MA_EXEC
)
3512 asciiflags
[6] = 'x';
3513 return (asciiflags
);
3516 /* Callback function, does the actual work for 'info proc
3520 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
3523 unsigned int pr_off
;
3525 pr_off
= (unsigned int) map
->pr_offset
;
3527 if (gdbarch_addr_bit (target_gdbarch ()) == 32)
3528 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
3529 (unsigned long) map
->pr_vaddr
,
3530 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3531 (unsigned long) map
->pr_size
,
3533 mappingflags (map
->pr_mflags
));
3535 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
3536 (unsigned long) map
->pr_vaddr
,
3537 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3538 (unsigned long) map
->pr_size
,
3540 mappingflags (map
->pr_mflags
));
3545 /* Implement the "info proc mappings" subcommand. */
3548 info_proc_mappings (procinfo
*pi
, int summary
)
3551 return; /* No output for summary mode. */
3553 printf_filtered (_("Mapped address spaces:\n\n"));
3554 if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
3555 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3562 printf_filtered (" %18s %18s %10s %10s %7s\n",
3569 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
3570 printf_filtered ("\n");
3573 /* Implement the "info proc" command. */
3576 procfs_info_proc (struct target_ops
*ops
, const char *args
,
3577 enum info_proc_what what
)
3579 struct cleanup
*old_chain
;
3580 procinfo
*process
= NULL
;
3581 procinfo
*thread
= NULL
;
3598 error (_("Not supported on this target."));
3601 old_chain
= make_cleanup (null_cleanup
, 0);
3602 gdb_argv
built_argv (args
);
3603 for (char *arg
: built_argv
)
3605 if (isdigit (arg
[0]))
3607 pid
= strtoul (arg
, &tmp
, 10);
3609 tid
= strtoul (++tmp
, NULL
, 10);
3611 else if (arg
[0] == '/')
3613 tid
= strtoul (arg
+ 1, NULL
, 10);
3617 pid
= ptid_get_pid (inferior_ptid
);
3619 error (_("No current process: you must name one."));
3622 /* Have pid, will travel.
3623 First see if it's a process we're already debugging. */
3624 process
= find_procinfo (pid
, 0);
3625 if (process
== NULL
)
3627 /* No. So open a procinfo for it, but
3628 remember to close it again when finished. */
3629 process
= create_procinfo (pid
, 0);
3630 make_cleanup (do_destroy_procinfo_cleanup
, process
);
3631 if (!open_procinfo_files (process
, FD_CTL
))
3632 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
3636 thread
= create_procinfo (pid
, tid
);
3640 printf_filtered (_("process %d flags:\n"), process
->pid
);
3641 proc_prettyprint_flags (proc_flags (process
), 1);
3642 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
3643 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
3644 if (proc_get_nthreads (process
) > 1)
3645 printf_filtered ("Process has %d threads.\n",
3646 proc_get_nthreads (process
));
3650 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
3651 proc_prettyprint_flags (proc_flags (thread
), 1);
3652 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
3653 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
3658 info_proc_mappings (process
, 0);
3661 do_cleanups (old_chain
);
3664 /* Modify the status of the system call identified by SYSCALLNUM in
3665 the set of syscalls that are currently traced/debugged.
3667 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
3668 will be updated. Otherwise, the exit syscalls set will be updated.
3670 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
3671 will be disabled. */
3674 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
3675 int mode
, int from_tty
)
3679 if (entry_or_exit
== PR_SYSENTRY
)
3680 sysset
= proc_get_traced_sysentry (pi
, NULL
);
3682 sysset
= proc_get_traced_sysexit (pi
, NULL
);
3685 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
3687 if (mode
== FLAG_SET
)
3688 praddset (sysset
, syscallnum
);
3690 prdelset (sysset
, syscallnum
);
3692 if (entry_or_exit
== PR_SYSENTRY
)
3694 if (!proc_set_traced_sysentry (pi
, sysset
))
3695 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
3699 if (!proc_set_traced_sysexit (pi
, sysset
))
3700 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
3705 proc_trace_syscalls (const char *args
, int from_tty
, int entry_or_exit
, int mode
)
3709 if (ptid_get_pid (inferior_ptid
) <= 0)
3710 error (_("you must be debugging a process to use this command."));
3712 if (args
== NULL
|| args
[0] == 0)
3713 error_no_arg (_("system call to trace"));
3715 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3716 if (isdigit (args
[0]))
3718 const int syscallnum
= atoi (args
);
3720 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
3725 proc_trace_sysentry_cmd (const char *args
, int from_tty
)
3727 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
3731 proc_trace_sysexit_cmd (const char *args
, int from_tty
)
3733 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
3737 proc_untrace_sysentry_cmd (const char *args
, int from_tty
)
3739 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
3743 proc_untrace_sysexit_cmd (const char *args
, int from_tty
)
3745 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
3749 _initialize_procfs (void)
3751 gdb::observers::inferior_created
.attach (procfs_inferior_created
);
3753 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
3754 _("Give a trace of entries into the syscall."));
3755 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
3756 _("Give a trace of exits from the syscall."));
3757 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
3758 _("Cancel a trace of entries into the syscall."));
3759 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
3760 _("Cancel a trace of exits from the syscall."));
3763 /* =================== END, GDB "MODULE" =================== */
3767 /* miscellaneous stubs: */
3769 /* The following satisfy a few random symbols mostly created by the
3770 solaris threads implementation, which I will chase down later. */
3772 /* Return a pid for which we guarantee we will be able to find a
3776 procfs_first_available (void)
3778 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
3781 /* =================== GCORE .NOTE "MODULE" =================== */
3784 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
3785 char *note_data
, int *note_size
,
3786 enum gdb_signal stop_signal
)
3788 struct regcache
*regcache
= get_thread_regcache (ptid
);
3789 gdb_gregset_t gregs
;
3790 gdb_fpregset_t fpregs
;
3791 unsigned long merged_pid
;
3793 merged_pid
= ptid_get_lwp (ptid
) << 16 | ptid_get_pid (ptid
);
3795 /* This part is the old method for fetching registers.
3796 It should be replaced by the newer one using regsets
3797 once it is implemented in this platform:
3798 gdbarch_iterate_over_regset_sections(). */
3800 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3801 inferior_ptid
= ptid
;
3802 target_fetch_registers (regcache
, -1);
3804 fill_gregset (regcache
, &gregs
, -1);
3805 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
3811 fill_fpregset (regcache
, &fpregs
, -1);
3812 note_data
= (char *) elfcore_write_prfpreg (obfd
,
3821 struct procfs_corefile_thread_data
{
3825 enum gdb_signal stop_signal
;
3829 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
3831 struct procfs_corefile_thread_data
*args
3832 = (struct procfs_corefile_thread_data
*) data
;
3836 ptid_t ptid
= ptid_build (pi
->pid
, thread
->tid
, 0);
3838 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
3847 find_signalled_thread (struct thread_info
*info
, void *data
)
3849 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
3850 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
3856 static enum gdb_signal
3857 find_stop_signal (void)
3859 struct thread_info
*info
=
3860 iterate_over_threads (find_signalled_thread
, NULL
);
3863 return info
->suspend
.stop_signal
;
3865 return GDB_SIGNAL_0
;
3869 procfs_make_note_section (struct target_ops
*self
, bfd
*obfd
, int *note_size
)
3871 struct cleanup
*old_chain
;
3872 gdb_gregset_t gregs
;
3873 gdb_fpregset_t fpregs
;
3874 char fname
[16] = {'\0'};
3875 char psargs
[80] = {'\0'};
3876 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3877 char *note_data
= NULL
;
3879 struct procfs_corefile_thread_data thread_args
;
3882 enum gdb_signal stop_signal
;
3884 if (get_exec_file (0))
3886 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
3887 fname
[sizeof (fname
) - 1] = 0;
3888 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3889 psargs
[sizeof (psargs
) - 1] = 0;
3891 inf_args
= get_inferior_args ();
3892 if (inf_args
&& *inf_args
&&
3893 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
3895 strncat (psargs
, " ",
3896 sizeof (psargs
) - strlen (psargs
));
3897 strncat (psargs
, inf_args
,
3898 sizeof (psargs
) - strlen (psargs
));
3902 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
3908 stop_signal
= find_stop_signal ();
3910 fill_gregset (get_current_regcache (), &gregs
, -1);
3911 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
3912 ptid_get_pid (inferior_ptid
),
3913 stop_signal
, &gregs
);
3915 thread_args
.obfd
= obfd
;
3916 thread_args
.note_data
= note_data
;
3917 thread_args
.note_size
= note_size
;
3918 thread_args
.stop_signal
= stop_signal
;
3919 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
3921 note_data
= thread_args
.note_data
;
3923 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
3927 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
3928 "CORE", NT_AUXV
, auxv
, auxv_len
);
3934 /* =================== END GCORE .NOTE "MODULE" =================== */