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>
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
*, const char *, 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
)
1624 do_cleanups (old_chain
);
1628 /* Loop ended, match not found. */
1632 /* Returns the pointer to the LDT entry of PTID. */
1635 procfs_find_LDT_entry (ptid_t ptid
)
1637 gdb_gregset_t
*gregs
;
1641 /* Find procinfo for the lwp. */
1642 if ((pi
= find_procinfo (ptid_get_pid (ptid
), ptid_get_lwp (ptid
))) == NULL
)
1644 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
1645 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
1648 /* get its general registers. */
1649 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
1651 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
1652 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
1655 /* Now extract the GS register's lower 16 bits. */
1656 key
= (*gregs
)[GS
] & 0xffff;
1658 /* Find the matching entry and return it. */
1659 return proc_get_LDT_entry (pi
, key
);
1664 /* =============== END, non-thread part of /proc "MODULE" =============== */
1666 /* =================== Thread "MODULE" =================== */
1668 /* NOTE: you'll see more ifdefs and duplication of functions here,
1669 since there is a different way to do threads on every OS. */
1671 /* Returns the number of threads for the process. */
1674 proc_get_nthreads (procinfo
*pi
)
1676 if (!pi
->status_valid
)
1677 if (!proc_get_status (pi
))
1680 /* Only works for the process procinfo, because the LWP procinfos do not
1681 get prstatus filled in. */
1682 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
1683 pi
= find_procinfo_or_die (pi
->pid
, 0);
1684 return pi
->prstatus
.pr_nlwp
;
1689 Return the ID of the thread that had an event of interest.
1690 (ie. the one that hit a breakpoint or other traced event). All
1691 other things being equal, this should be the ID of a thread that is
1692 currently executing. */
1695 proc_get_current_thread (procinfo
*pi
)
1697 /* Note: this should be applied to the root procinfo for the
1698 process, not to the procinfo for an LWP. If applied to the
1699 procinfo for an LWP, it will simply return that LWP's ID. In
1700 that case, find the parent process procinfo. */
1703 pi
= find_procinfo_or_die (pi
->pid
, 0);
1705 if (!pi
->status_valid
)
1706 if (!proc_get_status (pi
))
1709 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
1712 /* Discover the IDs of all the threads within the process, and create
1713 a procinfo for each of them (chained to the parent). This
1714 unfortunately requires a different method on every OS. Returns
1715 non-zero for success, zero for failure. */
1718 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
1720 if (thread
&& parent
) /* sanity */
1722 thread
->status_valid
= 0;
1723 if (!proc_get_status (thread
))
1724 destroy_one_procinfo (&parent
->thread_list
, thread
);
1726 return 0; /* keep iterating */
1730 do_closedir_cleanup (void *dir
)
1732 closedir ((DIR *) dir
);
1736 proc_update_threads (procinfo
*pi
)
1738 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
1739 struct dirent
*direntry
;
1740 struct cleanup
*old_chain
= NULL
;
1745 /* We should never have to apply this operation to any procinfo
1746 except the one for the main process. If that ever changes for
1747 any reason, then take out the following clause and replace it
1748 with one that makes sure the ctl_fd is open. */
1751 pi
= find_procinfo_or_die (pi
->pid
, 0);
1753 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
1755 /* Note: this brute-force method was originally devised for Unixware
1756 (support removed since), and will also work on Solaris 2.6 and
1757 2.7. The original comment mentioned the existence of a much
1758 simpler and more elegant way to do this on Solaris, but didn't
1759 point out what that was. */
1761 strcpy (pathname
, pi
->pathname
);
1762 strcat (pathname
, "/lwp");
1763 if ((dirp
= opendir (pathname
)) == NULL
)
1764 proc_error (pi
, "update_threads, opendir", __LINE__
);
1766 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
1767 while ((direntry
= readdir (dirp
)) != NULL
)
1768 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
1770 lwpid
= atoi (&direntry
->d_name
[0]);
1771 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
1772 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
1774 pi
->threads_valid
= 1;
1775 do_cleanups (old_chain
);
1779 /* Given a pointer to a function, call that function once for each lwp
1780 in the procinfo list, until the function returns non-zero, in which
1781 event return the value returned by the function.
1783 Note: this function does NOT call update_threads. If you want to
1784 discover new threads first, you must call that function explicitly.
1785 This function just makes a quick pass over the currently-known
1788 PI is the parent process procinfo. FUNC is the per-thread
1789 function. PTR is an opaque parameter for function. Returns the
1790 first non-zero return value from the callee, or zero. */
1793 proc_iterate_over_threads (procinfo
*pi
,
1794 int (*func
) (procinfo
*, procinfo
*, void *),
1797 procinfo
*thread
, *next
;
1800 /* We should never have to apply this operation to any procinfo
1801 except the one for the main process. If that ever changes for
1802 any reason, then take out the following clause and replace it
1803 with one that makes sure the ctl_fd is open. */
1806 pi
= find_procinfo_or_die (pi
->pid
, 0);
1808 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
1810 next
= thread
->next
; /* In case thread is destroyed. */
1811 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
1818 /* =================== END, Thread "MODULE" =================== */
1820 /* =================== END, /proc "MODULE" =================== */
1822 /* =================== GDB "MODULE" =================== */
1824 /* Here are all of the gdb target vector functions and their
1827 static ptid_t
do_attach (ptid_t ptid
);
1828 static void do_detach ();
1829 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
1830 int entry_or_exit
, int mode
, int from_tty
);
1832 /* Sets up the inferior to be debugged. Registers to trace signals,
1833 hardware faults, and syscalls. Note: does not set RLC flag: caller
1834 may want to customize that. Returns zero for success (note!
1835 unlike most functions in this module); on failure, returns the LINE
1836 NUMBER where it failed! */
1839 procfs_debug_inferior (procinfo
*pi
)
1841 fltset_t traced_faults
;
1842 sigset_t traced_signals
;
1843 sysset_t
*traced_syscall_entries
;
1844 sysset_t
*traced_syscall_exits
;
1847 /* Register to trace hardware faults in the child. */
1848 prfillset (&traced_faults
); /* trace all faults... */
1849 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
1850 if (!proc_set_traced_faults (pi
, &traced_faults
))
1853 /* Initially, register to trace all signals in the child. */
1854 prfillset (&traced_signals
);
1855 if (!proc_set_traced_signals (pi
, &traced_signals
))
1859 /* Register to trace the 'exit' system call (on entry). */
1860 traced_syscall_entries
= sysset_t_alloc (pi
);
1861 premptyset (traced_syscall_entries
);
1862 praddset (traced_syscall_entries
, SYS_exit
);
1863 praddset (traced_syscall_entries
, SYS_lwp_exit
);
1865 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
1866 xfree (traced_syscall_entries
);
1870 /* Method for tracing exec syscalls. */
1872 Not all systems with /proc have all the exec* syscalls with the same
1873 names. On the SGI, for example, there is no SYS_exec, but there
1874 *is* a SYS_execv. So, we try to account for that. */
1876 traced_syscall_exits
= sysset_t_alloc (pi
);
1877 premptyset (traced_syscall_exits
);
1879 praddset (traced_syscall_exits
, SYS_exec
);
1881 praddset (traced_syscall_exits
, SYS_execve
);
1882 praddset (traced_syscall_exits
, SYS_lwp_create
);
1883 praddset (traced_syscall_exits
, SYS_lwp_exit
);
1885 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
1886 xfree (traced_syscall_exits
);
1894 procfs_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1899 pid
= parse_pid_to_attach (args
);
1901 if (pid
== getpid ())
1902 error (_("Attaching GDB to itself is not a good idea..."));
1906 exec_file
= get_exec_file (0);
1909 printf_filtered (_("Attaching to program `%s', %s\n"),
1910 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
1912 printf_filtered (_("Attaching to %s\n"),
1913 target_pid_to_str (pid_to_ptid (pid
)));
1917 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1918 if (!target_is_pushed (ops
))
1923 procfs_detach (struct target_ops
*ops
, inferior
*inf
, int from_tty
)
1925 int pid
= ptid_get_pid (inferior_ptid
);
1929 const char *exec_file
;
1931 exec_file
= get_exec_file (0);
1932 if (exec_file
== NULL
)
1935 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
1936 target_pid_to_str (pid_to_ptid (pid
)));
1937 gdb_flush (gdb_stdout
);
1942 inferior_ptid
= null_ptid
;
1943 detach_inferior (pid
);
1944 inf_child_maybe_unpush_target (ops
);
1948 do_attach (ptid_t ptid
)
1951 struct inferior
*inf
;
1955 if ((pi
= create_procinfo (ptid_get_pid (ptid
), 0)) == NULL
)
1956 perror (_("procfs: out of memory in 'attach'"));
1958 if (!open_procinfo_files (pi
, FD_CTL
))
1960 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
1961 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
1962 ptid_get_pid (ptid
));
1963 dead_procinfo (pi
, errmsg
, NOKILL
);
1966 /* Stop the process (if it isn't already stopped). */
1967 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
1969 pi
->was_stopped
= 1;
1970 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
1974 pi
->was_stopped
= 0;
1975 /* Set the process to run again when we close it. */
1976 if (!proc_set_run_on_last_close (pi
))
1977 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
1979 /* Now stop the process. */
1980 if (!proc_stop_process (pi
))
1981 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
1982 pi
->ignore_next_sigstop
= 1;
1984 /* Save some of the /proc state to be restored if we detach. */
1985 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
1986 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
1987 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
1988 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
1989 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
1990 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
1992 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
1993 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
1995 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
1996 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
1998 if ((fail
= procfs_debug_inferior (pi
)) != 0)
1999 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
2001 inf
= current_inferior ();
2002 inferior_appeared (inf
, pi
->pid
);
2003 /* Let GDB know that the inferior was attached. */
2004 inf
->attach_flag
= 1;
2006 /* Create a procinfo for the current lwp. */
2007 lwpid
= proc_get_current_thread (pi
);
2008 create_procinfo (pi
->pid
, lwpid
);
2010 /* Add it to gdb's thread list. */
2011 ptid
= ptid_build (pi
->pid
, lwpid
, 0);
2022 /* Find procinfo for the main process. */
2023 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
),
2024 0); /* FIXME: threads */
2026 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
2027 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
2029 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
2030 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
2032 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
2033 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
2035 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
2036 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
2038 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
2039 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
2041 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
2042 if (!(pi
->was_stopped
)
2043 || query (_("Was stopped when attached, make it runnable again? ")))
2045 /* Clear any pending signal. */
2046 if (!proc_clear_current_fault (pi
))
2047 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
2049 if (!proc_clear_current_signal (pi
))
2050 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
2052 if (!proc_set_run_on_last_close (pi
))
2053 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
2056 destroy_procinfo (pi
);
2059 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
2062 ??? Is the following note still relevant? We can't get individual
2063 registers with the PT_GETREGS ptrace(2) request either, yet we
2064 don't bother with caching at all in that case.
2066 NOTE: Since the /proc interface cannot give us individual
2067 registers, we pay no attention to REGNUM, and just fetch them all.
2068 This results in the possibility that we will do unnecessarily many
2069 fetches, since we may be called repeatedly for individual
2070 registers. So we cache the results, and mark the cache invalid
2071 when the process is resumed. */
2074 procfs_fetch_registers (struct target_ops
*ops
,
2075 struct regcache
*regcache
, int regnum
)
2077 gdb_gregset_t
*gregs
;
2079 ptid_t ptid
= regcache_get_ptid (regcache
);
2080 int pid
= ptid_get_pid (ptid
);
2081 int tid
= ptid_get_lwp (ptid
);
2082 struct gdbarch
*gdbarch
= regcache
->arch ();
2084 pi
= find_procinfo_or_die (pid
, tid
);
2087 error (_("procfs: fetch_registers failed to find procinfo for %s"),
2088 target_pid_to_str (ptid
));
2090 gregs
= proc_get_gregs (pi
);
2092 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
2094 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
2096 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2098 gdb_fpregset_t
*fpregs
;
2100 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2101 || regnum
== gdbarch_pc_regnum (gdbarch
)
2102 || regnum
== gdbarch_sp_regnum (gdbarch
))
2103 return; /* Not a floating point register. */
2105 fpregs
= proc_get_fpregs (pi
);
2107 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
2109 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
2113 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
2114 this for all registers.
2116 NOTE: Since the /proc interface will not read individual registers,
2117 we will cache these requests until the process is resumed, and only
2118 then write them back to the inferior process.
2120 FIXME: is that a really bad idea? Have to think about cases where
2121 writing one register might affect the value of others, etc. */
2124 procfs_store_registers (struct target_ops
*ops
,
2125 struct regcache
*regcache
, int regnum
)
2127 gdb_gregset_t
*gregs
;
2129 ptid_t ptid
= regcache_get_ptid (regcache
);
2130 int pid
= ptid_get_pid (ptid
);
2131 int tid
= ptid_get_lwp (ptid
);
2132 struct gdbarch
*gdbarch
= regcache
->arch ();
2134 pi
= find_procinfo_or_die (pid
, tid
);
2137 error (_("procfs: store_registers: failed to find procinfo for %s"),
2138 target_pid_to_str (ptid
));
2140 gregs
= proc_get_gregs (pi
);
2142 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
2144 fill_gregset (regcache
, gregs
, regnum
);
2145 if (!proc_set_gregs (pi
))
2146 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
2148 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2150 gdb_fpregset_t
*fpregs
;
2152 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2153 || regnum
== gdbarch_pc_regnum (gdbarch
)
2154 || regnum
== gdbarch_sp_regnum (gdbarch
))
2155 return; /* Not a floating point register. */
2157 fpregs
= proc_get_fpregs (pi
);
2159 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
2161 fill_fpregset (regcache
, fpregs
, regnum
);
2162 if (!proc_set_fpregs (pi
))
2163 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
2168 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
2170 if (scall
== SYS_lwp_exit
)
2176 syscall_is_exit (procinfo
*pi
, int scall
)
2178 if (scall
== SYS_exit
)
2184 syscall_is_exec (procinfo
*pi
, int scall
)
2187 if (scall
== SYS_exec
)
2190 if (scall
== SYS_execve
)
2196 syscall_is_lwp_create (procinfo
*pi
, int scall
)
2198 if (scall
== SYS_lwp_create
)
2203 /* Retrieve the next stop event from the child process. If child has
2204 not stopped yet, wait for it to stop. Translate /proc eventcodes
2205 (or possibly wait eventcodes) into gdb internal event codes.
2206 Returns the id of process (and possibly thread) that incurred the
2207 event. Event codes are returned through a pointer parameter. */
2210 procfs_wait (struct target_ops
*ops
,
2211 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2213 /* First cut: loosely based on original version 2.1. */
2217 ptid_t retval
, temp_ptid
;
2218 int why
, what
, flags
;
2225 retval
= pid_to_ptid (-1);
2227 /* Find procinfo for main process. */
2228 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2231 /* We must assume that the status is stale now... */
2232 pi
->status_valid
= 0;
2233 pi
->gregs_valid
= 0;
2234 pi
->fpregs_valid
= 0;
2236 #if 0 /* just try this out... */
2237 flags
= proc_flags (pi
);
2238 why
= proc_why (pi
);
2239 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
2240 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
2242 /* If child is not stopped, wait for it to stop. */
2243 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
2244 !proc_wait_for_stop (pi
))
2246 /* wait_for_stop failed: has the child terminated? */
2247 if (errno
== ENOENT
)
2251 /* /proc file not found; presumably child has terminated. */
2252 wait_retval
= wait (&wstat
); /* "wait" for the child's exit. */
2255 if (wait_retval
!= ptid_get_pid (inferior_ptid
))
2256 error (_("procfs: couldn't stop "
2257 "process %d: wait returned %d."),
2258 ptid_get_pid (inferior_ptid
), wait_retval
);
2259 /* FIXME: might I not just use waitpid?
2260 Or try find_procinfo to see if I know about this child? */
2261 retval
= pid_to_ptid (wait_retval
);
2263 else if (errno
== EINTR
)
2267 /* Unknown error from wait_for_stop. */
2268 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
2273 /* This long block is reached if either:
2274 a) the child was already stopped, or
2275 b) we successfully waited for the child with wait_for_stop.
2276 This block will analyze the /proc status, and translate it
2277 into a waitstatus for GDB.
2279 If we actually had to call wait because the /proc file
2280 is gone (child terminated), then we skip this block,
2281 because we already have a waitstatus. */
2283 flags
= proc_flags (pi
);
2284 why
= proc_why (pi
);
2285 what
= proc_what (pi
);
2287 if (flags
& (PR_STOPPED
| PR_ISTOP
))
2289 /* If it's running async (for single_thread control),
2290 set it back to normal again. */
2291 if (flags
& PR_ASYNC
)
2292 if (!proc_unset_async (pi
))
2293 proc_error (pi
, "target_wait, unset_async", __LINE__
);
2296 proc_prettyprint_why (why
, what
, 1);
2298 /* The 'pid' we will return to GDB is composed of
2299 the process ID plus the lwp ID. */
2300 retval
= ptid_build (pi
->pid
, proc_get_current_thread (pi
), 0);
2304 wstat
= (what
<< 8) | 0177;
2307 if (syscall_is_lwp_exit (pi
, what
))
2309 if (print_thread_events
)
2310 printf_unfiltered (_("[%s exited]\n"),
2311 target_pid_to_str (retval
));
2312 delete_thread (retval
);
2313 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2316 else if (syscall_is_exit (pi
, what
))
2318 struct inferior
*inf
;
2320 /* Handle SYS_exit call only. */
2321 /* Stopped at entry to SYS_exit.
2322 Make it runnable, resume it, then use
2323 the wait system call to get its exit code.
2324 Proc_run_process always clears the current
2326 Then return its exit status. */
2327 pi
->status_valid
= 0;
2329 /* FIXME: what we should do is return
2330 TARGET_WAITKIND_SPURIOUS. */
2331 if (!proc_run_process (pi
, 0, 0))
2332 proc_error (pi
, "target_wait, run_process", __LINE__
);
2334 inf
= find_inferior_pid (pi
->pid
);
2335 if (inf
->attach_flag
)
2337 /* Don't call wait: simulate waiting for exit,
2338 return a "success" exit code. Bogus: what if
2339 it returns something else? */
2341 retval
= inferior_ptid
; /* ? ? ? */
2345 int temp
= wait (&wstat
);
2347 /* FIXME: shouldn't I make sure I get the right
2348 event from the right process? If (for
2349 instance) I have killed an earlier inferior
2350 process but failed to clean up after it
2351 somehow, I could get its termination event
2354 /* If wait returns -1, that's what we return
2357 retval
= pid_to_ptid (temp
);
2362 printf_filtered (_("procfs: trapped on entry to "));
2363 proc_prettyprint_syscall (proc_what (pi
), 0);
2364 printf_filtered ("\n");
2366 long i
, nsysargs
, *sysargs
;
2368 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
2369 (sysargs
= proc_sysargs (pi
)) != NULL
)
2371 printf_filtered (_("%ld syscall arguments:\n"),
2373 for (i
= 0; i
< nsysargs
; i
++)
2374 printf_filtered ("#%ld: 0x%08lx\n",
2380 /* How to exit gracefully, returning "unknown
2382 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2383 return inferior_ptid
;
2387 /* How to keep going without returning to wfi: */
2388 target_continue_no_signal (ptid
);
2394 if (syscall_is_exec (pi
, what
))
2396 /* Hopefully this is our own "fork-child" execing
2397 the real child. Hoax this event into a trap, and
2398 GDB will see the child about to execute its start
2400 wstat
= (SIGTRAP
<< 8) | 0177;
2402 else if (syscall_is_lwp_create (pi
, what
))
2404 /* This syscall is somewhat like fork/exec. We
2405 will get the event twice: once for the parent
2406 LWP, and once for the child. We should already
2407 know about the parent LWP, but the child will
2408 be new to us. So, whenever we get this event,
2409 if it represents a new thread, simply add the
2410 thread to the list. */
2412 /* If not in procinfo list, add it. */
2413 temp_tid
= proc_get_current_thread (pi
);
2414 if (!find_procinfo (pi
->pid
, temp_tid
))
2415 create_procinfo (pi
->pid
, temp_tid
);
2417 temp_ptid
= ptid_build (pi
->pid
, temp_tid
, 0);
2418 /* If not in GDB's thread list, add it. */
2419 if (!in_thread_list (temp_ptid
))
2420 add_thread (temp_ptid
);
2422 /* Return to WFI, but tell it to immediately resume. */
2423 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2424 return inferior_ptid
;
2426 else if (syscall_is_lwp_exit (pi
, what
))
2428 if (print_thread_events
)
2429 printf_unfiltered (_("[%s exited]\n"),
2430 target_pid_to_str (retval
));
2431 delete_thread (retval
);
2432 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2437 /* FIXME: Do we need to handle SYS_sproc,
2438 SYS_fork, or SYS_vfork here? The old procfs
2439 seemed to use this event to handle threads on
2440 older (non-LWP) systems, where I'm assuming
2441 that threads were actually separate processes.
2442 Irix, maybe? Anyway, low priority for now. */
2446 printf_filtered (_("procfs: trapped on exit from "));
2447 proc_prettyprint_syscall (proc_what (pi
), 0);
2448 printf_filtered ("\n");
2450 long i
, nsysargs
, *sysargs
;
2452 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
2453 (sysargs
= proc_sysargs (pi
)) != NULL
)
2455 printf_filtered (_("%ld syscall arguments:\n"),
2457 for (i
= 0; i
< nsysargs
; i
++)
2458 printf_filtered ("#%ld: 0x%08lx\n",
2462 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2463 return inferior_ptid
;
2468 wstat
= (SIGSTOP
<< 8) | 0177;
2473 printf_filtered (_("Retry #%d:\n"), retry
);
2474 pi
->status_valid
= 0;
2479 /* If not in procinfo list, add it. */
2480 temp_tid
= proc_get_current_thread (pi
);
2481 if (!find_procinfo (pi
->pid
, temp_tid
))
2482 create_procinfo (pi
->pid
, temp_tid
);
2484 /* If not in GDB's thread list, add it. */
2485 temp_ptid
= ptid_build (pi
->pid
, temp_tid
, 0);
2486 if (!in_thread_list (temp_ptid
))
2487 add_thread (temp_ptid
);
2489 status
->kind
= TARGET_WAITKIND_STOPPED
;
2490 status
->value
.sig
= GDB_SIGNAL_0
;
2495 wstat
= (what
<< 8) | 0177;
2500 wstat
= (SIGTRAP
<< 8) | 0177;
2502 /* FIXME: use si_signo where possible. */
2505 wstat
= (SIGILL
<< 8) | 0177;
2509 wstat
= (SIGTRAP
<< 8) | 0177;
2514 wstat
= (SIGSEGV
<< 8) | 0177;
2519 wstat
= (SIGFPE
<< 8) | 0177;
2521 case FLTPAGE
: /* Recoverable page fault */
2522 default: /* FIXME: use si_signo if possible for
2524 retval
= pid_to_ptid (-1);
2525 printf_filtered ("procfs:%d -- ", __LINE__
);
2526 printf_filtered (_("child stopped for unknown reason:\n"));
2527 proc_prettyprint_why (why
, what
, 1);
2528 error (_("... giving up..."));
2531 break; /* case PR_FAULTED: */
2532 default: /* switch (why) unmatched */
2533 printf_filtered ("procfs:%d -- ", __LINE__
);
2534 printf_filtered (_("child stopped for unknown reason:\n"));
2535 proc_prettyprint_why (why
, what
, 1);
2536 error (_("... giving up..."));
2539 /* Got this far without error: If retval isn't in the
2540 threads database, add it. */
2541 if (ptid_get_pid (retval
) > 0 &&
2542 !ptid_equal (retval
, inferior_ptid
) &&
2543 !in_thread_list (retval
))
2545 /* We have a new thread. We need to add it both to
2546 GDB's list and to our own. If we don't create a
2547 procinfo, resume may be unhappy later. */
2548 add_thread (retval
);
2549 if (find_procinfo (ptid_get_pid (retval
),
2550 ptid_get_lwp (retval
)) == NULL
)
2551 create_procinfo (ptid_get_pid (retval
),
2552 ptid_get_lwp (retval
));
2555 else /* Flags do not indicate STOPPED. */
2557 /* surely this can't happen... */
2558 printf_filtered ("procfs:%d -- process not stopped.\n",
2560 proc_prettyprint_flags (flags
, 1);
2561 error (_("procfs: ...giving up..."));
2566 store_waitstatus (status
, wstat
);
2572 /* Perform a partial transfer to/from the specified object. For
2573 memory transfers, fall back to the old memory xfer functions. */
2575 static enum target_xfer_status
2576 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2577 const char *annex
, gdb_byte
*readbuf
,
2578 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2579 ULONGEST
*xfered_len
)
2583 case TARGET_OBJECT_MEMORY
:
2584 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2586 case TARGET_OBJECT_AUXV
:
2587 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
2588 offset
, len
, xfered_len
);
2591 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2592 readbuf
, writebuf
, offset
, len
,
2597 /* Helper for procfs_xfer_partial that handles memory transfers.
2598 Arguments are like target_xfer_partial. */
2600 static enum target_xfer_status
2601 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2602 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2607 /* Find procinfo for main process. */
2608 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2609 if (pi
->as_fd
== 0 &&
2610 open_procinfo_files (pi
, FD_AS
) == 0)
2612 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
2613 return TARGET_XFER_E_IO
;
2616 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
2617 return TARGET_XFER_E_IO
;
2619 if (writebuf
!= NULL
)
2621 PROCFS_NOTE ("write memory:\n");
2622 nbytes
= write (pi
->as_fd
, writebuf
, len
);
2626 PROCFS_NOTE ("read memory:\n");
2627 nbytes
= read (pi
->as_fd
, readbuf
, len
);
2630 return TARGET_XFER_E_IO
;
2631 *xfered_len
= nbytes
;
2632 return TARGET_XFER_OK
;
2635 /* Called by target_resume before making child runnable. Mark cached
2636 registers and status's invalid. If there are "dirty" caches that
2637 need to be written back to the child process, do that.
2639 File descriptors are also cached. As they are a limited resource,
2640 we cannot hold onto them indefinitely. However, as they are
2641 expensive to open, we don't want to throw them away
2642 indescriminately either. As a compromise, we will keep the file
2643 descriptors for the parent process, but discard any file
2644 descriptors we may have accumulated for the threads.
2646 As this function is called by iterate_over_threads, it always
2647 returns zero (so that iterate_over_threads will keep
2651 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
2653 /* About to run the child; invalidate caches and do any other
2657 if (pi
->gregs_dirty
)
2658 if (parent
== NULL
||
2659 proc_get_current_thread (parent
) != pi
->tid
)
2660 if (!proc_set_gregs (pi
)) /* flush gregs cache */
2661 proc_warn (pi
, "target_resume, set_gregs",
2663 if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
2664 if (pi
->fpregs_dirty
)
2665 if (parent
== NULL
||
2666 proc_get_current_thread (parent
) != pi
->tid
)
2667 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
2668 proc_warn (pi
, "target_resume, set_fpregs",
2674 /* The presence of a parent indicates that this is an LWP.
2675 Close any file descriptors that it might have open.
2676 We don't do this to the master (parent) procinfo. */
2678 close_procinfo_files (pi
);
2680 pi
->gregs_valid
= 0;
2681 pi
->fpregs_valid
= 0;
2683 pi
->gregs_dirty
= 0;
2684 pi
->fpregs_dirty
= 0;
2686 pi
->status_valid
= 0;
2687 pi
->threads_valid
= 0;
2693 /* A callback function for iterate_over_threads. Find the
2694 asynchronous signal thread, and make it runnable. See if that
2695 helps matters any. */
2698 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
2701 if (proc_flags (pi
) & PR_ASLWP
)
2703 if (!proc_run_process (pi
, 0, -1))
2704 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
2712 /* Make the child process runnable. Normally we will then call
2713 procfs_wait and wait for it to stop again (unless gdb is async).
2715 If STEP is true, then arrange for the child to stop again after
2716 executing a single instruction. If SIGNO is zero, then cancel any
2717 pending signal; if non-zero, then arrange for the indicated signal
2718 to be delivered to the child when it runs. If PID is -1, then
2719 allow any child thread to run; if non-zero, then allow only the
2720 indicated thread to run. (not implemented yet). */
2723 procfs_resume (struct target_ops
*ops
,
2724 ptid_t ptid
, int step
, enum gdb_signal signo
)
2726 procinfo
*pi
, *thread
;
2730 prrun.prflags |= PRSVADDR;
2731 prrun.pr_vaddr = $PC; set resume address
2732 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
2733 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
2734 prrun.prflags |= PRCFAULT; clear current fault.
2736 PRSTRACE and PRSFAULT can be done by other means
2737 (proc_trace_signals, proc_trace_faults)
2738 PRSVADDR is unnecessary.
2739 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
2740 This basically leaves PRSTEP and PRCSIG.
2741 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
2742 So basically PR_STEP is the sole argument that must be passed
2743 to proc_run_process (for use in the prrun struct by ioctl). */
2745 /* Find procinfo for main process. */
2746 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2748 /* First cut: ignore pid argument. */
2751 /* Convert signal to host numbering. */
2753 (signo
== GDB_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
2756 native_signo
= gdb_signal_to_host (signo
);
2758 pi
->ignore_next_sigstop
= 0;
2760 /* Running the process voids all cached registers and status. */
2761 /* Void the threads' caches first. */
2762 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
2763 /* Void the process procinfo's caches. */
2764 invalidate_cache (NULL
, pi
, NULL
);
2766 if (ptid_get_pid (ptid
) != -1)
2768 /* Resume a specific thread, presumably suppressing the
2770 thread
= find_procinfo (ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
2773 if (thread
->tid
!= 0)
2775 /* We're to resume a specific thread, and not the
2776 others. Set the child process's PR_ASYNC flag. */
2777 if (!proc_set_async (pi
))
2778 proc_error (pi
, "target_resume, set_async", __LINE__
);
2780 proc_iterate_over_threads (pi
,
2781 make_signal_thread_runnable
,
2784 pi
= thread
; /* Substitute the thread's procinfo
2790 if (!proc_run_process (pi
, step
, native_signo
))
2793 warning (_("resume: target already running. "
2794 "Pretend to resume, and hope for the best!"));
2796 proc_error (pi
, "target_resume", __LINE__
);
2800 /* Set up to trace signals in the child process. */
2803 procfs_pass_signals (struct target_ops
*self
,
2804 int numsigs
, unsigned char *pass_signals
)
2807 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2810 prfillset (&signals
);
2812 for (signo
= 0; signo
< NSIG
; signo
++)
2814 int target_signo
= gdb_signal_from_host (signo
);
2815 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
2816 prdelset (&signals
, signo
);
2819 if (!proc_set_traced_signals (pi
, &signals
))
2820 proc_error (pi
, "pass_signals", __LINE__
);
2823 /* Print status information about the child process. */
2826 procfs_files_info (struct target_ops
*ignore
)
2828 struct inferior
*inf
= current_inferior ();
2830 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
2831 inf
->attach_flag
? "attached": "child",
2832 target_pid_to_str (inferior_ptid
));
2835 /* Make it die. Wait for it to die. Clean up after it. Note: this
2836 should only be applied to the real process, not to an LWP, because
2837 of the check for parent-process. If we need this to work for an
2838 LWP, it needs some more logic. */
2841 unconditionally_kill_inferior (procinfo
*pi
)
2845 parent_pid
= proc_parent_pid (pi
);
2846 if (!proc_kill (pi
, SIGKILL
))
2847 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
2848 destroy_procinfo (pi
);
2850 /* If pi is GDB's child, wait for it to die. */
2851 if (parent_pid
== getpid ())
2852 /* FIXME: should we use waitpid to make sure we get the right event?
2853 Should we check the returned event? */
2858 ret
= waitpid (pi
->pid
, &status
, 0);
2865 /* We're done debugging it, and we want it to go away. Then we want
2866 GDB to forget all about it. */
2869 procfs_kill_inferior (struct target_ops
*ops
)
2871 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
2873 /* Find procinfo for main process. */
2874 procinfo
*pi
= find_procinfo (ptid_get_pid (inferior_ptid
), 0);
2877 unconditionally_kill_inferior (pi
);
2878 target_mourn_inferior (inferior_ptid
);
2882 /* Forget we ever debugged this thing! */
2885 procfs_mourn_inferior (struct target_ops
*ops
)
2889 if (!ptid_equal (inferior_ptid
, null_ptid
))
2891 /* Find procinfo for main process. */
2892 pi
= find_procinfo (ptid_get_pid (inferior_ptid
), 0);
2894 destroy_procinfo (pi
);
2897 generic_mourn_inferior ();
2899 inf_child_maybe_unpush_target (ops
);
2902 /* When GDB forks to create a runnable inferior process, this function
2903 is called on the parent side of the fork. It's job is to do
2904 whatever is necessary to make the child ready to be debugged, and
2905 then wait for the child to synchronize. */
2908 procfs_init_inferior (struct target_ops
*ops
, int pid
)
2915 /* This routine called on the parent side (GDB side)
2916 after GDB forks the inferior. */
2917 if (!target_is_pushed (ops
))
2920 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
2921 perror (_("procfs: out of memory in 'init_inferior'"));
2923 if (!open_procinfo_files (pi
, FD_CTL
))
2924 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
2928 open_procinfo_files // done
2931 procfs_notice_signals
2938 /* If not stopped yet, wait for it to stop. */
2939 if (!(proc_flags (pi
) & PR_STOPPED
) &&
2940 !(proc_wait_for_stop (pi
)))
2941 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
2943 /* Save some of the /proc state to be restored if we detach. */
2944 /* FIXME: Why? In case another debugger was debugging it?
2945 We're it's parent, for Ghu's sake! */
2946 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
2947 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
2948 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
2949 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
2950 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
2951 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
2952 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
2953 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
2954 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
2955 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
2957 if ((fail
= procfs_debug_inferior (pi
)) != 0)
2958 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
2960 /* FIXME: logically, we should really be turning OFF run-on-last-close,
2961 and possibly even turning ON kill-on-last-close at this point. But
2962 I can't make that change without careful testing which I don't have
2963 time to do right now... */
2964 /* Turn on run-on-last-close flag so that the child
2965 will die if GDB goes away for some reason. */
2966 if (!proc_set_run_on_last_close (pi
))
2967 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
2969 /* We now have have access to the lwpid of the main thread/lwp. */
2970 lwpid
= proc_get_current_thread (pi
);
2972 /* Create a procinfo for the main lwp. */
2973 create_procinfo (pid
, lwpid
);
2975 /* We already have a main thread registered in the thread table at
2976 this point, but it didn't have any lwp info yet. Notify the core
2977 about it. This changes inferior_ptid as well. */
2978 thread_change_ptid (pid_to_ptid (pid
),
2979 ptid_build (pid
, lwpid
, 0));
2981 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2984 /* When GDB forks to create a new process, this function is called on
2985 the child side of the fork before GDB exec's the user program. Its
2986 job is to make the child minimally debuggable, so that the parent
2987 GDB process can connect to the child and take over. This function
2988 should do only the minimum to make that possible, and to
2989 synchronize with the parent process. The parent process should
2990 take care of the details. */
2993 procfs_set_exec_trap (void)
2995 /* This routine called on the child side (inferior side)
2996 after GDB forks the inferior. It must use only local variables,
2997 because it may be sharing data space with its parent. */
3002 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
3003 perror_with_name (_("procfs: create_procinfo failed in child."));
3005 if (open_procinfo_files (pi
, FD_CTL
) == 0)
3007 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
3008 gdb_flush (gdb_stderr
);
3009 /* No need to call "dead_procinfo", because we're going to
3014 /* Method for tracing exec syscalls. */
3016 Not all systems with /proc have all the exec* syscalls with the same
3017 names. On the SGI, for example, there is no SYS_exec, but there
3018 *is* a SYS_execv. So, we try to account for that. */
3020 exitset
= sysset_t_alloc (pi
);
3021 premptyset (exitset
);
3023 praddset (exitset
, SYS_exec
);
3025 praddset (exitset
, SYS_execve
);
3027 if (!proc_set_traced_sysexit (pi
, exitset
))
3029 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
3030 gdb_flush (gdb_stderr
);
3034 /* FIXME: should this be done in the parent instead? */
3035 /* Turn off inherit on fork flag so that all grand-children
3036 of gdb start with tracing flags cleared. */
3037 if (!proc_unset_inherit_on_fork (pi
))
3038 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
3040 /* Turn off run on last close flag, so that the child process
3041 cannot run away just because we close our handle on it.
3042 We want it to wait for the parent to attach. */
3043 if (!proc_unset_run_on_last_close (pi
))
3044 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
3046 /* FIXME: No need to destroy the procinfo --
3047 we have our own address space, and we're about to do an exec! */
3048 /*destroy_procinfo (pi);*/
3051 /* This function is called BEFORE gdb forks the inferior process. Its
3052 only real responsibility is to set things up for the fork, and tell
3053 GDB which two functions to call after the fork (one for the parent,
3054 and one for the child).
3056 This function does a complicated search for a unix shell program,
3057 which it then uses to parse arguments and environment variables to
3058 be sent to the child. I wonder whether this code could not be
3059 abstracted out and shared with other unix targets such as
3063 procfs_create_inferior (struct target_ops
*ops
, const char *exec_file
,
3064 const std::string
&allargs
, char **env
, int from_tty
)
3066 char *shell_file
= getenv ("SHELL");
3070 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
3073 /* We will be looking down the PATH to find shell_file. If we
3074 just do this the normal way (via execlp, which operates by
3075 attempting an exec for each element of the PATH until it
3076 finds one which succeeds), then there will be an exec for
3077 each failed attempt, each of which will cause a PR_SYSEXIT
3078 stop, and we won't know how to distinguish the PR_SYSEXIT's
3079 for these failed execs with the ones for successful execs
3080 (whether the exec has succeeded is stored at that time in the
3081 carry bit or some such architecture-specific and
3082 non-ABI-specified place).
3084 So I can't think of anything better than to search the PATH
3085 now. This has several disadvantages: (1) There is a race
3086 condition; if we find a file now and it is deleted before we
3087 exec it, we lose, even if the deletion leaves a valid file
3088 further down in the PATH, (2) there is no way to know exactly
3089 what an executable (in the sense of "capable of being
3090 exec'd") file is. Using access() loses because it may lose
3091 if the caller is the superuser; failing to use it loses if
3092 there are ACLs or some such. */
3096 /* FIXME-maybe: might want "set path" command so user can change what
3097 path is used from within GDB. */
3098 const char *path
= getenv ("PATH");
3100 struct stat statbuf
;
3103 path
= "/bin:/usr/bin";
3105 tryname
= (char *) alloca (strlen (path
) + strlen (shell_file
) + 2);
3106 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
3108 p1
= strchr (p
, ':');
3113 strncpy (tryname
, p
, len
);
3114 tryname
[len
] = '\0';
3115 strcat (tryname
, "/");
3116 strcat (tryname
, shell_file
);
3117 if (access (tryname
, X_OK
) < 0)
3119 if (stat (tryname
, &statbuf
) < 0)
3121 if (!S_ISREG (statbuf
.st_mode
))
3122 /* We certainly need to reject directories. I'm not quite
3123 as sure about FIFOs, sockets, etc., but I kind of doubt
3124 that people want to exec() these things. */
3129 /* Not found. This must be an error rather than merely passing
3130 the file to execlp(), because execlp() would try all the
3131 exec()s, causing GDB to get confused. */
3132 error (_("procfs:%d -- Can't find shell %s in PATH"),
3133 __LINE__
, shell_file
);
3135 shell_file
= tryname
;
3138 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
3139 NULL
, NULL
, shell_file
, NULL
);
3141 /* We have something that executes now. We'll be running through
3142 the shell at this point (if startup-with-shell is true), but the
3143 pid shouldn't change. */
3144 add_thread_silent (pid_to_ptid (pid
));
3146 procfs_init_inferior (ops
, pid
);
3149 /* An observer for the "inferior_created" event. */
3152 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
3156 /* Callback for update_thread_list. Calls "add_thread". */
3159 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
3161 ptid_t gdb_threadid
= ptid_build (pi
->pid
, thread
->tid
, 0);
3163 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
3164 add_thread (gdb_threadid
);
3169 /* Query all the threads that the target knows about, and give them
3170 back to GDB to add to its list. */
3173 procfs_update_thread_list (struct target_ops
*ops
)
3179 /* Find procinfo for main process. */
3180 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3181 proc_update_threads (pi
);
3182 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
3185 /* Return true if the thread is still 'alive'. This guy doesn't
3186 really seem to be doing his job. Got to investigate how to tell
3187 when a thread is really gone. */
3190 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
3195 proc
= ptid_get_pid (ptid
);
3196 thread
= ptid_get_lwp (ptid
);
3197 /* If I don't know it, it ain't alive! */
3198 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
3201 /* If I can't get its status, it ain't alive!
3202 What's more, I need to forget about it! */
3203 if (!proc_get_status (pi
))
3205 destroy_procinfo (pi
);
3208 /* I couldn't have got its status if it weren't alive, so it's
3213 /* Convert PTID to a string. Returns the string in a static
3217 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3219 static char buf
[80];
3221 if (ptid_get_lwp (ptid
) == 0)
3222 sprintf (buf
, "process %d", ptid_get_pid (ptid
));
3224 sprintf (buf
, "LWP %ld", ptid_get_lwp (ptid
));
3229 /* Insert a watchpoint. */
3232 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
3238 pi
= find_procinfo_or_die (ptid_get_pid (ptid
) == -1 ?
3239 ptid_get_pid (inferior_ptid
) : ptid_get_pid (ptid
),
3242 /* Translate from GDB's flags to /proc's. */
3243 if (len
> 0) /* len == 0 means delete watchpoint. */
3245 switch (rwflag
) { /* FIXME: need an enum! */
3246 case hw_write
: /* default watchpoint (write) */
3247 pflags
= WRITE_WATCHFLAG
;
3249 case hw_read
: /* read watchpoint */
3250 pflags
= READ_WATCHFLAG
;
3252 case hw_access
: /* access watchpoint */
3253 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
3255 case hw_execute
: /* execution HW breakpoint */
3256 pflags
= EXEC_WATCHFLAG
;
3258 default: /* Something weird. Return error. */
3261 if (after
) /* Stop after r/w access is completed. */
3262 pflags
|= AFTER_WATCHFLAG
;
3265 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
3267 if (errno
== E2BIG
) /* Typical error for no resources. */
3268 return -1; /* fail */
3269 /* GDB may try to remove the same watchpoint twice.
3270 If a remove request returns no match, don't error. */
3271 if (errno
== ESRCH
&& len
== 0)
3272 return 0; /* ignore */
3273 proc_error (pi
, "set_watchpoint", __LINE__
);
3278 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
3279 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
3280 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
3283 Note: procfs_can_use_hw_breakpoint() is not yet used by all
3284 procfs.c targets due to the fact that some of them still define
3285 target_can_use_hardware_watchpoint. */
3288 procfs_can_use_hw_breakpoint (struct target_ops
*self
,
3290 int cnt
, int othertype
)
3292 /* Due to the way that proc_set_watchpoint() is implemented, host
3293 and target pointers must be of the same size. If they are not,
3294 we can't use hardware watchpoints. This limitation is due to the
3295 fact that proc_set_watchpoint() calls
3296 procfs_address_to_host_pointer(); a close inspection of
3297 procfs_address_to_host_pointer will reveal that an internal error
3298 will be generated when the host and target pointer sizes are
3300 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
3302 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
3305 /* Other tests here??? */
3310 /* Returns non-zero if process is stopped on a hardware watchpoint
3311 fault, else returns zero. */
3314 procfs_stopped_by_watchpoint (struct target_ops
*ops
)
3318 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3320 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3322 if (proc_why (pi
) == PR_FAULTED
)
3324 if (proc_what (pi
) == FLTWATCH
)
3331 /* Returns 1 if the OS knows the position of the triggered watchpoint,
3332 and sets *ADDR to that address. Returns 0 if OS cannot report that
3333 address. This function is only called if
3334 procfs_stopped_by_watchpoint returned 1, thus no further checks are
3335 done. The function also assumes that ADDR is not NULL. */
3338 procfs_stopped_data_address (struct target_ops
*targ
, CORE_ADDR
*addr
)
3342 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3343 return proc_watchpoint_address (pi
, addr
);
3347 procfs_insert_watchpoint (struct target_ops
*self
,
3348 CORE_ADDR addr
, int len
,
3349 enum target_hw_bp_type type
,
3350 struct expression
*cond
)
3352 if (!target_have_steppable_watchpoint
3353 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
3355 /* When a hardware watchpoint fires off the PC will be left at
3356 the instruction following the one which caused the
3357 watchpoint. It will *NOT* be necessary for GDB to step over
3359 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
3363 /* When a hardware watchpoint fires off the PC will be left at
3364 the instruction which caused the watchpoint. It will be
3365 necessary for GDB to step over the watchpoint. */
3366 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
3371 procfs_remove_watchpoint (struct target_ops
*self
,
3372 CORE_ADDR addr
, int len
,
3373 enum target_hw_bp_type type
,
3374 struct expression
*cond
)
3376 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
3380 procfs_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3381 CORE_ADDR addr
, int len
)
3383 /* The man page for proc(4) on Solaris 2.6 and up says that the
3384 system can support "thousands" of hardware watchpoints, but gives
3385 no method for finding out how many; It doesn't say anything about
3386 the allowed size for the watched area either. So we just tell
3392 procfs_use_watchpoints (struct target_ops
*t
)
3394 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
3395 t
->to_insert_watchpoint
= procfs_insert_watchpoint
;
3396 t
->to_remove_watchpoint
= procfs_remove_watchpoint
;
3397 t
->to_region_ok_for_hw_watchpoint
= procfs_region_ok_for_hw_watchpoint
;
3398 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
3399 t
->to_stopped_data_address
= procfs_stopped_data_address
;
3402 /* Memory Mappings Functions: */
3404 /* Call a callback function once for each mapping, passing it the
3405 mapping, an optional secondary callback function, and some optional
3406 opaque data. Quit and return the first non-zero value returned
3409 PI is the procinfo struct for the process to be mapped. FUNC is
3410 the callback function to be called by this iterator. DATA is the
3411 optional opaque data to be passed to the callback function.
3412 CHILD_FUNC is the optional secondary function pointer to be passed
3413 to the child function. Returns the first non-zero return value
3414 from the callback function, or zero. */
3417 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
3419 int (*func
) (struct prmap
*map
,
3420 find_memory_region_ftype child_func
,
3423 char pathname
[MAX_PROC_NAME_SIZE
];
3424 struct prmap
*prmaps
;
3425 struct prmap
*prmap
;
3430 /* Get the number of mappings, allocate space,
3431 and read the mappings into prmaps. */
3433 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
3435 scoped_fd
map_fd (open (pathname
, O_RDONLY
));
3436 if (map_fd
.get () < 0)
3437 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
3439 /* Use stat to determine the file size, and compute
3440 the number of prmap_t objects it contains. */
3441 if (fstat (map_fd
.get (), &sbuf
) != 0)
3442 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
3444 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
3445 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
3446 if (read (map_fd
.get (), (char *) prmaps
, nmap
* sizeof (*prmaps
))
3447 != (nmap
* sizeof (*prmaps
)))
3448 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
3450 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
3451 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
3457 /* Implements the to_find_memory_regions method. Calls an external
3458 function for each memory region.
3459 Returns the integer value returned by the callback. */
3462 find_memory_regions_callback (struct prmap
*map
,
3463 find_memory_region_ftype func
, void *data
)
3465 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
3467 (map
->pr_mflags
& MA_READ
) != 0,
3468 (map
->pr_mflags
& MA_WRITE
) != 0,
3469 (map
->pr_mflags
& MA_EXEC
) != 0,
3470 1, /* MODIFIED is unknown, pass it as true. */
3474 /* External interface. Calls a callback function once for each
3475 mapped memory region in the child process, passing as arguments:
3477 CORE_ADDR virtual_address,
3479 int read, TRUE if region is readable by the child
3480 int write, TRUE if region is writable by the child
3481 int execute TRUE if region is executable by the child.
3483 Stops iterating and returns the first non-zero value returned by
3487 proc_find_memory_regions (struct target_ops
*self
,
3488 find_memory_region_ftype func
, void *data
)
3490 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3492 return iterate_over_mappings (pi
, func
, data
,
3493 find_memory_regions_callback
);
3496 /* Returns an ascii representation of a memory mapping's flags. */
3499 mappingflags (long flags
)
3501 static char asciiflags
[8];
3503 strcpy (asciiflags
, "-------");
3504 if (flags
& MA_STACK
)
3505 asciiflags
[1] = 's';
3506 if (flags
& MA_BREAK
)
3507 asciiflags
[2] = 'b';
3508 if (flags
& MA_SHARED
)
3509 asciiflags
[3] = 's';
3510 if (flags
& MA_READ
)
3511 asciiflags
[4] = 'r';
3512 if (flags
& MA_WRITE
)
3513 asciiflags
[5] = 'w';
3514 if (flags
& MA_EXEC
)
3515 asciiflags
[6] = 'x';
3516 return (asciiflags
);
3519 /* Callback function, does the actual work for 'info proc
3523 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
3526 unsigned int pr_off
;
3528 pr_off
= (unsigned int) map
->pr_offset
;
3530 if (gdbarch_addr_bit (target_gdbarch ()) == 32)
3531 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
3532 (unsigned long) map
->pr_vaddr
,
3533 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3534 (unsigned long) map
->pr_size
,
3536 mappingflags (map
->pr_mflags
));
3538 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
3539 (unsigned long) map
->pr_vaddr
,
3540 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3541 (unsigned long) map
->pr_size
,
3543 mappingflags (map
->pr_mflags
));
3548 /* Implement the "info proc mappings" subcommand. */
3551 info_proc_mappings (procinfo
*pi
, int summary
)
3554 return; /* No output for summary mode. */
3556 printf_filtered (_("Mapped address spaces:\n\n"));
3557 if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
3558 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3565 printf_filtered (" %18s %18s %10s %10s %7s\n",
3572 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
3573 printf_filtered ("\n");
3576 /* Implement the "info proc" command. */
3579 procfs_info_proc (struct target_ops
*ops
, const char *args
,
3580 enum info_proc_what what
)
3582 struct cleanup
*old_chain
;
3583 procinfo
*process
= NULL
;
3584 procinfo
*thread
= NULL
;
3601 error (_("Not supported on this target."));
3604 old_chain
= make_cleanup (null_cleanup
, 0);
3605 gdb_argv
built_argv (args
);
3606 for (char *arg
: built_argv
)
3608 if (isdigit (arg
[0]))
3610 pid
= strtoul (arg
, &tmp
, 10);
3612 tid
= strtoul (++tmp
, NULL
, 10);
3614 else if (arg
[0] == '/')
3616 tid
= strtoul (arg
+ 1, NULL
, 10);
3620 pid
= ptid_get_pid (inferior_ptid
);
3622 error (_("No current process: you must name one."));
3625 /* Have pid, will travel.
3626 First see if it's a process we're already debugging. */
3627 process
= find_procinfo (pid
, 0);
3628 if (process
== NULL
)
3630 /* No. So open a procinfo for it, but
3631 remember to close it again when finished. */
3632 process
= create_procinfo (pid
, 0);
3633 make_cleanup (do_destroy_procinfo_cleanup
, process
);
3634 if (!open_procinfo_files (process
, FD_CTL
))
3635 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
3639 thread
= create_procinfo (pid
, tid
);
3643 printf_filtered (_("process %d flags:\n"), process
->pid
);
3644 proc_prettyprint_flags (proc_flags (process
), 1);
3645 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
3646 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
3647 if (proc_get_nthreads (process
) > 1)
3648 printf_filtered ("Process has %d threads.\n",
3649 proc_get_nthreads (process
));
3653 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
3654 proc_prettyprint_flags (proc_flags (thread
), 1);
3655 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
3656 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
3661 info_proc_mappings (process
, 0);
3664 do_cleanups (old_chain
);
3667 /* Modify the status of the system call identified by SYSCALLNUM in
3668 the set of syscalls that are currently traced/debugged.
3670 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
3671 will be updated. Otherwise, the exit syscalls set will be updated.
3673 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
3674 will be disabled. */
3677 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
3678 int mode
, int from_tty
)
3682 if (entry_or_exit
== PR_SYSENTRY
)
3683 sysset
= proc_get_traced_sysentry (pi
, NULL
);
3685 sysset
= proc_get_traced_sysexit (pi
, NULL
);
3688 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
3690 if (mode
== FLAG_SET
)
3691 praddset (sysset
, syscallnum
);
3693 prdelset (sysset
, syscallnum
);
3695 if (entry_or_exit
== PR_SYSENTRY
)
3697 if (!proc_set_traced_sysentry (pi
, sysset
))
3698 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
3702 if (!proc_set_traced_sysexit (pi
, sysset
))
3703 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
3708 proc_trace_syscalls (const char *args
, int from_tty
, int entry_or_exit
, int mode
)
3712 if (ptid_get_pid (inferior_ptid
) <= 0)
3713 error (_("you must be debugging a process to use this command."));
3715 if (args
== NULL
|| args
[0] == 0)
3716 error_no_arg (_("system call to trace"));
3718 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3719 if (isdigit (args
[0]))
3721 const int syscallnum
= atoi (args
);
3723 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
3728 proc_trace_sysentry_cmd (const char *args
, int from_tty
)
3730 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
3734 proc_trace_sysexit_cmd (const char *args
, int from_tty
)
3736 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
3740 proc_untrace_sysentry_cmd (const char *args
, int from_tty
)
3742 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
3746 proc_untrace_sysexit_cmd (const char *args
, int from_tty
)
3748 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
3752 _initialize_procfs (void)
3754 observer_attach_inferior_created (procfs_inferior_created
);
3756 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
3757 _("Give a trace of entries into the syscall."));
3758 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
3759 _("Give a trace of exits from the syscall."));
3760 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
3761 _("Cancel a trace of entries into the syscall."));
3762 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
3763 _("Cancel a trace of exits from the syscall."));
3766 /* =================== END, GDB "MODULE" =================== */
3770 /* miscellaneous stubs: */
3772 /* The following satisfy a few random symbols mostly created by the
3773 solaris threads implementation, which I will chase down later. */
3775 /* Return a pid for which we guarantee we will be able to find a
3779 procfs_first_available (void)
3781 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
3784 /* =================== GCORE .NOTE "MODULE" =================== */
3787 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
3788 char *note_data
, int *note_size
,
3789 enum gdb_signal stop_signal
)
3791 struct regcache
*regcache
= get_thread_regcache (ptid
);
3792 gdb_gregset_t gregs
;
3793 gdb_fpregset_t fpregs
;
3794 unsigned long merged_pid
;
3796 merged_pid
= ptid_get_lwp (ptid
) << 16 | ptid_get_pid (ptid
);
3798 /* This part is the old method for fetching registers.
3799 It should be replaced by the newer one using regsets
3800 once it is implemented in this platform:
3801 gdbarch_iterate_over_regset_sections(). */
3803 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3804 inferior_ptid
= ptid
;
3805 target_fetch_registers (regcache
, -1);
3807 fill_gregset (regcache
, &gregs
, -1);
3808 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
3814 fill_fpregset (regcache
, &fpregs
, -1);
3815 note_data
= (char *) elfcore_write_prfpreg (obfd
,
3824 struct procfs_corefile_thread_data
{
3828 enum gdb_signal stop_signal
;
3832 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
3834 struct procfs_corefile_thread_data
*args
3835 = (struct procfs_corefile_thread_data
*) data
;
3839 ptid_t ptid
= ptid_build (pi
->pid
, thread
->tid
, 0);
3841 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
3850 find_signalled_thread (struct thread_info
*info
, void *data
)
3852 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
3853 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
3859 static enum gdb_signal
3860 find_stop_signal (void)
3862 struct thread_info
*info
=
3863 iterate_over_threads (find_signalled_thread
, NULL
);
3866 return info
->suspend
.stop_signal
;
3868 return GDB_SIGNAL_0
;
3872 procfs_make_note_section (struct target_ops
*self
, bfd
*obfd
, int *note_size
)
3874 struct cleanup
*old_chain
;
3875 gdb_gregset_t gregs
;
3876 gdb_fpregset_t fpregs
;
3877 char fname
[16] = {'\0'};
3878 char psargs
[80] = {'\0'};
3879 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3880 char *note_data
= NULL
;
3882 struct procfs_corefile_thread_data thread_args
;
3885 enum gdb_signal stop_signal
;
3887 if (get_exec_file (0))
3889 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
3890 fname
[sizeof (fname
) - 1] = 0;
3891 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3892 psargs
[sizeof (psargs
) - 1] = 0;
3894 inf_args
= get_inferior_args ();
3895 if (inf_args
&& *inf_args
&&
3896 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
3898 strncat (psargs
, " ",
3899 sizeof (psargs
) - strlen (psargs
));
3900 strncat (psargs
, inf_args
,
3901 sizeof (psargs
) - strlen (psargs
));
3905 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
3911 stop_signal
= find_stop_signal ();
3913 fill_gregset (get_current_regcache (), &gregs
, -1);
3914 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
3915 ptid_get_pid (inferior_ptid
),
3916 stop_signal
, &gregs
);
3918 thread_args
.obfd
= obfd
;
3919 thread_args
.note_data
= note_data
;
3920 thread_args
.note_size
= note_size
;
3921 thread_args
.stop_signal
= stop_signal
;
3922 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
3924 note_data
= thread_args
.note_data
;
3926 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
3930 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
3931 "CORE", NT_AUXV
, auxv
, auxv_len
);
3937 /* =================== END GCORE .NOTE "MODULE" =================== */