1 /* Machine independent support for Solaris /proc (process file system) for GDB.
3 Copyright (C) 1999-2021 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"
36 #include <sys/procfs.h>
37 #include <sys/fault.h>
38 #include <sys/syscall.h>
39 #include "gdbsupport/gdb_wait.h"
45 #include "observable.h"
46 #include "gdbsupport/scoped_fd.h"
47 #include "gdbsupport/pathstuff.h"
49 /* This module provides the interface between GDB and the
50 /proc file system, which is used on many versions of Unix
51 as a means for debuggers to control other processes.
53 /proc works by imitating a file system: you open a simulated file
54 that represents the process you wish to interact with, and perform
55 operations on that "file" in order to examine or change the state
58 The most important thing to know about /proc and this module is
59 that there are two very different interfaces to /proc:
61 One that uses the ioctl system call, and another that uses read
62 and write system calls.
64 This module supports only the Solaris version of the read/write
67 #include <sys/types.h>
68 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
70 #include <fcntl.h> /* for O_RDONLY */
71 #include <unistd.h> /* for "X_OK" */
72 #include <sys/stat.h> /* for struct stat */
74 /* Note: procfs-utils.h must be included after the above system header
75 files, because it redefines various system calls using macros.
76 This may be incompatible with the prototype declarations. */
78 #include "proc-utils.h"
80 /* Prototypes for supply_gregset etc. */
83 /* =================== TARGET_OPS "MODULE" =================== */
85 /* This module defines the GDB target vector and its methods. */
88 static enum target_xfer_status
procfs_xfer_memory (gdb_byte
*,
93 class procfs_target final
: public inf_child_target
96 void create_inferior (const char *, const std::string
&,
97 char **, int) override
;
99 void kill () override
;
101 void mourn_inferior () override
;
103 void attach (const char *, int) override
;
104 void detach (inferior
*inf
, int) override
;
106 void resume (ptid_t
, int, enum gdb_signal
) override
;
107 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
109 void fetch_registers (struct regcache
*, int) override
;
110 void store_registers (struct regcache
*, int) override
;
112 enum target_xfer_status
xfer_partial (enum target_object object
,
115 const gdb_byte
*writebuf
,
116 ULONGEST offset
, ULONGEST len
,
117 ULONGEST
*xfered_len
) override
;
119 void pass_signals (gdb::array_view
<const unsigned char>) override
;
121 void files_info () override
;
123 void update_thread_list () override
;
125 bool thread_alive (ptid_t ptid
) override
;
127 std::string
pid_to_str (ptid_t
) override
;
129 char *pid_to_exec_file (int pid
) override
;
131 thread_control_capabilities
get_thread_control_capabilities () override
132 { return tc_schedlock
; }
134 /* find_memory_regions support method for gcore */
135 int find_memory_regions (find_memory_region_ftype func
, void *data
)
138 gdb::unique_xmalloc_ptr
<char> make_corefile_notes (bfd
*, int *) override
;
140 bool info_proc (const char *, enum info_proc_what
) override
;
142 #if PR_MODEL_NATIVE == PR_MODEL_LP64
143 int auxv_parse (gdb_byte
**readptr
,
144 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
148 bool stopped_by_watchpoint () override
;
150 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
151 struct expression
*) override
;
153 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
154 struct expression
*) override
;
156 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
158 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
159 bool stopped_data_address (CORE_ADDR
*) override
;
161 void procfs_init_inferior (int pid
);
164 static procfs_target the_procfs_target
;
166 #if 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 /* =================== STRUCT PROCINFO "MODULE" =================== */
199 /* FIXME: this comment will soon be out of date W.R.T. threads. */
201 /* The procinfo struct is a wrapper to hold all the state information
202 concerning a /proc process. There should be exactly one procinfo
203 for each process, and since GDB currently can debug only one
204 process at a time, that means there should be only one procinfo.
205 All of the LWP's of a process can be accessed indirectly thru the
206 single process procinfo.
208 However, against the day when GDB may debug more than one process,
209 this data structure is kept in a list (which for now will hold no
210 more than one member), and many functions will have a pointer to a
211 procinfo as an argument.
213 There will be a separate procinfo structure for use by the (not yet
214 implemented) "info proc" command, so that we can print useful
215 information about any random process without interfering with the
216 inferior's procinfo information. */
218 /* format strings for /proc paths */
219 #define CTL_PROC_NAME_FMT "/proc/%d/ctl"
220 #define AS_PROC_NAME_FMT "/proc/%d/as"
221 #define MAP_PROC_NAME_FMT "/proc/%d/map"
222 #define STATUS_PROC_NAME_FMT "/proc/%d/status"
223 #define MAX_PROC_NAME_SIZE sizeof("/proc/999999/lwp/0123456789/lwpstatus")
225 typedef struct procinfo
{
226 struct procinfo
*next
;
227 int pid
; /* Process ID */
228 int tid
; /* Thread/LWP id */
232 int ignore_next_sigstop
;
234 int ctl_fd
; /* File descriptor for /proc control file */
235 int status_fd
; /* File descriptor for /proc status file */
236 int as_fd
; /* File descriptor for /proc as file */
238 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
240 fltset_t saved_fltset
; /* Saved traced hardware fault set */
241 sigset_t saved_sigset
; /* Saved traced signal set */
242 sigset_t saved_sighold
; /* Saved held signal set */
243 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
244 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
246 pstatus_t prstatus
; /* Current process status info */
248 struct procinfo
*thread_list
;
250 int status_valid
: 1;
252 int fpregs_valid
: 1;
253 int threads_valid
: 1;
256 static char errmsg
[128]; /* shared error msg buffer */
258 /* Function prototypes for procinfo module: */
260 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
261 static procinfo
*find_procinfo (int pid
, int tid
);
262 static procinfo
*create_procinfo (int pid
, int tid
);
263 static void destroy_procinfo (procinfo
*p
);
264 static void dead_procinfo (procinfo
*p
, const char *msg
, int killp
);
265 static int open_procinfo_files (procinfo
*p
, int which
);
266 static void close_procinfo_files (procinfo
*p
);
268 static int iterate_over_mappings
269 (procinfo
*pi
, find_memory_region_ftype child_func
, void *data
,
270 int (*func
) (struct prmap
*map
, find_memory_region_ftype child_func
,
273 /* The head of the procinfo list: */
274 static procinfo
*procinfo_list
;
276 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
280 find_procinfo (int pid
, int tid
)
284 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
291 /* Don't check threads_valid. If we're updating the
292 thread_list, we want to find whatever threads are already
293 here. This means that in general it is the caller's
294 responsibility to check threads_valid and update before
295 calling find_procinfo, if the caller wants to find a new
298 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
306 /* Calls find_procinfo, but errors on failure. */
309 find_procinfo_or_die (int pid
, int tid
)
311 procinfo
*pi
= find_procinfo (pid
, tid
);
316 error (_("procfs: couldn't find pid %d "
317 "(kernel thread %d) in procinfo list."),
320 error (_("procfs: couldn't find pid %d in procinfo list."), pid
);
325 /* Wrapper for `open'. The appropriate open call is attempted; if
326 unsuccessful, it will be retried as many times as needed for the
327 EAGAIN and EINTR conditions.
329 For other conditions, retry the open a limited number of times. In
330 addition, a short sleep is imposed prior to retrying the open. The
331 reason for this sleep is to give the kernel a chance to catch up
332 and create the file in question in the event that GDB "wins" the
333 race to open a file before the kernel has created it. */
336 open_with_retry (const char *pathname
, int flags
)
338 int retries_remaining
, status
;
340 retries_remaining
= 2;
344 status
= open (pathname
, flags
);
346 if (status
>= 0 || retries_remaining
== 0)
348 else if (errno
!= EINTR
&& errno
!= EAGAIN
)
358 /* Open the file descriptor for the process or LWP. We only open the
359 control file descriptor; the others are opened lazily as needed.
360 Returns the file descriptor, or zero for failure. */
362 enum { FD_CTL
, FD_STATUS
, FD_AS
};
365 open_procinfo_files (procinfo
*pi
, int which
)
367 char tmp
[MAX_PROC_NAME_SIZE
];
370 /* This function is getting ALMOST long enough to break up into
371 several. Here is some rationale:
373 There are several file descriptors that may need to be open
374 for any given process or LWP. The ones we're interested in are:
375 - control (ctl) write-only change the state
376 - status (status) read-only query the state
377 - address space (as) read/write access memory
378 - map (map) read-only virtual addr map
379 Most of these are opened lazily as they are needed.
380 The pathnames for the 'files' for an LWP look slightly
381 different from those of a first-class process:
382 Pathnames for a process (<proc-id>):
384 /proc/<proc-id>/status
387 Pathnames for an LWP (lwp-id):
388 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
389 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
390 An LWP has no map or address space file descriptor, since
391 the memory map and address space are shared by all LWPs. */
393 /* In this case, there are several different file descriptors that
394 we might be asked to open. The control file descriptor will be
395 opened early, but the others will be opened lazily as they are
398 strcpy (tmp
, pi
->pathname
);
399 switch (which
) { /* Which file descriptor to open? */
402 strcat (tmp
, "/lwpctl");
404 strcat (tmp
, "/ctl");
405 fd
= open_with_retry (tmp
, O_WRONLY
);
412 return 0; /* There is no 'as' file descriptor for an lwp. */
414 fd
= open_with_retry (tmp
, O_RDWR
);
421 strcat (tmp
, "/lwpstatus");
423 strcat (tmp
, "/status");
424 fd
= open_with_retry (tmp
, O_RDONLY
);
430 return 0; /* unknown file descriptor */
433 return 1; /* success */
436 /* Allocate a data structure and link it into the procinfo list.
437 First tries to find a pre-existing one (FIXME: why?). Returns the
438 pointer to new procinfo struct. */
441 create_procinfo (int pid
, int tid
)
443 procinfo
*pi
, *parent
= NULL
;
445 pi
= find_procinfo (pid
, tid
);
447 return pi
; /* Already exists, nothing to do. */
449 /* Find parent before doing malloc, to save having to cleanup. */
451 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
453 doesn't exist yet? */
455 pi
= XNEW (procinfo
);
456 memset (pi
, 0, sizeof (procinfo
));
460 pi
->saved_entryset
= XNEW (sysset_t
);
461 pi
->saved_exitset
= XNEW (sysset_t
);
463 /* Chain into list. */
466 xsnprintf (pi
->pathname
, sizeof (pi
->pathname
), "/proc/%d", pid
);
467 pi
->next
= procinfo_list
;
472 xsnprintf (pi
->pathname
, sizeof (pi
->pathname
), "/proc/%d/lwp/%d",
474 pi
->next
= parent
->thread_list
;
475 parent
->thread_list
= pi
;
480 /* Close all file descriptors associated with the procinfo. */
483 close_procinfo_files (procinfo
*pi
)
489 if (pi
->status_fd
> 0)
490 close (pi
->status_fd
);
491 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
494 /* Destructor function. Close, unlink and deallocate the object. */
497 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
501 /* Step one: unlink the procinfo from its list. */
505 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
508 ptr
->next
= pi
->next
;
512 /* Step two: close any open file descriptors. */
513 close_procinfo_files (pi
);
515 /* Step three: free the memory. */
516 xfree (pi
->saved_entryset
);
517 xfree (pi
->saved_exitset
);
522 destroy_procinfo (procinfo
*pi
)
526 if (pi
->tid
!= 0) /* Destroy a thread procinfo. */
528 tmp
= find_procinfo (pi
->pid
, 0); /* Find the parent process. */
529 destroy_one_procinfo (&tmp
->thread_list
, pi
);
531 else /* Destroy a process procinfo and all its threads. */
533 /* First destroy the children, if any; */
534 while (pi
->thread_list
!= NULL
)
535 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
536 /* Then destroy the parent. Genocide!!! */
537 destroy_one_procinfo (&procinfo_list
, pi
);
541 /* A deleter that calls destroy_procinfo. */
542 struct procinfo_deleter
544 void operator() (procinfo
*pi
) const
546 destroy_procinfo (pi
);
550 typedef std::unique_ptr
<procinfo
, procinfo_deleter
> procinfo_up
;
552 enum { NOKILL
, KILL
};
554 /* To be called on a non_recoverable error for a procinfo. Prints
555 error messages, optionally sends a SIGKILL to the process, then
556 destroys the data structure. */
559 dead_procinfo (procinfo
*pi
, const char *msg
, int kill_p
)
564 print_sys_errmsg (pi
->pathname
, errno
);
567 xsnprintf (procfile
, sizeof (procfile
), "process %d", pi
->pid
);
568 print_sys_errmsg (procfile
, errno
);
571 kill (pi
->pid
, SIGKILL
);
573 destroy_procinfo (pi
);
577 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
579 /* =================== /proc "MODULE" =================== */
581 /* This "module" is the interface layer between the /proc system API
582 and the gdb target vector functions. This layer consists of access
583 functions that encapsulate each of the basic operations that we
584 need to use from the /proc API.
586 The main motivation for this layer is to hide the fact that there
587 were two very different implementations of the /proc API. */
589 static long proc_flags (procinfo
*pi
);
590 static int proc_why (procinfo
*pi
);
591 static int proc_what (procinfo
*pi
);
592 static int proc_set_current_signal (procinfo
*pi
, int signo
);
593 static int proc_get_current_thread (procinfo
*pi
);
594 static int proc_iterate_over_threads
596 int (*func
) (procinfo
*, procinfo
*, void *),
600 proc_warn (procinfo
*pi
, const char *func
, int line
)
602 xsnprintf (errmsg
, sizeof (errmsg
), "procfs: %s line %d, %s",
603 func
, line
, pi
->pathname
);
604 print_sys_errmsg (errmsg
, errno
);
608 proc_error (procinfo
*pi
, const char *func
, int line
)
610 xsnprintf (errmsg
, sizeof (errmsg
), "procfs: %s line %d, %s",
611 func
, line
, pi
->pathname
);
612 perror_with_name (errmsg
);
615 /* Updates the status struct in the procinfo. There is a 'valid'
616 flag, to let other functions know when this function needs to be
617 called (so the status is only read when it is needed). The status
618 file descriptor is also only opened when it is needed. Returns
619 non-zero for success, zero for failure. */
622 proc_get_status (procinfo
*pi
)
624 /* Status file descriptor is opened "lazily". */
625 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
627 pi
->status_valid
= 0;
631 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
632 pi
->status_valid
= 0; /* fail */
635 /* Sigh... I have to read a different data structure,
636 depending on whether this is a main process or an LWP. */
638 pi
->status_valid
= (read (pi
->status_fd
,
639 (char *) &pi
->prstatus
.pr_lwp
,
640 sizeof (lwpstatus_t
))
641 == sizeof (lwpstatus_t
));
644 pi
->status_valid
= (read (pi
->status_fd
,
645 (char *) &pi
->prstatus
,
647 == sizeof (pstatus_t
));
651 if (pi
->status_valid
)
653 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
656 proc_get_current_thread (pi
));
659 /* The status struct includes general regs, so mark them valid too. */
660 pi
->gregs_valid
= pi
->status_valid
;
661 /* In the read/write multiple-fd model, the status struct includes
662 the fp regs too, so mark them valid too. */
663 pi
->fpregs_valid
= pi
->status_valid
;
664 return pi
->status_valid
; /* True if success, false if failure. */
667 /* Returns the process flags (pr_flags field). */
670 proc_flags (procinfo
*pi
)
672 if (!pi
->status_valid
)
673 if (!proc_get_status (pi
))
674 return 0; /* FIXME: not a good failure value (but what is?) */
676 return pi
->prstatus
.pr_lwp
.pr_flags
;
679 /* Returns the pr_why field (why the process stopped). */
682 proc_why (procinfo
*pi
)
684 if (!pi
->status_valid
)
685 if (!proc_get_status (pi
))
686 return 0; /* FIXME: not a good failure value (but what is?) */
688 return pi
->prstatus
.pr_lwp
.pr_why
;
691 /* Returns the pr_what field (details of why the process stopped). */
694 proc_what (procinfo
*pi
)
696 if (!pi
->status_valid
)
697 if (!proc_get_status (pi
))
698 return 0; /* FIXME: not a good failure value (but what is?) */
700 return pi
->prstatus
.pr_lwp
.pr_what
;
703 /* This function is only called when PI is stopped by a watchpoint.
704 Assuming the OS supports it, write to *ADDR the data address which
705 triggered it and return 1. Return 0 if it is not possible to know
709 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
711 if (!pi
->status_valid
)
712 if (!proc_get_status (pi
))
715 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch (),
716 builtin_type (target_gdbarch ())->builtin_data_ptr
,
717 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
721 /* Returns the pr_nsysarg field (number of args to the current
725 proc_nsysarg (procinfo
*pi
)
727 if (!pi
->status_valid
)
728 if (!proc_get_status (pi
))
731 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
734 /* Returns the pr_sysarg field (pointer to the arguments of current
738 proc_sysargs (procinfo
*pi
)
740 if (!pi
->status_valid
)
741 if (!proc_get_status (pi
))
744 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
747 /* Set or reset any of the following process flags:
748 PR_FORK -- forked child will inherit trace flags
749 PR_RLC -- traced process runs when last /proc file closed.
750 PR_KLC -- traced process is killed when last /proc file closed.
751 PR_ASYNC -- LWP's get to run/stop independently.
753 This function is done using read/write [PCSET/PCRESET/PCUNSET].
757 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
758 mode -- 1 for set, 0 for reset.
760 Returns non-zero for success, zero for failure. */
762 enum { FLAG_RESET
, FLAG_SET
};
765 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
767 long win
= 0; /* default to fail */
769 /* These operations affect the process as a whole, and applying them
770 to an individual LWP has the same meaning as applying them to the
771 main process. Therefore, if we're ever called with a pointer to
772 an LWP's procinfo, let's substitute the process's procinfo and
773 avoid opening the LWP's file descriptor unnecessarily. */
776 pi
= find_procinfo_or_die (pi
->pid
, 0);
780 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
782 else /* Reset the flag. */
786 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
788 /* The above operation renders the procinfo's cached pstatus
790 pi
->status_valid
= 0;
793 warning (_("procfs: modify_flag failed to turn %s %s"),
794 flag
== PR_FORK
? "PR_FORK" :
795 flag
== PR_RLC
? "PR_RLC" :
796 flag
== PR_ASYNC
? "PR_ASYNC" :
797 flag
== PR_KLC
? "PR_KLC" :
799 mode
== FLAG_RESET
? "off" : "on");
804 /* Set the run_on_last_close flag. Process with all threads will
805 become runnable when debugger closes all /proc fds. Returns
806 non-zero for success, zero for failure. */
809 proc_set_run_on_last_close (procinfo
*pi
)
811 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
814 /* Reset the run_on_last_close flag. The process will NOT become
815 runnable when debugger closes its file handles. Returns non-zero
816 for success, zero for failure. */
819 proc_unset_run_on_last_close (procinfo
*pi
)
821 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
824 /* Reset inherit_on_fork flag. If the process forks a child while we
825 are registered for events in the parent, then we will NOT receive
826 events from the child. Returns non-zero for success, zero for
830 proc_unset_inherit_on_fork (procinfo
*pi
)
832 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
835 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
836 (signal etc.), the remaining LWPs will continue to run. Returns
837 non-zero for success, zero for failure. */
840 proc_set_async (procinfo
*pi
)
842 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
845 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
846 (signal etc.), then all other LWPs will stop as well. Returns
847 non-zero for success, zero for failure. */
850 proc_unset_async (procinfo
*pi
)
852 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
855 /* Request the process/LWP to stop. Does not wait. Returns non-zero
856 for success, zero for failure. */
859 proc_stop_process (procinfo
*pi
)
863 /* We might conceivably apply this operation to an LWP, and the
864 LWP's ctl file descriptor might not be open. */
866 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
870 procfs_ctl_t cmd
= PCSTOP
;
872 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
878 /* Wait for the process or LWP to stop (block until it does). Returns
879 non-zero for success, zero for failure. */
882 proc_wait_for_stop (procinfo
*pi
)
886 /* We should never have to apply this operation to any procinfo
887 except the one for the main process. If that ever changes for
888 any reason, then take out the following clause and replace it
889 with one that makes sure the ctl_fd is open. */
892 pi
= find_procinfo_or_die (pi
->pid
, 0);
894 procfs_ctl_t cmd
= PCWSTOP
;
898 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
900 clear_sigint_trap ();
902 /* We been runnin' and we stopped -- need to update status. */
903 pi
->status_valid
= 0;
908 /* Make the process or LWP runnable.
910 Options (not all are implemented):
912 - clear current fault
913 - clear current signal
914 - abort the current system call
915 - stop as soon as finished with system call
917 Always clears the current fault. PI is the process or LWP to
918 operate on. If STEP is true, set the process or LWP to trap after
919 one instruction. If SIGNO is zero, clear the current signal if
920 any; if non-zero, set the current signal to this one. Returns
921 non-zero for success, zero for failure. */
924 proc_run_process (procinfo
*pi
, int step
, int signo
)
929 /* We will probably have to apply this operation to individual
930 threads, so make sure the control file descriptor is open. */
932 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
935 runflags
= PRCFAULT
; /* Always clear current fault. */
940 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
941 proc_set_current_signal (pi
, signo
);
947 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
952 /* Register to trace signals in the process or LWP. Returns non-zero
953 for success, zero for failure. */
956 proc_set_traced_signals (procinfo
*pi
, sigset_t
*sigset
)
960 /* We should never have to apply this operation to any procinfo
961 except the one for the main process. If that ever changes for
962 any reason, then take out the following clause and replace it
963 with one that makes sure the ctl_fd is open. */
966 pi
= find_procinfo_or_die (pi
->pid
, 0);
970 /* Use char array to avoid alignment issues. */
971 char sigset
[sizeof (sigset_t
)];
975 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
977 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
979 /* The above operation renders the procinfo's cached pstatus obsolete. */
980 pi
->status_valid
= 0;
983 warning (_("procfs: set_traced_signals failed"));
987 /* Register to trace hardware faults in the process or LWP. Returns
988 non-zero for success, zero for failure. */
991 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
995 /* We should never have to apply this operation to any procinfo
996 except the one for the main process. If that ever changes for
997 any reason, then take out the following clause and replace it
998 with one that makes sure the ctl_fd is open. */
1001 pi
= find_procinfo_or_die (pi
->pid
, 0);
1005 /* Use char array to avoid alignment issues. */
1006 char fltset
[sizeof (fltset_t
)];
1010 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1012 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1014 /* The above operation renders the procinfo's cached pstatus obsolete. */
1015 pi
->status_valid
= 0;
1020 /* Register to trace entry to system calls in the process or LWP.
1021 Returns non-zero for success, zero for failure. */
1024 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1028 /* We should never have to apply this operation to any procinfo
1029 except the one for the main process. If that ever changes for
1030 any reason, then take out the following clause and replace it
1031 with one that makes sure the ctl_fd is open. */
1034 pi
= find_procinfo_or_die (pi
->pid
, 0);
1038 /* Use char array to avoid alignment issues. */
1039 char sysset
[sizeof (sysset_t
)];
1043 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1045 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1047 /* The above operation renders the procinfo's cached pstatus
1049 pi
->status_valid
= 0;
1054 /* Register to trace exit from system calls in the process or LWP.
1055 Returns non-zero for success, zero for failure. */
1058 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1062 /* We should never have to apply this operation to any procinfo
1063 except the one for the main process. If that ever changes for
1064 any reason, then take out the following clause and replace it
1065 with one that makes sure the ctl_fd is open. */
1068 pi
= find_procinfo_or_die (pi
->pid
, 0);
1070 struct gdb_proc_ctl_pcsexit
{
1072 /* Use char array to avoid alignment issues. */
1073 char sysset
[sizeof (sysset_t
)];
1077 memcpy (&arg
.sysset
, sysset
, sizeof (sysset_t
));
1079 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1081 /* The above operation renders the procinfo's cached pstatus
1083 pi
->status_valid
= 0;
1088 /* Specify the set of blocked / held signals in the process or LWP.
1089 Returns non-zero for success, zero for failure. */
1092 proc_set_held_signals (procinfo
*pi
, sigset_t
*sighold
)
1096 /* We should never have to apply this operation to any procinfo
1097 except the one for the main process. If that ever changes for
1098 any reason, then take out the following clause and replace it
1099 with one that makes sure the ctl_fd is open. */
1102 pi
= find_procinfo_or_die (pi
->pid
, 0);
1106 /* Use char array to avoid alignment issues. */
1107 char hold
[sizeof (sigset_t
)];
1111 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1112 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1114 /* The above operation renders the procinfo's cached pstatus
1116 pi
->status_valid
= 0;
1121 /* Returns the set of signals that are held / blocked. Will also copy
1122 the sigset if SAVE is non-zero. */
1125 proc_get_held_signals (procinfo
*pi
, sigset_t
*save
)
1127 sigset_t
*ret
= NULL
;
1129 /* We should never have to apply this operation to any procinfo
1130 except the one for the main process. If that ever changes for
1131 any reason, then take out the following clause and replace it
1132 with one that makes sure the ctl_fd is open. */
1135 pi
= find_procinfo_or_die (pi
->pid
, 0);
1137 if (!pi
->status_valid
)
1138 if (!proc_get_status (pi
))
1141 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1143 memcpy (save
, ret
, sizeof (sigset_t
));
1148 /* Returns the set of signals that are traced / debugged. Will also
1149 copy the sigset if SAVE is non-zero. */
1152 proc_get_traced_signals (procinfo
*pi
, sigset_t
*save
)
1154 sigset_t
*ret
= NULL
;
1156 /* We should never have to apply this operation to any procinfo
1157 except the one for the main process. If that ever changes for
1158 any reason, then take out the following clause and replace it
1159 with one that makes sure the ctl_fd is open. */
1162 pi
= find_procinfo_or_die (pi
->pid
, 0);
1164 if (!pi
->status_valid
)
1165 if (!proc_get_status (pi
))
1168 ret
= &pi
->prstatus
.pr_sigtrace
;
1170 memcpy (save
, ret
, sizeof (sigset_t
));
1175 /* Returns the set of hardware faults that are traced /debugged. Will
1176 also copy the faultset if SAVE is non-zero. */
1179 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
1181 fltset_t
*ret
= NULL
;
1183 /* We should never have to apply this operation to any procinfo
1184 except the one for the main process. If that ever changes for
1185 any reason, then take out the following clause and replace it
1186 with one that makes sure the ctl_fd is open. */
1189 pi
= find_procinfo_or_die (pi
->pid
, 0);
1191 if (!pi
->status_valid
)
1192 if (!proc_get_status (pi
))
1195 ret
= &pi
->prstatus
.pr_flttrace
;
1197 memcpy (save
, ret
, sizeof (fltset_t
));
1202 /* Returns the set of syscalls that are traced /debugged on entry.
1203 Will also copy the syscall set if SAVE is non-zero. */
1206 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
1208 sysset_t
*ret
= NULL
;
1210 /* We should never have to apply this operation to any procinfo
1211 except the one for the main process. If that ever changes for
1212 any reason, then take out the following clause and replace it
1213 with one that makes sure the ctl_fd is open. */
1216 pi
= find_procinfo_or_die (pi
->pid
, 0);
1218 if (!pi
->status_valid
)
1219 if (!proc_get_status (pi
))
1222 ret
= &pi
->prstatus
.pr_sysentry
;
1224 memcpy (save
, ret
, sizeof (sysset_t
));
1229 /* Returns the set of syscalls that are traced /debugged on exit.
1230 Will also copy the syscall set if SAVE is non-zero. */
1233 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
1235 sysset_t
*ret
= NULL
;
1237 /* We should never have to apply this operation to any procinfo
1238 except the one for the main process. If that ever changes for
1239 any reason, then take out the following clause and replace it
1240 with one that makes sure the ctl_fd is open. */
1243 pi
= find_procinfo_or_die (pi
->pid
, 0);
1245 if (!pi
->status_valid
)
1246 if (!proc_get_status (pi
))
1249 ret
= &pi
->prstatus
.pr_sysexit
;
1251 memcpy (save
, ret
, sizeof (sysset_t
));
1256 /* The current fault (if any) is cleared; the associated signal will
1257 not be sent to the process or LWP when it resumes. Returns
1258 non-zero for success, zero for failure. */
1261 proc_clear_current_fault (procinfo
*pi
)
1265 /* We should never have to apply this operation to any procinfo
1266 except the one for the main process. If that ever changes for
1267 any reason, then take out the following clause and replace it
1268 with one that makes sure the ctl_fd is open. */
1271 pi
= find_procinfo_or_die (pi
->pid
, 0);
1273 procfs_ctl_t cmd
= PCCFAULT
;
1275 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1280 /* Set the "current signal" that will be delivered next to the
1281 process. NOTE: semantics are different from those of KILL. This
1282 signal will be delivered to the process or LWP immediately when it
1283 is resumed (even if the signal is held/blocked); it will NOT
1284 immediately cause another event of interest, and will NOT first
1285 trap back to the debugger. Returns non-zero for success, zero for
1289 proc_set_current_signal (procinfo
*pi
, int signo
)
1294 /* Use char array to avoid alignment issues. */
1295 char sinfo
[sizeof (siginfo_t
)];
1298 process_stratum_target
*wait_target
;
1300 struct target_waitstatus wait_status
;
1302 /* We should never have to apply this operation to any procinfo
1303 except the one for the main process. If that ever changes for
1304 any reason, then take out the following clause and replace it
1305 with one that makes sure the ctl_fd is open. */
1308 pi
= find_procinfo_or_die (pi
->pid
, 0);
1310 /* The pointer is just a type alias. */
1311 get_last_target_status (&wait_target
, &wait_ptid
, &wait_status
);
1312 if (wait_target
== &the_procfs_target
1313 && wait_ptid
== inferior_ptid
1314 && wait_status
.kind () == TARGET_WAITKIND_STOPPED
1315 && wait_status
.sig () == gdb_signal_from_host (signo
)
1316 && proc_get_status (pi
)
1317 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
1319 /* Use the siginfo associated with the signal being
1321 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (siginfo_t
));
1324 mysinfo
.si_signo
= signo
;
1325 mysinfo
.si_code
= 0;
1326 mysinfo
.si_pid
= getpid (); /* ?why? */
1327 mysinfo
.si_uid
= getuid (); /* ?why? */
1328 memcpy (arg
.sinfo
, &mysinfo
, sizeof (siginfo_t
));
1332 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1337 /* The current signal (if any) is cleared, and is not sent to the
1338 process or LWP when it resumes. Returns non-zero for success, zero
1342 proc_clear_current_signal (procinfo
*pi
)
1346 /* We should never have to apply this operation to any procinfo
1347 except the one for the main process. If that ever changes for
1348 any reason, then take out the following clause and replace it
1349 with one that makes sure the ctl_fd is open. */
1352 pi
= find_procinfo_or_die (pi
->pid
, 0);
1356 /* Use char array to avoid alignment issues. */
1357 char sinfo
[sizeof (siginfo_t
)];
1362 /* The pointer is just a type alias. */
1363 mysinfo
.si_signo
= 0;
1364 mysinfo
.si_code
= 0;
1365 mysinfo
.si_errno
= 0;
1366 mysinfo
.si_pid
= getpid (); /* ?why? */
1367 mysinfo
.si_uid
= getuid (); /* ?why? */
1368 memcpy (arg
.sinfo
, &mysinfo
, sizeof (siginfo_t
));
1370 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1375 /* Return the general-purpose registers for the process or LWP
1376 corresponding to PI. Upon failure, return NULL. */
1378 static gdb_gregset_t
*
1379 proc_get_gregs (procinfo
*pi
)
1381 if (!pi
->status_valid
|| !pi
->gregs_valid
)
1382 if (!proc_get_status (pi
))
1385 return &pi
->prstatus
.pr_lwp
.pr_reg
;
1388 /* Return the general-purpose registers for the process or LWP
1389 corresponding to PI. Upon failure, return NULL. */
1391 static gdb_fpregset_t
*
1392 proc_get_fpregs (procinfo
*pi
)
1394 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
1395 if (!proc_get_status (pi
))
1398 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
1401 /* Write the general-purpose registers back to the process or LWP
1402 corresponding to PI. Return non-zero for success, zero for
1406 proc_set_gregs (procinfo
*pi
)
1408 gdb_gregset_t
*gregs
;
1411 gregs
= proc_get_gregs (pi
);
1413 return 0; /* proc_get_regs has already warned. */
1415 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1421 /* Use char array to avoid alignment issues. */
1422 char gregs
[sizeof (gdb_gregset_t
)];
1426 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
1427 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1430 /* Policy: writing the registers invalidates our cache. */
1431 pi
->gregs_valid
= 0;
1435 /* Write the floating-pointer registers back to the process or LWP
1436 corresponding to PI. Return non-zero for success, zero for
1440 proc_set_fpregs (procinfo
*pi
)
1442 gdb_fpregset_t
*fpregs
;
1445 fpregs
= proc_get_fpregs (pi
);
1447 return 0; /* proc_get_fpregs has already warned. */
1449 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1455 /* Use char array to avoid alignment issues. */
1456 char fpregs
[sizeof (gdb_fpregset_t
)];
1460 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
1461 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1464 /* Policy: writing the registers invalidates our cache. */
1465 pi
->fpregs_valid
= 0;
1469 /* Send a signal to the proc or lwp with the semantics of "kill()".
1470 Returns non-zero for success, zero for failure. */
1473 proc_kill (procinfo
*pi
, int signo
)
1477 /* We might conceivably apply this operation to an LWP, and the
1478 LWP's ctl file descriptor might not be open. */
1480 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1484 procfs_ctl_t cmd
[2];
1488 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1494 /* Find the pid of the process that started this one. Returns the
1495 parent process pid, or zero. */
1498 proc_parent_pid (procinfo
*pi
)
1500 /* We should never have to apply this operation to any procinfo
1501 except the one for the main process. If that ever changes for
1502 any reason, then take out the following clause and replace it
1503 with one that makes sure the ctl_fd is open. */
1506 pi
= find_procinfo_or_die (pi
->pid
, 0);
1508 if (!pi
->status_valid
)
1509 if (!proc_get_status (pi
))
1512 return pi
->prstatus
.pr_ppid
;
1515 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
1516 (a.k.a void pointer)! */
1519 procfs_address_to_host_pointer (CORE_ADDR addr
)
1521 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
1524 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
1525 gdbarch_address_to_pointer (target_gdbarch (), ptr_type
,
1526 (gdb_byte
*) &ptr
, addr
);
1531 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
1535 char watch
[sizeof (prwatch_t
)];
1539 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
1540 convert a target address into something that can be stored in a
1541 native data structure. */
1542 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
1543 pwatch
.pr_size
= len
;
1544 pwatch
.pr_wflags
= wflags
;
1546 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
1547 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
1550 /* =============== END, non-thread part of /proc "MODULE" =============== */
1552 /* =================== Thread "MODULE" =================== */
1554 /* Returns the number of threads for the process. */
1557 proc_get_nthreads (procinfo
*pi
)
1559 if (!pi
->status_valid
)
1560 if (!proc_get_status (pi
))
1563 /* Only works for the process procinfo, because the LWP procinfos do not
1564 get prstatus filled in. */
1565 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
1566 pi
= find_procinfo_or_die (pi
->pid
, 0);
1567 return pi
->prstatus
.pr_nlwp
;
1570 /* Return the ID of the thread that had an event of interest.
1571 (ie. the one that hit a breakpoint or other traced event). All
1572 other things being equal, this should be the ID of a thread that is
1573 currently executing. */
1576 proc_get_current_thread (procinfo
*pi
)
1578 /* Note: this should be applied to the root procinfo for the
1579 process, not to the procinfo for an LWP. If applied to the
1580 procinfo for an LWP, it will simply return that LWP's ID. In
1581 that case, find the parent process procinfo. */
1584 pi
= find_procinfo_or_die (pi
->pid
, 0);
1586 if (!pi
->status_valid
)
1587 if (!proc_get_status (pi
))
1590 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
1593 /* Discover the IDs of all the threads within the process, and create
1594 a procinfo for each of them (chained to the parent). Returns
1595 non-zero for success, zero for failure. */
1598 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
1600 if (thread
&& parent
) /* sanity */
1602 thread
->status_valid
= 0;
1603 if (!proc_get_status (thread
))
1604 destroy_one_procinfo (&parent
->thread_list
, thread
);
1606 return 0; /* keep iterating */
1610 proc_update_threads (procinfo
*pi
)
1612 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
1613 struct dirent
*direntry
;
1618 /* We should never have to apply this operation to any procinfo
1619 except the one for the main process. If that ever changes for
1620 any reason, then take out the following clause and replace it
1621 with one that makes sure the ctl_fd is open. */
1624 pi
= find_procinfo_or_die (pi
->pid
, 0);
1626 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
1628 /* Note: this brute-force method was originally devised for Unixware
1629 (support removed since), and will also work on Solaris 2.6 and
1630 2.7. The original comment mentioned the existence of a much
1631 simpler and more elegant way to do this on Solaris, but didn't
1632 point out what that was. */
1634 strcpy (pathname
, pi
->pathname
);
1635 strcat (pathname
, "/lwp");
1636 dirp
.reset (opendir (pathname
));
1638 proc_error (pi
, "update_threads, opendir", __LINE__
);
1640 while ((direntry
= readdir (dirp
.get ())) != NULL
)
1641 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
1643 lwpid
= atoi (&direntry
->d_name
[0]);
1644 thread
= create_procinfo (pi
->pid
, lwpid
);
1646 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
1648 pi
->threads_valid
= 1;
1652 /* Given a pointer to a function, call that function once for each lwp
1653 in the procinfo list, until the function returns non-zero, in which
1654 event return the value returned by the function.
1656 Note: this function does NOT call update_threads. If you want to
1657 discover new threads first, you must call that function explicitly.
1658 This function just makes a quick pass over the currently-known
1661 PI is the parent process procinfo. FUNC is the per-thread
1662 function. PTR is an opaque parameter for function. Returns the
1663 first non-zero return value from the callee, or zero. */
1666 proc_iterate_over_threads (procinfo
*pi
,
1667 int (*func
) (procinfo
*, procinfo
*, void *),
1670 procinfo
*thread
, *next
;
1673 /* We should never have to apply this operation to any procinfo
1674 except the one for the main process. If that ever changes for
1675 any reason, then take out the following clause and replace it
1676 with one that makes sure the ctl_fd is open. */
1679 pi
= find_procinfo_or_die (pi
->pid
, 0);
1681 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
1683 next
= thread
->next
; /* In case thread is destroyed. */
1684 retval
= (*func
) (pi
, thread
, ptr
);
1692 /* =================== END, Thread "MODULE" =================== */
1694 /* =================== END, /proc "MODULE" =================== */
1696 /* =================== GDB "MODULE" =================== */
1698 /* Here are all of the gdb target vector functions and their
1701 static void do_attach (ptid_t ptid
);
1702 static void do_detach ();
1703 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
1704 int entry_or_exit
, int mode
, int from_tty
);
1706 /* Sets up the inferior to be debugged. Registers to trace signals,
1707 hardware faults, and syscalls. Note: does not set RLC flag: caller
1708 may want to customize that. Returns zero for success (note!
1709 unlike most functions in this module); on failure, returns the LINE
1710 NUMBER where it failed! */
1713 procfs_debug_inferior (procinfo
*pi
)
1715 fltset_t traced_faults
;
1716 sigset_t traced_signals
;
1717 sysset_t
*traced_syscall_entries
;
1718 sysset_t
*traced_syscall_exits
;
1721 /* Register to trace hardware faults in the child. */
1722 prfillset (&traced_faults
); /* trace all faults... */
1723 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
1724 if (!proc_set_traced_faults (pi
, &traced_faults
))
1727 /* Initially, register to trace all signals in the child. */
1728 prfillset (&traced_signals
);
1729 if (!proc_set_traced_signals (pi
, &traced_signals
))
1733 /* Register to trace the 'exit' system call (on entry). */
1734 traced_syscall_entries
= XNEW (sysset_t
);
1735 premptyset (traced_syscall_entries
);
1736 praddset (traced_syscall_entries
, SYS_exit
);
1737 praddset (traced_syscall_entries
, SYS_lwp_exit
);
1739 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
1740 xfree (traced_syscall_entries
);
1744 /* Method for tracing exec syscalls. */
1745 traced_syscall_exits
= XNEW (sysset_t
);
1746 premptyset (traced_syscall_exits
);
1747 praddset (traced_syscall_exits
, SYS_execve
);
1748 praddset (traced_syscall_exits
, SYS_lwp_create
);
1749 praddset (traced_syscall_exits
, SYS_lwp_exit
);
1751 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
1752 xfree (traced_syscall_exits
);
1760 procfs_target::attach (const char *args
, int from_tty
)
1764 pid
= parse_pid_to_attach (args
);
1766 if (pid
== getpid ())
1767 error (_("Attaching GDB to itself is not a good idea..."));
1769 /* Push the target if needed, ensure it gets un-pushed it if attach fails. */
1770 inferior
*inf
= current_inferior ();
1771 target_unpush_up unpusher
;
1772 if (!inf
->target_is_pushed (this))
1774 inf
->push_target (this);
1775 unpusher
.reset (this);
1780 const char *exec_file
= get_exec_file (0);
1783 printf_filtered (_("Attaching to program `%s', %s\n"),
1784 exec_file
, target_pid_to_str (ptid_t (pid
)).c_str ());
1786 printf_filtered (_("Attaching to %s\n"),
1787 target_pid_to_str (ptid_t (pid
)).c_str ());
1792 do_attach (ptid_t (pid
));
1794 /* Everything went fine, keep the target pushed. */
1795 unpusher
.release ();
1799 procfs_target::detach (inferior
*inf
, int from_tty
)
1801 int pid
= inferior_ptid
.pid ();
1805 const char *exec_file
;
1807 exec_file
= get_exec_file (0);
1808 if (exec_file
== NULL
)
1811 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
1812 target_pid_to_str (ptid_t (pid
)).c_str ());
1817 switch_to_no_thread ();
1818 detach_inferior (inf
);
1819 maybe_unpush_target ();
1823 do_attach (ptid_t ptid
)
1826 struct inferior
*inf
;
1830 pi
= create_procinfo (ptid
.pid (), 0);
1832 perror (_("procfs: out of memory in 'attach'"));
1834 if (!open_procinfo_files (pi
, FD_CTL
))
1836 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
1837 xsnprintf (errmsg
, sizeof (errmsg
),
1838 "do_attach: couldn't open /proc file for process %d",
1840 dead_procinfo (pi
, errmsg
, NOKILL
);
1843 /* Stop the process (if it isn't already stopped). */
1844 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
1846 pi
->was_stopped
= 1;
1847 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
1851 pi
->was_stopped
= 0;
1852 /* Set the process to run again when we close it. */
1853 if (!proc_set_run_on_last_close (pi
))
1854 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
1856 /* Now stop the process. */
1857 if (!proc_stop_process (pi
))
1858 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
1859 pi
->ignore_next_sigstop
= 1;
1861 /* Save some of the /proc state to be restored if we detach. */
1862 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
1863 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
1864 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
1865 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
1866 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
1867 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
1869 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
1870 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
1872 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
1873 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
1875 fail
= procfs_debug_inferior (pi
);
1877 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
1879 inf
= current_inferior ();
1880 inferior_appeared (inf
, pi
->pid
);
1881 /* Let GDB know that the inferior was attached. */
1882 inf
->attach_flag
= 1;
1884 /* Create a procinfo for the current lwp. */
1885 lwpid
= proc_get_current_thread (pi
);
1886 create_procinfo (pi
->pid
, lwpid
);
1888 /* Add it to gdb's thread list. */
1889 ptid
= ptid_t (pi
->pid
, lwpid
, 0);
1890 thread_info
*thr
= add_thread (&the_procfs_target
, ptid
);
1891 switch_to_thread (thr
);
1899 /* Find procinfo for the main process. */
1900 pi
= find_procinfo_or_die (inferior_ptid
.pid (),
1901 0); /* FIXME: threads */
1903 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
1904 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
1906 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
1907 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
1909 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
1910 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
1912 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
1913 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
1915 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
1916 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
1918 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
1919 if (!(pi
->was_stopped
)
1920 || query (_("Was stopped when attached, make it runnable again? ")))
1922 /* Clear any pending signal. */
1923 if (!proc_clear_current_fault (pi
))
1924 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
1926 if (!proc_clear_current_signal (pi
))
1927 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
1929 if (!proc_set_run_on_last_close (pi
))
1930 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
1933 destroy_procinfo (pi
);
1936 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
1939 NOTE: Since the /proc interface cannot give us individual
1940 registers, we pay no attention to REGNUM, and just fetch them all.
1941 This results in the possibility that we will do unnecessarily many
1942 fetches, since we may be called repeatedly for individual
1943 registers. So we cache the results, and mark the cache invalid
1944 when the process is resumed. */
1947 procfs_target::fetch_registers (struct regcache
*regcache
, int regnum
)
1949 gdb_gregset_t
*gregs
;
1951 ptid_t ptid
= regcache
->ptid ();
1952 int pid
= ptid
.pid ();
1953 int tid
= ptid
.lwp ();
1954 struct gdbarch
*gdbarch
= regcache
->arch ();
1956 pi
= find_procinfo_or_die (pid
, tid
);
1959 error (_("procfs: fetch_registers failed to find procinfo for %s"),
1960 target_pid_to_str (ptid
).c_str ());
1962 gregs
= proc_get_gregs (pi
);
1964 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
1966 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
1968 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
1970 gdb_fpregset_t
*fpregs
;
1972 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
1973 || regnum
== gdbarch_pc_regnum (gdbarch
)
1974 || regnum
== gdbarch_sp_regnum (gdbarch
))
1975 return; /* Not a floating point register. */
1977 fpregs
= proc_get_fpregs (pi
);
1979 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
1981 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
1985 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
1986 this for all registers.
1988 NOTE: Since the /proc interface will not read individual registers,
1989 we will cache these requests until the process is resumed, and only
1990 then write them back to the inferior process.
1992 FIXME: is that a really bad idea? Have to think about cases where
1993 writing one register might affect the value of others, etc. */
1996 procfs_target::store_registers (struct regcache
*regcache
, int regnum
)
1998 gdb_gregset_t
*gregs
;
2000 ptid_t ptid
= regcache
->ptid ();
2001 int pid
= ptid
.pid ();
2002 int tid
= ptid
.lwp ();
2003 struct gdbarch
*gdbarch
= regcache
->arch ();
2005 pi
= find_procinfo_or_die (pid
, tid
);
2008 error (_("procfs: store_registers: failed to find procinfo for %s"),
2009 target_pid_to_str (ptid
).c_str ());
2011 gregs
= proc_get_gregs (pi
);
2013 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
2015 fill_gregset (regcache
, gregs
, regnum
);
2016 if (!proc_set_gregs (pi
))
2017 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
2019 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2021 gdb_fpregset_t
*fpregs
;
2023 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2024 || regnum
== gdbarch_pc_regnum (gdbarch
)
2025 || regnum
== gdbarch_sp_regnum (gdbarch
))
2026 return; /* Not a floating point register. */
2028 fpregs
= proc_get_fpregs (pi
);
2030 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
2032 fill_fpregset (regcache
, fpregs
, regnum
);
2033 if (!proc_set_fpregs (pi
))
2034 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
2038 /* Retrieve the next stop event from the child process. If child has
2039 not stopped yet, wait for it to stop. Translate /proc eventcodes
2040 (or possibly wait eventcodes) into gdb internal event codes.
2041 Returns the id of process (and possibly thread) that incurred the
2042 event. Event codes are returned through a pointer parameter. */
2045 procfs_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
2046 target_wait_flags options
)
2048 /* First cut: loosely based on original version 2.1. */
2052 ptid_t retval
, temp_ptid
;
2053 int why
, what
, flags
;
2060 retval
= ptid_t (-1);
2062 /* Find procinfo for main process. */
2064 /* procfs_target currently only supports one inferior. */
2065 inferior
*inf
= current_inferior ();
2067 pi
= find_procinfo_or_die (inf
->pid
, 0);
2070 /* We must assume that the status is stale now... */
2071 pi
->status_valid
= 0;
2072 pi
->gregs_valid
= 0;
2073 pi
->fpregs_valid
= 0;
2075 #if 0 /* just try this out... */
2076 flags
= proc_flags (pi
);
2077 why
= proc_why (pi
);
2078 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
2079 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
2081 /* If child is not stopped, wait for it to stop. */
2082 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
2083 && !proc_wait_for_stop (pi
))
2085 /* wait_for_stop failed: has the child terminated? */
2086 if (errno
== ENOENT
)
2090 /* /proc file not found; presumably child has terminated. */
2091 wait_retval
= ::wait (&wstat
); /* "wait" for the child's exit. */
2094 if (wait_retval
!= inf
->pid
)
2095 error (_("procfs: couldn't stop "
2096 "process %d: wait returned %d."),
2097 inf
->pid
, wait_retval
);
2098 /* FIXME: might I not just use waitpid?
2099 Or try find_procinfo to see if I know about this child? */
2100 retval
= ptid_t (wait_retval
);
2102 else if (errno
== EINTR
)
2106 /* Unknown error from wait_for_stop. */
2107 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
2112 /* This long block is reached if either:
2113 a) the child was already stopped, or
2114 b) we successfully waited for the child with wait_for_stop.
2115 This block will analyze the /proc status, and translate it
2116 into a waitstatus for GDB.
2118 If we actually had to call wait because the /proc file
2119 is gone (child terminated), then we skip this block,
2120 because we already have a waitstatus. */
2122 flags
= proc_flags (pi
);
2123 why
= proc_why (pi
);
2124 what
= proc_what (pi
);
2126 if (flags
& (PR_STOPPED
| PR_ISTOP
))
2128 /* If it's running async (for single_thread control),
2129 set it back to normal again. */
2130 if (flags
& PR_ASYNC
)
2131 if (!proc_unset_async (pi
))
2132 proc_error (pi
, "target_wait, unset_async", __LINE__
);
2135 proc_prettyprint_why (why
, what
, 1);
2137 /* The 'pid' we will return to GDB is composed of
2138 the process ID plus the lwp ID. */
2139 retval
= ptid_t (pi
->pid
, proc_get_current_thread (pi
), 0);
2143 wstat
= (what
<< 8) | 0177;
2146 if (what
== SYS_lwp_exit
)
2148 if (print_thread_events
)
2149 printf_unfiltered (_("[%s exited]\n"),
2150 target_pid_to_str (retval
).c_str ());
2151 delete_thread (find_thread_ptid (this, retval
));
2152 target_continue_no_signal (ptid
);
2155 else if (what
== SYS_exit
)
2157 /* Handle SYS_exit call only. */
2158 /* Stopped at entry to SYS_exit.
2159 Make it runnable, resume it, then use
2160 the wait system call to get its exit code.
2161 Proc_run_process always clears the current
2163 Then return its exit status. */
2164 pi
->status_valid
= 0;
2166 /* FIXME: what we should do is return
2167 TARGET_WAITKIND_SPURIOUS. */
2168 if (!proc_run_process (pi
, 0, 0))
2169 proc_error (pi
, "target_wait, run_process", __LINE__
);
2171 if (inf
->attach_flag
)
2173 /* Don't call wait: simulate waiting for exit,
2174 return a "success" exit code. Bogus: what if
2175 it returns something else? */
2177 retval
= ptid_t (inf
->pid
); /* ? ? ? */
2181 int temp
= ::wait (&wstat
);
2183 /* FIXME: shouldn't I make sure I get the right
2184 event from the right process? If (for
2185 instance) I have killed an earlier inferior
2186 process but failed to clean up after it
2187 somehow, I could get its termination event
2190 /* If wait returns -1, that's what we return
2193 retval
= ptid_t (temp
);
2198 printf_filtered (_("procfs: trapped on entry to "));
2199 proc_prettyprint_syscall (proc_what (pi
), 0);
2200 printf_filtered ("\n");
2202 long i
, nsysargs
, *sysargs
;
2204 nsysargs
= proc_nsysarg (pi
);
2205 sysargs
= proc_sysargs (pi
);
2207 if (nsysargs
> 0 && sysargs
!= NULL
)
2209 printf_filtered (_("%ld syscall arguments:\n"),
2211 for (i
= 0; i
< nsysargs
; i
++)
2212 printf_filtered ("#%ld: 0x%08lx\n",
2216 /* How to keep going without returning to wfi: */
2217 target_continue_no_signal (ptid
);
2222 if (what
== SYS_execve
)
2224 /* Hopefully this is our own "fork-child" execing
2225 the real child. Hoax this event into a trap, and
2226 GDB will see the child about to execute its start
2228 wstat
= (SIGTRAP
<< 8) | 0177;
2230 else if (what
== SYS_lwp_create
)
2232 /* This syscall is somewhat like fork/exec. We
2233 will get the event twice: once for the parent
2234 LWP, and once for the child. We should already
2235 know about the parent LWP, but the child will
2236 be new to us. So, whenever we get this event,
2237 if it represents a new thread, simply add the
2238 thread to the list. */
2240 /* If not in procinfo list, add it. */
2241 temp_tid
= proc_get_current_thread (pi
);
2242 if (!find_procinfo (pi
->pid
, temp_tid
))
2243 create_procinfo (pi
->pid
, temp_tid
);
2245 temp_ptid
= ptid_t (pi
->pid
, temp_tid
, 0);
2246 /* If not in GDB's thread list, add it. */
2247 if (!in_thread_list (this, temp_ptid
))
2248 add_thread (this, temp_ptid
);
2250 target_continue_no_signal (ptid
);
2253 else if (what
== SYS_lwp_exit
)
2255 if (print_thread_events
)
2256 printf_unfiltered (_("[%s exited]\n"),
2257 target_pid_to_str (retval
).c_str ());
2258 delete_thread (find_thread_ptid (this, retval
));
2259 status
->set_spurious ();
2264 printf_filtered (_("procfs: trapped on exit from "));
2265 proc_prettyprint_syscall (proc_what (pi
), 0);
2266 printf_filtered ("\n");
2268 long i
, nsysargs
, *sysargs
;
2270 nsysargs
= proc_nsysarg (pi
);
2271 sysargs
= proc_sysargs (pi
);
2273 if (nsysargs
> 0 && sysargs
!= NULL
)
2275 printf_filtered (_("%ld syscall arguments:\n"),
2277 for (i
= 0; i
< nsysargs
; i
++)
2278 printf_filtered ("#%ld: 0x%08lx\n",
2282 target_continue_no_signal (ptid
);
2288 wstat
= (SIGSTOP
<< 8) | 0177;
2293 printf_filtered (_("Retry #%d:\n"), retry
);
2294 pi
->status_valid
= 0;
2299 /* If not in procinfo list, add it. */
2300 temp_tid
= proc_get_current_thread (pi
);
2301 if (!find_procinfo (pi
->pid
, temp_tid
))
2302 create_procinfo (pi
->pid
, temp_tid
);
2304 /* If not in GDB's thread list, add it. */
2305 temp_ptid
= ptid_t (pi
->pid
, temp_tid
, 0);
2306 if (!in_thread_list (this, temp_ptid
))
2307 add_thread (this, temp_ptid
);
2309 status
->set_stopped (GDB_SIGNAL_0
);
2314 wstat
= (what
<< 8) | 0177;
2318 int signo
= pi
->prstatus
.pr_lwp
.pr_info
.si_signo
;
2320 wstat
= (signo
<< 8) | 0177;
2323 default: /* switch (why) unmatched */
2324 printf_filtered ("procfs:%d -- ", __LINE__
);
2325 printf_filtered (_("child stopped for unknown reason:\n"));
2326 proc_prettyprint_why (why
, what
, 1);
2327 error (_("... giving up..."));
2330 /* Got this far without error: If retval isn't in the
2331 threads database, add it. */
2332 if (retval
.pid () > 0
2333 && !in_thread_list (this, retval
))
2335 /* We have a new thread. We need to add it both to
2336 GDB's list and to our own. If we don't create a
2337 procinfo, resume may be unhappy later. */
2338 add_thread (this, retval
);
2339 if (find_procinfo (retval
.pid (),
2340 retval
.lwp ()) == NULL
)
2341 create_procinfo (retval
.pid (),
2345 else /* Flags do not indicate STOPPED. */
2347 /* surely this can't happen... */
2348 printf_filtered ("procfs:%d -- process not stopped.\n",
2350 proc_prettyprint_flags (flags
, 1);
2351 error (_("procfs: ...giving up..."));
2356 *status
= host_status_to_waitstatus (wstat
);
2362 /* Perform a partial transfer to/from the specified object. For
2363 memory transfers, fall back to the old memory xfer functions. */
2365 enum target_xfer_status
2366 procfs_target::xfer_partial (enum target_object object
,
2367 const char *annex
, gdb_byte
*readbuf
,
2368 const gdb_byte
*writebuf
, ULONGEST offset
,
2369 ULONGEST len
, ULONGEST
*xfered_len
)
2373 case TARGET_OBJECT_MEMORY
:
2374 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2376 case TARGET_OBJECT_AUXV
:
2377 return memory_xfer_auxv (this, object
, annex
, readbuf
, writebuf
,
2378 offset
, len
, xfered_len
);
2381 return this->beneath ()->xfer_partial (object
, annex
,
2382 readbuf
, writebuf
, offset
, len
,
2387 /* Helper for procfs_xfer_partial that handles memory transfers.
2388 Arguments are like target_xfer_partial. */
2390 static enum target_xfer_status
2391 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2392 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2397 /* Find procinfo for main process. */
2398 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
2399 if (pi
->as_fd
== 0 && open_procinfo_files (pi
, FD_AS
) == 0)
2401 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
2402 return TARGET_XFER_E_IO
;
2405 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
2406 return TARGET_XFER_E_IO
;
2408 if (writebuf
!= NULL
)
2410 PROCFS_NOTE ("write memory:\n");
2411 nbytes
= write (pi
->as_fd
, writebuf
, len
);
2415 PROCFS_NOTE ("read memory:\n");
2416 nbytes
= read (pi
->as_fd
, readbuf
, len
);
2419 return TARGET_XFER_E_IO
;
2420 *xfered_len
= nbytes
;
2421 return TARGET_XFER_OK
;
2424 /* Called by target_resume before making child runnable. Mark cached
2425 registers and status's invalid. If there are "dirty" caches that
2426 need to be written back to the child process, do that.
2428 File descriptors are also cached. As they are a limited resource,
2429 we cannot hold onto them indefinitely. However, as they are
2430 expensive to open, we don't want to throw them away
2431 indiscriminately either. As a compromise, we will keep the file
2432 descriptors for the parent process, but discard any file
2433 descriptors we may have accumulated for the threads.
2435 As this function is called by iterate_over_threads, it always
2436 returns zero (so that iterate_over_threads will keep
2440 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
2442 /* About to run the child; invalidate caches and do any other
2447 /* The presence of a parent indicates that this is an LWP.
2448 Close any file descriptors that it might have open.
2449 We don't do this to the master (parent) procinfo. */
2451 close_procinfo_files (pi
);
2453 pi
->gregs_valid
= 0;
2454 pi
->fpregs_valid
= 0;
2455 pi
->status_valid
= 0;
2456 pi
->threads_valid
= 0;
2461 /* Make the child process runnable. Normally we will then call
2462 procfs_wait and wait for it to stop again (unless gdb is async).
2464 If STEP is true, then arrange for the child to stop again after
2465 executing a single instruction. If SIGNO is zero, then cancel any
2466 pending signal; if non-zero, then arrange for the indicated signal
2467 to be delivered to the child when it runs. If PID is -1, then
2468 allow any child thread to run; if non-zero, then allow only the
2469 indicated thread to run. (not implemented yet). */
2472 procfs_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
2474 procinfo
*pi
, *thread
;
2477 /* FIXME: Check/reword. */
2479 /* prrun.prflags |= PRCFAULT; clear current fault.
2480 PRCFAULT may be replaced by a PCCFAULT call (proc_clear_current_fault)
2481 This basically leaves PRSTEP and PRCSIG.
2482 PRCSIG is like PCSSIG (proc_clear_current_signal).
2483 So basically PR_STEP is the sole argument that must be passed
2484 to proc_run_process. */
2486 /* Find procinfo for main process. */
2487 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
2489 /* First cut: ignore pid argument. */
2492 /* Convert signal to host numbering. */
2493 if (signo
== 0 || (signo
== GDB_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
2496 native_signo
= gdb_signal_to_host (signo
);
2498 pi
->ignore_next_sigstop
= 0;
2500 /* Running the process voids all cached registers and status. */
2501 /* Void the threads' caches first. */
2502 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
2503 /* Void the process procinfo's caches. */
2504 invalidate_cache (NULL
, pi
, NULL
);
2506 if (ptid
.pid () != -1)
2508 /* Resume a specific thread, presumably suppressing the
2510 thread
= find_procinfo (ptid
.pid (), ptid
.lwp ());
2513 if (thread
->tid
!= 0)
2515 /* We're to resume a specific thread, and not the
2516 others. Set the child process's PR_ASYNC flag. */
2517 if (!proc_set_async (pi
))
2518 proc_error (pi
, "target_resume, set_async", __LINE__
);
2519 pi
= thread
; /* Substitute the thread's procinfo
2525 if (!proc_run_process (pi
, step
, native_signo
))
2528 warning (_("resume: target already running. "
2529 "Pretend to resume, and hope for the best!"));
2531 proc_error (pi
, "target_resume", __LINE__
);
2535 /* Set up to trace signals in the child process. */
2538 procfs_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2541 procinfo
*pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
2544 prfillset (&signals
);
2546 for (signo
= 0; signo
< NSIG
; signo
++)
2548 int target_signo
= gdb_signal_from_host (signo
);
2549 if (target_signo
< pass_signals
.size () && pass_signals
[target_signo
])
2550 prdelset (&signals
, signo
);
2553 if (!proc_set_traced_signals (pi
, &signals
))
2554 proc_error (pi
, "pass_signals", __LINE__
);
2557 /* Print status information about the child process. */
2560 procfs_target::files_info ()
2562 struct inferior
*inf
= current_inferior ();
2564 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
2565 inf
->attach_flag
? "attached": "child",
2566 target_pid_to_str (inferior_ptid
).c_str ());
2569 /* Make it die. Wait for it to die. Clean up after it. Note: this
2570 should only be applied to the real process, not to an LWP, because
2571 of the check for parent-process. If we need this to work for an
2572 LWP, it needs some more logic. */
2575 unconditionally_kill_inferior (procinfo
*pi
)
2579 parent_pid
= proc_parent_pid (pi
);
2580 if (!proc_kill (pi
, SIGKILL
))
2581 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
2582 destroy_procinfo (pi
);
2584 /* If pi is GDB's child, wait for it to die. */
2585 if (parent_pid
== getpid ())
2586 /* FIXME: should we use waitpid to make sure we get the right event?
2587 Should we check the returned event? */
2592 ret
= waitpid (pi
->pid
, &status
, 0);
2599 /* We're done debugging it, and we want it to go away. Then we want
2600 GDB to forget all about it. */
2603 procfs_target::kill ()
2605 if (inferior_ptid
!= null_ptid
) /* ? */
2607 /* Find procinfo for main process. */
2608 procinfo
*pi
= find_procinfo (inferior_ptid
.pid (), 0);
2611 unconditionally_kill_inferior (pi
);
2612 target_mourn_inferior (inferior_ptid
);
2616 /* Forget we ever debugged this thing! */
2619 procfs_target::mourn_inferior ()
2623 if (inferior_ptid
!= null_ptid
)
2625 /* Find procinfo for main process. */
2626 pi
= find_procinfo (inferior_ptid
.pid (), 0);
2628 destroy_procinfo (pi
);
2631 generic_mourn_inferior ();
2633 maybe_unpush_target ();
2636 /* When GDB forks to create a runnable inferior process, this function
2637 is called on the parent side of the fork. It's job is to do
2638 whatever is necessary to make the child ready to be debugged, and
2639 then wait for the child to synchronize. */
2642 procfs_target::procfs_init_inferior (int pid
)
2648 pi
= create_procinfo (pid
, 0);
2650 perror (_("procfs: out of memory in 'init_inferior'"));
2652 if (!open_procinfo_files (pi
, FD_CTL
))
2653 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
2657 open_procinfo_files // done
2660 procfs_notice_signals
2665 /* If not stopped yet, wait for it to stop. */
2666 if (!(proc_flags (pi
) & PR_STOPPED
) && !(proc_wait_for_stop (pi
)))
2667 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
2669 /* Save some of the /proc state to be restored if we detach. */
2670 /* FIXME: Why? In case another debugger was debugging it?
2671 We're it's parent, for Ghu's sake! */
2672 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
2673 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
2674 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
2675 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
2676 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
2677 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
2678 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
2679 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
2680 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
2681 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
2683 fail
= procfs_debug_inferior (pi
);
2685 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
2687 /* FIXME: logically, we should really be turning OFF run-on-last-close,
2688 and possibly even turning ON kill-on-last-close at this point. But
2689 I can't make that change without careful testing which I don't have
2690 time to do right now... */
2691 /* Turn on run-on-last-close flag so that the child
2692 will die if GDB goes away for some reason. */
2693 if (!proc_set_run_on_last_close (pi
))
2694 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
2696 /* We now have have access to the lwpid of the main thread/lwp. */
2697 lwpid
= proc_get_current_thread (pi
);
2699 /* Create a procinfo for the main lwp. */
2700 create_procinfo (pid
, lwpid
);
2702 /* We already have a main thread registered in the thread table at
2703 this point, but it didn't have any lwp info yet. Notify the core
2704 about it. This changes inferior_ptid as well. */
2705 thread_change_ptid (this, ptid_t (pid
), ptid_t (pid
, lwpid
, 0));
2707 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2710 /* When GDB forks to create a new process, this function is called on
2711 the child side of the fork before GDB exec's the user program. Its
2712 job is to make the child minimally debuggable, so that the parent
2713 GDB process can connect to the child and take over. This function
2714 should do only the minimum to make that possible, and to
2715 synchronize with the parent process. The parent process should
2716 take care of the details. */
2719 procfs_set_exec_trap (void)
2721 /* This routine called on the child side (inferior side)
2722 after GDB forks the inferior. It must use only local variables,
2723 because it may be sharing data space with its parent. */
2728 pi
= create_procinfo (getpid (), 0);
2730 perror_with_name (_("procfs: create_procinfo failed in child."));
2732 if (open_procinfo_files (pi
, FD_CTL
) == 0)
2734 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
2735 gdb_flush (gdb_stderr
);
2736 /* No need to call "dead_procinfo", because we're going to
2741 exitset
= XNEW (sysset_t
);
2742 premptyset (exitset
);
2743 praddset (exitset
, SYS_execve
);
2745 if (!proc_set_traced_sysexit (pi
, exitset
))
2747 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
2748 gdb_flush (gdb_stderr
);
2752 /* FIXME: should this be done in the parent instead? */
2753 /* Turn off inherit on fork flag so that all grand-children
2754 of gdb start with tracing flags cleared. */
2755 if (!proc_unset_inherit_on_fork (pi
))
2756 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
2758 /* Turn off run on last close flag, so that the child process
2759 cannot run away just because we close our handle on it.
2760 We want it to wait for the parent to attach. */
2761 if (!proc_unset_run_on_last_close (pi
))
2762 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
2764 /* FIXME: No need to destroy the procinfo --
2765 we have our own address space, and we're about to do an exec! */
2766 /*destroy_procinfo (pi);*/
2769 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2).
2770 This avoids a possible deadlock gdb and its vfork'ed child. */
2772 procfs_pre_trace (void)
2776 /* This function is called BEFORE gdb forks the inferior process. Its
2777 only real responsibility is to set things up for the fork, and tell
2778 GDB which two functions to call after the fork (one for the parent,
2779 and one for the child).
2781 This function does a complicated search for a unix shell program,
2782 which it then uses to parse arguments and environment variables to
2783 be sent to the child. I wonder whether this code could not be
2784 abstracted out and shared with other unix targets such as
2788 procfs_target::create_inferior (const char *exec_file
,
2789 const std::string
&allargs
,
2790 char **env
, int from_tty
)
2792 const char *shell_file
= get_shell ();
2796 if (strchr (shell_file
, '/') == NULL
)
2799 /* We will be looking down the PATH to find shell_file. If we
2800 just do this the normal way (via execlp, which operates by
2801 attempting an exec for each element of the PATH until it
2802 finds one which succeeds), then there will be an exec for
2803 each failed attempt, each of which will cause a PR_SYSEXIT
2804 stop, and we won't know how to distinguish the PR_SYSEXIT's
2805 for these failed execs with the ones for successful execs
2806 (whether the exec has succeeded is stored at that time in the
2807 carry bit or some such architecture-specific and
2808 non-ABI-specified place).
2810 So I can't think of anything better than to search the PATH
2811 now. This has several disadvantages: (1) There is a race
2812 condition; if we find a file now and it is deleted before we
2813 exec it, we lose, even if the deletion leaves a valid file
2814 further down in the PATH, (2) there is no way to know exactly
2815 what an executable (in the sense of "capable of being
2816 exec'd") file is. Using access() loses because it may lose
2817 if the caller is the superuser; failing to use it loses if
2818 there are ACLs or some such. */
2822 /* FIXME-maybe: might want "set path" command so user can change what
2823 path is used from within GDB. */
2824 const char *path
= getenv ("PATH");
2826 struct stat statbuf
;
2829 path
= "/bin:/usr/bin";
2831 tryname
= (char *) alloca (strlen (path
) + strlen (shell_file
) + 2);
2832 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
2834 p1
= strchr (p
, ':');
2839 strncpy (tryname
, p
, len
);
2840 tryname
[len
] = '\0';
2841 strcat (tryname
, "/");
2842 strcat (tryname
, shell_file
);
2843 if (access (tryname
, X_OK
) < 0)
2845 if (stat (tryname
, &statbuf
) < 0)
2847 if (!S_ISREG (statbuf
.st_mode
))
2848 /* We certainly need to reject directories. I'm not quite
2849 as sure about FIFOs, sockets, etc., but I kind of doubt
2850 that people want to exec() these things. */
2855 /* Not found. This must be an error rather than merely passing
2856 the file to execlp(), because execlp() would try all the
2857 exec()s, causing GDB to get confused. */
2858 error (_("procfs:%d -- Can't find shell %s in PATH"),
2859 __LINE__
, shell_file
);
2861 shell_file
= tryname
;
2864 inferior
*inf
= current_inferior ();
2865 if (!inf
->target_is_pushed (this))
2866 inf
->push_target (this);
2868 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
2869 NULL
, procfs_pre_trace
, shell_file
, NULL
);
2871 /* We have something that executes now. We'll be running through
2872 the shell at this point (if startup-with-shell is true), but the
2873 pid shouldn't change. */
2874 thread_info
*thr
= add_thread_silent (this, ptid_t (pid
));
2875 switch_to_thread (thr
);
2877 procfs_init_inferior (pid
);
2880 /* Callback for update_thread_list. Calls "add_thread". */
2883 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
2885 ptid_t gdb_threadid
= ptid_t (pi
->pid
, thread
->tid
, 0);
2887 thread_info
*thr
= find_thread_ptid (&the_procfs_target
, gdb_threadid
);
2888 if (thr
== NULL
|| thr
->state
== THREAD_EXITED
)
2889 add_thread (&the_procfs_target
, gdb_threadid
);
2894 /* Query all the threads that the target knows about, and give them
2895 back to GDB to add to its list. */
2898 procfs_target::update_thread_list ()
2904 /* Find procinfo for main process. */
2905 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
2906 proc_update_threads (pi
);
2907 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
2910 /* Return true if the thread is still 'alive'. This guy doesn't
2911 really seem to be doing his job. Got to investigate how to tell
2912 when a thread is really gone. */
2915 procfs_target::thread_alive (ptid_t ptid
)
2921 thread
= ptid
.lwp ();
2922 /* If I don't know it, it ain't alive! */
2923 pi
= find_procinfo (proc
, thread
);
2927 /* If I can't get its status, it ain't alive!
2928 What's more, I need to forget about it! */
2929 if (!proc_get_status (pi
))
2931 destroy_procinfo (pi
);
2934 /* I couldn't have got its status if it weren't alive, so it's
2939 /* Convert PTID to a string. */
2942 procfs_target::pid_to_str (ptid_t ptid
)
2944 if (ptid
.lwp () == 0)
2945 return string_printf ("process %d", ptid
.pid ());
2947 return string_printf ("LWP %ld", ptid
.lwp ());
2950 /* Accepts an integer PID; Returns a string representing a file that
2951 can be opened to get the symbols for the child process. */
2954 procfs_target::pid_to_exec_file (int pid
)
2956 static char buf
[PATH_MAX
];
2957 char name
[PATH_MAX
];
2959 /* Solaris 11 introduced /proc/<proc-id>/execname. */
2960 xsnprintf (name
, sizeof (name
), "/proc/%d/execname", pid
);
2961 scoped_fd
fd (gdb_open_cloexec (name
, O_RDONLY
, 0));
2962 if (fd
.get () < 0 || read (fd
.get (), buf
, PATH_MAX
- 1) < 0)
2964 /* If that fails, fall back to /proc/<proc-id>/path/a.out introduced in
2968 xsnprintf (name
, sizeof (name
), "/proc/%d/path/a.out", pid
);
2969 len
= readlink (name
, buf
, PATH_MAX
- 1);
2979 /* Insert a watchpoint. */
2982 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
2988 pi
= find_procinfo_or_die (ptid
.pid () == -1 ?
2989 inferior_ptid
.pid () : ptid
.pid (),
2992 /* Translate from GDB's flags to /proc's. */
2993 if (len
> 0) /* len == 0 means delete watchpoint. */
2995 switch (rwflag
) { /* FIXME: need an enum! */
2996 case hw_write
: /* default watchpoint (write) */
2999 case hw_read
: /* read watchpoint */
3002 case hw_access
: /* access watchpoint */
3003 pflags
= WA_READ
| WA_WRITE
;
3005 case hw_execute
: /* execution HW breakpoint */
3008 default: /* Something weird. Return error. */
3011 if (after
) /* Stop after r/w access is completed. */
3012 pflags
|= WA_TRAPAFTER
;
3015 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
3017 if (errno
== E2BIG
) /* Typical error for no resources. */
3018 return -1; /* fail */
3019 /* GDB may try to remove the same watchpoint twice.
3020 If a remove request returns no match, don't error. */
3021 if (errno
== ESRCH
&& len
== 0)
3022 return 0; /* ignore */
3023 proc_error (pi
, "set_watchpoint", __LINE__
);
3028 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
3029 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
3030 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
3034 procfs_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int othertype
)
3036 /* Due to the way that proc_set_watchpoint() is implemented, host
3037 and target pointers must be of the same size. If they are not,
3038 we can't use hardware watchpoints. This limitation is due to the
3039 fact that proc_set_watchpoint() calls
3040 procfs_address_to_host_pointer(); a close inspection of
3041 procfs_address_to_host_pointer will reveal that an internal error
3042 will be generated when the host and target pointer sizes are
3044 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
3046 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
3049 /* Other tests here??? */
3054 /* Returns non-zero if process is stopped on a hardware watchpoint
3055 fault, else returns zero. */
3058 procfs_target::stopped_by_watchpoint ()
3062 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3064 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3065 if (proc_why (pi
) == PR_FAULTED
)
3066 if (proc_what (pi
) == FLTWATCH
)
3071 /* Returns 1 if the OS knows the position of the triggered watchpoint,
3072 and sets *ADDR to that address. Returns 0 if OS cannot report that
3073 address. This function is only called if
3074 procfs_stopped_by_watchpoint returned 1, thus no further checks are
3075 done. The function also assumes that ADDR is not NULL. */
3078 procfs_target::stopped_data_address (CORE_ADDR
*addr
)
3082 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3083 return proc_watchpoint_address (pi
, addr
);
3087 procfs_target::insert_watchpoint (CORE_ADDR addr
, int len
,
3088 enum target_hw_bp_type type
,
3089 struct expression
*cond
)
3091 if (!target_have_steppable_watchpoint ()
3092 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
3093 /* When a hardware watchpoint fires off the PC will be left at
3094 the instruction following the one which caused the
3095 watchpoint. It will *NOT* be necessary for GDB to step over
3097 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
3099 /* When a hardware watchpoint fires off the PC will be left at
3100 the instruction which caused the watchpoint. It will be
3101 necessary for GDB to step over the watchpoint. */
3102 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
3106 procfs_target::remove_watchpoint (CORE_ADDR addr
, int len
,
3107 enum target_hw_bp_type type
,
3108 struct expression
*cond
)
3110 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
3114 procfs_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3116 /* The man page for proc(4) on Solaris 2.6 and up says that the
3117 system can support "thousands" of hardware watchpoints, but gives
3118 no method for finding out how many; It doesn't say anything about
3119 the allowed size for the watched area either. So we just tell
3124 /* Memory Mappings Functions: */
3126 /* Call a callback function once for each mapping, passing it the
3127 mapping, an optional secondary callback function, and some optional
3128 opaque data. Quit and return the first non-zero value returned
3131 PI is the procinfo struct for the process to be mapped. FUNC is
3132 the callback function to be called by this iterator. DATA is the
3133 optional opaque data to be passed to the callback function.
3134 CHILD_FUNC is the optional secondary function pointer to be passed
3135 to the child function. Returns the first non-zero return value
3136 from the callback function, or zero. */
3139 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
3141 int (*func
) (struct prmap
*map
,
3142 find_memory_region_ftype child_func
,
3145 char pathname
[MAX_PROC_NAME_SIZE
];
3146 struct prmap
*prmaps
;
3147 struct prmap
*prmap
;
3152 /* Get the number of mappings, allocate space,
3153 and read the mappings into prmaps. */
3155 xsnprintf (pathname
, sizeof (pathname
), "/proc/%d/map", pi
->pid
);
3157 scoped_fd
map_fd (open (pathname
, O_RDONLY
));
3158 if (map_fd
.get () < 0)
3159 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
3161 /* Use stat to determine the file size, and compute
3162 the number of prmap_t objects it contains. */
3163 if (fstat (map_fd
.get (), &sbuf
) != 0)
3164 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
3166 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
3167 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
3168 if (read (map_fd
.get (), (char *) prmaps
, nmap
* sizeof (*prmaps
))
3169 != (nmap
* sizeof (*prmaps
)))
3170 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
3172 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
3174 funcstat
= (*func
) (prmap
, child_func
, data
);
3182 /* Implements the to_find_memory_regions method. Calls an external
3183 function for each memory region.
3184 Returns the integer value returned by the callback. */
3187 find_memory_regions_callback (struct prmap
*map
,
3188 find_memory_region_ftype func
, void *data
)
3190 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
3192 (map
->pr_mflags
& MA_READ
) != 0,
3193 (map
->pr_mflags
& MA_WRITE
) != 0,
3194 (map
->pr_mflags
& MA_EXEC
) != 0,
3195 1, /* MODIFIED is unknown, pass it as true. */
3199 /* External interface. Calls a callback function once for each
3200 mapped memory region in the child process, passing as arguments:
3202 CORE_ADDR virtual_address,
3204 int read, TRUE if region is readable by the child
3205 int write, TRUE if region is writable by the child
3206 int execute TRUE if region is executable by the child.
3208 Stops iterating and returns the first non-zero value returned by
3212 procfs_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
3214 procinfo
*pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3216 return iterate_over_mappings (pi
, func
, data
,
3217 find_memory_regions_callback
);
3220 /* Returns an ascii representation of a memory mapping's flags. */
3223 mappingflags (long flags
)
3225 static char asciiflags
[8];
3227 strcpy (asciiflags
, "-------");
3228 if (flags
& MA_STACK
)
3229 asciiflags
[1] = 's';
3230 if (flags
& MA_BREAK
)
3231 asciiflags
[2] = 'b';
3232 if (flags
& MA_SHARED
)
3233 asciiflags
[3] = 's';
3234 if (flags
& MA_READ
)
3235 asciiflags
[4] = 'r';
3236 if (flags
& MA_WRITE
)
3237 asciiflags
[5] = 'w';
3238 if (flags
& MA_EXEC
)
3239 asciiflags
[6] = 'x';
3240 return (asciiflags
);
3243 /* Callback function, does the actual work for 'info proc
3247 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
3250 unsigned int pr_off
;
3252 pr_off
= (unsigned int) map
->pr_offset
;
3254 if (gdbarch_addr_bit (target_gdbarch ()) == 32)
3255 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
3256 (unsigned long) map
->pr_vaddr
,
3257 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3258 (unsigned long) map
->pr_size
,
3260 mappingflags (map
->pr_mflags
));
3262 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
3263 (unsigned long) map
->pr_vaddr
,
3264 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3265 (unsigned long) map
->pr_size
,
3267 mappingflags (map
->pr_mflags
));
3272 /* Implement the "info proc mappings" subcommand. */
3275 info_proc_mappings (procinfo
*pi
, int summary
)
3278 return; /* No output for summary mode. */
3280 printf_filtered (_("Mapped address spaces:\n\n"));
3281 if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
3282 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3289 printf_filtered (" %18s %18s %10s %10s %7s\n",
3296 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
3297 printf_filtered ("\n");
3300 /* Implement the "info proc" command. */
3303 procfs_target::info_proc (const char *args
, enum info_proc_what what
)
3305 procinfo
*process
= NULL
;
3306 procinfo
*thread
= NULL
;
3323 error (_("Not supported on this target."));
3326 gdb_argv
built_argv (args
);
3327 for (char *arg
: built_argv
)
3329 if (isdigit (arg
[0]))
3331 pid
= strtoul (arg
, &tmp
, 10);
3333 tid
= strtoul (++tmp
, NULL
, 10);
3335 else if (arg
[0] == '/')
3337 tid
= strtoul (arg
+ 1, NULL
, 10);
3341 procinfo_up temporary_procinfo
;
3343 pid
= inferior_ptid
.pid ();
3345 error (_("No current process: you must name one."));
3348 /* Have pid, will travel.
3349 First see if it's a process we're already debugging. */
3350 process
= find_procinfo (pid
, 0);
3351 if (process
== NULL
)
3353 /* No. So open a procinfo for it, but
3354 remember to close it again when finished. */
3355 process
= create_procinfo (pid
, 0);
3356 temporary_procinfo
.reset (process
);
3357 if (!open_procinfo_files (process
, FD_CTL
))
3358 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
3362 thread
= create_procinfo (pid
, tid
);
3366 printf_filtered (_("process %d flags:\n"), process
->pid
);
3367 proc_prettyprint_flags (proc_flags (process
), 1);
3368 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
3369 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
3370 if (proc_get_nthreads (process
) > 1)
3371 printf_filtered ("Process has %d threads.\n",
3372 proc_get_nthreads (process
));
3376 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
3377 proc_prettyprint_flags (proc_flags (thread
), 1);
3378 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
3379 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
3383 info_proc_mappings (process
, 0);
3388 /* Modify the status of the system call identified by SYSCALLNUM in
3389 the set of syscalls that are currently traced/debugged.
3391 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
3392 will be updated. Otherwise, the exit syscalls set will be updated.
3394 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
3395 will be disabled. */
3398 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
3399 int mode
, int from_tty
)
3403 if (entry_or_exit
== PR_SYSENTRY
)
3404 sysset
= proc_get_traced_sysentry (pi
, NULL
);
3406 sysset
= proc_get_traced_sysexit (pi
, NULL
);
3409 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
3411 if (mode
== FLAG_SET
)
3412 praddset (sysset
, syscallnum
);
3414 prdelset (sysset
, syscallnum
);
3416 if (entry_or_exit
== PR_SYSENTRY
)
3418 if (!proc_set_traced_sysentry (pi
, sysset
))
3419 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
3423 if (!proc_set_traced_sysexit (pi
, sysset
))
3424 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
3429 proc_trace_syscalls (const char *args
, int from_tty
, int entry_or_exit
, int mode
)
3433 if (inferior_ptid
.pid () <= 0)
3434 error (_("you must be debugging a process to use this command."));
3436 if (args
== NULL
|| args
[0] == 0)
3437 error_no_arg (_("system call to trace"));
3439 pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3440 if (isdigit (args
[0]))
3442 const int syscallnum
= atoi (args
);
3444 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
3449 proc_trace_sysentry_cmd (const char *args
, int from_tty
)
3451 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
3455 proc_trace_sysexit_cmd (const char *args
, int from_tty
)
3457 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
3461 proc_untrace_sysentry_cmd (const char *args
, int from_tty
)
3463 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
3467 proc_untrace_sysexit_cmd (const char *args
, int from_tty
)
3469 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
3472 void _initialize_procfs ();
3474 _initialize_procfs ()
3476 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
3477 _("Give a trace of entries into the syscall."));
3478 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
3479 _("Give a trace of exits from the syscall."));
3480 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
3481 _("Cancel a trace of entries into the syscall."));
3482 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
3483 _("Cancel a trace of exits from the syscall."));
3485 add_inf_child_target (&the_procfs_target
);
3488 /* =================== END, GDB "MODULE" =================== */
3492 /* miscellaneous stubs: */
3494 /* The following satisfy a few random symbols mostly created by the
3495 solaris threads implementation, which I will chase down later. */
3497 /* Return a pid for which we guarantee we will be able to find a
3501 procfs_first_available (void)
3503 return ptid_t (procinfo_list
? procinfo_list
->pid
: -1);
3506 /* =================== GCORE .NOTE "MODULE" =================== */
3509 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
3510 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
3511 int *note_size
, enum gdb_signal stop_signal
)
3513 struct regcache
*regcache
= get_thread_regcache (&the_procfs_target
, ptid
);
3514 gdb_gregset_t gregs
;
3515 gdb_fpregset_t fpregs
;
3516 unsigned long merged_pid
;
3518 merged_pid
= ptid
.lwp () << 16 | ptid
.pid ();
3520 /* This part is the old method for fetching registers.
3521 It should be replaced by the newer one using regsets
3522 once it is implemented in this platform:
3523 gdbarch_iterate_over_regset_sections(). */
3525 target_fetch_registers (regcache
, -1);
3527 fill_gregset (regcache
, &gregs
, -1);
3528 note_data
.reset (elfcore_write_lwpstatus (obfd
,
3529 note_data
.release (),
3534 fill_fpregset (regcache
, &fpregs
, -1);
3535 note_data
.reset (elfcore_write_prfpreg (obfd
,
3536 note_data
.release (),
3542 struct procfs_corefile_thread_data
3544 procfs_corefile_thread_data (bfd
*obfd
,
3545 gdb::unique_xmalloc_ptr
<char> ¬e_data
,
3546 int *note_size
, gdb_signal stop_signal
)
3547 : obfd (obfd
), note_data (note_data
), note_size (note_size
),
3548 stop_signal (stop_signal
)
3552 gdb::unique_xmalloc_ptr
<char> ¬e_data
;
3554 enum gdb_signal stop_signal
;
3558 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
3560 struct procfs_corefile_thread_data
*args
3561 = (struct procfs_corefile_thread_data
*) data
;
3565 ptid_t ptid
= ptid_t (pi
->pid
, thread
->tid
, 0);
3567 procfs_do_thread_registers (args
->obfd
, ptid
,
3576 find_signalled_thread (struct thread_info
*info
, void *data
)
3578 if (info
->stop_signal () != GDB_SIGNAL_0
3579 && info
->ptid
.pid () == inferior_ptid
.pid ())
3585 static enum gdb_signal
3586 find_stop_signal (void)
3588 struct thread_info
*info
=
3589 iterate_over_threads (find_signalled_thread
, NULL
);
3592 return info
->stop_signal ();
3594 return GDB_SIGNAL_0
;
3597 gdb::unique_xmalloc_ptr
<char>
3598 procfs_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
3600 gdb_gregset_t gregs
;
3601 char fname
[16] = {'\0'};
3602 char psargs
[80] = {'\0'};
3603 procinfo
*pi
= find_procinfo_or_die (inferior_ptid
.pid (), 0);
3604 gdb::unique_xmalloc_ptr
<char> note_data
;
3605 enum gdb_signal stop_signal
;
3607 if (get_exec_file (0))
3609 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
3610 fname
[sizeof (fname
) - 1] = 0;
3611 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3612 psargs
[sizeof (psargs
) - 1] = 0;
3614 const std::string
&inf_args
= current_inferior ()->args ();
3615 if (!inf_args
.empty () &&
3616 inf_args
.length () < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
3618 strncat (psargs
, " ",
3619 sizeof (psargs
) - strlen (psargs
));
3620 strncat (psargs
, inf_args
.c_str (),
3621 sizeof (psargs
) - strlen (psargs
));
3625 note_data
.reset (elfcore_write_prpsinfo (obfd
,
3626 note_data
.release (),
3631 stop_signal
= find_stop_signal ();
3633 fill_gregset (get_current_regcache (), &gregs
, -1);
3634 note_data
.reset (elfcore_write_pstatus (obfd
, note_data
.release (), note_size
,
3635 inferior_ptid
.pid (),
3636 stop_signal
, &gregs
));
3638 procfs_corefile_thread_data
thread_args (obfd
, note_data
, note_size
,
3640 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
3643 gdb::optional
<gdb::byte_vector
> auxv
=
3644 target_read_alloc (current_inferior ()->top_target (),
3645 TARGET_OBJECT_AUXV
, NULL
);
3646 if (auxv
&& !auxv
->empty ())
3647 note_data
.reset (elfcore_write_note (obfd
, note_data
.release (), note_size
,
3648 "CORE", NT_AUXV
, auxv
->data (),
3653 /* =================== END GCORE .NOTE "MODULE" =================== */