1 /* Machine independent support for Solaris /proc (process file system) for GDB.
3 Copyright (C) 1999-2018 Free Software Foundation, Inc.
5 Written by Michael Snyder at Cygnus Solutions.
6 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "elf-bfd.h" /* for elfcore_write_* */
30 #include "gdbthread.h"
32 #include "inf-child.h"
33 #include "nat/fork-inferior.h"
34 #include "filestuff.h"
36 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
38 #include <sys/procfs.h>
39 #include <sys/fault.h>
40 #include <sys/syscall.h>
48 #include "observable.h"
49 #include "common/scoped_fd.h"
51 /* This module provides the interface between GDB and the
52 /proc file system, which is used on many versions of Unix
53 as a means for debuggers to control other processes.
55 /proc works by imitating a file system: you open a simulated file
56 that represents the process you wish to interact with, and perform
57 operations on that "file" in order to examine or change the state
60 The most important thing to know about /proc and this module is
61 that there are two very different interfaces to /proc:
63 One that uses the ioctl system call, and another that uses read
64 and write system calls.
66 This module supports only the Solaris version of the read/write
69 #include <sys/types.h>
70 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
72 #include <fcntl.h> /* for O_RDONLY */
73 #include <unistd.h> /* for "X_OK" */
74 #include <sys/stat.h> /* for struct stat */
76 /* Note: procfs-utils.h must be included after the above system header
77 files, because it redefines various system calls using macros.
78 This may be incompatible with the prototype declarations. */
80 #include "proc-utils.h"
82 /* Prototypes for supply_gregset etc. */
85 /* =================== TARGET_OPS "MODULE" =================== */
87 /* This module defines the GDB target vector and its methods. */
90 static enum target_xfer_status
procfs_xfer_memory (gdb_byte
*,
95 class procfs_target final
: public inf_child_target
98 void create_inferior (const char *, const std::string
&,
99 char **, int) override
;
101 void kill () override
;
103 void mourn_inferior () override
;
105 void attach (const char *, int) override
;
106 void detach (inferior
*inf
, int) override
;
108 void resume (ptid_t
, int, enum gdb_signal
) override
;
109 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
111 void fetch_registers (struct regcache
*, int) override
;
112 void store_registers (struct regcache
*, int) override
;
114 enum target_xfer_status
xfer_partial (enum target_object object
,
117 const gdb_byte
*writebuf
,
118 ULONGEST offset
, ULONGEST len
,
119 ULONGEST
*xfered_len
) override
;
121 void pass_signals (int, unsigned char *) override
;
123 void files_info () override
;
125 void update_thread_list () override
;
127 int thread_alive (ptid_t ptid
) override
;
129 const char *pid_to_str (ptid_t
) 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 char *make_corefile_notes (bfd
*, int *) override
;
140 bool info_proc (const char *, enum info_proc_what
) override
;
142 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
143 int auxv_parse (gdb_byte
**readptr
,
144 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
148 int 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 int stopped_data_address (CORE_ADDR
*) override
;
162 static procfs_target the_procfs_target
;
164 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
165 /* When GDB is built as 64-bit application on Solaris, the auxv data
166 is presented in 64-bit format. We need to provide a custom parser
169 procfs_target::auxv_parse (gdb_byte
**readptr
,
170 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
172 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
173 gdb_byte
*ptr
= *readptr
;
178 if (endptr
- ptr
< 8 * 2)
181 *typep
= extract_unsigned_integer (ptr
, 4, byte_order
);
183 /* The size of data is always 64-bit. If the application is 32-bit,
184 it will be zero extended, as expected. */
185 *valp
= extract_unsigned_integer (ptr
, 8, byte_order
);
193 /* =================== END, TARGET_OPS "MODULE" =================== */
195 /* World Unification:
197 Put any typedefs, defines etc. here that are required for the
198 unification of code that handles different versions of /proc. */
200 enum { READ_WATCHFLAG
= WA_READ
,
201 WRITE_WATCHFLAG
= WA_WRITE
,
202 EXEC_WATCHFLAG
= WA_EXEC
,
203 AFTER_WATCHFLAG
= WA_TRAPAFTER
207 /* =================== STRUCT PROCINFO "MODULE" =================== */
209 /* FIXME: this comment will soon be out of date W.R.T. threads. */
211 /* The procinfo struct is a wrapper to hold all the state information
212 concerning a /proc process. There should be exactly one procinfo
213 for each process, and since GDB currently can debug only one
214 process at a time, that means there should be only one procinfo.
215 All of the LWP's of a process can be accessed indirectly thru the
216 single process procinfo.
218 However, against the day when GDB may debug more than one process,
219 this data structure is kept in a list (which for now will hold no
220 more than one member), and many functions will have a pointer to a
221 procinfo as an argument.
223 There will be a separate procinfo structure for use by the (not yet
224 implemented) "info proc" command, so that we can print useful
225 information about any random process without interfering with the
226 inferior's procinfo information. */
228 /* format strings for /proc paths */
229 #define MAIN_PROC_NAME_FMT "/proc/%d"
230 #define CTL_PROC_NAME_FMT "/proc/%d/ctl"
231 #define AS_PROC_NAME_FMT "/proc/%d/as"
232 #define MAP_PROC_NAME_FMT "/proc/%d/map"
233 #define STATUS_PROC_NAME_FMT "/proc/%d/status"
234 #define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
236 typedef struct procinfo
{
237 struct procinfo
*next
;
238 int pid
; /* Process ID */
239 int tid
; /* Thread/LWP id */
243 int ignore_next_sigstop
;
245 int ctl_fd
; /* File descriptor for /proc control file */
246 int status_fd
; /* File descriptor for /proc status file */
247 int as_fd
; /* File descriptor for /proc as file */
249 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
251 fltset_t saved_fltset
; /* Saved traced hardware fault set */
252 sigset_t saved_sigset
; /* Saved traced signal set */
253 sigset_t saved_sighold
; /* Saved held signal set */
254 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
255 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
257 pstatus_t prstatus
; /* Current process status info */
259 struct procinfo
*thread_list
;
261 int status_valid
: 1;
263 int fpregs_valid
: 1;
264 int threads_valid
: 1;
267 static char errmsg
[128]; /* shared error msg buffer */
269 /* Function prototypes for procinfo module: */
271 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
272 static procinfo
*find_procinfo (int pid
, int tid
);
273 static procinfo
*create_procinfo (int pid
, int tid
);
274 static void destroy_procinfo (procinfo
*p
);
275 static void do_destroy_procinfo_cleanup (void *);
276 static void dead_procinfo (procinfo
*p
, const char *msg
, int killp
);
277 static int open_procinfo_files (procinfo
*p
, int which
);
278 static void close_procinfo_files (procinfo
*p
);
279 static sysset_t
*sysset_t_alloc (procinfo
*pi
);
281 static int iterate_over_mappings
282 (procinfo
*pi
, find_memory_region_ftype child_func
, void *data
,
283 int (*func
) (struct prmap
*map
, find_memory_region_ftype child_func
,
286 /* The head of the procinfo list: */
287 static procinfo
*procinfo_list
;
289 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
293 find_procinfo (int pid
, int tid
)
297 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
304 /* Don't check threads_valid. If we're updating the
305 thread_list, we want to find whatever threads are already
306 here. This means that in general it is the caller's
307 responsibility to check threads_valid and update before
308 calling find_procinfo, if the caller wants to find a new
311 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
319 /* Calls find_procinfo, but errors on failure. */
322 find_procinfo_or_die (int pid
, int tid
)
324 procinfo
*pi
= find_procinfo (pid
, tid
);
329 error (_("procfs: couldn't find pid %d "
330 "(kernel thread %d) in procinfo list."),
333 error (_("procfs: couldn't find pid %d in procinfo list."), pid
);
338 /* Wrapper for `open'. The appropriate open call is attempted; if
339 unsuccessful, it will be retried as many times as needed for the
340 EAGAIN and EINTR conditions.
342 For other conditions, retry the open a limited number of times. In
343 addition, a short sleep is imposed prior to retrying the open. The
344 reason for this sleep is to give the kernel a chance to catch up
345 and create the file in question in the event that GDB "wins" the
346 race to open a file before the kernel has created it. */
349 open_with_retry (const char *pathname
, int flags
)
351 int retries_remaining
, status
;
353 retries_remaining
= 2;
357 status
= open (pathname
, flags
);
359 if (status
>= 0 || retries_remaining
== 0)
361 else if (errno
!= EINTR
&& errno
!= EAGAIN
)
371 /* Open the file descriptor for the process or LWP. We only open the
372 control file descriptor; the others are opened lazily as needed.
373 Returns the file descriptor, or zero for failure. */
375 enum { FD_CTL
, FD_STATUS
, FD_AS
};
378 open_procinfo_files (procinfo
*pi
, int which
)
380 char tmp
[MAX_PROC_NAME_SIZE
];
383 /* This function is getting ALMOST long enough to break up into
384 several. Here is some rationale:
386 There are several file descriptors that may need to be open
387 for any given process or LWP. The ones we're intereted in are:
388 - control (ctl) write-only change the state
389 - status (status) read-only query the state
390 - address space (as) read/write access memory
391 - map (map) read-only virtual addr map
392 Most of these are opened lazily as they are needed.
393 The pathnames for the 'files' for an LWP look slightly
394 different from those of a first-class process:
395 Pathnames for a process (<proc-id>):
397 /proc/<proc-id>/status
400 Pathnames for an LWP (lwp-id):
401 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
402 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
403 An LWP has no map or address space file descriptor, since
404 the memory map and address space are shared by all LWPs. */
406 /* In this case, there are several different file descriptors that
407 we might be asked to open. The control file descriptor will be
408 opened early, but the others will be opened lazily as they are
411 strcpy (tmp
, pi
->pathname
);
412 switch (which
) { /* Which file descriptor to open? */
415 strcat (tmp
, "/lwpctl");
417 strcat (tmp
, "/ctl");
418 fd
= open_with_retry (tmp
, O_WRONLY
);
425 return 0; /* There is no 'as' file descriptor for an lwp. */
427 fd
= open_with_retry (tmp
, O_RDWR
);
434 strcat (tmp
, "/lwpstatus");
436 strcat (tmp
, "/status");
437 fd
= open_with_retry (tmp
, O_RDONLY
);
443 return 0; /* unknown file descriptor */
446 return 1; /* success */
449 /* Allocate a data structure and link it into the procinfo list.
450 First tries to find a pre-existing one (FIXME: why?). Returns the
451 pointer to new procinfo struct. */
454 create_procinfo (int pid
, int tid
)
456 procinfo
*pi
, *parent
= NULL
;
458 if ((pi
= find_procinfo (pid
, tid
)))
459 return pi
; /* Already exists, nothing to do. */
461 /* Find parent before doing malloc, to save having to cleanup. */
463 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
465 doesn't exist yet? */
467 pi
= XNEW (procinfo
);
468 memset (pi
, 0, sizeof (procinfo
));
472 pi
->saved_entryset
= sysset_t_alloc (pi
);
473 pi
->saved_exitset
= sysset_t_alloc (pi
);
475 /* Chain into list. */
478 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
479 pi
->next
= procinfo_list
;
484 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
485 pi
->next
= parent
->thread_list
;
486 parent
->thread_list
= pi
;
491 /* Close all file descriptors associated with the procinfo. */
494 close_procinfo_files (procinfo
*pi
)
500 if (pi
->status_fd
> 0)
501 close (pi
->status_fd
);
502 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
505 /* Destructor function. Close, unlink and deallocate the object. */
508 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
512 /* Step one: unlink the procinfo from its list. */
516 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
519 ptr
->next
= pi
->next
;
523 /* Step two: close any open file descriptors. */
524 close_procinfo_files (pi
);
526 /* Step three: free the memory. */
527 xfree (pi
->saved_entryset
);
528 xfree (pi
->saved_exitset
);
533 destroy_procinfo (procinfo
*pi
)
537 if (pi
->tid
!= 0) /* Destroy a thread procinfo. */
539 tmp
= find_procinfo (pi
->pid
, 0); /* Find the parent process. */
540 destroy_one_procinfo (&tmp
->thread_list
, pi
);
542 else /* Destroy a process procinfo and all its threads. */
544 /* First destroy the children, if any; */
545 while (pi
->thread_list
!= NULL
)
546 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
547 /* Then destroy the parent. Genocide!!! */
548 destroy_one_procinfo (&procinfo_list
, pi
);
553 do_destroy_procinfo_cleanup (void *pi
)
555 destroy_procinfo ((procinfo
*) pi
);
558 enum { NOKILL
, KILL
};
560 /* To be called on a non_recoverable error for a procinfo. Prints
561 error messages, optionally sends a SIGKILL to the process, then
562 destroys the data structure. */
565 dead_procinfo (procinfo
*pi
, const char *msg
, int kill_p
)
571 print_sys_errmsg (pi
->pathname
, errno
);
575 sprintf (procfile
, "process %d", pi
->pid
);
576 print_sys_errmsg (procfile
, errno
);
579 kill (pi
->pid
, SIGKILL
);
581 destroy_procinfo (pi
);
585 /* Allocate and (partially) initialize a sysset_t struct. */
588 sysset_t_alloc (procinfo
*pi
)
590 return (sysset_t
*) xmalloc (sizeof (sysset_t
));
593 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
595 /* =================== /proc "MODULE" =================== */
597 /* This "module" is the interface layer between the /proc system API
598 and the gdb target vector functions. This layer consists of access
599 functions that encapsulate each of the basic operations that we
600 need to use from the /proc API.
602 The main motivation for this layer is to hide the fact that there
603 are two very different implementations of the /proc API. Rather
604 than have a bunch of #ifdefs all thru the gdb target vector
605 functions, we do our best to hide them all in here. */
607 static long proc_flags (procinfo
*pi
);
608 static int proc_why (procinfo
*pi
);
609 static int proc_what (procinfo
*pi
);
610 static int proc_set_current_signal (procinfo
*pi
, int signo
);
611 static int proc_get_current_thread (procinfo
*pi
);
612 static int proc_iterate_over_threads
614 int (*func
) (procinfo
*, procinfo
*, void *),
618 proc_warn (procinfo
*pi
, const char *func
, int line
)
620 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
621 print_sys_errmsg (errmsg
, errno
);
625 proc_error (procinfo
*pi
, const char *func
, int line
)
627 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
628 perror_with_name (errmsg
);
631 /* Updates the status struct in the procinfo. There is a 'valid'
632 flag, to let other functions know when this function needs to be
633 called (so the status is only read when it is needed). The status
634 file descriptor is also only opened when it is needed. Returns
635 non-zero for success, zero for failure. */
638 proc_get_status (procinfo
*pi
)
640 /* Status file descriptor is opened "lazily". */
641 if (pi
->status_fd
== 0 &&
642 open_procinfo_files (pi
, FD_STATUS
) == 0)
644 pi
->status_valid
= 0;
648 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
649 pi
->status_valid
= 0; /* fail */
652 /* Sigh... I have to read a different data structure,
653 depending on whether this is a main process or an LWP. */
655 pi
->status_valid
= (read (pi
->status_fd
,
656 (char *) &pi
->prstatus
.pr_lwp
,
657 sizeof (lwpstatus_t
))
658 == sizeof (lwpstatus_t
));
661 pi
->status_valid
= (read (pi
->status_fd
,
662 (char *) &pi
->prstatus
,
664 == sizeof (pstatus_t
));
668 if (pi
->status_valid
)
670 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
673 proc_get_current_thread (pi
));
676 /* The status struct includes general regs, so mark them valid too. */
677 pi
->gregs_valid
= pi
->status_valid
;
678 /* In the read/write multiple-fd model, the status struct includes
679 the fp regs too, so mark them valid too. */
680 pi
->fpregs_valid
= pi
->status_valid
;
681 return pi
->status_valid
; /* True if success, false if failure. */
684 /* Returns the process flags (pr_flags field). */
687 proc_flags (procinfo
*pi
)
689 if (!pi
->status_valid
)
690 if (!proc_get_status (pi
))
691 return 0; /* FIXME: not a good failure value (but what is?) */
693 return pi
->prstatus
.pr_lwp
.pr_flags
;
696 /* Returns the pr_why field (why the process stopped). */
699 proc_why (procinfo
*pi
)
701 if (!pi
->status_valid
)
702 if (!proc_get_status (pi
))
703 return 0; /* FIXME: not a good failure value (but what is?) */
705 return pi
->prstatus
.pr_lwp
.pr_why
;
708 /* Returns the pr_what field (details of why the process stopped). */
711 proc_what (procinfo
*pi
)
713 if (!pi
->status_valid
)
714 if (!proc_get_status (pi
))
715 return 0; /* FIXME: not a good failure value (but what is?) */
717 return pi
->prstatus
.pr_lwp
.pr_what
;
720 /* This function is only called when PI is stopped by a watchpoint.
721 Assuming the OS supports it, write to *ADDR the data address which
722 triggered it and return 1. Return 0 if it is not possible to know
726 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
728 if (!pi
->status_valid
)
729 if (!proc_get_status (pi
))
732 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch (),
733 builtin_type (target_gdbarch ())->builtin_data_ptr
,
734 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
738 /* Returns the pr_nsysarg field (number of args to the current
742 proc_nsysarg (procinfo
*pi
)
744 if (!pi
->status_valid
)
745 if (!proc_get_status (pi
))
748 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
751 /* Returns the pr_sysarg field (pointer to the arguments of current
755 proc_sysargs (procinfo
*pi
)
757 if (!pi
->status_valid
)
758 if (!proc_get_status (pi
))
761 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
764 /* Set or reset any of the following process flags:
765 PR_FORK -- forked child will inherit trace flags
766 PR_RLC -- traced process runs when last /proc file closed.
767 PR_KLC -- traced process is killed when last /proc file closed.
768 PR_ASYNC -- LWP's get to run/stop independently.
770 This function is done using read/write [PCSET/PCRESET/PCUNSET].
774 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
775 mode -- 1 for set, 0 for reset.
777 Returns non-zero for success, zero for failure. */
779 enum { FLAG_RESET
, FLAG_SET
};
782 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
784 long win
= 0; /* default to fail */
786 /* These operations affect the process as a whole, and applying them
787 to an individual LWP has the same meaning as applying them to the
788 main process. Therefore, if we're ever called with a pointer to
789 an LWP's procinfo, let's substitute the process's procinfo and
790 avoid opening the LWP's file descriptor unnecessarily. */
793 pi
= find_procinfo_or_die (pi
->pid
, 0);
797 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
799 else /* Reset the flag. */
803 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
805 /* The above operation renders the procinfo's cached pstatus
807 pi
->status_valid
= 0;
810 warning (_("procfs: modify_flag failed to turn %s %s"),
811 flag
== PR_FORK
? "PR_FORK" :
812 flag
== PR_RLC
? "PR_RLC" :
813 flag
== PR_ASYNC
? "PR_ASYNC" :
814 flag
== PR_KLC
? "PR_KLC" :
816 mode
== FLAG_RESET
? "off" : "on");
821 /* Set the run_on_last_close flag. Process with all threads will
822 become runnable when debugger closes all /proc fds. Returns
823 non-zero for success, zero for failure. */
826 proc_set_run_on_last_close (procinfo
*pi
)
828 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
831 /* Reset the run_on_last_close flag. The process will NOT become
832 runnable when debugger closes its file handles. Returns non-zero
833 for success, zero for failure. */
836 proc_unset_run_on_last_close (procinfo
*pi
)
838 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
841 /* Reset inherit_on_fork flag. If the process forks a child while we
842 are registered for events in the parent, then we will NOT recieve
843 events from the child. Returns non-zero for success, zero for
847 proc_unset_inherit_on_fork (procinfo
*pi
)
849 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
852 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
853 (signal etc.), the remaining LWPs will continue to run. Returns
854 non-zero for success, zero for failure. */
857 proc_set_async (procinfo
*pi
)
859 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
862 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
863 (signal etc.), then all other LWPs will stop as well. Returns
864 non-zero for success, zero for failure. */
867 proc_unset_async (procinfo
*pi
)
869 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
872 /* Request the process/LWP to stop. Does not wait. Returns non-zero
873 for success, zero for failure. */
876 proc_stop_process (procinfo
*pi
)
880 /* We might conceivably apply this operation to an LWP, and the
881 LWP's ctl file descriptor might not be open. */
883 if (pi
->ctl_fd
== 0 &&
884 open_procinfo_files (pi
, FD_CTL
) == 0)
888 procfs_ctl_t cmd
= PCSTOP
;
890 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
896 /* Wait for the process or LWP to stop (block until it does). Returns
897 non-zero for success, zero for failure. */
900 proc_wait_for_stop (procinfo
*pi
)
904 /* We should never have to apply this operation to any procinfo
905 except the one for the main process. If that ever changes for
906 any reason, then take out the following clause and replace it
907 with one that makes sure the ctl_fd is open. */
910 pi
= find_procinfo_or_die (pi
->pid
, 0);
912 procfs_ctl_t cmd
= PCWSTOP
;
914 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
915 /* We been runnin' and we stopped -- need to update status. */
916 pi
->status_valid
= 0;
921 /* Make the process or LWP runnable.
923 Options (not all are implemented):
925 - clear current fault
926 - clear current signal
927 - abort the current system call
928 - stop as soon as finished with system call
929 - (ioctl): set traced signal set
930 - (ioctl): set held signal set
931 - (ioctl): set traced fault set
932 - (ioctl): set start pc (vaddr)
934 Always clears the current fault. PI is the process or LWP to
935 operate on. If STEP is true, set the process or LWP to trap after
936 one instruction. If SIGNO is zero, clear the current signal if
937 any; if non-zero, set the current signal to this one. Returns
938 non-zero for success, zero for failure. */
941 proc_run_process (procinfo
*pi
, int step
, int signo
)
946 /* We will probably have to apply this operation to individual
947 threads, so make sure the control file descriptor is open. */
949 if (pi
->ctl_fd
== 0 &&
950 open_procinfo_files (pi
, FD_CTL
) == 0)
955 runflags
= PRCFAULT
; /* Always clear current fault. */
960 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
961 proc_set_current_signal (pi
, signo
);
967 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
972 /* Register to trace signals in the process or LWP. Returns non-zero
973 for success, zero for failure. */
976 proc_set_traced_signals (procinfo
*pi
, sigset_t
*sigset
)
980 /* We should never have to apply this operation to any procinfo
981 except the one for the main process. If that ever changes for
982 any reason, then take out the following clause and replace it
983 with one that makes sure the ctl_fd is open. */
986 pi
= find_procinfo_or_die (pi
->pid
, 0);
990 /* Use char array to avoid alignment issues. */
991 char sigset
[sizeof (sigset_t
)];
995 memcpy (&arg
.sigset
, sigset
, sizeof (sigset_t
));
997 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
999 /* The above operation renders the procinfo's cached pstatus obsolete. */
1000 pi
->status_valid
= 0;
1003 warning (_("procfs: set_traced_signals failed"));
1007 /* Register to trace hardware faults in the process or LWP. Returns
1008 non-zero for success, zero for failure. */
1011 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1015 /* We should never have to apply this operation to any procinfo
1016 except the one for the main process. If that ever changes for
1017 any reason, then take out the following clause and replace it
1018 with one that makes sure the ctl_fd is open. */
1021 pi
= find_procinfo_or_die (pi
->pid
, 0);
1025 /* Use char array to avoid alignment issues. */
1026 char fltset
[sizeof (fltset_t
)];
1030 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1032 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1034 /* The above operation renders the procinfo's cached pstatus obsolete. */
1035 pi
->status_valid
= 0;
1040 /* Register to trace entry to system calls in the process or LWP.
1041 Returns non-zero for success, zero for failure. */
1044 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1048 /* We should never have to apply this operation to any procinfo
1049 except the one for the main process. If that ever changes for
1050 any reason, then take out the following clause and replace it
1051 with one that makes sure the ctl_fd is open. */
1054 pi
= find_procinfo_or_die (pi
->pid
, 0);
1056 struct gdb_proc_ctl_pcsentry
{
1058 /* Use char array to avoid alignment issues. */
1059 char sysset
[sizeof (sysset_t
)];
1061 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
);
1063 argp
= (struct gdb_proc_ctl_pcsentry
*) xmalloc (argp_size
);
1065 argp
->cmd
= PCSENTRY
;
1066 memcpy (&argp
->sysset
, sysset
, sizeof (sysset_t
));
1068 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1071 /* The above operation renders the procinfo's cached pstatus
1073 pi
->status_valid
= 0;
1078 /* Register to trace exit from system calls in the process or LWP.
1079 Returns non-zero for success, zero for failure. */
1082 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1086 /* We should never have to apply this operation to any procinfo
1087 except the one for the main process. If that ever changes for
1088 any reason, then take out the following clause and replace it
1089 with one that makes sure the ctl_fd is open. */
1092 pi
= find_procinfo_or_die (pi
->pid
, 0);
1094 struct gdb_proc_ctl_pcsexit
{
1096 /* Use char array to avoid alignment issues. */
1097 char sysset
[sizeof (sysset_t
)];
1099 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
);
1101 argp
= (struct gdb_proc_ctl_pcsexit
*) xmalloc (argp_size
);
1103 argp
->cmd
= PCSEXIT
;
1104 memcpy (&argp
->sysset
, sysset
, sizeof (sysset_t
));
1106 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1109 /* The above operation renders the procinfo's cached pstatus
1111 pi
->status_valid
= 0;
1116 /* Specify the set of blocked / held signals in the process or LWP.
1117 Returns non-zero for success, zero for failure. */
1120 proc_set_held_signals (procinfo
*pi
, sigset_t
*sighold
)
1124 /* We should never have to apply this operation to any procinfo
1125 except the one for the main process. If that ever changes for
1126 any reason, then take out the following clause and replace it
1127 with one that makes sure the ctl_fd is open. */
1130 pi
= find_procinfo_or_die (pi
->pid
, 0);
1134 /* Use char array to avoid alignment issues. */
1135 char hold
[sizeof (sigset_t
)];
1139 memcpy (&arg
.hold
, sighold
, sizeof (sigset_t
));
1140 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1142 /* The above operation renders the procinfo's cached pstatus
1144 pi
->status_valid
= 0;
1149 /* Returns the set of signals that are held / blocked. Will also copy
1150 the sigset if SAVE is non-zero. */
1153 proc_get_held_signals (procinfo
*pi
, sigset_t
*save
)
1155 sigset_t
*ret
= NULL
;
1157 /* We should never have to apply this operation to any procinfo
1158 except the one for the main process. If that ever changes for
1159 any reason, then take out the following clause and replace it
1160 with one that makes sure the ctl_fd is open. */
1163 pi
= find_procinfo_or_die (pi
->pid
, 0);
1165 if (!pi
->status_valid
)
1166 if (!proc_get_status (pi
))
1169 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1171 memcpy (save
, ret
, sizeof (sigset_t
));
1176 /* Returns the set of signals that are traced / debugged. Will also
1177 copy the sigset if SAVE is non-zero. */
1180 proc_get_traced_signals (procinfo
*pi
, sigset_t
*save
)
1182 sigset_t
*ret
= NULL
;
1184 /* We should never have to apply this operation to any procinfo
1185 except the one for the main process. If that ever changes for
1186 any reason, then take out the following clause and replace it
1187 with one that makes sure the ctl_fd is open. */
1190 pi
= find_procinfo_or_die (pi
->pid
, 0);
1192 if (!pi
->status_valid
)
1193 if (!proc_get_status (pi
))
1196 ret
= &pi
->prstatus
.pr_sigtrace
;
1198 memcpy (save
, ret
, sizeof (sigset_t
));
1203 /* Returns the set of hardware faults that are traced /debugged. Will
1204 also copy the faultset if SAVE is non-zero. */
1207 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
1209 fltset_t
*ret
= NULL
;
1211 /* We should never have to apply this operation to any procinfo
1212 except the one for the main process. If that ever changes for
1213 any reason, then take out the following clause and replace it
1214 with one that makes sure the ctl_fd is open. */
1217 pi
= find_procinfo_or_die (pi
->pid
, 0);
1219 if (!pi
->status_valid
)
1220 if (!proc_get_status (pi
))
1223 ret
= &pi
->prstatus
.pr_flttrace
;
1225 memcpy (save
, ret
, sizeof (fltset_t
));
1230 /* Returns the set of syscalls that are traced /debugged on entry.
1231 Will also copy the syscall set if SAVE is non-zero. */
1234 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
1236 sysset_t
*ret
= NULL
;
1238 /* We should never have to apply this operation to any procinfo
1239 except the one for the main process. If that ever changes for
1240 any reason, then take out the following clause and replace it
1241 with one that makes sure the ctl_fd is open. */
1244 pi
= find_procinfo_or_die (pi
->pid
, 0);
1246 if (!pi
->status_valid
)
1247 if (!proc_get_status (pi
))
1250 ret
= &pi
->prstatus
.pr_sysentry
;
1252 memcpy (save
, ret
, sizeof (sysset_t
));
1257 /* Returns the set of syscalls that are traced /debugged on exit.
1258 Will also copy the syscall set if SAVE is non-zero. */
1261 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
1263 sysset_t
*ret
= NULL
;
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 if (!pi
->status_valid
)
1274 if (!proc_get_status (pi
))
1277 ret
= &pi
->prstatus
.pr_sysexit
;
1279 memcpy (save
, ret
, sizeof (sysset_t
));
1284 /* The current fault (if any) is cleared; the associated signal will
1285 not be sent to the process or LWP when it resumes. Returns
1286 non-zero for success, zero for failure. */
1289 proc_clear_current_fault (procinfo
*pi
)
1293 /* We should never have to apply this operation to any procinfo
1294 except the one for the main process. If that ever changes for
1295 any reason, then take out the following clause and replace it
1296 with one that makes sure the ctl_fd is open. */
1299 pi
= find_procinfo_or_die (pi
->pid
, 0);
1301 procfs_ctl_t cmd
= PCCFAULT
;
1303 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1308 /* Set the "current signal" that will be delivered next to the
1309 process. NOTE: semantics are different from those of KILL. This
1310 signal will be delivered to the process or LWP immediately when it
1311 is resumed (even if the signal is held/blocked); it will NOT
1312 immediately cause another event of interest, and will NOT first
1313 trap back to the debugger. Returns non-zero for success, zero for
1317 proc_set_current_signal (procinfo
*pi
, int signo
)
1322 /* Use char array to avoid alignment issues. */
1323 char sinfo
[sizeof (siginfo_t
)];
1327 struct target_waitstatus wait_status
;
1329 /* We should never have to apply this operation to any procinfo
1330 except the one for the main process. If that ever changes for
1331 any reason, then take out the following clause and replace it
1332 with one that makes sure the ctl_fd is open. */
1335 pi
= find_procinfo_or_die (pi
->pid
, 0);
1337 /* The pointer is just a type alias. */
1338 get_last_target_status (&wait_ptid
, &wait_status
);
1339 if (ptid_equal (wait_ptid
, inferior_ptid
)
1340 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
1341 && wait_status
.value
.sig
== gdb_signal_from_host (signo
)
1342 && proc_get_status (pi
)
1343 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
1345 /* Use the siginfo associated with the signal being
1347 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (siginfo_t
));
1350 mysinfo
.si_signo
= signo
;
1351 mysinfo
.si_code
= 0;
1352 mysinfo
.si_pid
= getpid (); /* ?why? */
1353 mysinfo
.si_uid
= getuid (); /* ?why? */
1354 memcpy (arg
.sinfo
, &mysinfo
, sizeof (siginfo_t
));
1358 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1363 /* The current signal (if any) is cleared, and is not sent to the
1364 process or LWP when it resumes. Returns non-zero for success, zero
1368 proc_clear_current_signal (procinfo
*pi
)
1372 /* We should never have to apply this operation to any procinfo
1373 except the one for the main process. If that ever changes for
1374 any reason, then take out the following clause and replace it
1375 with one that makes sure the ctl_fd is open. */
1378 pi
= find_procinfo_or_die (pi
->pid
, 0);
1382 /* Use char array to avoid alignment issues. */
1383 char sinfo
[sizeof (siginfo_t
)];
1388 /* The pointer is just a type alias. */
1389 mysinfo
.si_signo
= 0;
1390 mysinfo
.si_code
= 0;
1391 mysinfo
.si_errno
= 0;
1392 mysinfo
.si_pid
= getpid (); /* ?why? */
1393 mysinfo
.si_uid
= getuid (); /* ?why? */
1394 memcpy (arg
.sinfo
, &mysinfo
, sizeof (siginfo_t
));
1396 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1401 /* Return the general-purpose registers for the process or LWP
1402 corresponding to PI. Upon failure, return NULL. */
1404 static gdb_gregset_t
*
1405 proc_get_gregs (procinfo
*pi
)
1407 if (!pi
->status_valid
|| !pi
->gregs_valid
)
1408 if (!proc_get_status (pi
))
1411 return &pi
->prstatus
.pr_lwp
.pr_reg
;
1414 /* Return the general-purpose registers for the process or LWP
1415 corresponding to PI. Upon failure, return NULL. */
1417 static gdb_fpregset_t
*
1418 proc_get_fpregs (procinfo
*pi
)
1420 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
1421 if (!proc_get_status (pi
))
1424 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
1427 /* Write the general-purpose registers back to the process or LWP
1428 corresponding to PI. Return non-zero for success, zero for
1432 proc_set_gregs (procinfo
*pi
)
1434 gdb_gregset_t
*gregs
;
1437 gregs
= proc_get_gregs (pi
);
1439 return 0; /* proc_get_regs has already warned. */
1441 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1449 /* Use char array to avoid alignment issues. */
1450 char gregs
[sizeof (gdb_gregset_t
)];
1454 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
1455 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1458 /* Policy: writing the registers invalidates our cache. */
1459 pi
->gregs_valid
= 0;
1463 /* Write the floating-pointer registers back to the process or LWP
1464 corresponding to PI. Return non-zero for success, zero for
1468 proc_set_fpregs (procinfo
*pi
)
1470 gdb_fpregset_t
*fpregs
;
1473 fpregs
= proc_get_fpregs (pi
);
1475 return 0; /* proc_get_fpregs has already warned. */
1477 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
1485 /* Use char array to avoid alignment issues. */
1486 char fpregs
[sizeof (gdb_fpregset_t
)];
1490 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
1491 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1494 /* Policy: writing the registers invalidates our cache. */
1495 pi
->fpregs_valid
= 0;
1499 /* Send a signal to the proc or lwp with the semantics of "kill()".
1500 Returns non-zero for success, zero for failure. */
1503 proc_kill (procinfo
*pi
, int signo
)
1507 /* We might conceivably apply this operation to an LWP, and the
1508 LWP's ctl file descriptor might not be open. */
1510 if (pi
->ctl_fd
== 0 &&
1511 open_procinfo_files (pi
, FD_CTL
) == 0)
1517 procfs_ctl_t cmd
[2];
1521 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1527 /* Find the pid of the process that started this one. Returns the
1528 parent process pid, or zero. */
1531 proc_parent_pid (procinfo
*pi
)
1533 /* We should never have to apply this operation to any procinfo
1534 except the one for the main process. If that ever changes for
1535 any reason, then take out the following clause and replace it
1536 with one that makes sure the ctl_fd is open. */
1539 pi
= find_procinfo_or_die (pi
->pid
, 0);
1541 if (!pi
->status_valid
)
1542 if (!proc_get_status (pi
))
1545 return pi
->prstatus
.pr_ppid
;
1548 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
1549 (a.k.a void pointer)! */
1552 procfs_address_to_host_pointer (CORE_ADDR addr
)
1554 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
1557 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
1558 gdbarch_address_to_pointer (target_gdbarch (), ptr_type
,
1559 (gdb_byte
*) &ptr
, addr
);
1564 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
1568 char watch
[sizeof (prwatch_t
)];
1572 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
1573 convert a target address into something that can be stored in a
1574 native data structure. */
1575 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
1576 pwatch
.pr_size
= len
;
1577 pwatch
.pr_wflags
= wflags
;
1579 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
1580 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
1583 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
1585 #include <sys/sysi86.h>
1587 /* The KEY is actually the value of the lower 16 bits of the GS
1588 register for the LWP that we're interested in. Returns the
1589 matching ssh struct (LDT entry). */
1592 proc_get_LDT_entry (procinfo
*pi
, int key
)
1594 static struct ssd
*ldt_entry
= NULL
;
1595 char pathname
[MAX_PROC_NAME_SIZE
];
1597 /* Allocate space for one LDT entry.
1598 This alloc must persist, because we return a pointer to it. */
1599 if (ldt_entry
== NULL
)
1600 ldt_entry
= XNEW (struct ssd
);
1602 /* Open the file descriptor for the LDT table. */
1603 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
1604 scoped_fd
fd (open_with_retry (pathname
, O_RDONLY
));
1607 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
1611 /* Now 'read' thru the table, find a match and return it. */
1612 while (read (fd
.get (), ldt_entry
, sizeof (struct ssd
))
1613 == sizeof (struct ssd
))
1615 if (ldt_entry
->sel
== 0 &&
1616 ldt_entry
->bo
== 0 &&
1617 ldt_entry
->acc1
== 0 &&
1618 ldt_entry
->acc2
== 0)
1619 break; /* end of table */
1620 /* If key matches, return this entry. */
1621 if (ldt_entry
->sel
== key
)
1624 /* Loop ended, match not found. */
1628 /* Returns the pointer to the LDT entry of PTID. */
1631 procfs_find_LDT_entry (ptid_t ptid
)
1633 gdb_gregset_t
*gregs
;
1637 /* Find procinfo for the lwp. */
1638 if ((pi
= find_procinfo (ptid_get_pid (ptid
), ptid_get_lwp (ptid
))) == NULL
)
1640 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
1641 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
1644 /* get its general registers. */
1645 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
1647 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
1648 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
1651 /* Now extract the GS register's lower 16 bits. */
1652 key
= (*gregs
)[GS
] & 0xffff;
1654 /* Find the matching entry and return it. */
1655 return proc_get_LDT_entry (pi
, key
);
1660 /* =============== END, non-thread part of /proc "MODULE" =============== */
1662 /* =================== Thread "MODULE" =================== */
1664 /* NOTE: you'll see more ifdefs and duplication of functions here,
1665 since there is a different way to do threads on every OS. */
1667 /* Returns the number of threads for the process. */
1670 proc_get_nthreads (procinfo
*pi
)
1672 if (!pi
->status_valid
)
1673 if (!proc_get_status (pi
))
1676 /* Only works for the process procinfo, because the LWP procinfos do not
1677 get prstatus filled in. */
1678 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
1679 pi
= find_procinfo_or_die (pi
->pid
, 0);
1680 return pi
->prstatus
.pr_nlwp
;
1685 Return the ID of the thread that had an event of interest.
1686 (ie. the one that hit a breakpoint or other traced event). All
1687 other things being equal, this should be the ID of a thread that is
1688 currently executing. */
1691 proc_get_current_thread (procinfo
*pi
)
1693 /* Note: this should be applied to the root procinfo for the
1694 process, not to the procinfo for an LWP. If applied to the
1695 procinfo for an LWP, it will simply return that LWP's ID. In
1696 that case, find the parent process procinfo. */
1699 pi
= find_procinfo_or_die (pi
->pid
, 0);
1701 if (!pi
->status_valid
)
1702 if (!proc_get_status (pi
))
1705 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
1708 /* Discover the IDs of all the threads within the process, and create
1709 a procinfo for each of them (chained to the parent). This
1710 unfortunately requires a different method on every OS. Returns
1711 non-zero for success, zero for failure. */
1714 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
1716 if (thread
&& parent
) /* sanity */
1718 thread
->status_valid
= 0;
1719 if (!proc_get_status (thread
))
1720 destroy_one_procinfo (&parent
->thread_list
, thread
);
1722 return 0; /* keep iterating */
1726 do_closedir_cleanup (void *dir
)
1728 closedir ((DIR *) dir
);
1732 proc_update_threads (procinfo
*pi
)
1734 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
1735 struct dirent
*direntry
;
1736 struct cleanup
*old_chain
= NULL
;
1741 /* We should never have to apply this operation to any procinfo
1742 except the one for the main process. If that ever changes for
1743 any reason, then take out the following clause and replace it
1744 with one that makes sure the ctl_fd is open. */
1747 pi
= find_procinfo_or_die (pi
->pid
, 0);
1749 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
1751 /* Note: this brute-force method was originally devised for Unixware
1752 (support removed since), and will also work on Solaris 2.6 and
1753 2.7. The original comment mentioned the existence of a much
1754 simpler and more elegant way to do this on Solaris, but didn't
1755 point out what that was. */
1757 strcpy (pathname
, pi
->pathname
);
1758 strcat (pathname
, "/lwp");
1759 if ((dirp
= opendir (pathname
)) == NULL
)
1760 proc_error (pi
, "update_threads, opendir", __LINE__
);
1762 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
1763 while ((direntry
= readdir (dirp
)) != NULL
)
1764 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
1766 lwpid
= atoi (&direntry
->d_name
[0]);
1767 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
1768 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
1770 pi
->threads_valid
= 1;
1771 do_cleanups (old_chain
);
1775 /* Given a pointer to a function, call that function once for each lwp
1776 in the procinfo list, until the function returns non-zero, in which
1777 event return the value returned by the function.
1779 Note: this function does NOT call update_threads. If you want to
1780 discover new threads first, you must call that function explicitly.
1781 This function just makes a quick pass over the currently-known
1784 PI is the parent process procinfo. FUNC is the per-thread
1785 function. PTR is an opaque parameter for function. Returns the
1786 first non-zero return value from the callee, or zero. */
1789 proc_iterate_over_threads (procinfo
*pi
,
1790 int (*func
) (procinfo
*, procinfo
*, void *),
1793 procinfo
*thread
, *next
;
1796 /* We should never have to apply this operation to any procinfo
1797 except the one for the main process. If that ever changes for
1798 any reason, then take out the following clause and replace it
1799 with one that makes sure the ctl_fd is open. */
1802 pi
= find_procinfo_or_die (pi
->pid
, 0);
1804 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
1806 next
= thread
->next
; /* In case thread is destroyed. */
1807 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
1814 /* =================== END, Thread "MODULE" =================== */
1816 /* =================== END, /proc "MODULE" =================== */
1818 /* =================== GDB "MODULE" =================== */
1820 /* Here are all of the gdb target vector functions and their
1823 static ptid_t
do_attach (ptid_t ptid
);
1824 static void do_detach ();
1825 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
1826 int entry_or_exit
, int mode
, int from_tty
);
1828 /* Sets up the inferior to be debugged. Registers to trace signals,
1829 hardware faults, and syscalls. Note: does not set RLC flag: caller
1830 may want to customize that. Returns zero for success (note!
1831 unlike most functions in this module); on failure, returns the LINE
1832 NUMBER where it failed! */
1835 procfs_debug_inferior (procinfo
*pi
)
1837 fltset_t traced_faults
;
1838 sigset_t traced_signals
;
1839 sysset_t
*traced_syscall_entries
;
1840 sysset_t
*traced_syscall_exits
;
1843 /* Register to trace hardware faults in the child. */
1844 prfillset (&traced_faults
); /* trace all faults... */
1845 prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
1846 if (!proc_set_traced_faults (pi
, &traced_faults
))
1849 /* Initially, register to trace all signals in the child. */
1850 prfillset (&traced_signals
);
1851 if (!proc_set_traced_signals (pi
, &traced_signals
))
1855 /* Register to trace the 'exit' system call (on entry). */
1856 traced_syscall_entries
= sysset_t_alloc (pi
);
1857 premptyset (traced_syscall_entries
);
1858 praddset (traced_syscall_entries
, SYS_exit
);
1859 praddset (traced_syscall_entries
, SYS_lwp_exit
);
1861 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
1862 xfree (traced_syscall_entries
);
1866 /* Method for tracing exec syscalls. */
1868 Not all systems with /proc have all the exec* syscalls with the same
1869 names. On the SGI, for example, there is no SYS_exec, but there
1870 *is* a SYS_execv. So, we try to account for that. */
1872 traced_syscall_exits
= sysset_t_alloc (pi
);
1873 premptyset (traced_syscall_exits
);
1875 praddset (traced_syscall_exits
, SYS_exec
);
1877 praddset (traced_syscall_exits
, SYS_execve
);
1878 praddset (traced_syscall_exits
, SYS_lwp_create
);
1879 praddset (traced_syscall_exits
, SYS_lwp_exit
);
1881 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
1882 xfree (traced_syscall_exits
);
1890 procfs_target::attach (const char *args
, int from_tty
)
1895 pid
= parse_pid_to_attach (args
);
1897 if (pid
== getpid ())
1898 error (_("Attaching GDB to itself is not a good idea..."));
1902 exec_file
= get_exec_file (0);
1905 printf_filtered (_("Attaching to program `%s', %s\n"),
1906 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
1908 printf_filtered (_("Attaching to %s\n"),
1909 target_pid_to_str (pid_to_ptid (pid
)));
1913 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1914 if (!target_is_pushed (this))
1919 procfs_target::detach (inferior
*inf
, int from_tty
)
1921 int pid
= ptid_get_pid (inferior_ptid
);
1925 const char *exec_file
;
1927 exec_file
= get_exec_file (0);
1928 if (exec_file
== NULL
)
1931 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
1932 target_pid_to_str (pid_to_ptid (pid
)));
1933 gdb_flush (gdb_stdout
);
1938 inferior_ptid
= null_ptid
;
1939 detach_inferior (pid
);
1940 maybe_unpush_target ();
1944 do_attach (ptid_t ptid
)
1947 struct inferior
*inf
;
1951 if ((pi
= create_procinfo (ptid_get_pid (ptid
), 0)) == NULL
)
1952 perror (_("procfs: out of memory in 'attach'"));
1954 if (!open_procinfo_files (pi
, FD_CTL
))
1956 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
1957 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
1958 ptid_get_pid (ptid
));
1959 dead_procinfo (pi
, errmsg
, NOKILL
);
1962 /* Stop the process (if it isn't already stopped). */
1963 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
1965 pi
->was_stopped
= 1;
1966 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
1970 pi
->was_stopped
= 0;
1971 /* Set the process to run again when we close it. */
1972 if (!proc_set_run_on_last_close (pi
))
1973 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
1975 /* Now stop the process. */
1976 if (!proc_stop_process (pi
))
1977 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
1978 pi
->ignore_next_sigstop
= 1;
1980 /* Save some of the /proc state to be restored if we detach. */
1981 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
1982 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
1983 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
1984 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
1985 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
1986 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
1988 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
1989 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
1991 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
1992 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
1994 if ((fail
= procfs_debug_inferior (pi
)) != 0)
1995 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
1997 inf
= current_inferior ();
1998 inferior_appeared (inf
, pi
->pid
);
1999 /* Let GDB know that the inferior was attached. */
2000 inf
->attach_flag
= 1;
2002 /* Create a procinfo for the current lwp. */
2003 lwpid
= proc_get_current_thread (pi
);
2004 create_procinfo (pi
->pid
, lwpid
);
2006 /* Add it to gdb's thread list. */
2007 ptid
= ptid_build (pi
->pid
, lwpid
, 0);
2018 /* Find procinfo for the main process. */
2019 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
),
2020 0); /* FIXME: threads */
2022 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
2023 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
2025 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
2026 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
2028 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
2029 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
2031 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
2032 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
2034 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
2035 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
2037 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
2038 if (!(pi
->was_stopped
)
2039 || query (_("Was stopped when attached, make it runnable again? ")))
2041 /* Clear any pending signal. */
2042 if (!proc_clear_current_fault (pi
))
2043 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
2045 if (!proc_clear_current_signal (pi
))
2046 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
2048 if (!proc_set_run_on_last_close (pi
))
2049 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
2052 destroy_procinfo (pi
);
2055 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
2058 ??? Is the following note still relevant? We can't get individual
2059 registers with the PT_GETREGS ptrace(2) request either, yet we
2060 don't bother with caching at all in that case.
2062 NOTE: Since the /proc interface cannot give us individual
2063 registers, we pay no attention to REGNUM, and just fetch them all.
2064 This results in the possibility that we will do unnecessarily many
2065 fetches, since we may be called repeatedly for individual
2066 registers. So we cache the results, and mark the cache invalid
2067 when the process is resumed. */
2070 procfs_target::fetch_registers (struct regcache
*regcache
, int regnum
)
2072 gdb_gregset_t
*gregs
;
2074 ptid_t ptid
= regcache_get_ptid (regcache
);
2075 int pid
= ptid_get_pid (ptid
);
2076 int tid
= ptid_get_lwp (ptid
);
2077 struct gdbarch
*gdbarch
= regcache
->arch ();
2079 pi
= find_procinfo_or_die (pid
, tid
);
2082 error (_("procfs: fetch_registers failed to find procinfo for %s"),
2083 target_pid_to_str (ptid
));
2085 gregs
= proc_get_gregs (pi
);
2087 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
2089 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
2091 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2093 gdb_fpregset_t
*fpregs
;
2095 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2096 || regnum
== gdbarch_pc_regnum (gdbarch
)
2097 || regnum
== gdbarch_sp_regnum (gdbarch
))
2098 return; /* Not a floating point register. */
2100 fpregs
= proc_get_fpregs (pi
);
2102 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
2104 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
2108 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
2109 this for all registers.
2111 NOTE: Since the /proc interface will not read individual registers,
2112 we will cache these requests until the process is resumed, and only
2113 then write them back to the inferior process.
2115 FIXME: is that a really bad idea? Have to think about cases where
2116 writing one register might affect the value of others, etc. */
2119 procfs_target::store_registers (struct regcache
*regcache
, int regnum
)
2121 gdb_gregset_t
*gregs
;
2123 ptid_t ptid
= regcache_get_ptid (regcache
);
2124 int pid
= ptid_get_pid (ptid
);
2125 int tid
= ptid_get_lwp (ptid
);
2126 struct gdbarch
*gdbarch
= regcache
->arch ();
2128 pi
= find_procinfo_or_die (pid
, tid
);
2131 error (_("procfs: store_registers: failed to find procinfo for %s"),
2132 target_pid_to_str (ptid
));
2134 gregs
= proc_get_gregs (pi
);
2136 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
2138 fill_gregset (regcache
, gregs
, regnum
);
2139 if (!proc_set_gregs (pi
))
2140 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
2142 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
2144 gdb_fpregset_t
*fpregs
;
2146 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
2147 || regnum
== gdbarch_pc_regnum (gdbarch
)
2148 || regnum
== gdbarch_sp_regnum (gdbarch
))
2149 return; /* Not a floating point register. */
2151 fpregs
= proc_get_fpregs (pi
);
2153 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
2155 fill_fpregset (regcache
, fpregs
, regnum
);
2156 if (!proc_set_fpregs (pi
))
2157 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
2162 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
2164 if (scall
== SYS_lwp_exit
)
2170 syscall_is_exit (procinfo
*pi
, int scall
)
2172 if (scall
== SYS_exit
)
2178 syscall_is_exec (procinfo
*pi
, int scall
)
2181 if (scall
== SYS_exec
)
2184 if (scall
== SYS_execve
)
2190 syscall_is_lwp_create (procinfo
*pi
, int scall
)
2192 if (scall
== SYS_lwp_create
)
2197 /* Retrieve the next stop event from the child process. If child has
2198 not stopped yet, wait for it to stop. Translate /proc eventcodes
2199 (or possibly wait eventcodes) into gdb internal event codes.
2200 Returns the id of process (and possibly thread) that incurred the
2201 event. Event codes are returned through a pointer parameter. */
2204 procfs_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
2207 /* First cut: loosely based on original version 2.1. */
2211 ptid_t retval
, temp_ptid
;
2212 int why
, what
, flags
;
2219 retval
= pid_to_ptid (-1);
2221 /* Find procinfo for main process. */
2222 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2225 /* We must assume that the status is stale now... */
2226 pi
->status_valid
= 0;
2227 pi
->gregs_valid
= 0;
2228 pi
->fpregs_valid
= 0;
2230 #if 0 /* just try this out... */
2231 flags
= proc_flags (pi
);
2232 why
= proc_why (pi
);
2233 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
2234 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
2236 /* If child is not stopped, wait for it to stop. */
2237 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
2238 !proc_wait_for_stop (pi
))
2240 /* wait_for_stop failed: has the child terminated? */
2241 if (errno
== ENOENT
)
2245 /* /proc file not found; presumably child has terminated. */
2246 wait_retval
= ::wait (&wstat
); /* "wait" for the child's exit. */
2249 if (wait_retval
!= ptid_get_pid (inferior_ptid
))
2250 error (_("procfs: couldn't stop "
2251 "process %d: wait returned %d."),
2252 ptid_get_pid (inferior_ptid
), wait_retval
);
2253 /* FIXME: might I not just use waitpid?
2254 Or try find_procinfo to see if I know about this child? */
2255 retval
= pid_to_ptid (wait_retval
);
2257 else if (errno
== EINTR
)
2261 /* Unknown error from wait_for_stop. */
2262 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
2267 /* This long block is reached if either:
2268 a) the child was already stopped, or
2269 b) we successfully waited for the child with wait_for_stop.
2270 This block will analyze the /proc status, and translate it
2271 into a waitstatus for GDB.
2273 If we actually had to call wait because the /proc file
2274 is gone (child terminated), then we skip this block,
2275 because we already have a waitstatus. */
2277 flags
= proc_flags (pi
);
2278 why
= proc_why (pi
);
2279 what
= proc_what (pi
);
2281 if (flags
& (PR_STOPPED
| PR_ISTOP
))
2283 /* If it's running async (for single_thread control),
2284 set it back to normal again. */
2285 if (flags
& PR_ASYNC
)
2286 if (!proc_unset_async (pi
))
2287 proc_error (pi
, "target_wait, unset_async", __LINE__
);
2290 proc_prettyprint_why (why
, what
, 1);
2292 /* The 'pid' we will return to GDB is composed of
2293 the process ID plus the lwp ID. */
2294 retval
= ptid_build (pi
->pid
, proc_get_current_thread (pi
), 0);
2298 wstat
= (what
<< 8) | 0177;
2301 if (syscall_is_lwp_exit (pi
, what
))
2303 if (print_thread_events
)
2304 printf_unfiltered (_("[%s exited]\n"),
2305 target_pid_to_str (retval
));
2306 delete_thread (retval
);
2307 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2310 else if (syscall_is_exit (pi
, what
))
2312 struct inferior
*inf
;
2314 /* Handle SYS_exit call only. */
2315 /* Stopped at entry to SYS_exit.
2316 Make it runnable, resume it, then use
2317 the wait system call to get its exit code.
2318 Proc_run_process always clears the current
2320 Then return its exit status. */
2321 pi
->status_valid
= 0;
2323 /* FIXME: what we should do is return
2324 TARGET_WAITKIND_SPURIOUS. */
2325 if (!proc_run_process (pi
, 0, 0))
2326 proc_error (pi
, "target_wait, run_process", __LINE__
);
2328 inf
= find_inferior_pid (pi
->pid
);
2329 if (inf
->attach_flag
)
2331 /* Don't call wait: simulate waiting for exit,
2332 return a "success" exit code. Bogus: what if
2333 it returns something else? */
2335 retval
= inferior_ptid
; /* ? ? ? */
2339 int temp
= ::wait (&wstat
);
2341 /* FIXME: shouldn't I make sure I get the right
2342 event from the right process? If (for
2343 instance) I have killed an earlier inferior
2344 process but failed to clean up after it
2345 somehow, I could get its termination event
2348 /* If wait returns -1, that's what we return
2351 retval
= pid_to_ptid (temp
);
2356 printf_filtered (_("procfs: trapped on entry to "));
2357 proc_prettyprint_syscall (proc_what (pi
), 0);
2358 printf_filtered ("\n");
2360 long i
, nsysargs
, *sysargs
;
2362 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
2363 (sysargs
= proc_sysargs (pi
)) != NULL
)
2365 printf_filtered (_("%ld syscall arguments:\n"),
2367 for (i
= 0; i
< nsysargs
; i
++)
2368 printf_filtered ("#%ld: 0x%08lx\n",
2374 /* How to exit gracefully, returning "unknown
2376 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2377 return inferior_ptid
;
2381 /* How to keep going without returning to wfi: */
2382 target_continue_no_signal (ptid
);
2388 if (syscall_is_exec (pi
, what
))
2390 /* Hopefully this is our own "fork-child" execing
2391 the real child. Hoax this event into a trap, and
2392 GDB will see the child about to execute its start
2394 wstat
= (SIGTRAP
<< 8) | 0177;
2396 else if (syscall_is_lwp_create (pi
, what
))
2398 /* This syscall is somewhat like fork/exec. We
2399 will get the event twice: once for the parent
2400 LWP, and once for the child. We should already
2401 know about the parent LWP, but the child will
2402 be new to us. So, whenever we get this event,
2403 if it represents a new thread, simply add the
2404 thread to the list. */
2406 /* If not in procinfo list, add it. */
2407 temp_tid
= proc_get_current_thread (pi
);
2408 if (!find_procinfo (pi
->pid
, temp_tid
))
2409 create_procinfo (pi
->pid
, temp_tid
);
2411 temp_ptid
= ptid_build (pi
->pid
, temp_tid
, 0);
2412 /* If not in GDB's thread list, add it. */
2413 if (!in_thread_list (temp_ptid
))
2414 add_thread (temp_ptid
);
2416 /* Return to WFI, but tell it to immediately resume. */
2417 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2418 return inferior_ptid
;
2420 else if (syscall_is_lwp_exit (pi
, what
))
2422 if (print_thread_events
)
2423 printf_unfiltered (_("[%s exited]\n"),
2424 target_pid_to_str (retval
));
2425 delete_thread (retval
);
2426 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2431 /* FIXME: Do we need to handle SYS_sproc,
2432 SYS_fork, or SYS_vfork here? The old procfs
2433 seemed to use this event to handle threads on
2434 older (non-LWP) systems, where I'm assuming
2435 that threads were actually separate processes.
2436 Irix, maybe? Anyway, low priority for now. */
2440 printf_filtered (_("procfs: trapped on exit from "));
2441 proc_prettyprint_syscall (proc_what (pi
), 0);
2442 printf_filtered ("\n");
2444 long i
, nsysargs
, *sysargs
;
2446 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
2447 (sysargs
= proc_sysargs (pi
)) != NULL
)
2449 printf_filtered (_("%ld syscall arguments:\n"),
2451 for (i
= 0; i
< nsysargs
; i
++)
2452 printf_filtered ("#%ld: 0x%08lx\n",
2456 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
2457 return inferior_ptid
;
2462 wstat
= (SIGSTOP
<< 8) | 0177;
2467 printf_filtered (_("Retry #%d:\n"), retry
);
2468 pi
->status_valid
= 0;
2473 /* If not in procinfo list, add it. */
2474 temp_tid
= proc_get_current_thread (pi
);
2475 if (!find_procinfo (pi
->pid
, temp_tid
))
2476 create_procinfo (pi
->pid
, temp_tid
);
2478 /* If not in GDB's thread list, add it. */
2479 temp_ptid
= ptid_build (pi
->pid
, temp_tid
, 0);
2480 if (!in_thread_list (temp_ptid
))
2481 add_thread (temp_ptid
);
2483 status
->kind
= TARGET_WAITKIND_STOPPED
;
2484 status
->value
.sig
= GDB_SIGNAL_0
;
2489 wstat
= (what
<< 8) | 0177;
2494 wstat
= (SIGTRAP
<< 8) | 0177;
2496 /* FIXME: use si_signo where possible. */
2499 wstat
= (SIGILL
<< 8) | 0177;
2503 wstat
= (SIGTRAP
<< 8) | 0177;
2508 wstat
= (SIGSEGV
<< 8) | 0177;
2513 wstat
= (SIGFPE
<< 8) | 0177;
2515 case FLTPAGE
: /* Recoverable page fault */
2516 default: /* FIXME: use si_signo if possible for
2518 retval
= pid_to_ptid (-1);
2519 printf_filtered ("procfs:%d -- ", __LINE__
);
2520 printf_filtered (_("child stopped for unknown reason:\n"));
2521 proc_prettyprint_why (why
, what
, 1);
2522 error (_("... giving up..."));
2525 break; /* case PR_FAULTED: */
2526 default: /* switch (why) unmatched */
2527 printf_filtered ("procfs:%d -- ", __LINE__
);
2528 printf_filtered (_("child stopped for unknown reason:\n"));
2529 proc_prettyprint_why (why
, what
, 1);
2530 error (_("... giving up..."));
2533 /* Got this far without error: If retval isn't in the
2534 threads database, add it. */
2535 if (ptid_get_pid (retval
) > 0 &&
2536 !ptid_equal (retval
, inferior_ptid
) &&
2537 !in_thread_list (retval
))
2539 /* We have a new thread. We need to add it both to
2540 GDB's list and to our own. If we don't create a
2541 procinfo, resume may be unhappy later. */
2542 add_thread (retval
);
2543 if (find_procinfo (ptid_get_pid (retval
),
2544 ptid_get_lwp (retval
)) == NULL
)
2545 create_procinfo (ptid_get_pid (retval
),
2546 ptid_get_lwp (retval
));
2549 else /* Flags do not indicate STOPPED. */
2551 /* surely this can't happen... */
2552 printf_filtered ("procfs:%d -- process not stopped.\n",
2554 proc_prettyprint_flags (flags
, 1);
2555 error (_("procfs: ...giving up..."));
2560 store_waitstatus (status
, wstat
);
2566 /* Perform a partial transfer to/from the specified object. For
2567 memory transfers, fall back to the old memory xfer functions. */
2569 enum target_xfer_status
2570 procfs_target::xfer_partial (enum target_object object
,
2571 const char *annex
, gdb_byte
*readbuf
,
2572 const gdb_byte
*writebuf
, ULONGEST offset
,
2573 ULONGEST len
, ULONGEST
*xfered_len
)
2577 case TARGET_OBJECT_MEMORY
:
2578 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2580 case TARGET_OBJECT_AUXV
:
2581 return memory_xfer_auxv (this, object
, annex
, readbuf
, writebuf
,
2582 offset
, len
, xfered_len
);
2585 return this->beneath
->xfer_partial (object
, annex
,
2586 readbuf
, writebuf
, offset
, len
,
2591 /* Helper for procfs_xfer_partial that handles memory transfers.
2592 Arguments are like target_xfer_partial. */
2594 static enum target_xfer_status
2595 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2596 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2601 /* Find procinfo for main process. */
2602 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2603 if (pi
->as_fd
== 0 &&
2604 open_procinfo_files (pi
, FD_AS
) == 0)
2606 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
2607 return TARGET_XFER_E_IO
;
2610 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
2611 return TARGET_XFER_E_IO
;
2613 if (writebuf
!= NULL
)
2615 PROCFS_NOTE ("write memory:\n");
2616 nbytes
= write (pi
->as_fd
, writebuf
, len
);
2620 PROCFS_NOTE ("read memory:\n");
2621 nbytes
= read (pi
->as_fd
, readbuf
, len
);
2624 return TARGET_XFER_E_IO
;
2625 *xfered_len
= nbytes
;
2626 return TARGET_XFER_OK
;
2629 /* Called by target_resume before making child runnable. Mark cached
2630 registers and status's invalid. If there are "dirty" caches that
2631 need to be written back to the child process, do that.
2633 File descriptors are also cached. As they are a limited resource,
2634 we cannot hold onto them indefinitely. However, as they are
2635 expensive to open, we don't want to throw them away
2636 indescriminately either. As a compromise, we will keep the file
2637 descriptors for the parent process, but discard any file
2638 descriptors we may have accumulated for the threads.
2640 As this function is called by iterate_over_threads, it always
2641 returns zero (so that iterate_over_threads will keep
2645 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
2647 /* About to run the child; invalidate caches and do any other
2651 if (pi
->gregs_dirty
)
2652 if (parent
== NULL
||
2653 proc_get_current_thread (parent
) != pi
->tid
)
2654 if (!proc_set_gregs (pi
)) /* flush gregs cache */
2655 proc_warn (pi
, "target_resume, set_gregs",
2657 if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
2658 if (pi
->fpregs_dirty
)
2659 if (parent
== NULL
||
2660 proc_get_current_thread (parent
) != pi
->tid
)
2661 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
2662 proc_warn (pi
, "target_resume, set_fpregs",
2668 /* The presence of a parent indicates that this is an LWP.
2669 Close any file descriptors that it might have open.
2670 We don't do this to the master (parent) procinfo. */
2672 close_procinfo_files (pi
);
2674 pi
->gregs_valid
= 0;
2675 pi
->fpregs_valid
= 0;
2677 pi
->gregs_dirty
= 0;
2678 pi
->fpregs_dirty
= 0;
2680 pi
->status_valid
= 0;
2681 pi
->threads_valid
= 0;
2687 /* A callback function for iterate_over_threads. Find the
2688 asynchronous signal thread, and make it runnable. See if that
2689 helps matters any. */
2692 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
2695 if (proc_flags (pi
) & PR_ASLWP
)
2697 if (!proc_run_process (pi
, 0, -1))
2698 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
2706 /* Make the child process runnable. Normally we will then call
2707 procfs_wait and wait for it to stop again (unless gdb is async).
2709 If STEP is true, then arrange for the child to stop again after
2710 executing a single instruction. If SIGNO is zero, then cancel any
2711 pending signal; if non-zero, then arrange for the indicated signal
2712 to be delivered to the child when it runs. If PID is -1, then
2713 allow any child thread to run; if non-zero, then allow only the
2714 indicated thread to run. (not implemented yet). */
2717 procfs_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
2719 procinfo
*pi
, *thread
;
2723 prrun.prflags |= PRSVADDR;
2724 prrun.pr_vaddr = $PC; set resume address
2725 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
2726 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
2727 prrun.prflags |= PRCFAULT; clear current fault.
2729 PRSTRACE and PRSFAULT can be done by other means
2730 (proc_trace_signals, proc_trace_faults)
2731 PRSVADDR is unnecessary.
2732 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
2733 This basically leaves PRSTEP and PRCSIG.
2734 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
2735 So basically PR_STEP is the sole argument that must be passed
2736 to proc_run_process (for use in the prrun struct by ioctl). */
2738 /* Find procinfo for main process. */
2739 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2741 /* First cut: ignore pid argument. */
2744 /* Convert signal to host numbering. */
2746 (signo
== GDB_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
2749 native_signo
= gdb_signal_to_host (signo
);
2751 pi
->ignore_next_sigstop
= 0;
2753 /* Running the process voids all cached registers and status. */
2754 /* Void the threads' caches first. */
2755 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
2756 /* Void the process procinfo's caches. */
2757 invalidate_cache (NULL
, pi
, NULL
);
2759 if (ptid_get_pid (ptid
) != -1)
2761 /* Resume a specific thread, presumably suppressing the
2763 thread
= find_procinfo (ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
2766 if (thread
->tid
!= 0)
2768 /* We're to resume a specific thread, and not the
2769 others. Set the child process's PR_ASYNC flag. */
2770 if (!proc_set_async (pi
))
2771 proc_error (pi
, "target_resume, set_async", __LINE__
);
2773 proc_iterate_over_threads (pi
,
2774 make_signal_thread_runnable
,
2777 pi
= thread
; /* Substitute the thread's procinfo
2783 if (!proc_run_process (pi
, step
, native_signo
))
2786 warning (_("resume: target already running. "
2787 "Pretend to resume, and hope for the best!"));
2789 proc_error (pi
, "target_resume", __LINE__
);
2793 /* Set up to trace signals in the child process. */
2796 procfs_target::pass_signals (int numsigs
, unsigned char *pass_signals
)
2799 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
2802 prfillset (&signals
);
2804 for (signo
= 0; signo
< NSIG
; signo
++)
2806 int target_signo
= gdb_signal_from_host (signo
);
2807 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
2808 prdelset (&signals
, signo
);
2811 if (!proc_set_traced_signals (pi
, &signals
))
2812 proc_error (pi
, "pass_signals", __LINE__
);
2815 /* Print status information about the child process. */
2818 procfs_target::files_info ()
2820 struct inferior
*inf
= current_inferior ();
2822 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
2823 inf
->attach_flag
? "attached": "child",
2824 target_pid_to_str (inferior_ptid
));
2827 /* Make it die. Wait for it to die. Clean up after it. Note: this
2828 should only be applied to the real process, not to an LWP, because
2829 of the check for parent-process. If we need this to work for an
2830 LWP, it needs some more logic. */
2833 unconditionally_kill_inferior (procinfo
*pi
)
2837 parent_pid
= proc_parent_pid (pi
);
2838 if (!proc_kill (pi
, SIGKILL
))
2839 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
2840 destroy_procinfo (pi
);
2842 /* If pi is GDB's child, wait for it to die. */
2843 if (parent_pid
== getpid ())
2844 /* FIXME: should we use waitpid to make sure we get the right event?
2845 Should we check the returned event? */
2850 ret
= waitpid (pi
->pid
, &status
, 0);
2857 /* We're done debugging it, and we want it to go away. Then we want
2858 GDB to forget all about it. */
2861 procfs_target::kill ()
2863 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
2865 /* Find procinfo for main process. */
2866 procinfo
*pi
= find_procinfo (ptid_get_pid (inferior_ptid
), 0);
2869 unconditionally_kill_inferior (pi
);
2870 target_mourn_inferior (inferior_ptid
);
2874 /* Forget we ever debugged this thing! */
2877 procfs_target::mourn_inferior ()
2881 if (!ptid_equal (inferior_ptid
, null_ptid
))
2883 /* Find procinfo for main process. */
2884 pi
= find_procinfo (ptid_get_pid (inferior_ptid
), 0);
2886 destroy_procinfo (pi
);
2889 generic_mourn_inferior ();
2891 maybe_unpush_target ();
2894 /* When GDB forks to create a runnable inferior process, this function
2895 is called on the parent side of the fork. It's job is to do
2896 whatever is necessary to make the child ready to be debugged, and
2897 then wait for the child to synchronize. */
2900 procfs_init_inferior (struct target_ops
*ops
, int pid
)
2907 /* This routine called on the parent side (GDB side)
2908 after GDB forks the inferior. */
2909 if (!target_is_pushed (ops
))
2912 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
2913 perror (_("procfs: out of memory in 'init_inferior'"));
2915 if (!open_procinfo_files (pi
, FD_CTL
))
2916 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
2920 open_procinfo_files // done
2923 procfs_notice_signals
2930 /* If not stopped yet, wait for it to stop. */
2931 if (!(proc_flags (pi
) & PR_STOPPED
) &&
2932 !(proc_wait_for_stop (pi
)))
2933 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
2935 /* Save some of the /proc state to be restored if we detach. */
2936 /* FIXME: Why? In case another debugger was debugging it?
2937 We're it's parent, for Ghu's sake! */
2938 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
2939 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
2940 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
2941 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
2942 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
2943 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
2944 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
2945 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
2946 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
2947 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
2949 if ((fail
= procfs_debug_inferior (pi
)) != 0)
2950 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
2952 /* FIXME: logically, we should really be turning OFF run-on-last-close,
2953 and possibly even turning ON kill-on-last-close at this point. But
2954 I can't make that change without careful testing which I don't have
2955 time to do right now... */
2956 /* Turn on run-on-last-close flag so that the child
2957 will die if GDB goes away for some reason. */
2958 if (!proc_set_run_on_last_close (pi
))
2959 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
2961 /* We now have have access to the lwpid of the main thread/lwp. */
2962 lwpid
= proc_get_current_thread (pi
);
2964 /* Create a procinfo for the main lwp. */
2965 create_procinfo (pid
, lwpid
);
2967 /* We already have a main thread registered in the thread table at
2968 this point, but it didn't have any lwp info yet. Notify the core
2969 about it. This changes inferior_ptid as well. */
2970 thread_change_ptid (pid_to_ptid (pid
),
2971 ptid_build (pid
, lwpid
, 0));
2973 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2976 /* When GDB forks to create a new process, this function is called on
2977 the child side of the fork before GDB exec's the user program. Its
2978 job is to make the child minimally debuggable, so that the parent
2979 GDB process can connect to the child and take over. This function
2980 should do only the minimum to make that possible, and to
2981 synchronize with the parent process. The parent process should
2982 take care of the details. */
2985 procfs_set_exec_trap (void)
2987 /* This routine called on the child side (inferior side)
2988 after GDB forks the inferior. It must use only local variables,
2989 because it may be sharing data space with its parent. */
2994 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
2995 perror_with_name (_("procfs: create_procinfo failed in child."));
2997 if (open_procinfo_files (pi
, FD_CTL
) == 0)
2999 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
3000 gdb_flush (gdb_stderr
);
3001 /* No need to call "dead_procinfo", because we're going to
3006 /* Method for tracing exec syscalls. */
3008 Not all systems with /proc have all the exec* syscalls with the same
3009 names. On the SGI, for example, there is no SYS_exec, but there
3010 *is* a SYS_execv. So, we try to account for that. */
3012 exitset
= sysset_t_alloc (pi
);
3013 premptyset (exitset
);
3015 praddset (exitset
, SYS_exec
);
3017 praddset (exitset
, SYS_execve
);
3019 if (!proc_set_traced_sysexit (pi
, exitset
))
3021 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
3022 gdb_flush (gdb_stderr
);
3026 /* FIXME: should this be done in the parent instead? */
3027 /* Turn off inherit on fork flag so that all grand-children
3028 of gdb start with tracing flags cleared. */
3029 if (!proc_unset_inherit_on_fork (pi
))
3030 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
3032 /* Turn off run on last close flag, so that the child process
3033 cannot run away just because we close our handle on it.
3034 We want it to wait for the parent to attach. */
3035 if (!proc_unset_run_on_last_close (pi
))
3036 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
3038 /* FIXME: No need to destroy the procinfo --
3039 we have our own address space, and we're about to do an exec! */
3040 /*destroy_procinfo (pi);*/
3043 /* This function is called BEFORE gdb forks the inferior process. Its
3044 only real responsibility is to set things up for the fork, and tell
3045 GDB which two functions to call after the fork (one for the parent,
3046 and one for the child).
3048 This function does a complicated search for a unix shell program,
3049 which it then uses to parse arguments and environment variables to
3050 be sent to the child. I wonder whether this code could not be
3051 abstracted out and shared with other unix targets such as
3055 procfs_target::create_inferior (const char *exec_file
,
3056 const std::string
&allargs
,
3057 char **env
, int from_tty
)
3059 char *shell_file
= getenv ("SHELL");
3063 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
3066 /* We will be looking down the PATH to find shell_file. If we
3067 just do this the normal way (via execlp, which operates by
3068 attempting an exec for each element of the PATH until it
3069 finds one which succeeds), then there will be an exec for
3070 each failed attempt, each of which will cause a PR_SYSEXIT
3071 stop, and we won't know how to distinguish the PR_SYSEXIT's
3072 for these failed execs with the ones for successful execs
3073 (whether the exec has succeeded is stored at that time in the
3074 carry bit or some such architecture-specific and
3075 non-ABI-specified place).
3077 So I can't think of anything better than to search the PATH
3078 now. This has several disadvantages: (1) There is a race
3079 condition; if we find a file now and it is deleted before we
3080 exec it, we lose, even if the deletion leaves a valid file
3081 further down in the PATH, (2) there is no way to know exactly
3082 what an executable (in the sense of "capable of being
3083 exec'd") file is. Using access() loses because it may lose
3084 if the caller is the superuser; failing to use it loses if
3085 there are ACLs or some such. */
3089 /* FIXME-maybe: might want "set path" command so user can change what
3090 path is used from within GDB. */
3091 const char *path
= getenv ("PATH");
3093 struct stat statbuf
;
3096 path
= "/bin:/usr/bin";
3098 tryname
= (char *) alloca (strlen (path
) + strlen (shell_file
) + 2);
3099 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
3101 p1
= strchr (p
, ':');
3106 strncpy (tryname
, p
, len
);
3107 tryname
[len
] = '\0';
3108 strcat (tryname
, "/");
3109 strcat (tryname
, shell_file
);
3110 if (access (tryname
, X_OK
) < 0)
3112 if (stat (tryname
, &statbuf
) < 0)
3114 if (!S_ISREG (statbuf
.st_mode
))
3115 /* We certainly need to reject directories. I'm not quite
3116 as sure about FIFOs, sockets, etc., but I kind of doubt
3117 that people want to exec() these things. */
3122 /* Not found. This must be an error rather than merely passing
3123 the file to execlp(), because execlp() would try all the
3124 exec()s, causing GDB to get confused. */
3125 error (_("procfs:%d -- Can't find shell %s in PATH"),
3126 __LINE__
, shell_file
);
3128 shell_file
= tryname
;
3131 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
3132 NULL
, NULL
, shell_file
, NULL
);
3134 /* We have something that executes now. We'll be running through
3135 the shell at this point (if startup-with-shell is true), but the
3136 pid shouldn't change. */
3137 add_thread_silent (pid_to_ptid (pid
));
3139 procfs_init_inferior (this, pid
);
3142 /* An observer for the "inferior_created" event. */
3145 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
3149 /* Callback for update_thread_list. Calls "add_thread". */
3152 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
3154 ptid_t gdb_threadid
= ptid_build (pi
->pid
, thread
->tid
, 0);
3156 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
3157 add_thread (gdb_threadid
);
3162 /* Query all the threads that the target knows about, and give them
3163 back to GDB to add to its list. */
3166 procfs_target::update_thread_list ()
3172 /* Find procinfo for main process. */
3173 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3174 proc_update_threads (pi
);
3175 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
3178 /* Return true if the thread is still 'alive'. This guy doesn't
3179 really seem to be doing his job. Got to investigate how to tell
3180 when a thread is really gone. */
3183 procfs_target::thread_alive (ptid_t ptid
)
3188 proc
= ptid_get_pid (ptid
);
3189 thread
= ptid_get_lwp (ptid
);
3190 /* If I don't know it, it ain't alive! */
3191 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
3194 /* If I can't get its status, it ain't alive!
3195 What's more, I need to forget about it! */
3196 if (!proc_get_status (pi
))
3198 destroy_procinfo (pi
);
3201 /* I couldn't have got its status if it weren't alive, so it's
3206 /* Convert PTID to a string. Returns the string in a static
3210 procfs_target::pid_to_str (ptid_t ptid
)
3212 static char buf
[80];
3214 if (ptid_get_lwp (ptid
) == 0)
3215 sprintf (buf
, "process %d", ptid_get_pid (ptid
));
3217 sprintf (buf
, "LWP %ld", ptid_get_lwp (ptid
));
3222 /* Insert a watchpoint. */
3225 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
3231 pi
= find_procinfo_or_die (ptid_get_pid (ptid
) == -1 ?
3232 ptid_get_pid (inferior_ptid
) : ptid_get_pid (ptid
),
3235 /* Translate from GDB's flags to /proc's. */
3236 if (len
> 0) /* len == 0 means delete watchpoint. */
3238 switch (rwflag
) { /* FIXME: need an enum! */
3239 case hw_write
: /* default watchpoint (write) */
3240 pflags
= WRITE_WATCHFLAG
;
3242 case hw_read
: /* read watchpoint */
3243 pflags
= READ_WATCHFLAG
;
3245 case hw_access
: /* access watchpoint */
3246 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
3248 case hw_execute
: /* execution HW breakpoint */
3249 pflags
= EXEC_WATCHFLAG
;
3251 default: /* Something weird. Return error. */
3254 if (after
) /* Stop after r/w access is completed. */
3255 pflags
|= AFTER_WATCHFLAG
;
3258 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
3260 if (errno
== E2BIG
) /* Typical error for no resources. */
3261 return -1; /* fail */
3262 /* GDB may try to remove the same watchpoint twice.
3263 If a remove request returns no match, don't error. */
3264 if (errno
== ESRCH
&& len
== 0)
3265 return 0; /* ignore */
3266 proc_error (pi
, "set_watchpoint", __LINE__
);
3271 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
3272 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
3273 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
3276 Note: procfs_can_use_hw_breakpoint() is not yet used by all
3277 procfs.c targets due to the fact that some of them still define
3278 target_can_use_hardware_watchpoint. */
3281 procfs_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int othertype
)
3283 /* Due to the way that proc_set_watchpoint() is implemented, host
3284 and target pointers must be of the same size. If they are not,
3285 we can't use hardware watchpoints. This limitation is due to the
3286 fact that proc_set_watchpoint() calls
3287 procfs_address_to_host_pointer(); a close inspection of
3288 procfs_address_to_host_pointer will reveal that an internal error
3289 will be generated when the host and target pointer sizes are
3291 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
3293 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
3296 /* Other tests here??? */
3301 /* Returns non-zero if process is stopped on a hardware watchpoint
3302 fault, else returns zero. */
3305 procfs_target::stopped_by_watchpoint ()
3309 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3311 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3313 if (proc_why (pi
) == PR_FAULTED
)
3315 if (proc_what (pi
) == FLTWATCH
)
3322 /* Returns 1 if the OS knows the position of the triggered watchpoint,
3323 and sets *ADDR to that address. Returns 0 if OS cannot report that
3324 address. This function is only called if
3325 procfs_stopped_by_watchpoint returned 1, thus no further checks are
3326 done. The function also assumes that ADDR is not NULL. */
3329 procfs_target::stopped_data_address (CORE_ADDR
*addr
)
3333 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3334 return proc_watchpoint_address (pi
, addr
);
3338 procfs_target::insert_watchpoint (CORE_ADDR addr
, int len
,
3339 enum target_hw_bp_type type
,
3340 struct expression
*cond
)
3342 if (!target_have_steppable_watchpoint
3343 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
3345 /* When a hardware watchpoint fires off the PC will be left at
3346 the instruction following the one which caused the
3347 watchpoint. It will *NOT* be necessary for GDB to step over
3349 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
3353 /* When a hardware watchpoint fires off the PC will be left at
3354 the instruction which caused the watchpoint. It will be
3355 necessary for GDB to step over the watchpoint. */
3356 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
3361 procfs_target::remove_watchpoint (CORE_ADDR addr
, int len
,
3362 enum target_hw_bp_type type
,
3363 struct expression
*cond
)
3365 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
3369 procfs_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3371 /* The man page for proc(4) on Solaris 2.6 and up says that the
3372 system can support "thousands" of hardware watchpoints, but gives
3373 no method for finding out how many; It doesn't say anything about
3374 the allowed size for the watched area either. So we just tell
3379 /* Memory Mappings Functions: */
3381 /* Call a callback function once for each mapping, passing it the
3382 mapping, an optional secondary callback function, and some optional
3383 opaque data. Quit and return the first non-zero value returned
3386 PI is the procinfo struct for the process to be mapped. FUNC is
3387 the callback function to be called by this iterator. DATA is the
3388 optional opaque data to be passed to the callback function.
3389 CHILD_FUNC is the optional secondary function pointer to be passed
3390 to the child function. Returns the first non-zero return value
3391 from the callback function, or zero. */
3394 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
3396 int (*func
) (struct prmap
*map
,
3397 find_memory_region_ftype child_func
,
3400 char pathname
[MAX_PROC_NAME_SIZE
];
3401 struct prmap
*prmaps
;
3402 struct prmap
*prmap
;
3407 /* Get the number of mappings, allocate space,
3408 and read the mappings into prmaps. */
3410 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
3412 scoped_fd
map_fd (open (pathname
, O_RDONLY
));
3413 if (map_fd
.get () < 0)
3414 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
3416 /* Use stat to determine the file size, and compute
3417 the number of prmap_t objects it contains. */
3418 if (fstat (map_fd
.get (), &sbuf
) != 0)
3419 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
3421 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
3422 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
3423 if (read (map_fd
.get (), (char *) prmaps
, nmap
* sizeof (*prmaps
))
3424 != (nmap
* sizeof (*prmaps
)))
3425 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
3427 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
3428 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
3434 /* Implements the to_find_memory_regions method. Calls an external
3435 function for each memory region.
3436 Returns the integer value returned by the callback. */
3439 find_memory_regions_callback (struct prmap
*map
,
3440 find_memory_region_ftype func
, void *data
)
3442 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
3444 (map
->pr_mflags
& MA_READ
) != 0,
3445 (map
->pr_mflags
& MA_WRITE
) != 0,
3446 (map
->pr_mflags
& MA_EXEC
) != 0,
3447 1, /* MODIFIED is unknown, pass it as true. */
3451 /* External interface. Calls a callback function once for each
3452 mapped memory region in the child process, passing as arguments:
3454 CORE_ADDR virtual_address,
3456 int read, TRUE if region is readable by the child
3457 int write, TRUE if region is writable by the child
3458 int execute TRUE if region is executable by the child.
3460 Stops iterating and returns the first non-zero value returned by
3464 procfs_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
3466 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3468 return iterate_over_mappings (pi
, func
, data
,
3469 find_memory_regions_callback
);
3472 /* Returns an ascii representation of a memory mapping's flags. */
3475 mappingflags (long flags
)
3477 static char asciiflags
[8];
3479 strcpy (asciiflags
, "-------");
3480 if (flags
& MA_STACK
)
3481 asciiflags
[1] = 's';
3482 if (flags
& MA_BREAK
)
3483 asciiflags
[2] = 'b';
3484 if (flags
& MA_SHARED
)
3485 asciiflags
[3] = 's';
3486 if (flags
& MA_READ
)
3487 asciiflags
[4] = 'r';
3488 if (flags
& MA_WRITE
)
3489 asciiflags
[5] = 'w';
3490 if (flags
& MA_EXEC
)
3491 asciiflags
[6] = 'x';
3492 return (asciiflags
);
3495 /* Callback function, does the actual work for 'info proc
3499 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
3502 unsigned int pr_off
;
3504 pr_off
= (unsigned int) map
->pr_offset
;
3506 if (gdbarch_addr_bit (target_gdbarch ()) == 32)
3507 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
3508 (unsigned long) map
->pr_vaddr
,
3509 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3510 (unsigned long) map
->pr_size
,
3512 mappingflags (map
->pr_mflags
));
3514 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
3515 (unsigned long) map
->pr_vaddr
,
3516 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
3517 (unsigned long) map
->pr_size
,
3519 mappingflags (map
->pr_mflags
));
3524 /* Implement the "info proc mappings" subcommand. */
3527 info_proc_mappings (procinfo
*pi
, int summary
)
3530 return; /* No output for summary mode. */
3532 printf_filtered (_("Mapped address spaces:\n\n"));
3533 if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
3534 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3541 printf_filtered (" %18s %18s %10s %10s %7s\n",
3548 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
3549 printf_filtered ("\n");
3552 /* Implement the "info proc" command. */
3555 procfs_target::info_proc (const char *args
, enum info_proc_what what
)
3557 struct cleanup
*old_chain
;
3558 procinfo
*process
= NULL
;
3559 procinfo
*thread
= NULL
;
3576 error (_("Not supported on this target."));
3579 old_chain
= make_cleanup (null_cleanup
, 0);
3580 gdb_argv
built_argv (args
);
3581 for (char *arg
: built_argv
)
3583 if (isdigit (arg
[0]))
3585 pid
= strtoul (arg
, &tmp
, 10);
3587 tid
= strtoul (++tmp
, NULL
, 10);
3589 else if (arg
[0] == '/')
3591 tid
= strtoul (arg
+ 1, NULL
, 10);
3595 pid
= ptid_get_pid (inferior_ptid
);
3597 error (_("No current process: you must name one."));
3600 /* Have pid, will travel.
3601 First see if it's a process we're already debugging. */
3602 process
= find_procinfo (pid
, 0);
3603 if (process
== NULL
)
3605 /* No. So open a procinfo for it, but
3606 remember to close it again when finished. */
3607 process
= create_procinfo (pid
, 0);
3608 make_cleanup (do_destroy_procinfo_cleanup
, process
);
3609 if (!open_procinfo_files (process
, FD_CTL
))
3610 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
3614 thread
= create_procinfo (pid
, tid
);
3618 printf_filtered (_("process %d flags:\n"), process
->pid
);
3619 proc_prettyprint_flags (proc_flags (process
), 1);
3620 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
3621 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
3622 if (proc_get_nthreads (process
) > 1)
3623 printf_filtered ("Process has %d threads.\n",
3624 proc_get_nthreads (process
));
3628 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
3629 proc_prettyprint_flags (proc_flags (thread
), 1);
3630 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
3631 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
3636 info_proc_mappings (process
, 0);
3639 do_cleanups (old_chain
);
3644 /* Modify the status of the system call identified by SYSCALLNUM in
3645 the set of syscalls that are currently traced/debugged.
3647 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
3648 will be updated. Otherwise, the exit syscalls set will be updated.
3650 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
3651 will be disabled. */
3654 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
3655 int mode
, int from_tty
)
3659 if (entry_or_exit
== PR_SYSENTRY
)
3660 sysset
= proc_get_traced_sysentry (pi
, NULL
);
3662 sysset
= proc_get_traced_sysexit (pi
, NULL
);
3665 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
3667 if (mode
== FLAG_SET
)
3668 praddset (sysset
, syscallnum
);
3670 prdelset (sysset
, syscallnum
);
3672 if (entry_or_exit
== PR_SYSENTRY
)
3674 if (!proc_set_traced_sysentry (pi
, sysset
))
3675 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
3679 if (!proc_set_traced_sysexit (pi
, sysset
))
3680 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
3685 proc_trace_syscalls (const char *args
, int from_tty
, int entry_or_exit
, int mode
)
3689 if (ptid_get_pid (inferior_ptid
) <= 0)
3690 error (_("you must be debugging a process to use this command."));
3692 if (args
== NULL
|| args
[0] == 0)
3693 error_no_arg (_("system call to trace"));
3695 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3696 if (isdigit (args
[0]))
3698 const int syscallnum
= atoi (args
);
3700 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
3705 proc_trace_sysentry_cmd (const char *args
, int from_tty
)
3707 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
3711 proc_trace_sysexit_cmd (const char *args
, int from_tty
)
3713 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
3717 proc_untrace_sysentry_cmd (const char *args
, int from_tty
)
3719 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
3723 proc_untrace_sysexit_cmd (const char *args
, int from_tty
)
3725 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
3729 _initialize_procfs (void)
3731 gdb::observers::inferior_created
.attach (procfs_inferior_created
);
3733 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
3734 _("Give a trace of entries into the syscall."));
3735 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
3736 _("Give a trace of exits from the syscall."));
3737 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
3738 _("Cancel a trace of entries into the syscall."));
3739 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
3740 _("Cancel a trace of exits from the syscall."));
3742 add_target (&the_procfs_target
);
3745 /* =================== END, GDB "MODULE" =================== */
3749 /* miscellaneous stubs: */
3751 /* The following satisfy a few random symbols mostly created by the
3752 solaris threads implementation, which I will chase down later. */
3754 /* Return a pid for which we guarantee we will be able to find a
3758 procfs_first_available (void)
3760 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
3763 /* =================== GCORE .NOTE "MODULE" =================== */
3766 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
3767 char *note_data
, int *note_size
,
3768 enum gdb_signal stop_signal
)
3770 struct regcache
*regcache
= get_thread_regcache (ptid
);
3771 gdb_gregset_t gregs
;
3772 gdb_fpregset_t fpregs
;
3773 unsigned long merged_pid
;
3775 merged_pid
= ptid_get_lwp (ptid
) << 16 | ptid_get_pid (ptid
);
3777 /* This part is the old method for fetching registers.
3778 It should be replaced by the newer one using regsets
3779 once it is implemented in this platform:
3780 gdbarch_iterate_over_regset_sections(). */
3782 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3783 inferior_ptid
= ptid
;
3784 target_fetch_registers (regcache
, -1);
3786 fill_gregset (regcache
, &gregs
, -1);
3787 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
3793 fill_fpregset (regcache
, &fpregs
, -1);
3794 note_data
= (char *) elfcore_write_prfpreg (obfd
,
3803 struct procfs_corefile_thread_data
{
3807 enum gdb_signal stop_signal
;
3811 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
3813 struct procfs_corefile_thread_data
*args
3814 = (struct procfs_corefile_thread_data
*) data
;
3818 ptid_t ptid
= ptid_build (pi
->pid
, thread
->tid
, 0);
3820 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
3829 find_signalled_thread (struct thread_info
*info
, void *data
)
3831 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
3832 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
3838 static enum gdb_signal
3839 find_stop_signal (void)
3841 struct thread_info
*info
=
3842 iterate_over_threads (find_signalled_thread
, NULL
);
3845 return info
->suspend
.stop_signal
;
3847 return GDB_SIGNAL_0
;
3851 procfs_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
3853 struct cleanup
*old_chain
;
3854 gdb_gregset_t gregs
;
3855 gdb_fpregset_t fpregs
;
3856 char fname
[16] = {'\0'};
3857 char psargs
[80] = {'\0'};
3858 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3859 char *note_data
= NULL
;
3861 struct procfs_corefile_thread_data thread_args
;
3864 enum gdb_signal stop_signal
;
3866 if (get_exec_file (0))
3868 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
3869 fname
[sizeof (fname
) - 1] = 0;
3870 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3871 psargs
[sizeof (psargs
) - 1] = 0;
3873 inf_args
= get_inferior_args ();
3874 if (inf_args
&& *inf_args
&&
3875 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
3877 strncat (psargs
, " ",
3878 sizeof (psargs
) - strlen (psargs
));
3879 strncat (psargs
, inf_args
,
3880 sizeof (psargs
) - strlen (psargs
));
3884 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
3890 stop_signal
= find_stop_signal ();
3892 fill_gregset (get_current_regcache (), &gregs
, -1);
3893 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
3894 ptid_get_pid (inferior_ptid
),
3895 stop_signal
, &gregs
);
3897 thread_args
.obfd
= obfd
;
3898 thread_args
.note_data
= note_data
;
3899 thread_args
.note_size
= note_size
;
3900 thread_args
.stop_signal
= stop_signal
;
3901 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
3903 note_data
= thread_args
.note_data
;
3905 auxv_len
= target_read_alloc (target_stack
, TARGET_OBJECT_AUXV
,
3909 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
3910 "CORE", NT_AUXV
, auxv
, auxv_len
);
3916 /* =================== END GCORE .NOTE "MODULE" =================== */