1 /* Machine independent support for Solaris /proc (process file system) for GDB.
3 Copyright (C) 1999-2018 Free Software Foundation, Inc.
5 Written by Michael Snyder at Cygnus Solutions.
6 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "elf-bfd.h" /* for elfcore_write_* */
30 #include "gdbthread.h"
32 #include "inf-child.h"
33 #include "nat/fork-inferior.h"
34 #include "filestuff.h"
36 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
38 #include <sys/procfs.h>
39 #include <sys/fault.h>
40 #include <sys/syscall.h>
48 #include "observable.h"
49 #include "common/scoped_fd.h"
51 /* This module provides the interface between GDB and the
52 /proc file system, which is used on many versions of Unix
53 as a means for debuggers to control other processes.
55 /proc works by imitating a file system: you open a simulated file
56 that represents the process you wish to interact with, and perform
57 operations on that "file" in order to examine or change the state
60 The most important thing to know about /proc and this module is
61 that there are two very different interfaces to /proc:
63 One that uses the ioctl system call, and another that uses read
64 and write system calls.
66 This module supports only the Solaris version of the read/write
69 #include <sys/types.h>
70 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
72 #include <fcntl.h> /* for O_RDONLY */
73 #include <unistd.h> /* for "X_OK" */
74 #include <sys/stat.h> /* for struct stat */
76 /* Note: procfs-utils.h must be included after the above system header
77 files, because it redefines various system calls using macros.
78 This may be incompatible with the prototype declarations. */
80 #include "proc-utils.h"
82 /* Prototypes for supply_gregset etc. */
85 /* =================== TARGET_OPS "MODULE" =================== */
87 /* This module defines the GDB target vector and its methods. */
90 static enum target_xfer_status
procfs_xfer_memory (gdb_byte
*,
95 class procfs_target final
: public inf_child_target
98 void create_inferior (const char *, const std::string
&,
99 char **, int) override
;
101 void kill () override
;
103 void mourn_inferior () override
;
105 void attach (const char *, int) override
;
106 void detach (inferior
*inf
, int) override
;
108 void resume (ptid_t
, int, enum gdb_signal
) override
;
109 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
111 void fetch_registers (struct regcache
*, int) override
;
112 void store_registers (struct regcache
*, int) override
;
114 enum target_xfer_status
xfer_partial (enum target_object object
,
117 const gdb_byte
*writebuf
,
118 ULONGEST offset
, ULONGEST len
,
119 ULONGEST
*xfered_len
) override
;
121 void pass_signals (int, unsigned char *) override
;
123 void files_info () override
;
125 void update_thread_list () override
;
127 bool thread_alive (ptid_t ptid
) override
;
129 const char *pid_to_str (ptid_t
) override
;
131 char *pid_to_exec_file (int pid
) override
;
133 thread_control_capabilities
get_thread_control_capabilities () override
134 { return tc_schedlock
; }
136 /* find_memory_regions support method for gcore */
137 int find_memory_regions (find_memory_region_ftype func
, void *data
)
140 char *make_corefile_notes (bfd
*, int *) override
;
142 bool info_proc (const char *, enum info_proc_what
) override
;
144 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
145 int auxv_parse (gdb_byte
**readptr
,
146 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
150 bool stopped_by_watchpoint () override
;
152 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
153 struct expression
*) override
;
155 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
156 struct expression
*) override
;
158 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
160 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
161 bool stopped_data_address (CORE_ADDR
*) override
;
164 static procfs_target the_procfs_target
;
166 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
167 /* When GDB is built as 64-bit application on Solaris, the auxv data
168 is presented in 64-bit format. We need to provide a custom parser
171 procfs_target::auxv_parse (gdb_byte
**readptr
,
172 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
174 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
175 gdb_byte
*ptr
= *readptr
;
180 if (endptr
- ptr
< 8 * 2)
183 *typep
= extract_unsigned_integer (ptr
, 4, byte_order
);
185 /* The size of data is always 64-bit. If the application is 32-bit,
186 it will be zero extended, as expected. */
187 *valp
= extract_unsigned_integer (ptr
, 8, byte_order
);
195 /* =================== END, TARGET_OPS "MODULE" =================== */
197 /* World Unification:
199 Put any typedefs, defines etc. here that are required for the
200 unification of code that handles different versions of /proc. */
202 enum { READ_WATCHFLAG
= WA_READ
,
203 WRITE_WATCHFLAG
= WA_WRITE
,
204 EXEC_WATCHFLAG
= WA_EXEC
,
205 AFTER_WATCHFLAG
= WA_TRAPAFTER
209 /* =================== STRUCT PROCINFO "MODULE" =================== */
211 /* FIXME: this comment will soon be out of date W.R.T. threads. */
213 /* The procinfo struct is a wrapper to hold all the state information
214 concerning a /proc process. There should be exactly one procinfo
215 for each process, and since GDB currently can debug only one
216 process at a time, that means there should be only one procinfo.
217 All of the LWP's of a process can be accessed indirectly thru the
218 single process procinfo.
220 However, against the day when GDB may debug more than one process,
221 this data structure is kept in a list (which for now will hold no
222 more than one member), and many functions will have a pointer to a
223 procinfo as an argument.
225 There will be a separate procinfo structure for use by the (not yet
226 implemented) "info proc" command, so that we can print useful
227 information about any random process without interfering with the
228 inferior's procinfo information. */
230 /* format strings for /proc paths */
231 #define MAIN_PROC_NAME_FMT "/proc/%d"
232 #define CTL_PROC_NAME_FMT "/proc/%d/ctl"
233 #define AS_PROC_NAME_FMT "/proc/%d/as"
234 #define MAP_PROC_NAME_FMT "/proc/%d/map"
235 #define STATUS_PROC_NAME_FMT "/proc/%d/status"
236 #define MAX_PROC_NAME_SIZE sizeof("/proc/999999/lwp/0123456789/lwpstatus")
238 typedef struct procinfo
{
239 struct procinfo
*next
;
240 int pid
; /* Process ID */
241 int tid
; /* Thread/LWP id */
245 int ignore_next_sigstop
;
247 int ctl_fd
; /* File descriptor for /proc control file */
248 int status_fd
; /* File descriptor for /proc status file */
249 int as_fd
; /* File descriptor for /proc as file */
251 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
253 fltset_t saved_fltset
; /* Saved traced hardware fault set */
254 sigset_t saved_sigset
; /* Saved traced signal set */
255 sigset_t saved_sighold
; /* Saved held signal set */
256 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
257 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
259 pstatus_t prstatus
; /* Current process status info */
261 struct procinfo
*thread_list
;
263 int status_valid
: 1;
265 int fpregs_valid
: 1;
266 int threads_valid
: 1;
269 static char errmsg
[128]; /* shared error msg buffer */
271 /* Function prototypes for procinfo module: */
273 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
274 static procinfo
*find_procinfo (int pid
, int tid
);
275 static procinfo
*create_procinfo (int pid
, int tid
);
276 static void destroy_procinfo (procinfo
*p
);
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/%d/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
);
553 /* A deleter that calls destroy_procinfo. */
554 struct procinfo_deleter
556 void operator() (procinfo
*pi
) const
558 destroy_procinfo (pi
);
562 typedef std::unique_ptr
<procinfo
, procinfo_deleter
> procinfo_up
;
564 enum { NOKILL
, KILL
};
566 /* To be called on a non_recoverable error for a procinfo. Prints
567 error messages, optionally sends a SIGKILL to the process, then
568 destroys the data structure. */
571 dead_procinfo (procinfo
*pi
, const char *msg
, int kill_p
)
577 print_sys_errmsg (pi
->pathname
, errno
);
581 sprintf (procfile
, "process %d", pi
->pid
);
582 print_sys_errmsg (procfile
, errno
);
585 kill (pi
->pid
, SIGKILL
);
587 destroy_procinfo (pi
);
591 /* Allocate and (partially) initialize a sysset_t struct. */
594 sysset_t_alloc (procinfo
*pi
)
596 return (sysset_t
*) xmalloc (sizeof (sysset_t
));
599 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
601 /* =================== /proc "MODULE" =================== */
603 /* This "module" is the interface layer between the /proc system API
604 and the gdb target vector functions. This layer consists of access
605 functions that encapsulate each of the basic operations that we
606 need to use from the /proc API.
608 The main motivation for this layer is to hide the fact that there
609 are two very different implementations of the /proc API. Rather
610 than have a bunch of #ifdefs all thru the gdb target vector
611 functions, we do our best to hide them all in here. */
613 static long proc_flags (procinfo
*pi
);
614 static int proc_why (procinfo
*pi
);
615 static int proc_what (procinfo
*pi
);
616 static int proc_set_current_signal (procinfo
*pi
, int signo
);
617 static int proc_get_current_thread (procinfo
*pi
);
618 static int proc_iterate_over_threads
620 int (*func
) (procinfo
*, procinfo
*, void *),
624 proc_warn (procinfo
*pi
, const char *func
, int line
)
626 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
627 print_sys_errmsg (errmsg
, errno
);
631 proc_error (procinfo
*pi
, const char *func
, int line
)
633 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
634 perror_with_name (errmsg
);
637 /* Updates the status struct in the procinfo. There is a 'valid'
638 flag, to let other functions know when this function needs to be
639 called (so the status is only read when it is needed). The status
640 file descriptor is also only opened when it is needed. Returns
641 non-zero for success, zero for failure. */
644 proc_get_status (procinfo
*pi
)
646 /* Status file descriptor is opened "lazily". */
647 if (pi
->status_fd
== 0 &&
648 open_procinfo_files (pi
, FD_STATUS
) == 0)
650 pi
->status_valid
= 0;
654 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
655 pi
->status_valid
= 0; /* fail */
658 /* Sigh... I have to read a different data structure,
659 depending on whether this is a main process or an LWP. */
661 pi
->status_valid
= (read (pi
->status_fd
,
662 (char *) &pi
->prstatus
.pr_lwp
,
663 sizeof (lwpstatus_t
))
664 == sizeof (lwpstatus_t
));
667 pi
->status_valid
= (read (pi
->status_fd
,
668 (char *) &pi
->prstatus
,
670 == sizeof (pstatus_t
));
674 if (pi
->status_valid
)
676 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
679 proc_get_current_thread (pi
));
682 /* The status struct includes general regs, so mark them valid too. */
683 pi
->gregs_valid
= pi
->status_valid
;
684 /* In the read/write multiple-fd model, the status struct includes
685 the fp regs too, so mark them valid too. */
686 pi
->fpregs_valid
= pi
->status_valid
;
687 return pi
->status_valid
; /* True if success, false if failure. */
690 /* Returns the process flags (pr_flags field). */
693 proc_flags (procinfo
*pi
)
695 if (!pi
->status_valid
)
696 if (!proc_get_status (pi
))
697 return 0; /* FIXME: not a good failure value (but what is?) */
699 return pi
->prstatus
.pr_lwp
.pr_flags
;
702 /* Returns the pr_why field (why the process stopped). */
705 proc_why (procinfo
*pi
)
707 if (!pi
->status_valid
)
708 if (!proc_get_status (pi
))
709 return 0; /* FIXME: not a good failure value (but what is?) */
711 return pi
->prstatus
.pr_lwp
.pr_why
;
714 /* Returns the pr_what field (details of why the process stopped). */
717 proc_what (procinfo
*pi
)
719 if (!pi
->status_valid
)
720 if (!proc_get_status (pi
))
721 return 0; /* FIXME: not a good failure value (but what is?) */
723 return pi
->prstatus
.pr_lwp
.pr_what
;
726 /* This function is only called when PI is stopped by a watchpoint.
727 Assuming the OS supports it, write to *ADDR the data address which
728 triggered it and return 1. Return 0 if it is not possible to know
732 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
734 if (!pi
->status_valid
)
735 if (!proc_get_status (pi
))
738 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch (),
739 builtin_type (target_gdbarch ())->builtin_data_ptr
,
740 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
744 /* Returns the pr_nsysarg field (number of args to the current
748 proc_nsysarg (procinfo
*pi
)
750 if (!pi
->status_valid
)
751 if (!proc_get_status (pi
))
754 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
757 /* Returns the pr_sysarg field (pointer to the arguments of current
761 proc_sysargs (procinfo
*pi
)
763 if (!pi
->status_valid
)
764 if (!proc_get_status (pi
))
767 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
770 /* Set or reset any of the following process flags:
771 PR_FORK -- forked child will inherit trace flags
772 PR_RLC -- traced process runs when last /proc file closed.
773 PR_KLC -- traced process is killed when last /proc file closed.
774 PR_ASYNC -- LWP's get to run/stop independently.
776 This function is done using read/write [PCSET/PCRESET/PCUNSET].
780 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
781 mode -- 1 for set, 0 for reset.
783 Returns non-zero for success, zero for failure. */
785 enum { FLAG_RESET
, FLAG_SET
};
788 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
790 long win
= 0; /* default to fail */
792 /* These operations affect the process as a whole, and applying them
793 to an individual LWP has the same meaning as applying them to the
794 main process. Therefore, if we're ever called with a pointer to
795 an LWP's procinfo, let's substitute the process's procinfo and
796 avoid opening the LWP's file descriptor unnecessarily. */
799 pi
= find_procinfo_or_die (pi
->pid
, 0);
803 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
805 else /* Reset the flag. */
809 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
811 /* The above operation renders the procinfo's cached pstatus
813 pi
->status_valid
= 0;
816 warning (_("procfs: modify_flag failed to turn %s %s"),
817 flag
== PR_FORK
? "PR_FORK" :
818 flag
== PR_RLC
? "PR_RLC" :
819 flag
== PR_ASYNC
? "PR_ASYNC" :
820 flag
== PR_KLC
? "PR_KLC" :
822 mode
== FLAG_RESET
? "off" : "on");
827 /* Set the run_on_last_close flag. Process with all threads will
828 become runnable when debugger closes all /proc fds. Returns
829 non-zero for success, zero for failure. */
832 proc_set_run_on_last_close (procinfo
*pi
)
834 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
837 /* Reset the run_on_last_close flag. The process will NOT become
838 runnable when debugger closes its file handles. Returns non-zero
839 for success, zero for failure. */
842 proc_unset_run_on_last_close (procinfo
*pi
)
844 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
847 /* Reset inherit_on_fork flag. If the process forks a child while we
848 are registered for events in the parent, then we will NOT recieve
849 events from the child. Returns non-zero for success, zero for
853 proc_unset_inherit_on_fork (procinfo
*pi
)
855 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
858 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
859 (signal etc.), the remaining LWPs will continue to run. Returns
860 non-zero for success, zero for failure. */
863 proc_set_async (procinfo
*pi
)
865 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
868 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
869 (signal etc.), then all other LWPs will stop as well. Returns
870 non-zero for success, zero for failure. */
873 proc_unset_async (procinfo
*pi
)
875 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
878 /* Request the process/LWP to stop. Does not wait. Returns non-zero
879 for success, zero for failure. */
882 proc_stop_process (procinfo
*pi
)
886 /* We might conceivably apply this operation to an LWP, and the
887 LWP's ctl file descriptor might not be open. */
889 if (pi
->ctl_fd
== 0 &&
890 open_procinfo_files (pi
, FD_CTL
) == 0)
894 procfs_ctl_t cmd
= PCSTOP
;
896 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
902 /* Wait for the process or LWP to stop (block until it does). Returns
903 non-zero for success, zero for failure. */
906 proc_wait_for_stop (procinfo
*pi
)
910 /* We should never have to apply this operation to any procinfo
911 except the one for the main process. If that ever changes for
912 any reason, then take out the following clause and replace it
913 with one that makes sure the ctl_fd is open. */
916 pi
= find_procinfo_or_die (pi
->pid
, 0);
918 procfs_ctl_t cmd
= PCWSTOP
;
920 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
921 /* We been runnin' and we stopped -- need to update status. */
922 pi
->status_valid
= 0;
927 /* Make the process or LWP runnable.
929 Options (not all are implemented):
931 - clear current fault
932 - clear current signal
933 - abort the current system call
934 - stop as soon as finished with system call
935 - (ioctl): set traced signal set
936 - (ioctl): set held signal set
937 - (ioctl): set traced fault set
938 - (ioctl): set start pc (vaddr)
940 Always clears the current fault. PI is the process or LWP to
941 operate on. If STEP is true, set the process or LWP to trap after
942 one instruction. If SIGNO is zero, clear the current signal if
943 any; if non-zero, set the current signal to this one. Returns
944 non-zero for success, zero for failure. */
947 proc_run_process (procinfo
*pi
, int step
, int signo
)
952 /* We will probably have to apply this operation to individual
953 threads, so make sure the control file descriptor is open. */
955 if (pi
->ctl_fd
== 0 &&
956 open_procinfo_files (pi
, FD_CTL
) == 0)
961 runflags
= PRCFAULT
; /* Always clear current fault. */
966 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
967 proc_set_current_signal (pi
, signo
);
973 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
978 /* Register to trace signals in the process or LWP. Returns non-zero
979 for success, zero for failure. */
982 proc_set_traced_signals (procinfo
*pi
, sigset_t
*sigset
)
986 /* We should never have to apply this operation to any procinfo
987 except the one for the main process. If that ever changes for
988 any reason, then take out the following clause and replace it
989 with one that makes sure the ctl_fd is open. */
992 pi
= find_procinfo_or_die (pi
->pid
, 0);
996 /* Use char array to avoid alignment issues. */
997 char sigset
[sizeof (sigset_t
)];
1001 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
1003 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1005 /* The above operation renders the procinfo's cached pstatus obsolete. */
1006 pi
->status_valid
= 0;
1009 warning (_("procfs: set_traced_signals failed"));
1013 /* Register to trace hardware faults in the process or LWP. Returns
1014 non-zero for success, zero for failure. */
1017 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1021 /* We should never have to apply this operation to any procinfo
1022 except the one for the main process. If that ever changes for
1023 any reason, then take out the following clause and replace it
1024 with one that makes sure the ctl_fd is open. */
1027 pi
= find_procinfo_or_die (pi
->pid
, 0);
1031 /* Use char array to avoid alignment issues. */
1032 char fltset
[sizeof (fltset_t
)];
1036 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1038 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1040 /* The above operation renders the procinfo's cached pstatus obsolete. */
1041 pi
->status_valid
= 0;
1046 /* Register to trace entry to system calls in the process or LWP.
1047 Returns non-zero for success, zero for failure. */
1050 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1054 /* We should never have to apply this operation to any procinfo
1055 except the one for the main process. If that ever changes for
1056 any reason, then take out the following clause and replace it
1057 with one that makes sure the ctl_fd is open. */
1060 pi
= find_procinfo_or_die (pi
->pid
, 0);
1062 struct gdb_proc_ctl_pcsentry
{
1064 /* Use char array to avoid alignment issues. */
1065 char sysset
[sizeof (sysset_t
)];
1067 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
);
1069 argp
= (struct gdb_proc_ctl_pcsentry
*) xmalloc (argp_size
);
1071 argp
->cmd
= PCSENTRY
;
1072 memcpy (&argp
->sysset
, sysset
, sizeof (sysset_t
));
1074 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1077 /* The above operation renders the procinfo's cached pstatus
1079 pi
->status_valid
= 0;
1084 /* Register to trace exit from system calls in the process or LWP.
1085 Returns non-zero for success, zero for failure. */
1088 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1092 /* We should never have to apply this operation to any procinfo
1093 except the one for the main process. If that ever changes for
1094 any reason, then take out the following clause and replace it
1095 with one that makes sure the ctl_fd is open. */
1098 pi
= find_procinfo_or_die (pi
->pid
, 0);
1100 struct gdb_proc_ctl_pcsexit
{
1102 /* Use char array to avoid alignment issues. */
1103 char sysset
[sizeof (sysset_t
)];
1105 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
);
1107 argp
= (struct gdb_proc_ctl_pcsexit
*) xmalloc (argp_size
);
1109 argp
->cmd
= PCSEXIT
;
1110 memcpy (&argp
->sysset
, sysset
, sizeof (sysset_t
));
1112 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1115 /* The above operation renders the procinfo's cached pstatus
1117 pi
->status_valid
= 0;
1122 /* Specify the set of blocked / held signals in the process or LWP.
1123 Returns non-zero for success, zero for failure. */
1126 proc_set_held_signals (procinfo
*pi
, sigset_t
*sighold
)
1130 /* We should never have to apply this operation to any procinfo
1131 except the one for the main process. If that ever changes for
1132 any reason, then take out the following clause and replace it
1133 with one that makes sure the ctl_fd is open. */
1136 pi
= find_procinfo_or_die (pi
->pid
, 0);
1140 /* Use char array to avoid alignment issues. */
1141 char hold
[sizeof (sigset_t
)];
1145 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1146 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1148 /* The above operation renders the procinfo's cached pstatus
1150 pi
->status_valid
= 0;
1155 /* Returns the set of signals that are held / blocked. Will also copy
1156 the sigset if SAVE is non-zero. */
1159 proc_get_held_signals (procinfo
*pi
, sigset_t
*save
)
1161 sigset_t
*ret
= NULL
;
1163 /* We should never have to apply this operation to any procinfo
1164 except the one for the main process. If that ever changes for
1165 any reason, then take out the following clause and replace it
1166 with one that makes sure the ctl_fd is open. */
1169 pi
= find_procinfo_or_die (pi
->pid
, 0);
1171 if (!pi
->status_valid
)
1172 if (!proc_get_status (pi
))
1175 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1177 memcpy (save
, ret
, sizeof (sigset_t
));
1182 /* Returns the set of signals that are traced / debugged. Will also
1183 copy the sigset if SAVE is non-zero. */
1186 proc_get_traced_signals (procinfo
*pi
, sigset_t
*save
)
1188 sigset_t
*ret
= NULL
;
1190 /* We should never have to apply this operation to any procinfo
1191 except the one for the main process. If that ever changes for
1192 any reason, then take out the following clause and replace it
1193 with one that makes sure the ctl_fd is open. */
1196 pi
= find_procinfo_or_die (pi
->pid
, 0);
1198 if (!pi
->status_valid
)
1199 if (!proc_get_status (pi
))
1202 ret
= &pi
->prstatus
.pr_sigtrace
;
1204 memcpy (save
, ret
, sizeof (sigset_t
));
1209 /* Returns the set of hardware faults that are traced /debugged. Will
1210 also copy the faultset if SAVE is non-zero. */
1213 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
1215 fltset_t
*ret
= NULL
;
1217 /* We should never have to apply this operation to any procinfo
1218 except the one for the main process. If that ever changes for
1219 any reason, then take out the following clause and replace it
1220 with one that makes sure the ctl_fd is open. */
1223 pi
= find_procinfo_or_die (pi
->pid
, 0);
1225 if (!pi
->status_valid
)
1226 if (!proc_get_status (pi
))
1229 ret
= &pi
->prstatus
.pr_flttrace
;
1231 memcpy (save
, ret
, sizeof (fltset_t
));
1236 /* Returns the set of syscalls that are traced /debugged on entry.
1237 Will also copy the syscall set if SAVE is non-zero. */
1240 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
1242 sysset_t
*ret
= NULL
;
1244 /* We should never have to apply this operation to any procinfo
1245 except the one for the main process. If that ever changes for
1246 any reason, then take out the following clause and replace it
1247 with one that makes sure the ctl_fd is open. */
1250 pi
= find_procinfo_or_die (pi
->pid
, 0);
1252 if (!pi
->status_valid
)
1253 if (!proc_get_status (pi
))
1256 ret
= &pi
->prstatus
.pr_sysentry
;
1258 memcpy (save
, ret
, sizeof (sysset_t
));
1263 /* Returns the set of syscalls that are traced /debugged on exit.
1264 Will also copy the syscall set if SAVE is non-zero. */
1267 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
1269 sysset_t
*ret
= NULL
;
1271 /* We should never have to apply this operation to any procinfo
1272 except the one for the main process. If that ever changes for
1273 any reason, then take out the following clause and replace it
1274 with one that makes sure the ctl_fd is open. */
1277 pi
= find_procinfo_or_die (pi
->pid
, 0);
1279 if (!pi
->status_valid
)
1280 if (!proc_get_status (pi
))
1283 ret
= &pi
->prstatus
.pr_sysexit
;
1285 memcpy (save
, ret
, sizeof (sysset_t
));
1290 /* The current fault (if any) is cleared; the associated signal will
1291 not be sent to the process or LWP when it resumes. Returns
1292 non-zero for success, zero for failure. */
1295 proc_clear_current_fault (procinfo
*pi
)
1299 /* We should never have to apply this operation to any procinfo
1300 except the one for the main process. If that ever changes for
1301 any reason, then take out the following clause and replace it
1302 with one that makes sure the ctl_fd is open. */
1305 pi
= find_procinfo_or_die (pi
->pid
, 0);
1307 procfs_ctl_t cmd
= PCCFAULT
;
1309 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1314 /* Set the "current signal" that will be delivered next to the
1315 process. NOTE: semantics are different from those of KILL. This
1316 signal will be delivered to the process or LWP immediately when it
1317 is resumed (even if the signal is held/blocked); it will NOT
1318 immediately cause another event of interest, and will NOT first
1319 trap back to the debugger. Returns non-zero for success, zero for
1323 proc_set_current_signal (procinfo
*pi
, int signo
)
1328 /* Use char array to avoid alignment issues. */
1329 char sinfo
[sizeof (siginfo_t
)];
1333 struct target_waitstatus wait_status
;
1335 /* We should never have to apply this operation to any procinfo
1336 except the one for the main process. If that ever changes for
1337 any reason, then take out the following clause and replace it
1338 with one that makes sure the ctl_fd is open. */
1341 pi
= find_procinfo_or_die (pi
->pid
, 0);
1343 /* The pointer is just a type alias. */
1344 get_last_target_status (&wait_ptid
, &wait_status
);
1345 if (wait_ptid
== inferior_ptid
1346 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
1347 && wait_status
.value
.sig
== gdb_signal_from_host (signo
)
1348 && proc_get_status (pi
)
1349 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
1351 /* Use the siginfo associated with the signal being
1353 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (siginfo_t
));
1356 mysinfo
.si_signo
= signo
;
1357 mysinfo
.si_code
= 0;
1358 mysinfo
.si_pid
= getpid (); /* ?why? */
1359 mysinfo
.si_uid
= getuid (); /* ?why? */
1360 memcpy (arg
.sinfo
, &mysinfo
, sizeof (siginfo_t
));
1364 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1369 /* The current signal (if any) is cleared, and is not sent to the
1370 process or LWP when it resumes. Returns non-zero for success, zero
1374 proc_clear_current_signal (procinfo
*pi
)
1378 /* We should never have to apply this operation to any procinfo
1379 except the one for the main process. If that ever changes for
1380 any reason, then take out the following clause and replace it
1381 with one that makes sure the ctl_fd is open. */
1384 pi
= find_procinfo_or_die (pi
->pid
, 0);
1388 /* Use char array to avoid alignment issues. */
1389 char sinfo
[sizeof (siginfo_t
)];
1394 /* The pointer is just a type alias. */
1395 mysinfo
.si_signo
= 0;
1396 mysinfo
.si_code
= 0;
1397 mysinfo
.si_errno
= 0;
1398 mysinfo
.si_pid
= getpid (); /* ?why? */
1399 mysinfo
.si_uid
= getuid (); /* ?why? */
1400 memcpy (arg
.sinfo
, &mysinfo
, sizeof (siginfo_t
));
1402 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1407 /* Return the general-purpose registers for the process or LWP
1408 corresponding to PI. Upon failure, return NULL. */
1410 static gdb_gregset_t
*
1411 proc_get_gregs (procinfo
*pi
)
1413 if (!pi
->status_valid
|| !pi
->gregs_valid
)
1414 if (!proc_get_status (pi
))
1417 return &pi
->prstatus
.pr_lwp
.pr_reg
;
1420 /* Return the general-purpose registers for the process or LWP
1421 corresponding to PI. Upon failure, return NULL. */
1423 static gdb_fpregset_t
*
1424 proc_get_fpregs (procinfo
*pi
)
1426 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
1427 if (!proc_get_status (pi
))
1430 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
1433 /* Write the general-purpose registers back to the process or LWP
1434 corresponding to PI. Return non-zero for success, zero for
1438 proc_set_gregs (procinfo
*pi
)
1440 gdb_gregset_t
*gregs
;
1443 gregs
= proc_get_gregs (pi
);
1445 return 0; /* proc_get_regs has already warned. */
1447 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1455 /* Use char array to avoid alignment issues. */
1456 char gregs
[sizeof (gdb_gregset_t
)];
1460 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
1461 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1464 /* Policy: writing the registers invalidates our cache. */
1465 pi
->gregs_valid
= 0;
1469 /* Write the floating-pointer registers back to the process or LWP
1470 corresponding to PI. Return non-zero for success, zero for
1474 proc_set_fpregs (procinfo
*pi
)
1476 gdb_fpregset_t
*fpregs
;
1479 fpregs
= proc_get_fpregs (pi
);
1481 return 0; /* proc_get_fpregs has already warned. */
1483 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1491 /* Use char array to avoid alignment issues. */
1492 char fpregs
[sizeof (gdb_fpregset_t
)];
1496 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
1497 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1500 /* Policy: writing the registers invalidates our cache. */
1501 pi
->fpregs_valid
= 0;
1505 /* Send a signal to the proc or lwp with the semantics of "kill()".
1506 Returns non-zero for success, zero for failure. */
1509 proc_kill (procinfo
*pi
, int signo
)
1513 /* We might conceivably apply this operation to an LWP, and the
1514 LWP's ctl file descriptor might not be open. */
1516 if (pi
->ctl_fd
== 0 &&
1517 open_procinfo_files (pi
, FD_CTL
) == 0)
1523 procfs_ctl_t cmd
[2];
1527 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1533 /* Find the pid of the process that started this one. Returns the
1534 parent process pid, or zero. */
1537 proc_parent_pid (procinfo
*pi
)
1539 /* We should never have to apply this operation to any procinfo
1540 except the one for the main process. If that ever changes for
1541 any reason, then take out the following clause and replace it
1542 with one that makes sure the ctl_fd is open. */
1545 pi
= find_procinfo_or_die (pi
->pid
, 0);
1547 if (!pi
->status_valid
)
1548 if (!proc_get_status (pi
))
1551 return pi
->prstatus
.pr_ppid
;
1554 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
1555 (a.k.a void pointer)! */
1558 procfs_address_to_host_pointer (CORE_ADDR addr
)
1560 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
1563 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
1564 gdbarch_address_to_pointer (target_gdbarch (), ptr_type
,
1565 (gdb_byte
*) &ptr
, addr
);
1570 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
1574 char watch
[sizeof (prwatch_t
)];
1578 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
1579 convert a target address into something that can be stored in a
1580 native data structure. */
1581 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
1582 pwatch
.pr_size
= len
;
1583 pwatch
.pr_wflags
= wflags
;
1585 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
1586 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
1589 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
1591 #include <sys/sysi86.h>
1593 /* The KEY is actually the value of the lower 16 bits of the GS
1594 register for the LWP that we're interested in. Returns the
1595 matching ssh struct (LDT entry). */
1598 proc_get_LDT_entry (procinfo
*pi
, int key
)
1600 static struct ssd
*ldt_entry
= NULL
;
1601 char pathname
[MAX_PROC_NAME_SIZE
];
1603 /* Allocate space for one LDT entry.
1604 This alloc must persist, because we return a pointer to it. */
1605 if (ldt_entry
== NULL
)
1606 ldt_entry
= XNEW (struct ssd
);
1608 /* Open the file descriptor for the LDT table. */
1609 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
1610 scoped_fd
fd (open_with_retry (pathname
, O_RDONLY
));
1613 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
1617 /* Now 'read' thru the table, find a match and return it. */
1618 while (read (fd
.get (), ldt_entry
, sizeof (struct ssd
))
1619 == sizeof (struct ssd
))
1621 if (ldt_entry
->sel
== 0 &&
1622 ldt_entry
->bo
== 0 &&
1623 ldt_entry
->acc1
== 0 &&
1624 ldt_entry
->acc2
== 0)
1625 break; /* end of table */
1626 /* If key matches, return this entry. */
1627 if (ldt_entry
->sel
== key
)
1630 /* Loop ended, match not found. */
1634 /* Returns the pointer to the LDT entry of PTID. */
1637 procfs_find_LDT_entry (ptid_t ptid
)
1639 gdb_gregset_t
*gregs
;
1643 /* Find procinfo for the lwp. */
1644 if ((pi
= find_procinfo (ptid
.pid (), ptid
.lwp ())) == NULL
)
1646 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
1647 ptid
.pid (), ptid
.lwp ());
1650 /* get its general registers. */
1651 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
1653 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
1654 ptid
.pid (), ptid
.lwp ());
1657 /* Now extract the GS register's lower 16 bits. */
1658 key
= (*gregs
)[GS
] & 0xffff;
1660 /* Find the matching entry and return it. */
1661 return proc_get_LDT_entry (pi
, key
);
1666 /* =============== END, non-thread part of /proc "MODULE" =============== */
1668 /* =================== Thread "MODULE" =================== */
1670 /* NOTE: you'll see more ifdefs and duplication of functions here,
1671 since there is a different way to do threads on every OS. */
1673 /* Returns the number of threads for the process. */
1676 proc_get_nthreads (procinfo
*pi
)
1678 if (!pi
->status_valid
)
1679 if (!proc_get_status (pi
))
1682 /* Only works for the process procinfo, because the LWP procinfos do not
1683 get prstatus filled in. */
1684 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
1685 pi
= find_procinfo_or_die (pi
->pid
, 0);
1686 return pi
->prstatus
.pr_nlwp
;
1691 Return the ID of the thread that had an event of interest.
1692 (ie. the one that hit a breakpoint or other traced event). All
1693 other things being equal, this should be the ID of a thread that is
1694 currently executing. */
1697 proc_get_current_thread (procinfo
*pi
)
1699 /* Note: this should be applied to the root procinfo for the
1700 process, not to the procinfo for an LWP. If applied to the
1701 procinfo for an LWP, it will simply return that LWP's ID. In
1702 that case, find the parent process procinfo. */
1705 pi
= find_procinfo_or_die (pi
->pid
, 0);
1707 if (!pi
->status_valid
)
1708 if (!proc_get_status (pi
))
1711 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
1714 /* Discover the IDs of all the threads within the process, and create
1715 a procinfo for each of them (chained to the parent). This
1716 unfortunately requires a different method on every OS. Returns
1717 non-zero for success, zero for failure. */
1720 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
1722 if (thread
&& parent
) /* sanity */
1724 thread
->status_valid
= 0;
1725 if (!proc_get_status (thread
))
1726 destroy_one_procinfo (&parent
->thread_list
, thread
);
1728 return 0; /* keep iterating */
1732 proc_update_threads (procinfo
*pi
)
1734 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
1735 struct dirent
*direntry
;
1740 /* We should never have to apply this operation to any procinfo
1741 except the one for the main process. If that ever changes for
1742 any reason, then take out the following clause and replace it
1743 with one that makes sure the ctl_fd is open. */
1746 pi
= find_procinfo_or_die (pi
->pid
, 0);
1748 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
1750 /* Note: this brute-force method was originally devised for Unixware
1751 (support removed since), and will also work on Solaris 2.6 and
1752 2.7. The original comment mentioned the existence of a much
1753 simpler and more elegant way to do this on Solaris, but didn't
1754 point out what that was. */
1756 strcpy (pathname
, pi
->pathname
);
1757 strcat (pathname
, "/lwp");
1758 dirp
.reset (opendir (pathname
));
1760 proc_error (pi
, "update_threads, opendir", __LINE__
);
1762 while ((direntry
= readdir (dirp
.get ())) != NULL
)
1763 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
1765 lwpid
= atoi (&direntry
->d_name
[0]);
1766 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
1767 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
1769 pi
->threads_valid
= 1;
1773 /* Given a pointer to a function, call that function once for each lwp
1774 in the procinfo list, until the function returns non-zero, in which
1775 event return the value returned by the function.
1777 Note: this function does NOT call update_threads. If you want to
1778 discover new threads first, you must call that function explicitly.
1779 This function just makes a quick pass over the currently-known
1782 PI is the parent process procinfo. FUNC is the per-thread
1783 function. PTR is an opaque parameter for function. Returns the
1784 first non-zero return value from the callee, or zero. */
1787 proc_iterate_over_threads (procinfo
*pi
,
1788 int (*func
) (procinfo
*, procinfo
*, void *),
1791 procinfo
*thread
, *next
;
1794 /* We should never have to apply this operation to any procinfo
1795 except the one for the main process. If that ever changes for
1796 any reason, then take out the following clause and replace it
1797 with one that makes sure the ctl_fd is open. */
1800 pi
= find_procinfo_or_die (pi
->pid
, 0);
1802 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
1804 next
= thread
->next
; /* In case thread is destroyed. */
1805 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
1812 /* =================== END, Thread "MODULE" =================== */
1814 /* =================== END, /proc "MODULE" =================== */
1816 /* =================== GDB "MODULE" =================== */
1818 /* Here are all of the gdb target vector functions and their
1821 static ptid_t
do_attach (ptid_t ptid
);
1822 static void do_detach ();
1823 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
1824 int entry_or_exit
, int mode
, int from_tty
);
1826 /* Sets up the inferior to be debugged. Registers to trace signals,
1827 hardware faults, and syscalls. Note: does not set RLC flag: caller
1828 may want to customize that. Returns zero for success (note!
1829 unlike most functions in this module); on failure, returns the LINE
1830 NUMBER where it failed! */
1833 procfs_debug_inferior (procinfo
*pi
)
1835 fltset_t traced_faults
;
1836 sigset_t traced_signals
;
1837 sysset_t
*traced_syscall_entries
;
1838 sysset_t
*traced_syscall_exits
;
1841 /* Register to trace hardware faults in the child. */
1842 prfillset (&traced_faults
); /* trace all faults... */
1843 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
1844 if (!proc_set_traced_faults (pi
, &traced_faults
))
1847 /* Initially, register to trace all signals in the child. */
1848 prfillset (&traced_signals
);
1849 if (!proc_set_traced_signals (pi
, &traced_signals
))
1853 /* Register to trace the 'exit' system call (on entry). */
1854 traced_syscall_entries
= sysset_t_alloc (pi
);
1855 premptyset (traced_syscall_entries
);
1856 praddset (traced_syscall_entries
, SYS_exit
);
1857 praddset (traced_syscall_entries
, SYS_lwp_exit
);
1859 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
1860 xfree (traced_syscall_entries
);
1864 /* Method for tracing exec syscalls. */
1866 Not all systems with /proc have all the exec* syscalls with the same
1867 names. On the SGI, for example, there is no SYS_exec, but there
1868 *is* a SYS_execv. So, we try to account for that. */
1870 traced_syscall_exits
= sysset_t_alloc (pi
);
1871 premptyset (traced_syscall_exits
);
1873 praddset (traced_syscall_exits
, SYS_exec
);
1875 praddset (traced_syscall_exits
, SYS_execve
);
1876 praddset (traced_syscall_exits
, SYS_lwp_create
);
1877 praddset (traced_syscall_exits
, SYS_lwp_exit
);
1879 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
1880 xfree (traced_syscall_exits
);
1888 procfs_target::attach (const char *args
, int from_tty
)
1893 pid
= parse_pid_to_attach (args
);
1895 if (pid
== getpid ())
1896 error (_("Attaching GDB to itself is not a good idea..."));
1900 exec_file
= get_exec_file (0);
1903 printf_filtered (_("Attaching to program `%s', %s\n"),
1904 exec_file
, target_pid_to_str (ptid_t (pid
)));
1906 printf_filtered (_("Attaching to %s\n"),
1907 target_pid_to_str (ptid_t (pid
)));
1911 inferior_ptid
= do_attach (ptid_t (pid
));
1912 if (!target_is_pushed (this))
1917 procfs_target::detach (inferior
*inf
, int from_tty
)
1919 int pid
= inferior_ptid
.pid ();
1923 const char *exec_file
;
1925 exec_file
= get_exec_file (0);
1926 if (exec_file
== NULL
)
1929 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
1930 target_pid_to_str (ptid_t (pid
)));
1931 gdb_flush (gdb_stdout
);
1936 inferior_ptid
= null_ptid
;
1937 detach_inferior (inf
);
1938 maybe_unpush_target ();
1942 do_attach (ptid_t ptid
)
1945 struct inferior
*inf
;
1949 if ((pi
= create_procinfo (ptid
.pid (), 0)) == NULL
)
1950 perror (_("procfs: out of memory in 'attach'"));
1952 if (!open_procinfo_files (pi
, FD_CTL
))
1954 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
1955 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
1957 dead_procinfo (pi
, errmsg
, NOKILL
);
1960 /* Stop the process (if it isn't already stopped). */
1961 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
1963 pi
->was_stopped
= 1;
1964 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
1968 pi
->was_stopped
= 0;
1969 /* Set the process to run again when we close it. */
1970 if (!proc_set_run_on_last_close (pi
))
1971 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
1973 /* Now stop the process. */
1974 if (!proc_stop_process (pi
))
1975 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
1976 pi
->ignore_next_sigstop
= 1;
1978 /* Save some of the /proc state to be restored if we detach. */
1979 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
1980 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
1981 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
1982 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
1983 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
1984 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
1986 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
1987 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
1989 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
1990 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
1992 if ((fail
= procfs_debug_inferior (pi
)) != 0)
1993 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
1995 inf
= current_inferior ();
1996 inferior_appeared (inf
, pi
->pid
);
1997 /* Let GDB know that the inferior was attached. */
1998 inf
->attach_flag
= 1;
2000 /* Create a procinfo for the current lwp. */
2001 lwpid
= proc_get_current_thread (pi
);
2002 create_procinfo (pi
->pid
, lwpid
);
2004 /* Add it to gdb's thread list. */
2005 ptid
= ptid_t (pi
->pid
, lwpid
, 0);
2016 /* Find procinfo for the main process. */
2017 pi
= find_procinfo_or_die (inferior_ptid
.pid (),
2018 0); /* FIXME: threads */
2020 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
2021 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
2023 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
2024 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
2026 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
2027 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
2029 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
2030 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
2032 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
2033 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
2035 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
2036 if (!(pi
->was_stopped
)
2037 || query (_("Was stopped when attached, make it runnable again? ")))
2039 /* Clear any pending signal. */
2040 if (!proc_clear_current_fault (pi
))
2041 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
2043 if (!proc_clear_current_signal (pi
))
2044 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
2046 if (!proc_set_run_on_last_close (pi
))
2047 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
2050 destroy_procinfo (pi
);
2053 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
2056 ??? Is the following note still relevant? We can't get individual
2057 registers with the PT_GETREGS ptrace(2) request either, yet we
2058 don't bother with caching at all in that case.
2060 NOTE: Since the /proc interface cannot give us individual
2061 registers, we pay no attention to REGNUM, and just fetch them all.
2062 This results in the possibility that we will do unnecessarily many
2063 fetches, since we may be called repeatedly for individual
2064 registers. So we cache the results, and mark the cache invalid
2065 when the process is resumed. */
2068 procfs_target::fetch_registers (struct regcache
*regcache
, int regnum
)
2070 gdb_gregset_t
*gregs
;
2072 ptid_t ptid
= regcache
->ptid ();
2073 int pid
= ptid
.pid ();
2074 int tid
= ptid
.lwp ();
2075 struct gdbarch
*gdbarch
= regcache
->arch ();
2077 pi
= find_procinfo_or_die (pid
, tid
);
2080 error (_("procfs: fetch_registers failed to find procinfo for %s"),
2081 target_pid_to_str (ptid
));
2083 gregs
= proc_get_gregs (pi
);
2085 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
2087 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
2089 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2091 gdb_fpregset_t
*fpregs
;
2093 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2094 || regnum
== gdbarch_pc_regnum (gdbarch
)
2095 || regnum
== gdbarch_sp_regnum (gdbarch
))
2096 return; /* Not a floating point register. */
2098 fpregs
= proc_get_fpregs (pi
);
2100 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
2102 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
2106 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
2107 this for all registers.
2109 NOTE: Since the /proc interface will not read individual registers,
2110 we will cache these requests until the process is resumed, and only
2111 then write them back to the inferior process.
2113 FIXME: is that a really bad idea? Have to think about cases where
2114 writing one register might affect the value of others, etc. */
2117 procfs_target::store_registers (struct regcache
*regcache
, int regnum
)
2119 gdb_gregset_t
*gregs
;
2121 ptid_t ptid
= regcache
->ptid ();
2122 int pid
= ptid
.pid ();
2123 int tid
= ptid
.lwp ();
2124 struct gdbarch
*gdbarch
= regcache
->arch ();
2126 pi
= find_procinfo_or_die (pid
, tid
);
2129 error (_("procfs: store_registers: failed to find procinfo for %s"),
2130 target_pid_to_str (ptid
));
2132 gregs
= proc_get_gregs (pi
);
2134 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
2136 fill_gregset (regcache
, gregs
, regnum
);
2137 if (!proc_set_gregs (pi
))
2138 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
2140 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2142 gdb_fpregset_t
*fpregs
;
2144 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2145 || regnum
== gdbarch_pc_regnum (gdbarch
)
2146 || regnum
== gdbarch_sp_regnum (gdbarch
))
2147 return; /* Not a floating point register. */
2149 fpregs
= proc_get_fpregs (pi
);
2151 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
2153 fill_fpregset (regcache
, fpregs
, regnum
);
2154 if (!proc_set_fpregs (pi
))
2155 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
2160 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
2162 if (scall
== SYS_lwp_exit
)
2168 syscall_is_exit (procinfo
*pi
, int scall
)
2170 if (scall
== SYS_exit
)
2176 syscall_is_exec (procinfo
*pi
, int scall
)
2179 if (scall
== SYS_exec
)
2182 if (scall
== SYS_execve
)
2188 syscall_is_lwp_create (procinfo
*pi
, int scall
)
2190 if (scall
== SYS_lwp_create
)
2195 /* Retrieve the next stop event from the child process. If child has
2196 not stopped yet, wait for it to stop. Translate /proc eventcodes
2197 (or possibly wait eventcodes) into gdb internal event codes.
2198 Returns the id of process (and possibly thread) that incurred the
2199 event. Event codes are returned through a pointer parameter. */
2202 procfs_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
2205 /* First cut: loosely based on original version 2.1. */
2209 ptid_t retval
, temp_ptid
;
2210 int why
, what
, flags
;
2217 retval
= ptid_t (-1);
2219 /* Find procinfo for main process. */
2220 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
2223 /* We must assume that the status is stale now... */
2224 pi
->status_valid
= 0;
2225 pi
->gregs_valid
= 0;
2226 pi
->fpregs_valid
= 0;
2228 #if 0 /* just try this out... */
2229 flags
= proc_flags (pi
);
2230 why
= proc_why (pi
);
2231 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
2232 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
2234 /* If child is not stopped, wait for it to stop. */
2235 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
2236 !proc_wait_for_stop (pi
))
2238 /* wait_for_stop failed: has the child terminated? */
2239 if (errno
== ENOENT
)
2243 /* /proc file not found; presumably child has terminated. */
2244 wait_retval
= ::wait (&wstat
); /* "wait" for the child's exit. */
2247 if (wait_retval
!= inferior_ptid
.pid ())
2248 error (_("procfs: couldn't stop "
2249 "process %d: wait returned %d."),
2250 inferior_ptid
.pid (), wait_retval
);
2251 /* FIXME: might I not just use waitpid?
2252 Or try find_procinfo to see if I know about this child? */
2253 retval
= ptid_t (wait_retval
);
2255 else if (errno
== EINTR
)
2259 /* Unknown error from wait_for_stop. */
2260 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
2265 /* This long block is reached if either:
2266 a) the child was already stopped, or
2267 b) we successfully waited for the child with wait_for_stop.
2268 This block will analyze the /proc status, and translate it
2269 into a waitstatus for GDB.
2271 If we actually had to call wait because the /proc file
2272 is gone (child terminated), then we skip this block,
2273 because we already have a waitstatus. */
2275 flags
= proc_flags (pi
);
2276 why
= proc_why (pi
);
2277 what
= proc_what (pi
);
2279 if (flags
& (PR_STOPPED
| PR_ISTOP
))
2281 /* If it's running async (for single_thread control),
2282 set it back to normal again. */
2283 if (flags
& PR_ASYNC
)
2284 if (!proc_unset_async (pi
))
2285 proc_error (pi
, "target_wait, unset_async", __LINE__
);
2288 proc_prettyprint_why (why
, what
, 1);
2290 /* The 'pid' we will return to GDB is composed of
2291 the process ID plus the lwp ID. */
2292 retval
= ptid_t (pi
->pid
, proc_get_current_thread (pi
), 0);
2296 wstat
= (what
<< 8) | 0177;
2299 if (syscall_is_lwp_exit (pi
, what
))
2301 if (print_thread_events
)
2302 printf_unfiltered (_("[%s exited]\n"),
2303 target_pid_to_str (retval
));
2304 delete_thread (find_thread_ptid (retval
));
2305 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2308 else if (syscall_is_exit (pi
, what
))
2310 struct inferior
*inf
;
2312 /* Handle SYS_exit call only. */
2313 /* Stopped at entry to SYS_exit.
2314 Make it runnable, resume it, then use
2315 the wait system call to get its exit code.
2316 Proc_run_process always clears the current
2318 Then return its exit status. */
2319 pi
->status_valid
= 0;
2321 /* FIXME: what we should do is return
2322 TARGET_WAITKIND_SPURIOUS. */
2323 if (!proc_run_process (pi
, 0, 0))
2324 proc_error (pi
, "target_wait, run_process", __LINE__
);
2326 inf
= find_inferior_pid (pi
->pid
);
2327 if (inf
->attach_flag
)
2329 /* Don't call wait: simulate waiting for exit,
2330 return a "success" exit code. Bogus: what if
2331 it returns something else? */
2333 retval
= inferior_ptid
; /* ? ? ? */
2337 int temp
= ::wait (&wstat
);
2339 /* FIXME: shouldn't I make sure I get the right
2340 event from the right process? If (for
2341 instance) I have killed an earlier inferior
2342 process but failed to clean up after it
2343 somehow, I could get its termination event
2346 /* If wait returns -1, that's what we return
2349 retval
= ptid_t (temp
);
2354 printf_filtered (_("procfs: trapped on entry to "));
2355 proc_prettyprint_syscall (proc_what (pi
), 0);
2356 printf_filtered ("\n");
2358 long i
, nsysargs
, *sysargs
;
2360 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
2361 (sysargs
= proc_sysargs (pi
)) != NULL
)
2363 printf_filtered (_("%ld syscall arguments:\n"),
2365 for (i
= 0; i
< nsysargs
; i
++)
2366 printf_filtered ("#%ld: 0x%08lx\n",
2372 /* How to exit gracefully, returning "unknown
2374 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2375 return inferior_ptid
;
2379 /* How to keep going without returning to wfi: */
2380 target_continue_no_signal (ptid
);
2386 if (syscall_is_exec (pi
, what
))
2388 /* Hopefully this is our own "fork-child" execing
2389 the real child. Hoax this event into a trap, and
2390 GDB will see the child about to execute its start
2392 wstat
= (SIGTRAP
<< 8) | 0177;
2394 else if (syscall_is_lwp_create (pi
, what
))
2396 /* This syscall is somewhat like fork/exec. We
2397 will get the event twice: once for the parent
2398 LWP, and once for the child. We should already
2399 know about the parent LWP, but the child will
2400 be new to us. So, whenever we get this event,
2401 if it represents a new thread, simply add the
2402 thread to the list. */
2404 /* If not in procinfo list, add it. */
2405 temp_tid
= proc_get_current_thread (pi
);
2406 if (!find_procinfo (pi
->pid
, temp_tid
))
2407 create_procinfo (pi
->pid
, temp_tid
);
2409 temp_ptid
= ptid_t (pi
->pid
, temp_tid
, 0);
2410 /* If not in GDB's thread list, add it. */
2411 if (!in_thread_list (temp_ptid
))
2412 add_thread (temp_ptid
);
2414 /* Return to WFI, but tell it to immediately resume. */
2415 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2416 return inferior_ptid
;
2418 else if (syscall_is_lwp_exit (pi
, what
))
2420 if (print_thread_events
)
2421 printf_unfiltered (_("[%s exited]\n"),
2422 target_pid_to_str (retval
));
2423 delete_thread (find_thread_ptid (retval
));
2424 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2429 /* FIXME: Do we need to handle SYS_sproc,
2430 SYS_fork, or SYS_vfork here? The old procfs
2431 seemed to use this event to handle threads on
2432 older (non-LWP) systems, where I'm assuming
2433 that threads were actually separate processes.
2434 Irix, maybe? Anyway, low priority for now. */
2438 printf_filtered (_("procfs: trapped on exit from "));
2439 proc_prettyprint_syscall (proc_what (pi
), 0);
2440 printf_filtered ("\n");
2442 long i
, nsysargs
, *sysargs
;
2444 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
2445 (sysargs
= proc_sysargs (pi
)) != NULL
)
2447 printf_filtered (_("%ld syscall arguments:\n"),
2449 for (i
= 0; i
< nsysargs
; i
++)
2450 printf_filtered ("#%ld: 0x%08lx\n",
2454 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2455 return inferior_ptid
;
2460 wstat
= (SIGSTOP
<< 8) | 0177;
2465 printf_filtered (_("Retry #%d:\n"), retry
);
2466 pi
->status_valid
= 0;
2471 /* If not in procinfo list, add it. */
2472 temp_tid
= proc_get_current_thread (pi
);
2473 if (!find_procinfo (pi
->pid
, temp_tid
))
2474 create_procinfo (pi
->pid
, temp_tid
);
2476 /* If not in GDB's thread list, add it. */
2477 temp_ptid
= ptid_t (pi
->pid
, temp_tid
, 0);
2478 if (!in_thread_list (temp_ptid
))
2479 add_thread (temp_ptid
);
2481 status
->kind
= TARGET_WAITKIND_STOPPED
;
2482 status
->value
.sig
= GDB_SIGNAL_0
;
2487 wstat
= (what
<< 8) | 0177;
2492 wstat
= (SIGTRAP
<< 8) | 0177;
2494 /* FIXME: use si_signo where possible. */
2497 wstat
= (SIGILL
<< 8) | 0177;
2501 wstat
= (SIGTRAP
<< 8) | 0177;
2506 wstat
= (SIGSEGV
<< 8) | 0177;
2511 wstat
= (SIGFPE
<< 8) | 0177;
2513 case FLTPAGE
: /* Recoverable page fault */
2514 default: /* FIXME: use si_signo if possible for
2516 retval
= ptid_t (-1);
2517 printf_filtered ("procfs:%d -- ", __LINE__
);
2518 printf_filtered (_("child stopped for unknown reason:\n"));
2519 proc_prettyprint_why (why
, what
, 1);
2520 error (_("... giving up..."));
2523 break; /* case PR_FAULTED: */
2524 default: /* switch (why) unmatched */
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 /* Got this far without error: If retval isn't in the
2532 threads database, add it. */
2533 if (retval
.pid () > 0 &&
2534 retval
!= inferior_ptid
&&
2535 !in_thread_list (retval
))
2537 /* We have a new thread. We need to add it both to
2538 GDB's list and to our own. If we don't create a
2539 procinfo, resume may be unhappy later. */
2540 add_thread (retval
);
2541 if (find_procinfo (retval
.pid (),
2542 retval
.lwp ()) == NULL
)
2543 create_procinfo (retval
.pid (),
2547 else /* Flags do not indicate STOPPED. */
2549 /* surely this can't happen... */
2550 printf_filtered ("procfs:%d -- process not stopped.\n",
2552 proc_prettyprint_flags (flags
, 1);
2553 error (_("procfs: ...giving up..."));
2558 store_waitstatus (status
, wstat
);
2564 /* Perform a partial transfer to/from the specified object. For
2565 memory transfers, fall back to the old memory xfer functions. */
2567 enum target_xfer_status
2568 procfs_target::xfer_partial (enum target_object object
,
2569 const char *annex
, gdb_byte
*readbuf
,
2570 const gdb_byte
*writebuf
, ULONGEST offset
,
2571 ULONGEST len
, ULONGEST
*xfered_len
)
2575 case TARGET_OBJECT_MEMORY
:
2576 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2578 case TARGET_OBJECT_AUXV
:
2579 return memory_xfer_auxv (this, object
, annex
, readbuf
, writebuf
,
2580 offset
, len
, xfered_len
);
2583 return this->beneath ()->xfer_partial (object
, annex
,
2584 readbuf
, writebuf
, offset
, len
,
2589 /* Helper for procfs_xfer_partial that handles memory transfers.
2590 Arguments are like target_xfer_partial. */
2592 static enum target_xfer_status
2593 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2594 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2599 /* Find procinfo for main process. */
2600 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
2601 if (pi
->as_fd
== 0 &&
2602 open_procinfo_files (pi
, FD_AS
) == 0)
2604 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
2605 return TARGET_XFER_E_IO
;
2608 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
2609 return TARGET_XFER_E_IO
;
2611 if (writebuf
!= NULL
)
2613 PROCFS_NOTE ("write memory:\n");
2614 nbytes
= write (pi
->as_fd
, writebuf
, len
);
2618 PROCFS_NOTE ("read memory:\n");
2619 nbytes
= read (pi
->as_fd
, readbuf
, len
);
2622 return TARGET_XFER_E_IO
;
2623 *xfered_len
= nbytes
;
2624 return TARGET_XFER_OK
;
2627 /* Called by target_resume before making child runnable. Mark cached
2628 registers and status's invalid. If there are "dirty" caches that
2629 need to be written back to the child process, do that.
2631 File descriptors are also cached. As they are a limited resource,
2632 we cannot hold onto them indefinitely. However, as they are
2633 expensive to open, we don't want to throw them away
2634 indescriminately either. As a compromise, we will keep the file
2635 descriptors for the parent process, but discard any file
2636 descriptors we may have accumulated for the threads.
2638 As this function is called by iterate_over_threads, it always
2639 returns zero (so that iterate_over_threads will keep
2643 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
2645 /* About to run the child; invalidate caches and do any other
2649 if (pi
->gregs_dirty
)
2650 if (parent
== NULL
||
2651 proc_get_current_thread (parent
) != pi
->tid
)
2652 if (!proc_set_gregs (pi
)) /* flush gregs cache */
2653 proc_warn (pi
, "target_resume, set_gregs",
2655 if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
2656 if (pi
->fpregs_dirty
)
2657 if (parent
== NULL
||
2658 proc_get_current_thread (parent
) != pi
->tid
)
2659 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
2660 proc_warn (pi
, "target_resume, set_fpregs",
2666 /* The presence of a parent indicates that this is an LWP.
2667 Close any file descriptors that it might have open.
2668 We don't do this to the master (parent) procinfo. */
2670 close_procinfo_files (pi
);
2672 pi
->gregs_valid
= 0;
2673 pi
->fpregs_valid
= 0;
2675 pi
->gregs_dirty
= 0;
2676 pi
->fpregs_dirty
= 0;
2678 pi
->status_valid
= 0;
2679 pi
->threads_valid
= 0;
2685 /* A callback function for iterate_over_threads. Find the
2686 asynchronous signal thread, and make it runnable. See if that
2687 helps matters any. */
2690 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
2693 if (proc_flags (pi
) & PR_ASLWP
)
2695 if (!proc_run_process (pi
, 0, -1))
2696 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
2704 /* Make the child process runnable. Normally we will then call
2705 procfs_wait and wait for it to stop again (unless gdb is async).
2707 If STEP is true, then arrange for the child to stop again after
2708 executing a single instruction. If SIGNO is zero, then cancel any
2709 pending signal; if non-zero, then arrange for the indicated signal
2710 to be delivered to the child when it runs. If PID is -1, then
2711 allow any child thread to run; if non-zero, then allow only the
2712 indicated thread to run. (not implemented yet). */
2715 procfs_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
2717 procinfo
*pi
, *thread
;
2721 prrun.prflags |= PRSVADDR;
2722 prrun.pr_vaddr = $PC; set resume address
2723 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
2724 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
2725 prrun.prflags |= PRCFAULT; clear current fault.
2727 PRSTRACE and PRSFAULT can be done by other means
2728 (proc_trace_signals, proc_trace_faults)
2729 PRSVADDR is unnecessary.
2730 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
2731 This basically leaves PRSTEP and PRCSIG.
2732 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
2733 So basically PR_STEP is the sole argument that must be passed
2734 to proc_run_process (for use in the prrun struct by ioctl). */
2736 /* Find procinfo for main process. */
2737 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
2739 /* First cut: ignore pid argument. */
2742 /* Convert signal to host numbering. */
2744 (signo
== GDB_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
2747 native_signo
= gdb_signal_to_host (signo
);
2749 pi
->ignore_next_sigstop
= 0;
2751 /* Running the process voids all cached registers and status. */
2752 /* Void the threads' caches first. */
2753 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
2754 /* Void the process procinfo's caches. */
2755 invalidate_cache (NULL
, pi
, NULL
);
2757 if (ptid
.pid () != -1)
2759 /* Resume a specific thread, presumably suppressing the
2761 thread
= find_procinfo (ptid
.pid (), ptid
.lwp ());
2764 if (thread
->tid
!= 0)
2766 /* We're to resume a specific thread, and not the
2767 others. Set the child process's PR_ASYNC flag. */
2768 if (!proc_set_async (pi
))
2769 proc_error (pi
, "target_resume, set_async", __LINE__
);
2771 proc_iterate_over_threads (pi
,
2772 make_signal_thread_runnable
,
2775 pi
= thread
; /* Substitute the thread's procinfo
2781 if (!proc_run_process (pi
, step
, native_signo
))
2784 warning (_("resume: target already running. "
2785 "Pretend to resume, and hope for the best!"));
2787 proc_error (pi
, "target_resume", __LINE__
);
2791 /* Set up to trace signals in the child process. */
2794 procfs_target::pass_signals (int numsigs
, unsigned char *pass_signals
)
2797 procinfo
*pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
2800 prfillset (&signals
);
2802 for (signo
= 0; signo
< NSIG
; signo
++)
2804 int target_signo
= gdb_signal_from_host (signo
);
2805 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
2806 prdelset (&signals
, signo
);
2809 if (!proc_set_traced_signals (pi
, &signals
))
2810 proc_error (pi
, "pass_signals", __LINE__
);
2813 /* Print status information about the child process. */
2816 procfs_target::files_info ()
2818 struct inferior
*inf
= current_inferior ();
2820 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
2821 inf
->attach_flag
? "attached": "child",
2822 target_pid_to_str (inferior_ptid
));
2825 /* Make it die. Wait for it to die. Clean up after it. Note: this
2826 should only be applied to the real process, not to an LWP, because
2827 of the check for parent-process. If we need this to work for an
2828 LWP, it needs some more logic. */
2831 unconditionally_kill_inferior (procinfo
*pi
)
2835 parent_pid
= proc_parent_pid (pi
);
2836 if (!proc_kill (pi
, SIGKILL
))
2837 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
2838 destroy_procinfo (pi
);
2840 /* If pi is GDB's child, wait for it to die. */
2841 if (parent_pid
== getpid ())
2842 /* FIXME: should we use waitpid to make sure we get the right event?
2843 Should we check the returned event? */
2848 ret
= waitpid (pi
->pid
, &status
, 0);
2855 /* We're done debugging it, and we want it to go away. Then we want
2856 GDB to forget all about it. */
2859 procfs_target::kill ()
2861 if (inferior_ptid
!= null_ptid
) /* ? */
2863 /* Find procinfo for main process. */
2864 procinfo
*pi
= find_procinfo (inferior_ptid
.pid (), 0);
2867 unconditionally_kill_inferior (pi
);
2868 target_mourn_inferior (inferior_ptid
);
2872 /* Forget we ever debugged this thing! */
2875 procfs_target::mourn_inferior ()
2879 if (inferior_ptid
!= null_ptid
)
2881 /* Find procinfo for main process. */
2882 pi
= find_procinfo (inferior_ptid
.pid (), 0);
2884 destroy_procinfo (pi
);
2887 generic_mourn_inferior ();
2889 maybe_unpush_target ();
2892 /* When GDB forks to create a runnable inferior process, this function
2893 is called on the parent side of the fork. It's job is to do
2894 whatever is necessary to make the child ready to be debugged, and
2895 then wait for the child to synchronize. */
2898 procfs_init_inferior (struct target_ops
*ops
, int pid
)
2904 /* This routine called on the parent side (GDB side)
2905 after GDB forks the inferior. */
2906 if (!target_is_pushed (ops
))
2909 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
2910 perror (_("procfs: out of memory in 'init_inferior'"));
2912 if (!open_procinfo_files (pi
, FD_CTL
))
2913 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
2917 open_procinfo_files // done
2920 procfs_notice_signals
2927 /* If not stopped yet, wait for it to stop. */
2928 if (!(proc_flags (pi
) & PR_STOPPED
) &&
2929 !(proc_wait_for_stop (pi
)))
2930 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
2932 /* Save some of the /proc state to be restored if we detach. */
2933 /* FIXME: Why? In case another debugger was debugging it?
2934 We're it's parent, for Ghu's sake! */
2935 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
2936 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
2937 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
2938 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
2939 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
2940 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
2941 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
2942 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
2943 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
2944 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
2946 if ((fail
= procfs_debug_inferior (pi
)) != 0)
2947 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
2949 /* FIXME: logically, we should really be turning OFF run-on-last-close,
2950 and possibly even turning ON kill-on-last-close at this point. But
2951 I can't make that change without careful testing which I don't have
2952 time to do right now... */
2953 /* Turn on run-on-last-close flag so that the child
2954 will die if GDB goes away for some reason. */
2955 if (!proc_set_run_on_last_close (pi
))
2956 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
2958 /* We now have have access to the lwpid of the main thread/lwp. */
2959 lwpid
= proc_get_current_thread (pi
);
2961 /* Create a procinfo for the main lwp. */
2962 create_procinfo (pid
, lwpid
);
2964 /* We already have a main thread registered in the thread table at
2965 this point, but it didn't have any lwp info yet. Notify the core
2966 about it. This changes inferior_ptid as well. */
2967 thread_change_ptid (ptid_t (pid
),
2968 ptid_t (pid
, lwpid
, 0));
2970 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2973 /* When GDB forks to create a new process, this function is called on
2974 the child side of the fork before GDB exec's the user program. Its
2975 job is to make the child minimally debuggable, so that the parent
2976 GDB process can connect to the child and take over. This function
2977 should do only the minimum to make that possible, and to
2978 synchronize with the parent process. The parent process should
2979 take care of the details. */
2982 procfs_set_exec_trap (void)
2984 /* This routine called on the child side (inferior side)
2985 after GDB forks the inferior. It must use only local variables,
2986 because it may be sharing data space with its parent. */
2991 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
2992 perror_with_name (_("procfs: create_procinfo failed in child."));
2994 if (open_procinfo_files (pi
, FD_CTL
) == 0)
2996 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
2997 gdb_flush (gdb_stderr
);
2998 /* No need to call "dead_procinfo", because we're going to
3003 /* Method for tracing exec syscalls. */
3005 Not all systems with /proc have all the exec* syscalls with the same
3006 names. On the SGI, for example, there is no SYS_exec, but there
3007 *is* a SYS_execv. So, we try to account for that. */
3009 exitset
= sysset_t_alloc (pi
);
3010 premptyset (exitset
);
3012 praddset (exitset
, SYS_exec
);
3014 praddset (exitset
, SYS_execve
);
3016 if (!proc_set_traced_sysexit (pi
, exitset
))
3018 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
3019 gdb_flush (gdb_stderr
);
3023 /* FIXME: should this be done in the parent instead? */
3024 /* Turn off inherit on fork flag so that all grand-children
3025 of gdb start with tracing flags cleared. */
3026 if (!proc_unset_inherit_on_fork (pi
))
3027 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
3029 /* Turn off run on last close flag, so that the child process
3030 cannot run away just because we close our handle on it.
3031 We want it to wait for the parent to attach. */
3032 if (!proc_unset_run_on_last_close (pi
))
3033 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
3035 /* FIXME: No need to destroy the procinfo --
3036 we have our own address space, and we're about to do an exec! */
3037 /*destroy_procinfo (pi);*/
3040 /* This function is called BEFORE gdb forks the inferior process. Its
3041 only real responsibility is to set things up for the fork, and tell
3042 GDB which two functions to call after the fork (one for the parent,
3043 and one for the child).
3045 This function does a complicated search for a unix shell program,
3046 which it then uses to parse arguments and environment variables to
3047 be sent to the child. I wonder whether this code could not be
3048 abstracted out and shared with other unix targets such as
3052 procfs_target::create_inferior (const char *exec_file
,
3053 const std::string
&allargs
,
3054 char **env
, int from_tty
)
3056 char *shell_file
= getenv ("SHELL");
3060 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
3063 /* We will be looking down the PATH to find shell_file. If we
3064 just do this the normal way (via execlp, which operates by
3065 attempting an exec for each element of the PATH until it
3066 finds one which succeeds), then there will be an exec for
3067 each failed attempt, each of which will cause a PR_SYSEXIT
3068 stop, and we won't know how to distinguish the PR_SYSEXIT's
3069 for these failed execs with the ones for successful execs
3070 (whether the exec has succeeded is stored at that time in the
3071 carry bit or some such architecture-specific and
3072 non-ABI-specified place).
3074 So I can't think of anything better than to search the PATH
3075 now. This has several disadvantages: (1) There is a race
3076 condition; if we find a file now and it is deleted before we
3077 exec it, we lose, even if the deletion leaves a valid file
3078 further down in the PATH, (2) there is no way to know exactly
3079 what an executable (in the sense of "capable of being
3080 exec'd") file is. Using access() loses because it may lose
3081 if the caller is the superuser; failing to use it loses if
3082 there are ACLs or some such. */
3086 /* FIXME-maybe: might want "set path" command so user can change what
3087 path is used from within GDB. */
3088 const char *path
= getenv ("PATH");
3090 struct stat statbuf
;
3093 path
= "/bin:/usr/bin";
3095 tryname
= (char *) alloca (strlen (path
) + strlen (shell_file
) + 2);
3096 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
3098 p1
= strchr (p
, ':');
3103 strncpy (tryname
, p
, len
);
3104 tryname
[len
] = '\0';
3105 strcat (tryname
, "/");
3106 strcat (tryname
, shell_file
);
3107 if (access (tryname
, X_OK
) < 0)
3109 if (stat (tryname
, &statbuf
) < 0)
3111 if (!S_ISREG (statbuf
.st_mode
))
3112 /* We certainly need to reject directories. I'm not quite
3113 as sure about FIFOs, sockets, etc., but I kind of doubt
3114 that people want to exec() these things. */
3119 /* Not found. This must be an error rather than merely passing
3120 the file to execlp(), because execlp() would try all the
3121 exec()s, causing GDB to get confused. */
3122 error (_("procfs:%d -- Can't find shell %s in PATH"),
3123 __LINE__
, shell_file
);
3125 shell_file
= tryname
;
3128 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
3129 NULL
, NULL
, shell_file
, NULL
);
3131 /* We have something that executes now. We'll be running through
3132 the shell at this point (if startup-with-shell is true), but the
3133 pid shouldn't change. */
3134 add_thread_silent (ptid_t (pid
));
3136 procfs_init_inferior (this, pid
);
3139 /* An observer for the "inferior_created" event. */
3142 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
3146 /* Callback for update_thread_list. Calls "add_thread". */
3149 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
3151 ptid_t gdb_threadid
= ptid_t (pi
->pid
, thread
->tid
, 0);
3153 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
3154 add_thread (gdb_threadid
);
3159 /* Query all the threads that the target knows about, and give them
3160 back to GDB to add to its list. */
3163 procfs_target::update_thread_list ()
3169 /* Find procinfo for main process. */
3170 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3171 proc_update_threads (pi
);
3172 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
3175 /* Return true if the thread is still 'alive'. This guy doesn't
3176 really seem to be doing his job. Got to investigate how to tell
3177 when a thread is really gone. */
3180 procfs_target::thread_alive (ptid_t ptid
)
3186 thread
= ptid
.lwp ();
3187 /* If I don't know it, it ain't alive! */
3188 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
3191 /* If I can't get its status, it ain't alive!
3192 What's more, I need to forget about it! */
3193 if (!proc_get_status (pi
))
3195 destroy_procinfo (pi
);
3198 /* I couldn't have got its status if it weren't alive, so it's
3203 /* Convert PTID to a string. Returns the string in a static
3207 procfs_target::pid_to_str (ptid_t ptid
)
3209 static char buf
[80];
3211 if (ptid
.lwp () == 0)
3212 sprintf (buf
, "process %d", ptid
.pid ());
3214 sprintf (buf
, "LWP %ld", ptid
.lwp ());
3219 /* Accepts an integer PID; Returns a string representing a file that
3220 can be opened to get the symbols for the child process. */
3223 procfs_target::pid_to_exec_file (int pid
)
3225 static char buf
[PATH_MAX
];
3226 char name
[PATH_MAX
];
3228 /* Solaris 11 introduced /proc/<proc-id>/execname. */
3229 xsnprintf (name
, PATH_MAX
, "/proc/%d/execname", pid
);
3230 scoped_fd
fd (gdb_open_cloexec (name
, O_RDONLY
, 0));
3231 if (fd
.get () < 0 || read (fd
.get (), buf
, PATH_MAX
- 1) < 0)
3233 /* If that fails, fall back to /proc/<proc-id>/path/a.out introduced in
3237 xsnprintf (name
, PATH_MAX
, "/proc/%d/path/a.out", pid
);
3238 len
= readlink (name
, buf
, PATH_MAX
- 1);
3248 /* Insert a watchpoint. */
3251 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
3257 pi
= find_procinfo_or_die (ptid
.pid () == -1 ?
3258 inferior_ptid
.pid () : ptid
.pid (),
3261 /* Translate from GDB's flags to /proc's. */
3262 if (len
> 0) /* len == 0 means delete watchpoint. */
3264 switch (rwflag
) { /* FIXME: need an enum! */
3265 case hw_write
: /* default watchpoint (write) */
3266 pflags
= WRITE_WATCHFLAG
;
3268 case hw_read
: /* read watchpoint */
3269 pflags
= READ_WATCHFLAG
;
3271 case hw_access
: /* access watchpoint */
3272 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
3274 case hw_execute
: /* execution HW breakpoint */
3275 pflags
= EXEC_WATCHFLAG
;
3277 default: /* Something weird. Return error. */
3280 if (after
) /* Stop after r/w access is completed. */
3281 pflags
|= AFTER_WATCHFLAG
;
3284 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
3286 if (errno
== E2BIG
) /* Typical error for no resources. */
3287 return -1; /* fail */
3288 /* GDB may try to remove the same watchpoint twice.
3289 If a remove request returns no match, don't error. */
3290 if (errno
== ESRCH
&& len
== 0)
3291 return 0; /* ignore */
3292 proc_error (pi
, "set_watchpoint", __LINE__
);
3297 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
3298 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
3299 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
3302 Note: procfs_can_use_hw_breakpoint() is not yet used by all
3303 procfs.c targets due to the fact that some of them still define
3304 target_can_use_hardware_watchpoint. */
3307 procfs_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int othertype
)
3309 /* Due to the way that proc_set_watchpoint() is implemented, host
3310 and target pointers must be of the same size. If they are not,
3311 we can't use hardware watchpoints. This limitation is due to the
3312 fact that proc_set_watchpoint() calls
3313 procfs_address_to_host_pointer(); a close inspection of
3314 procfs_address_to_host_pointer will reveal that an internal error
3315 will be generated when the host and target pointer sizes are
3317 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
3319 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
3322 /* Other tests here??? */
3327 /* Returns non-zero if process is stopped on a hardware watchpoint
3328 fault, else returns zero. */
3331 procfs_target::stopped_by_watchpoint ()
3335 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3337 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3339 if (proc_why (pi
) == PR_FAULTED
)
3341 if (proc_what (pi
) == FLTWATCH
)
3348 /* Returns 1 if the OS knows the position of the triggered watchpoint,
3349 and sets *ADDR to that address. Returns 0 if OS cannot report that
3350 address. This function is only called if
3351 procfs_stopped_by_watchpoint returned 1, thus no further checks are
3352 done. The function also assumes that ADDR is not NULL. */
3355 procfs_target::stopped_data_address (CORE_ADDR
*addr
)
3359 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3360 return proc_watchpoint_address (pi
, addr
);
3364 procfs_target::insert_watchpoint (CORE_ADDR addr
, int len
,
3365 enum target_hw_bp_type type
,
3366 struct expression
*cond
)
3368 if (!target_have_steppable_watchpoint
3369 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
3371 /* When a hardware watchpoint fires off the PC will be left at
3372 the instruction following the one which caused the
3373 watchpoint. It will *NOT* be necessary for GDB to step over
3375 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
3379 /* When a hardware watchpoint fires off the PC will be left at
3380 the instruction which caused the watchpoint. It will be
3381 necessary for GDB to step over the watchpoint. */
3382 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
3387 procfs_target::remove_watchpoint (CORE_ADDR addr
, int len
,
3388 enum target_hw_bp_type type
,
3389 struct expression
*cond
)
3391 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
3395 procfs_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3397 /* The man page for proc(4) on Solaris 2.6 and up says that the
3398 system can support "thousands" of hardware watchpoints, but gives
3399 no method for finding out how many; It doesn't say anything about
3400 the allowed size for the watched area either. So we just tell
3405 /* Memory Mappings Functions: */
3407 /* Call a callback function once for each mapping, passing it the
3408 mapping, an optional secondary callback function, and some optional
3409 opaque data. Quit and return the first non-zero value returned
3412 PI is the procinfo struct for the process to be mapped. FUNC is
3413 the callback function to be called by this iterator. DATA is the
3414 optional opaque data to be passed to the callback function.
3415 CHILD_FUNC is the optional secondary function pointer to be passed
3416 to the child function. Returns the first non-zero return value
3417 from the callback function, or zero. */
3420 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
3422 int (*func
) (struct prmap
*map
,
3423 find_memory_region_ftype child_func
,
3426 char pathname
[MAX_PROC_NAME_SIZE
];
3427 struct prmap
*prmaps
;
3428 struct prmap
*prmap
;
3433 /* Get the number of mappings, allocate space,
3434 and read the mappings into prmaps. */
3436 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
3438 scoped_fd
map_fd (open (pathname
, O_RDONLY
));
3439 if (map_fd
.get () < 0)
3440 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
3442 /* Use stat to determine the file size, and compute
3443 the number of prmap_t objects it contains. */
3444 if (fstat (map_fd
.get (), &sbuf
) != 0)
3445 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
3447 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
3448 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
3449 if (read (map_fd
.get (), (char *) prmaps
, nmap
* sizeof (*prmaps
))
3450 != (nmap
* sizeof (*prmaps
)))
3451 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
3453 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
3454 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
3460 /* Implements the to_find_memory_regions method. Calls an external
3461 function for each memory region.
3462 Returns the integer value returned by the callback. */
3465 find_memory_regions_callback (struct prmap
*map
,
3466 find_memory_region_ftype func
, void *data
)
3468 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
3470 (map
->pr_mflags
& MA_READ
) != 0,
3471 (map
->pr_mflags
& MA_WRITE
) != 0,
3472 (map
->pr_mflags
& MA_EXEC
) != 0,
3473 1, /* MODIFIED is unknown, pass it as true. */
3477 /* External interface. Calls a callback function once for each
3478 mapped memory region in the child process, passing as arguments:
3480 CORE_ADDR virtual_address,
3482 int read, TRUE if region is readable by the child
3483 int write, TRUE if region is writable by the child
3484 int execute TRUE if region is executable by the child.
3486 Stops iterating and returns the first non-zero value returned by
3490 procfs_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
3492 procinfo
*pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3494 return iterate_over_mappings (pi
, func
, data
,
3495 find_memory_regions_callback
);
3498 /* Returns an ascii representation of a memory mapping's flags. */
3501 mappingflags (long flags
)
3503 static char asciiflags
[8];
3505 strcpy (asciiflags
, "-------");
3506 if (flags
& MA_STACK
)
3507 asciiflags
[1] = 's';
3508 if (flags
& MA_BREAK
)
3509 asciiflags
[2] = 'b';
3510 if (flags
& MA_SHARED
)
3511 asciiflags
[3] = 's';
3512 if (flags
& MA_READ
)
3513 asciiflags
[4] = 'r';
3514 if (flags
& MA_WRITE
)
3515 asciiflags
[5] = 'w';
3516 if (flags
& MA_EXEC
)
3517 asciiflags
[6] = 'x';
3518 return (asciiflags
);
3521 /* Callback function, does the actual work for 'info proc
3525 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
3528 unsigned int pr_off
;
3530 pr_off
= (unsigned int) map
->pr_offset
;
3532 if (gdbarch_addr_bit (target_gdbarch ()) == 32)
3533 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
3534 (unsigned long) map
->pr_vaddr
,
3535 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3536 (unsigned long) map
->pr_size
,
3538 mappingflags (map
->pr_mflags
));
3540 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
3541 (unsigned long) map
->pr_vaddr
,
3542 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3543 (unsigned long) map
->pr_size
,
3545 mappingflags (map
->pr_mflags
));
3550 /* Implement the "info proc mappings" subcommand. */
3553 info_proc_mappings (procinfo
*pi
, int summary
)
3556 return; /* No output for summary mode. */
3558 printf_filtered (_("Mapped address spaces:\n\n"));
3559 if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
3560 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3567 printf_filtered (" %18s %18s %10s %10s %7s\n",
3574 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
3575 printf_filtered ("\n");
3578 /* Implement the "info proc" command. */
3581 procfs_target::info_proc (const char *args
, enum info_proc_what what
)
3583 procinfo
*process
= NULL
;
3584 procinfo
*thread
= NULL
;
3601 error (_("Not supported on this target."));
3604 gdb_argv
built_argv (args
);
3605 for (char *arg
: built_argv
)
3607 if (isdigit (arg
[0]))
3609 pid
= strtoul (arg
, &tmp
, 10);
3611 tid
= strtoul (++tmp
, NULL
, 10);
3613 else if (arg
[0] == '/')
3615 tid
= strtoul (arg
+ 1, NULL
, 10);
3619 procinfo_up temporary_procinfo
;
3621 pid
= inferior_ptid
.pid ();
3623 error (_("No current process: you must name one."));
3626 /* Have pid, will travel.
3627 First see if it's a process we're already debugging. */
3628 process
= find_procinfo (pid
, 0);
3629 if (process
== NULL
)
3631 /* No. So open a procinfo for it, but
3632 remember to close it again when finished. */
3633 process
= create_procinfo (pid
, 0);
3634 temporary_procinfo
.reset (process
);
3635 if (!open_procinfo_files (process
, FD_CTL
))
3636 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
3640 thread
= create_procinfo (pid
, tid
);
3644 printf_filtered (_("process %d flags:\n"), process
->pid
);
3645 proc_prettyprint_flags (proc_flags (process
), 1);
3646 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
3647 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
3648 if (proc_get_nthreads (process
) > 1)
3649 printf_filtered ("Process has %d threads.\n",
3650 proc_get_nthreads (process
));
3654 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
3655 proc_prettyprint_flags (proc_flags (thread
), 1);
3656 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
3657 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
3662 info_proc_mappings (process
, 0);
3668 /* Modify the status of the system call identified by SYSCALLNUM in
3669 the set of syscalls that are currently traced/debugged.
3671 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
3672 will be updated. Otherwise, the exit syscalls set will be updated.
3674 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
3675 will be disabled. */
3678 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
3679 int mode
, int from_tty
)
3683 if (entry_or_exit
== PR_SYSENTRY
)
3684 sysset
= proc_get_traced_sysentry (pi
, NULL
);
3686 sysset
= proc_get_traced_sysexit (pi
, NULL
);
3689 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
3691 if (mode
== FLAG_SET
)
3692 praddset (sysset
, syscallnum
);
3694 prdelset (sysset
, syscallnum
);
3696 if (entry_or_exit
== PR_SYSENTRY
)
3698 if (!proc_set_traced_sysentry (pi
, sysset
))
3699 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
3703 if (!proc_set_traced_sysexit (pi
, sysset
))
3704 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
3709 proc_trace_syscalls (const char *args
, int from_tty
, int entry_or_exit
, int mode
)
3713 if (inferior_ptid
.pid () <= 0)
3714 error (_("you must be debugging a process to use this command."));
3716 if (args
== NULL
|| args
[0] == 0)
3717 error_no_arg (_("system call to trace"));
3719 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3720 if (isdigit (args
[0]))
3722 const int syscallnum
= atoi (args
);
3724 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
3729 proc_trace_sysentry_cmd (const char *args
, int from_tty
)
3731 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
3735 proc_trace_sysexit_cmd (const char *args
, int from_tty
)
3737 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
3741 proc_untrace_sysentry_cmd (const char *args
, int from_tty
)
3743 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
3747 proc_untrace_sysexit_cmd (const char *args
, int from_tty
)
3749 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
3753 _initialize_procfs (void)
3755 gdb::observers::inferior_created
.attach (procfs_inferior_created
);
3757 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
3758 _("Give a trace of entries into the syscall."));
3759 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
3760 _("Give a trace of exits from the syscall."));
3761 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
3762 _("Cancel a trace of entries into the syscall."));
3763 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
3764 _("Cancel a trace of exits from the syscall."));
3766 add_inf_child_target (&the_procfs_target
);
3769 /* =================== END, GDB "MODULE" =================== */
3773 /* miscellaneous stubs: */
3775 /* The following satisfy a few random symbols mostly created by the
3776 solaris threads implementation, which I will chase down later. */
3778 /* Return a pid for which we guarantee we will be able to find a
3782 procfs_first_available (void)
3784 return ptid_t (procinfo_list
? procinfo_list
->pid
: -1);
3787 /* =================== GCORE .NOTE "MODULE" =================== */
3790 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
3791 char *note_data
, int *note_size
,
3792 enum gdb_signal stop_signal
)
3794 struct regcache
*regcache
= get_thread_regcache (ptid
);
3795 gdb_gregset_t gregs
;
3796 gdb_fpregset_t fpregs
;
3797 unsigned long merged_pid
;
3799 merged_pid
= ptid
.lwp () << 16 | ptid
.pid ();
3801 /* This part is the old method for fetching registers.
3802 It should be replaced by the newer one using regsets
3803 once it is implemented in this platform:
3804 gdbarch_iterate_over_regset_sections(). */
3806 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3807 inferior_ptid
= ptid
;
3808 target_fetch_registers (regcache
, -1);
3810 fill_gregset (regcache
, &gregs
, -1);
3811 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
3817 fill_fpregset (regcache
, &fpregs
, -1);
3818 note_data
= (char *) elfcore_write_prfpreg (obfd
,
3827 struct procfs_corefile_thread_data
{
3831 enum gdb_signal stop_signal
;
3835 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
3837 struct procfs_corefile_thread_data
*args
3838 = (struct procfs_corefile_thread_data
*) data
;
3842 ptid_t ptid
= ptid_t (pi
->pid
, thread
->tid
, 0);
3844 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
3853 find_signalled_thread (struct thread_info
*info
, void *data
)
3855 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
3856 && info
->ptid
.pid () == inferior_ptid
.pid ())
3862 static enum gdb_signal
3863 find_stop_signal (void)
3865 struct thread_info
*info
=
3866 iterate_over_threads (find_signalled_thread
, NULL
);
3869 return info
->suspend
.stop_signal
;
3871 return GDB_SIGNAL_0
;
3875 procfs_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
3877 gdb_gregset_t gregs
;
3878 char fname
[16] = {'\0'};
3879 char psargs
[80] = {'\0'};
3880 procinfo
*pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3881 char *note_data
= NULL
;
3882 const char *inf_args
;
3883 struct procfs_corefile_thread_data thread_args
;
3884 enum gdb_signal stop_signal
;
3886 if (get_exec_file (0))
3888 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
3889 fname
[sizeof (fname
) - 1] = 0;
3890 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3891 psargs
[sizeof (psargs
) - 1] = 0;
3893 inf_args
= get_inferior_args ();
3894 if (inf_args
&& *inf_args
&&
3895 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
3897 strncat (psargs
, " ",
3898 sizeof (psargs
) - strlen (psargs
));
3899 strncat (psargs
, inf_args
,
3900 sizeof (psargs
) - strlen (psargs
));
3904 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
3910 stop_signal
= find_stop_signal ();
3912 fill_gregset (get_current_regcache (), &gregs
, -1);
3913 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
3914 inferior_ptid
.pid (),
3915 stop_signal
, &gregs
);
3917 thread_args
.obfd
= obfd
;
3918 thread_args
.note_data
= note_data
;
3919 thread_args
.note_size
= note_size
;
3920 thread_args
.stop_signal
= stop_signal
;
3921 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
3923 note_data
= thread_args
.note_data
;
3925 gdb::optional
<gdb::byte_vector
> auxv
=
3926 target_read_alloc (current_top_target (), TARGET_OBJECT_AUXV
, NULL
);
3927 if (auxv
&& !auxv
->empty ())
3928 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
3929 "CORE", NT_AUXV
, auxv
->data (),
3934 /* =================== END GCORE .NOTE "MODULE" =================== */