1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
3 Copyright (C) 1999-2014 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"
34 #if defined (NEW_PROC_API)
35 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
38 #include <sys/procfs.h>
39 #ifdef HAVE_SYS_FAULT_H
40 #include <sys/fault.h>
42 #ifdef HAVE_SYS_SYSCALL_H
43 #include <sys/syscall.h>
45 #include <sys/errno.h>
51 #include "gdb_assert.h"
57 /* This module provides the interface between GDB and the
58 /proc file system, which is used on many versions of Unix
59 as a means for debuggers to control other processes.
61 Examples of the systems that use this interface are:
68 /proc works by imitating a file system: you open a simulated file
69 that represents the process you wish to interact with, and perform
70 operations on that "file" in order to examine or change the state
73 The most important thing to know about /proc and this module is
74 that there are two very different interfaces to /proc:
76 One that uses the ioctl system call, and another that uses read
77 and write system calls.
79 This module has to support both /proc interfaces. This means that
80 there are two different ways of doing every basic operation.
82 In order to keep most of the code simple and clean, I have defined
83 an interface "layer" which hides all these system calls. An ifdef
84 (NEW_PROC_API) determines which interface we are using, and most or
85 all occurrances of this ifdef should be confined to this interface
88 /* Determine which /proc API we are using: The ioctl API defines
89 PIOCSTATUS, while the read/write (multiple fd) API never does. */
92 #include <sys/types.h>
93 #include <dirent.h> /* opendir/readdir, for listing the LWP's */
96 #include <fcntl.h> /* for O_RDONLY */
97 #include <unistd.h> /* for "X_OK" */
98 #include <sys/stat.h> /* for struct stat */
100 /* Note: procfs-utils.h must be included after the above system header
101 files, because it redefines various system calls using macros.
102 This may be incompatible with the prototype declarations. */
104 #include "proc-utils.h"
106 /* Prototypes for supply_gregset etc. */
109 /* =================== TARGET_OPS "MODULE" =================== */
111 /* This module defines the GDB target vector and its methods. */
113 static void procfs_attach (struct target_ops
*, const char *, int);
114 static void procfs_detach (struct target_ops
*, const char *, int);
115 static void procfs_resume (struct target_ops
*,
116 ptid_t
, int, enum gdb_signal
);
117 static void procfs_stop (struct target_ops
*self
, ptid_t
);
118 static void procfs_files_info (struct target_ops
*);
119 static void procfs_fetch_registers (struct target_ops
*,
120 struct regcache
*, int);
121 static void procfs_store_registers (struct target_ops
*,
122 struct regcache
*, int);
123 static void procfs_pass_signals (struct target_ops
*self
,
124 int, unsigned char *);
125 static void procfs_kill_inferior (struct target_ops
*ops
);
126 static void procfs_mourn_inferior (struct target_ops
*ops
);
127 static void procfs_create_inferior (struct target_ops
*, char *,
128 char *, char **, int);
129 static ptid_t
procfs_wait (struct target_ops
*,
130 ptid_t
, struct target_waitstatus
*, int);
131 static enum target_xfer_status
procfs_xfer_memory (gdb_byte
*,
135 static target_xfer_partial_ftype procfs_xfer_partial
;
137 static int procfs_thread_alive (struct target_ops
*ops
, ptid_t
);
139 static void procfs_find_new_threads (struct target_ops
*ops
);
140 static char *procfs_pid_to_str (struct target_ops
*, ptid_t
);
142 static int proc_find_memory_regions (struct target_ops
*self
,
143 find_memory_region_ftype
, void *);
145 static char * procfs_make_note_section (struct target_ops
*self
,
148 static int procfs_can_use_hw_breakpoint (struct target_ops
*self
,
151 static void procfs_info_proc (struct target_ops
*, const char *,
152 enum info_proc_what
);
154 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
155 /* When GDB is built as 64-bit application on Solaris, the auxv data
156 is presented in 64-bit format. We need to provide a custom parser
159 procfs_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
160 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
162 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
163 gdb_byte
*ptr
= *readptr
;
168 if (endptr
- ptr
< 8 * 2)
171 *typep
= extract_unsigned_integer (ptr
, 4, byte_order
);
173 /* The size of data is always 64-bit. If the application is 32-bit,
174 it will be zero extended, as expected. */
175 *valp
= extract_unsigned_integer (ptr
, 8, byte_order
);
186 struct target_ops
*t
= inf_child_target ();
188 t
->to_create_inferior
= procfs_create_inferior
;
189 t
->to_kill
= procfs_kill_inferior
;
190 t
->to_mourn_inferior
= procfs_mourn_inferior
;
191 t
->to_attach
= procfs_attach
;
192 t
->to_detach
= procfs_detach
;
193 t
->to_wait
= procfs_wait
;
194 t
->to_resume
= procfs_resume
;
195 t
->to_fetch_registers
= procfs_fetch_registers
;
196 t
->to_store_registers
= procfs_store_registers
;
197 t
->to_xfer_partial
= procfs_xfer_partial
;
198 t
->to_pass_signals
= procfs_pass_signals
;
199 t
->to_files_info
= procfs_files_info
;
200 t
->to_stop
= procfs_stop
;
202 t
->to_find_new_threads
= procfs_find_new_threads
;
203 t
->to_thread_alive
= procfs_thread_alive
;
204 t
->to_pid_to_str
= procfs_pid_to_str
;
206 t
->to_has_thread_control
= tc_schedlock
;
207 t
->to_find_memory_regions
= proc_find_memory_regions
;
208 t
->to_make_corefile_notes
= procfs_make_note_section
;
209 t
->to_info_proc
= procfs_info_proc
;
211 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
212 t
->to_auxv_parse
= procfs_auxv_parse
;
215 t
->to_magic
= OPS_MAGIC
;
220 /* =================== END, TARGET_OPS "MODULE" =================== */
222 /* World Unification:
224 Put any typedefs, defines etc. here that are required for the
225 unification of code that handles different versions of /proc. */
227 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
229 enum { READ_WATCHFLAG
= WA_READ
,
230 WRITE_WATCHFLAG
= WA_WRITE
,
231 EXEC_WATCHFLAG
= WA_EXEC
,
232 AFTER_WATCHFLAG
= WA_TRAPAFTER
235 #else /* Irix method for watchpoints */
236 enum { READ_WATCHFLAG
= MA_READ
,
237 WRITE_WATCHFLAG
= MA_WRITE
,
238 EXEC_WATCHFLAG
= MA_EXEC
,
239 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
244 #ifdef HAVE_PR_SIGSET_T
245 typedef pr_sigset_t gdb_sigset_t
;
247 typedef sigset_t gdb_sigset_t
;
251 #ifdef HAVE_PR_SIGACTION64_T
252 typedef pr_sigaction64_t gdb_sigaction_t
;
254 typedef struct sigaction gdb_sigaction_t
;
258 #ifdef HAVE_PR_SIGINFO64_T
259 typedef pr_siginfo64_t gdb_siginfo_t
;
261 typedef siginfo_t gdb_siginfo_t
;
264 /* On mips-irix, praddset and prdelset are defined in such a way that
265 they return a value, which causes GCC to emit a -Wunused error
266 because the returned value is not used. Prevent this warning
267 by casting the return value to void. On sparc-solaris, this issue
268 does not exist because the definition of these macros already include
269 that cast to void. */
270 #define gdb_praddset(sp, flag) ((void) praddset (sp, flag))
271 #define gdb_prdelset(sp, flag) ((void) prdelset (sp, flag))
273 /* gdb_premptysysset */
275 #define gdb_premptysysset premptysysset
277 #define gdb_premptysysset premptyset
282 #define gdb_praddsysset praddsysset
284 #define gdb_praddsysset gdb_praddset
289 #define gdb_prdelsysset prdelsysset
291 #define gdb_prdelsysset gdb_prdelset
294 /* prissyssetmember */
295 #ifdef prissyssetmember
296 #define gdb_pr_issyssetmember prissyssetmember
298 #define gdb_pr_issyssetmember prismember
301 /* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't
302 as intuitively descriptive as it could be, so we'll define
303 DYNAMIC_SYSCALLS to mean the same thing. Anyway, at the time of
304 this writing, this feature is only found on AIX5 systems and
305 basically means that the set of syscalls is not fixed. I.e,
306 there's no nice table that one can #include to get all of the
307 syscall numbers. Instead, they're stored in /proc/PID/sysent
308 for each process. We are at least guaranteed that they won't
309 change over the lifetime of the process. But each process could
310 (in theory) have different syscall numbers. */
311 #ifdef HAVE_PRSYSENT_T
312 #define DYNAMIC_SYSCALLS
317 /* =================== STRUCT PROCINFO "MODULE" =================== */
319 /* FIXME: this comment will soon be out of date W.R.T. threads. */
321 /* The procinfo struct is a wrapper to hold all the state information
322 concerning a /proc process. There should be exactly one procinfo
323 for each process, and since GDB currently can debug only one
324 process at a time, that means there should be only one procinfo.
325 All of the LWP's of a process can be accessed indirectly thru the
326 single process procinfo.
328 However, against the day when GDB may debug more than one process,
329 this data structure is kept in a list (which for now will hold no
330 more than one member), and many functions will have a pointer to a
331 procinfo as an argument.
333 There will be a separate procinfo structure for use by the (not yet
334 implemented) "info proc" command, so that we can print useful
335 information about any random process without interfering with the
336 inferior's procinfo information. */
339 /* format strings for /proc paths */
340 # ifndef CTL_PROC_NAME_FMT
341 # define MAIN_PROC_NAME_FMT "/proc/%d"
342 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
343 # define AS_PROC_NAME_FMT "/proc/%d/as"
344 # define MAP_PROC_NAME_FMT "/proc/%d/map"
345 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
346 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
348 /* the name of the proc status struct depends on the implementation */
349 typedef pstatus_t gdb_prstatus_t
;
350 typedef lwpstatus_t gdb_lwpstatus_t
;
351 #else /* ! NEW_PROC_API */
352 /* format strings for /proc paths */
353 # ifndef CTL_PROC_NAME_FMT
354 # define MAIN_PROC_NAME_FMT "/proc/%05d"
355 # define CTL_PROC_NAME_FMT "/proc/%05d"
356 # define AS_PROC_NAME_FMT "/proc/%05d"
357 # define MAP_PROC_NAME_FMT "/proc/%05d"
358 # define STATUS_PROC_NAME_FMT "/proc/%05d"
359 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
361 /* The name of the proc status struct depends on the implementation. */
362 typedef prstatus_t gdb_prstatus_t
;
363 typedef prstatus_t gdb_lwpstatus_t
;
364 #endif /* NEW_PROC_API */
366 typedef struct procinfo
{
367 struct procinfo
*next
;
368 int pid
; /* Process ID */
369 int tid
; /* Thread/LWP id */
373 int ignore_next_sigstop
;
375 /* The following four fd fields may be identical, or may contain
376 several different fd's, depending on the version of /proc
377 (old ioctl or new read/write). */
379 int ctl_fd
; /* File descriptor for /proc control file */
381 /* The next three file descriptors are actually only needed in the
382 read/write, multiple-file-descriptor implemenation
383 (NEW_PROC_API). However, to avoid a bunch of #ifdefs in the
384 code, we will use them uniformly by (in the case of the ioctl
385 single-file-descriptor implementation) filling them with copies
386 of the control fd. */
387 int status_fd
; /* File descriptor for /proc status file */
388 int as_fd
; /* File descriptor for /proc as file */
390 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
392 fltset_t saved_fltset
; /* Saved traced hardware fault set */
393 gdb_sigset_t saved_sigset
; /* Saved traced signal set */
394 gdb_sigset_t saved_sighold
; /* Saved held signal set */
395 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
396 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
398 gdb_prstatus_t prstatus
; /* Current process status info */
401 gdb_fpregset_t fpregset
; /* Current floating point registers */
404 #ifdef DYNAMIC_SYSCALLS
405 int num_syscalls
; /* Total number of syscalls */
406 char **syscall_names
; /* Syscall number to name map */
409 struct procinfo
*thread_list
;
411 int status_valid
: 1;
413 int fpregs_valid
: 1;
414 int threads_valid
: 1;
417 static char errmsg
[128]; /* shared error msg buffer */
419 /* Function prototypes for procinfo module: */
421 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
422 static procinfo
*find_procinfo (int pid
, int tid
);
423 static procinfo
*create_procinfo (int pid
, int tid
);
424 static void destroy_procinfo (procinfo
* p
);
425 static void do_destroy_procinfo_cleanup (void *);
426 static void dead_procinfo (procinfo
* p
, char *msg
, int killp
);
427 static int open_procinfo_files (procinfo
* p
, int which
);
428 static void close_procinfo_files (procinfo
* p
);
429 static int sysset_t_size (procinfo
*p
);
430 static sysset_t
*sysset_t_alloc (procinfo
* pi
);
431 #ifdef DYNAMIC_SYSCALLS
432 static void load_syscalls (procinfo
*pi
);
433 static void free_syscalls (procinfo
*pi
);
434 static int find_syscall (procinfo
*pi
, char *name
);
435 #endif /* DYNAMIC_SYSCALLS */
437 static int iterate_over_mappings
438 (procinfo
*pi
, find_memory_region_ftype child_func
, void *data
,
439 int (*func
) (struct prmap
*map
, find_memory_region_ftype child_func
,
442 /* The head of the procinfo list: */
443 static procinfo
* procinfo_list
;
445 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
449 find_procinfo (int pid
, int tid
)
453 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
460 /* Don't check threads_valid. If we're updating the
461 thread_list, we want to find whatever threads are already
462 here. This means that in general it is the caller's
463 responsibility to check threads_valid and update before
464 calling find_procinfo, if the caller wants to find a new
467 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
475 /* Calls find_procinfo, but errors on failure. */
478 find_procinfo_or_die (int pid
, int tid
)
480 procinfo
*pi
= find_procinfo (pid
, tid
);
485 error (_("procfs: couldn't find pid %d "
486 "(kernel thread %d) in procinfo list."),
489 error (_("procfs: couldn't find pid %d in procinfo list."), pid
);
494 /* Wrapper for `open'. The appropriate open call is attempted; if
495 unsuccessful, it will be retried as many times as needed for the
496 EAGAIN and EINTR conditions.
498 For other conditions, retry the open a limited number of times. In
499 addition, a short sleep is imposed prior to retrying the open. The
500 reason for this sleep is to give the kernel a chance to catch up
501 and create the file in question in the event that GDB "wins" the
502 race to open a file before the kernel has created it. */
505 open_with_retry (const char *pathname
, int flags
)
507 int retries_remaining
, status
;
509 retries_remaining
= 2;
513 status
= open (pathname
, flags
);
515 if (status
>= 0 || retries_remaining
== 0)
517 else if (errno
!= EINTR
&& errno
!= EAGAIN
)
527 /* Open the file descriptor for the process or LWP. If NEW_PROC_API
528 is defined, we only open the control file descriptor; the others
529 are opened lazily as needed. Otherwise (if not NEW_PROC_API),
530 there is only one real file descriptor, but we keep multiple copies
531 of it so that the code that uses them does not have to be #ifdef'd.
532 Returns the file descriptor, or zero for failure. */
534 enum { FD_CTL
, FD_STATUS
, FD_AS
};
537 open_procinfo_files (procinfo
*pi
, int which
)
540 char tmp
[MAX_PROC_NAME_SIZE
];
544 /* This function is getting ALMOST long enough to break up into
545 several. Here is some rationale:
547 NEW_PROC_API (Solaris 2.6, Solaris 2.7):
548 There are several file descriptors that may need to be open
549 for any given process or LWP. The ones we're intereted in are:
550 - control (ctl) write-only change the state
551 - status (status) read-only query the state
552 - address space (as) read/write access memory
553 - map (map) read-only virtual addr map
554 Most of these are opened lazily as they are needed.
555 The pathnames for the 'files' for an LWP look slightly
556 different from those of a first-class process:
557 Pathnames for a process (<proc-id>):
559 /proc/<proc-id>/status
562 Pathnames for an LWP (lwp-id):
563 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
564 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
565 An LWP has no map or address space file descriptor, since
566 the memory map and address space are shared by all LWPs.
568 Everyone else (Solaris 2.5, Irix, OSF)
569 There is only one file descriptor for each process or LWP.
570 For convenience, we copy the same file descriptor into all
571 three fields of the procinfo struct (ctl_fd, status_fd, and
572 as_fd, see NEW_PROC_API above) so that code that uses them
573 doesn't need any #ifdef's.
578 Each LWP has an independent file descriptor, but these
579 are not obtained via the 'open' system call like the rest:
580 instead, they're obtained thru an ioctl call (PIOCOPENLWP)
581 to the file descriptor of the parent process.
584 These do not even have their own independent file descriptor.
585 All operations are carried out on the file descriptor of the
586 parent process. Therefore we just call open again for each
587 thread, getting a new handle for the same 'file'. */
590 /* In this case, there are several different file descriptors that
591 we might be asked to open. The control file descriptor will be
592 opened early, but the others will be opened lazily as they are
595 strcpy (tmp
, pi
->pathname
);
596 switch (which
) { /* Which file descriptor to open? */
599 strcat (tmp
, "/lwpctl");
601 strcat (tmp
, "/ctl");
602 fd
= open_with_retry (tmp
, O_WRONLY
);
609 return 0; /* There is no 'as' file descriptor for an lwp. */
611 fd
= open_with_retry (tmp
, O_RDWR
);
618 strcat (tmp
, "/lwpstatus");
620 strcat (tmp
, "/status");
621 fd
= open_with_retry (tmp
, O_RDONLY
);
627 return 0; /* unknown file descriptor */
629 #else /* not NEW_PROC_API */
630 /* In this case, there is only one file descriptor for each procinfo
631 (ie. each process or LWP). In fact, only the file descriptor for
632 the process can actually be opened by an 'open' system call. The
633 ones for the LWPs have to be obtained thru an IOCTL call on the
634 process's file descriptor.
636 For convenience, we copy each procinfo's single file descriptor
637 into all of the fields occupied by the several file descriptors
638 of the NEW_PROC_API implementation. That way, the code that uses
639 them can be written without ifdefs. */
642 #ifdef PIOCTSTATUS /* OSF */
643 /* Only one FD; just open it. */
644 if ((fd
= open_with_retry (pi
->pathname
, O_RDWR
)) < 0)
646 #else /* Sol 2.5, Irix, other? */
647 if (pi
->tid
== 0) /* Master procinfo for the process */
649 fd
= open_with_retry (pi
->pathname
, O_RDWR
);
653 else /* LWP thread procinfo */
655 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
659 /* Find the procinfo for the entire process. */
660 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
663 /* Now obtain the file descriptor for the LWP. */
664 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) < 0)
666 #else /* Irix, other? */
667 return 0; /* Don't know how to open threads. */
668 #endif /* Sol 2.5 PIOCOPENLWP */
670 #endif /* OSF PIOCTSTATUS */
671 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
672 #endif /* NEW_PROC_API */
674 return 1; /* success */
677 /* Allocate a data structure and link it into the procinfo list.
678 First tries to find a pre-existing one (FIXME: why?). Returns the
679 pointer to new procinfo struct. */
682 create_procinfo (int pid
, int tid
)
684 procinfo
*pi
, *parent
= NULL
;
686 if ((pi
= find_procinfo (pid
, tid
)))
687 return pi
; /* Already exists, nothing to do. */
689 /* Find parent before doing malloc, to save having to cleanup. */
691 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
693 doesn't exist yet? */
695 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
696 memset (pi
, 0, sizeof (procinfo
));
700 #ifdef DYNAMIC_SYSCALLS
704 pi
->saved_entryset
= sysset_t_alloc (pi
);
705 pi
->saved_exitset
= sysset_t_alloc (pi
);
707 /* Chain into list. */
710 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
711 pi
->next
= procinfo_list
;
717 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
719 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
721 pi
->next
= parent
->thread_list
;
722 parent
->thread_list
= pi
;
727 /* Close all file descriptors associated with the procinfo. */
730 close_procinfo_files (procinfo
*pi
)
737 if (pi
->status_fd
> 0)
738 close (pi
->status_fd
);
740 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
743 /* Destructor function. Close, unlink and deallocate the object. */
746 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
750 /* Step one: unlink the procinfo from its list. */
754 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
757 ptr
->next
= pi
->next
;
761 /* Step two: close any open file descriptors. */
762 close_procinfo_files (pi
);
764 /* Step three: free the memory. */
765 #ifdef DYNAMIC_SYSCALLS
768 xfree (pi
->saved_entryset
);
769 xfree (pi
->saved_exitset
);
774 destroy_procinfo (procinfo
*pi
)
778 if (pi
->tid
!= 0) /* Destroy a thread procinfo. */
780 tmp
= find_procinfo (pi
->pid
, 0); /* Find the parent process. */
781 destroy_one_procinfo (&tmp
->thread_list
, pi
);
783 else /* Destroy a process procinfo and all its threads. */
785 /* First destroy the children, if any; */
786 while (pi
->thread_list
!= NULL
)
787 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
788 /* Then destroy the parent. Genocide!!! */
789 destroy_one_procinfo (&procinfo_list
, pi
);
794 do_destroy_procinfo_cleanup (void *pi
)
796 destroy_procinfo (pi
);
799 enum { NOKILL
, KILL
};
801 /* To be called on a non_recoverable error for a procinfo. Prints
802 error messages, optionally sends a SIGKILL to the process, then
803 destroys the data structure. */
806 dead_procinfo (procinfo
*pi
, char *msg
, int kill_p
)
812 print_sys_errmsg (pi
->pathname
, errno
);
816 sprintf (procfile
, "process %d", pi
->pid
);
817 print_sys_errmsg (procfile
, errno
);
820 kill (pi
->pid
, SIGKILL
);
822 destroy_procinfo (pi
);
826 /* Returns the (complete) size of a sysset_t struct. Normally, this
827 is just sizeof (sysset_t), but in the case of Monterey/64, the
828 actual size of sysset_t isn't known until runtime. */
831 sysset_t_size (procinfo
* pi
)
833 #ifndef DYNAMIC_SYSCALLS
834 return sizeof (sysset_t
);
836 return sizeof (sysset_t
) - sizeof (uint64_t)
837 + sizeof (uint64_t) * ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
838 / (8 * sizeof (uint64_t)));
842 /* Allocate and (partially) initialize a sysset_t struct. */
845 sysset_t_alloc (procinfo
* pi
)
848 int size
= sysset_t_size (pi
);
850 ret
= xmalloc (size
);
851 #ifdef DYNAMIC_SYSCALLS
852 ret
->pr_size
= ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
853 / (8 * sizeof (uint64_t)));
858 #ifdef DYNAMIC_SYSCALLS
860 /* Extract syscall numbers and names from /proc/<pid>/sysent. Initialize
861 pi->num_syscalls with the number of syscalls and pi->syscall_names
862 with the names. (Certain numbers may be skipped in which case the
863 names for these numbers will be left as NULL.) */
865 #define MAX_SYSCALL_NAME_LENGTH 256
866 #define MAX_SYSCALLS 65536
869 load_syscalls (procinfo
*pi
)
871 char pathname
[MAX_PROC_NAME_SIZE
];
874 prsyscall_t
*syscalls
;
875 int i
, size
, maxcall
;
876 struct cleanup
*cleanups
;
878 pi
->num_syscalls
= 0;
879 pi
->syscall_names
= 0;
881 /* Open the file descriptor for the sysent file. */
882 sprintf (pathname
, "/proc/%d/sysent", pi
->pid
);
883 sysent_fd
= open_with_retry (pathname
, O_RDONLY
);
886 error (_("load_syscalls: Can't open /proc/%d/sysent"), pi
->pid
);
888 cleanups
= make_cleanup_close (sysent_fd
);
890 size
= sizeof header
- sizeof (prsyscall_t
);
891 if (read (sysent_fd
, &header
, size
) != size
)
893 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
896 if (header
.pr_nsyscalls
== 0)
898 error (_("load_syscalls: /proc/%d/sysent contains no syscalls!"),
902 size
= header
.pr_nsyscalls
* sizeof (prsyscall_t
);
903 syscalls
= xmalloc (size
);
904 make_cleanup (free_current_contents
, &syscalls
);
906 if (read (sysent_fd
, syscalls
, size
) != size
)
907 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
909 /* Find maximum syscall number. This may not be the same as
910 pr_nsyscalls since that value refers to the number of entries
911 in the table. (Also, the docs indicate that some system
912 call numbers may be skipped.) */
914 maxcall
= syscalls
[0].pr_number
;
916 for (i
= 1; i
< header
.pr_nsyscalls
; i
++)
917 if (syscalls
[i
].pr_number
> maxcall
918 && syscalls
[i
].pr_nameoff
> 0
919 && syscalls
[i
].pr_number
< MAX_SYSCALLS
)
920 maxcall
= syscalls
[i
].pr_number
;
922 pi
->num_syscalls
= maxcall
+1;
923 pi
->syscall_names
= xmalloc (pi
->num_syscalls
* sizeof (char *));
925 for (i
= 0; i
< pi
->num_syscalls
; i
++)
926 pi
->syscall_names
[i
] = NULL
;
928 /* Read the syscall names in. */
929 for (i
= 0; i
< header
.pr_nsyscalls
; i
++)
931 char namebuf
[MAX_SYSCALL_NAME_LENGTH
];
935 if (syscalls
[i
].pr_number
>= MAX_SYSCALLS
936 || syscalls
[i
].pr_number
< 0
937 || syscalls
[i
].pr_nameoff
<= 0
938 || (lseek (sysent_fd
, (off_t
) syscalls
[i
].pr_nameoff
, SEEK_SET
)
939 != (off_t
) syscalls
[i
].pr_nameoff
))
942 nread
= read (sysent_fd
, namebuf
, sizeof namebuf
);
946 callnum
= syscalls
[i
].pr_number
;
948 if (pi
->syscall_names
[callnum
] != NULL
)
950 /* FIXME: Generate warning. */
954 namebuf
[nread
-1] = '\0';
955 size
= strlen (namebuf
) + 1;
956 pi
->syscall_names
[callnum
] = xmalloc (size
);
957 strncpy (pi
->syscall_names
[callnum
], namebuf
, size
-1);
958 pi
->syscall_names
[callnum
][size
-1] = '\0';
961 do_cleanups (cleanups
);
964 /* Free the space allocated for the syscall names from the procinfo
968 free_syscalls (procinfo
*pi
)
970 if (pi
->syscall_names
)
974 for (i
= 0; i
< pi
->num_syscalls
; i
++)
975 if (pi
->syscall_names
[i
] != NULL
)
976 xfree (pi
->syscall_names
[i
]);
978 xfree (pi
->syscall_names
);
979 pi
->syscall_names
= 0;
983 /* Given a name, look up (and return) the corresponding syscall number.
984 If no match is found, return -1. */
987 find_syscall (procinfo
*pi
, char *name
)
991 for (i
= 0; i
< pi
->num_syscalls
; i
++)
993 if (pi
->syscall_names
[i
] && strcmp (name
, pi
->syscall_names
[i
]) == 0)
1000 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
1002 /* =================== /proc "MODULE" =================== */
1004 /* This "module" is the interface layer between the /proc system API
1005 and the gdb target vector functions. This layer consists of access
1006 functions that encapsulate each of the basic operations that we
1007 need to use from the /proc API.
1009 The main motivation for this layer is to hide the fact that there
1010 are two very different implementations of the /proc API. Rather
1011 than have a bunch of #ifdefs all thru the gdb target vector
1012 functions, we do our best to hide them all in here. */
1014 static long proc_flags (procinfo
* pi
);
1015 static int proc_why (procinfo
* pi
);
1016 static int proc_what (procinfo
* pi
);
1017 static int proc_set_current_signal (procinfo
* pi
, int signo
);
1018 static int proc_get_current_thread (procinfo
* pi
);
1019 static int proc_iterate_over_threads
1021 int (*func
) (procinfo
*, procinfo
*, void *),
1025 proc_warn (procinfo
*pi
, char *func
, int line
)
1027 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1028 print_sys_errmsg (errmsg
, errno
);
1032 proc_error (procinfo
*pi
, char *func
, int line
)
1034 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1035 perror_with_name (errmsg
);
1038 /* Updates the status struct in the procinfo. There is a 'valid'
1039 flag, to let other functions know when this function needs to be
1040 called (so the status is only read when it is needed). The status
1041 file descriptor is also only opened when it is needed. Returns
1042 non-zero for success, zero for failure. */
1045 proc_get_status (procinfo
*pi
)
1047 /* Status file descriptor is opened "lazily". */
1048 if (pi
->status_fd
== 0 &&
1049 open_procinfo_files (pi
, FD_STATUS
) == 0)
1051 pi
->status_valid
= 0;
1056 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
1057 pi
->status_valid
= 0; /* fail */
1060 /* Sigh... I have to read a different data structure,
1061 depending on whether this is a main process or an LWP. */
1063 pi
->status_valid
= (read (pi
->status_fd
,
1064 (char *) &pi
->prstatus
.pr_lwp
,
1065 sizeof (lwpstatus_t
))
1066 == sizeof (lwpstatus_t
));
1069 pi
->status_valid
= (read (pi
->status_fd
,
1070 (char *) &pi
->prstatus
,
1071 sizeof (gdb_prstatus_t
))
1072 == sizeof (gdb_prstatus_t
));
1075 #else /* ioctl method */
1076 #ifdef PIOCTSTATUS /* osf */
1077 if (pi
->tid
== 0) /* main process */
1079 /* Just read the danged status. Now isn't that simple? */
1081 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1088 tid_t pr_error_thread
;
1089 struct prstatus status
;
1092 thread_status
.pr_count
= 1;
1093 thread_status
.status
.pr_tid
= pi
->tid
;
1094 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
1097 memcpy (&pi
->prstatus
, &thread_status
.status
,
1098 sizeof (pi
->prstatus
));
1099 pi
->status_valid
= 1;
1103 /* Just read the danged status. Now isn't that simple? */
1104 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1108 if (pi
->status_valid
)
1110 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1113 proc_get_current_thread (pi
));
1116 /* The status struct includes general regs, so mark them valid too. */
1117 pi
->gregs_valid
= pi
->status_valid
;
1119 /* In the read/write multiple-fd model, the status struct includes
1120 the fp regs too, so mark them valid too. */
1121 pi
->fpregs_valid
= pi
->status_valid
;
1123 return pi
->status_valid
; /* True if success, false if failure. */
1126 /* Returns the process flags (pr_flags field). */
1129 proc_flags (procinfo
*pi
)
1131 if (!pi
->status_valid
)
1132 if (!proc_get_status (pi
))
1133 return 0; /* FIXME: not a good failure value (but what is?) */
1136 return pi
->prstatus
.pr_lwp
.pr_flags
;
1138 return pi
->prstatus
.pr_flags
;
1142 /* Returns the pr_why field (why the process stopped). */
1145 proc_why (procinfo
*pi
)
1147 if (!pi
->status_valid
)
1148 if (!proc_get_status (pi
))
1149 return 0; /* FIXME: not a good failure value (but what is?) */
1152 return pi
->prstatus
.pr_lwp
.pr_why
;
1154 return pi
->prstatus
.pr_why
;
1158 /* Returns the pr_what field (details of why the process stopped). */
1161 proc_what (procinfo
*pi
)
1163 if (!pi
->status_valid
)
1164 if (!proc_get_status (pi
))
1165 return 0; /* FIXME: not a good failure value (but what is?) */
1168 return pi
->prstatus
.pr_lwp
.pr_what
;
1170 return pi
->prstatus
.pr_what
;
1174 /* This function is only called when PI is stopped by a watchpoint.
1175 Assuming the OS supports it, write to *ADDR the data address which
1176 triggered it and return 1. Return 0 if it is not possible to know
1180 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
1182 if (!pi
->status_valid
)
1183 if (!proc_get_status (pi
))
1187 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch (),
1188 builtin_type (target_gdbarch ())->builtin_data_ptr
,
1189 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
1191 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch (),
1192 builtin_type (target_gdbarch ())->builtin_data_ptr
,
1193 (gdb_byte
*) &pi
->prstatus
.pr_info
.si_addr
);
1198 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1200 /* Returns the pr_nsysarg field (number of args to the current
1204 proc_nsysarg (procinfo
*pi
)
1206 if (!pi
->status_valid
)
1207 if (!proc_get_status (pi
))
1211 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1213 return pi
->prstatus
.pr_nsysarg
;
1217 /* Returns the pr_sysarg field (pointer to the arguments of current
1221 proc_sysargs (procinfo
*pi
)
1223 if (!pi
->status_valid
)
1224 if (!proc_get_status (pi
))
1228 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1230 return (long *) &pi
->prstatus
.pr_sysarg
;
1233 #endif /* PIOCSSPCACT */
1235 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
1236 /* Returns the pr_cursig field (current signal). */
1239 proc_cursig (struct procinfo
*pi
)
1241 if (!pi
->status_valid
)
1242 if (!proc_get_status (pi
))
1243 return 0; /* FIXME: not a good failure value (but what is?) */
1246 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1248 return pi
->prstatus
.pr_cursig
;
1251 #endif /* PROCFS_DONT_PIOCSSIG_CURSIG */
1253 /* === I appologize for the messiness of this function.
1254 === This is an area where the different versions of
1255 === /proc are more inconsistent than usual.
1257 Set or reset any of the following process flags:
1258 PR_FORK -- forked child will inherit trace flags
1259 PR_RLC -- traced process runs when last /proc file closed.
1260 PR_KLC -- traced process is killed when last /proc file closed.
1261 PR_ASYNC -- LWP's get to run/stop independently.
1263 There are three methods for doing this function:
1264 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1266 2) Middle: PIOCSET/PIOCRESET
1268 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1271 Note: Irix does not define PR_ASYNC.
1272 Note: OSF does not define PR_KLC.
1273 Note: OSF is the only one that can ONLY use the oldest method.
1277 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1278 mode -- 1 for set, 0 for reset.
1280 Returns non-zero for success, zero for failure. */
1282 enum { FLAG_RESET
, FLAG_SET
};
1285 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
1287 long win
= 0; /* default to fail */
1289 /* These operations affect the process as a whole, and applying them
1290 to an individual LWP has the same meaning as applying them to the
1291 main process. Therefore, if we're ever called with a pointer to
1292 an LWP's procinfo, let's substitute the process's procinfo and
1293 avoid opening the LWP's file descriptor unnecessarily. */
1296 pi
= find_procinfo_or_die (pi
->pid
, 0);
1298 #ifdef NEW_PROC_API /* Newest method: Newer Solarii. */
1299 /* First normalize the PCUNSET/PCRESET command opcode
1300 (which for no obvious reason has a different definition
1301 from one operating system to the next...) */
1303 #define GDBRESET PCUNSET
1306 #define GDBRESET PCRESET
1310 procfs_ctl_t arg
[2];
1312 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
1314 else /* Reset the flag. */
1318 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1321 #ifdef PIOCSET /* Irix/Sol5 method */
1322 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC). */
1324 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1326 else /* Reset the flag. */
1328 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1332 #ifdef PIOCSRLC /* Oldest method: OSF */
1335 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1337 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1339 else /* Clear run-on-last-close */
1341 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1345 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1347 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1349 else /* Clear inherit-on-fork */
1351 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1355 win
= 0; /* Fail -- unknown flag (can't do PR_ASYNC). */
1362 /* The above operation renders the procinfo's cached pstatus
1364 pi
->status_valid
= 0;
1367 warning (_("procfs: modify_flag failed to turn %s %s"),
1368 flag
== PR_FORK
? "PR_FORK" :
1369 flag
== PR_RLC
? "PR_RLC" :
1371 flag
== PR_ASYNC
? "PR_ASYNC" :
1374 flag
== PR_KLC
? "PR_KLC" :
1377 mode
== FLAG_RESET
? "off" : "on");
1382 /* Set the run_on_last_close flag. Process with all threads will
1383 become runnable when debugger closes all /proc fds. Returns
1384 non-zero for success, zero for failure. */
1387 proc_set_run_on_last_close (procinfo
*pi
)
1389 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1392 /* Reset the run_on_last_close flag. The process will NOT become
1393 runnable when debugger closes its file handles. Returns non-zero
1394 for success, zero for failure. */
1397 proc_unset_run_on_last_close (procinfo
*pi
)
1399 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1402 /* Reset inherit_on_fork flag. If the process forks a child while we
1403 are registered for events in the parent, then we will NOT recieve
1404 events from the child. Returns non-zero for success, zero for
1408 proc_unset_inherit_on_fork (procinfo
*pi
)
1410 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1414 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
1415 (signal etc.), the remaining LWPs will continue to run. Returns
1416 non-zero for success, zero for failure. */
1419 proc_set_async (procinfo
*pi
)
1421 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1424 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
1425 (signal etc.), then all other LWPs will stop as well. Returns
1426 non-zero for success, zero for failure. */
1429 proc_unset_async (procinfo
*pi
)
1431 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1433 #endif /* PR_ASYNC */
1435 /* Request the process/LWP to stop. Does not wait. Returns non-zero
1436 for success, zero for failure. */
1439 proc_stop_process (procinfo
*pi
)
1443 /* We might conceivably apply this operation to an LWP, and the
1444 LWP's ctl file descriptor might not be open. */
1446 if (pi
->ctl_fd
== 0 &&
1447 open_procinfo_files (pi
, FD_CTL
) == 0)
1452 procfs_ctl_t cmd
= PCSTOP
;
1454 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1455 #else /* ioctl method */
1456 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1457 /* Note: the call also reads the prstatus. */
1460 pi
->status_valid
= 1;
1461 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1464 proc_get_current_thread (pi
));
1472 /* Wait for the process or LWP to stop (block until it does). Returns
1473 non-zero for success, zero for failure. */
1476 proc_wait_for_stop (procinfo
*pi
)
1480 /* We should never have to apply this operation to any procinfo
1481 except the one for the main process. If that ever changes for
1482 any reason, then take out the following clause and replace it
1483 with one that makes sure the ctl_fd is open. */
1486 pi
= find_procinfo_or_die (pi
->pid
, 0);
1490 procfs_ctl_t cmd
= PCWSTOP
;
1492 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1493 /* We been runnin' and we stopped -- need to update status. */
1494 pi
->status_valid
= 0;
1496 #else /* ioctl method */
1497 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1498 /* Above call also refreshes the prstatus. */
1501 pi
->status_valid
= 1;
1502 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1505 proc_get_current_thread (pi
));
1512 /* Make the process or LWP runnable.
1514 Options (not all are implemented):
1516 - clear current fault
1517 - clear current signal
1518 - abort the current system call
1519 - stop as soon as finished with system call
1520 - (ioctl): set traced signal set
1521 - (ioctl): set held signal set
1522 - (ioctl): set traced fault set
1523 - (ioctl): set start pc (vaddr)
1525 Always clears the current fault. PI is the process or LWP to
1526 operate on. If STEP is true, set the process or LWP to trap after
1527 one instruction. If SIGNO is zero, clear the current signal if
1528 any; if non-zero, set the current signal to this one. Returns
1529 non-zero for success, zero for failure. */
1532 proc_run_process (procinfo
*pi
, int step
, int signo
)
1537 /* We will probably have to apply this operation to individual
1538 threads, so make sure the control file descriptor is open. */
1540 if (pi
->ctl_fd
== 0 &&
1541 open_procinfo_files (pi
, FD_CTL
) == 0)
1546 runflags
= PRCFAULT
; /* Always clear current fault. */
1551 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
1552 proc_set_current_signal (pi
, signo
);
1556 procfs_ctl_t cmd
[2];
1560 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1562 #else /* ioctl method */
1566 memset (&prrun
, 0, sizeof (prrun
));
1567 prrun
.pr_flags
= runflags
;
1568 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1575 /* Register to trace signals in the process or LWP. Returns non-zero
1576 for success, zero for failure. */
1579 proc_set_traced_signals (procinfo
*pi
, gdb_sigset_t
*sigset
)
1583 /* We should never have to apply this operation to any procinfo
1584 except the one for the main process. If that ever changes for
1585 any reason, then take out the following clause and replace it
1586 with one that makes sure the ctl_fd is open. */
1589 pi
= find_procinfo_or_die (pi
->pid
, 0);
1595 /* Use char array to avoid alignment issues. */
1596 char sigset
[sizeof (gdb_sigset_t
)];
1600 memcpy (&arg
.sigset
, sigset
, sizeof (gdb_sigset_t
));
1602 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1604 #else /* ioctl method */
1605 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1607 /* The above operation renders the procinfo's cached pstatus obsolete. */
1608 pi
->status_valid
= 0;
1611 warning (_("procfs: set_traced_signals failed"));
1615 /* Register to trace hardware faults in the process or LWP. Returns
1616 non-zero for success, zero for failure. */
1619 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1623 /* We should never have to apply this operation to any procinfo
1624 except the one for the main process. If that ever changes for
1625 any reason, then take out the following clause and replace it
1626 with one that makes sure the ctl_fd is open. */
1629 pi
= find_procinfo_or_die (pi
->pid
, 0);
1635 /* Use char array to avoid alignment issues. */
1636 char fltset
[sizeof (fltset_t
)];
1640 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1642 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1644 #else /* ioctl method */
1645 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1647 /* The above operation renders the procinfo's cached pstatus obsolete. */
1648 pi
->status_valid
= 0;
1653 /* Register to trace entry to system calls in the process or LWP.
1654 Returns non-zero for success, zero for failure. */
1657 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1661 /* We should never have to apply this operation to any procinfo
1662 except the one for the main process. If that ever changes for
1663 any reason, then take out the following clause and replace it
1664 with one that makes sure the ctl_fd is open. */
1667 pi
= find_procinfo_or_die (pi
->pid
, 0);
1671 struct gdb_proc_ctl_pcsentry
{
1673 /* Use char array to avoid alignment issues. */
1674 char sysset
[sizeof (sysset_t
)];
1676 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
)
1678 + sysset_t_size (pi
);
1680 argp
= xmalloc (argp_size
);
1682 argp
->cmd
= PCSENTRY
;
1683 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1685 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1688 #else /* ioctl method */
1689 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1691 /* The above operation renders the procinfo's cached pstatus
1693 pi
->status_valid
= 0;
1698 /* Register to trace exit from system calls in the process or LWP.
1699 Returns non-zero for success, zero for failure. */
1702 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1706 /* We should never have to apply this operation to any procinfo
1707 except the one for the main process. If that ever changes for
1708 any reason, then take out the following clause and replace it
1709 with one that makes sure the ctl_fd is open. */
1712 pi
= find_procinfo_or_die (pi
->pid
, 0);
1716 struct gdb_proc_ctl_pcsexit
{
1718 /* Use char array to avoid alignment issues. */
1719 char sysset
[sizeof (sysset_t
)];
1721 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
)
1723 + sysset_t_size (pi
);
1725 argp
= xmalloc (argp_size
);
1727 argp
->cmd
= PCSEXIT
;
1728 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1730 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1733 #else /* ioctl method */
1734 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1736 /* The above operation renders the procinfo's cached pstatus
1738 pi
->status_valid
= 0;
1743 /* Specify the set of blocked / held signals in the process or LWP.
1744 Returns non-zero for success, zero for failure. */
1747 proc_set_held_signals (procinfo
*pi
, gdb_sigset_t
*sighold
)
1751 /* We should never have to apply this operation to any procinfo
1752 except the one for the main process. If that ever changes for
1753 any reason, then take out the following clause and replace it
1754 with one that makes sure the ctl_fd is open. */
1757 pi
= find_procinfo_or_die (pi
->pid
, 0);
1763 /* Use char array to avoid alignment issues. */
1764 char hold
[sizeof (gdb_sigset_t
)];
1768 memcpy (&arg
.hold
, sighold
, sizeof (gdb_sigset_t
));
1769 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1772 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1774 /* The above operation renders the procinfo's cached pstatus
1776 pi
->status_valid
= 0;
1781 /* Returns the set of signals that are held / blocked. Will also copy
1782 the sigset if SAVE is non-zero. */
1784 static gdb_sigset_t
*
1785 proc_get_held_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1787 gdb_sigset_t
*ret
= NULL
;
1789 /* We should never have to apply this operation to any procinfo
1790 except the one for the main process. If that ever changes for
1791 any reason, then take out the following clause and replace it
1792 with one that makes sure the ctl_fd is open. */
1795 pi
= find_procinfo_or_die (pi
->pid
, 0);
1798 if (!pi
->status_valid
)
1799 if (!proc_get_status (pi
))
1802 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1803 #else /* not NEW_PROC_API */
1805 static gdb_sigset_t sigheld
;
1807 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1810 #endif /* NEW_PROC_API */
1812 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1817 /* Returns the set of signals that are traced / debugged. Will also
1818 copy the sigset if SAVE is non-zero. */
1820 static gdb_sigset_t
*
1821 proc_get_traced_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1823 gdb_sigset_t
*ret
= NULL
;
1825 /* We should never have to apply this operation to any procinfo
1826 except the one for the main process. If that ever changes for
1827 any reason, then take out the following clause and replace it
1828 with one that makes sure the ctl_fd is open. */
1831 pi
= find_procinfo_or_die (pi
->pid
, 0);
1834 if (!pi
->status_valid
)
1835 if (!proc_get_status (pi
))
1838 ret
= &pi
->prstatus
.pr_sigtrace
;
1841 static gdb_sigset_t sigtrace
;
1843 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
1848 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1853 /* Returns the set of hardware faults that are traced /debugged. Will
1854 also copy the faultset if SAVE is non-zero. */
1857 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
1859 fltset_t
*ret
= NULL
;
1861 /* We should never have to apply this operation to any procinfo
1862 except the one for the main process. If that ever changes for
1863 any reason, then take out the following clause and replace it
1864 with one that makes sure the ctl_fd is open. */
1867 pi
= find_procinfo_or_die (pi
->pid
, 0);
1870 if (!pi
->status_valid
)
1871 if (!proc_get_status (pi
))
1874 ret
= &pi
->prstatus
.pr_flttrace
;
1877 static fltset_t flttrace
;
1879 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
1884 memcpy (save
, ret
, sizeof (fltset_t
));
1889 /* Returns the set of syscalls that are traced /debugged on entry.
1890 Will also copy the syscall set if SAVE is non-zero. */
1893 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
1895 sysset_t
*ret
= NULL
;
1897 /* We should never have to apply this operation to any procinfo
1898 except the one for the main process. If that ever changes for
1899 any reason, then take out the following clause and replace it
1900 with one that makes sure the ctl_fd is open. */
1903 pi
= find_procinfo_or_die (pi
->pid
, 0);
1906 if (!pi
->status_valid
)
1907 if (!proc_get_status (pi
))
1910 #ifndef DYNAMIC_SYSCALLS
1911 ret
= &pi
->prstatus
.pr_sysentry
;
1912 #else /* DYNAMIC_SYSCALLS */
1914 static sysset_t
*sysentry
;
1918 sysentry
= sysset_t_alloc (pi
);
1920 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
1922 if (pi
->prstatus
.pr_sysentry_offset
== 0)
1924 gdb_premptysysset (sysentry
);
1930 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysentry_offset
,
1932 != (off_t
) pi
->prstatus
.pr_sysentry_offset
)
1934 size
= sysset_t_size (pi
);
1935 gdb_premptysysset (sysentry
);
1936 rsize
= read (pi
->status_fd
, sysentry
, size
);
1941 #endif /* DYNAMIC_SYSCALLS */
1942 #else /* !NEW_PROC_API */
1944 static sysset_t sysentry
;
1946 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
1949 #endif /* NEW_PROC_API */
1951 memcpy (save
, ret
, sysset_t_size (pi
));
1956 /* Returns the set of syscalls that are traced /debugged on exit.
1957 Will also copy the syscall set if SAVE is non-zero. */
1960 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
1962 sysset_t
* ret
= NULL
;
1964 /* We should never have to apply this operation to any procinfo
1965 except the one for the main process. If that ever changes for
1966 any reason, then take out the following clause and replace it
1967 with one that makes sure the ctl_fd is open. */
1970 pi
= find_procinfo_or_die (pi
->pid
, 0);
1973 if (!pi
->status_valid
)
1974 if (!proc_get_status (pi
))
1977 #ifndef DYNAMIC_SYSCALLS
1978 ret
= &pi
->prstatus
.pr_sysexit
;
1979 #else /* DYNAMIC_SYSCALLS */
1981 static sysset_t
*sysexit
;
1985 sysexit
= sysset_t_alloc (pi
);
1987 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
1989 if (pi
->prstatus
.pr_sysexit_offset
== 0)
1991 gdb_premptysysset (sysexit
);
1997 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysexit_offset
,
1999 != (off_t
) pi
->prstatus
.pr_sysexit_offset
)
2001 size
= sysset_t_size (pi
);
2002 gdb_premptysysset (sysexit
);
2003 rsize
= read (pi
->status_fd
, sysexit
, size
);
2008 #endif /* DYNAMIC_SYSCALLS */
2011 static sysset_t sysexit
;
2013 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2018 memcpy (save
, ret
, sysset_t_size (pi
));
2023 /* The current fault (if any) is cleared; the associated signal will
2024 not be sent to the process or LWP when it resumes. Returns
2025 non-zero for success, zero for failure. */
2028 proc_clear_current_fault (procinfo
*pi
)
2032 /* We should never have to apply this operation to any procinfo
2033 except the one for the main process. If that ever changes for
2034 any reason, then take out the following clause and replace it
2035 with one that makes sure the ctl_fd is open. */
2038 pi
= find_procinfo_or_die (pi
->pid
, 0);
2042 procfs_ctl_t cmd
= PCCFAULT
;
2044 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2047 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2053 /* Set the "current signal" that will be delivered next to the
2054 process. NOTE: semantics are different from those of KILL. This
2055 signal will be delivered to the process or LWP immediately when it
2056 is resumed (even if the signal is held/blocked); it will NOT
2057 immediately cause another event of interest, and will NOT first
2058 trap back to the debugger. Returns non-zero for success, zero for
2062 proc_set_current_signal (procinfo
*pi
, int signo
)
2067 /* Use char array to avoid alignment issues. */
2068 char sinfo
[sizeof (gdb_siginfo_t
)];
2070 gdb_siginfo_t mysinfo
;
2072 struct target_waitstatus wait_status
;
2074 /* We should never have to apply this operation to any procinfo
2075 except the one for the main process. If that ever changes for
2076 any reason, then take out the following clause and replace it
2077 with one that makes sure the ctl_fd is open. */
2080 pi
= find_procinfo_or_die (pi
->pid
, 0);
2082 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2083 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2084 receives a PIOCSSIG with a signal identical to the current
2085 signal, it messes up the current signal. Work around the kernel
2088 signo
== proc_cursig (pi
))
2089 return 1; /* I assume this is a success? */
2092 /* The pointer is just a type alias. */
2093 get_last_target_status (&wait_ptid
, &wait_status
);
2094 if (ptid_equal (wait_ptid
, inferior_ptid
)
2095 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
2096 && wait_status
.value
.sig
== gdb_signal_from_host (signo
)
2097 && proc_get_status (pi
)
2099 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
2101 && pi
->prstatus
.pr_info
.si_signo
== signo
2104 /* Use the siginfo associated with the signal being
2107 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (gdb_siginfo_t
));
2109 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_info
, sizeof (gdb_siginfo_t
));
2113 mysinfo
.si_signo
= signo
;
2114 mysinfo
.si_code
= 0;
2115 mysinfo
.si_pid
= getpid (); /* ?why? */
2116 mysinfo
.si_uid
= getuid (); /* ?why? */
2117 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2122 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2124 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2130 /* The current signal (if any) is cleared, and is not sent to the
2131 process or LWP when it resumes. Returns non-zero for success, zero
2135 proc_clear_current_signal (procinfo
*pi
)
2139 /* We should never have to apply this operation to any procinfo
2140 except the one for the main process. If that ever changes for
2141 any reason, then take out the following clause and replace it
2142 with one that makes sure the ctl_fd is open. */
2145 pi
= find_procinfo_or_die (pi
->pid
, 0);
2151 /* Use char array to avoid alignment issues. */
2152 char sinfo
[sizeof (gdb_siginfo_t
)];
2154 gdb_siginfo_t mysinfo
;
2157 /* The pointer is just a type alias. */
2158 mysinfo
.si_signo
= 0;
2159 mysinfo
.si_code
= 0;
2160 mysinfo
.si_errno
= 0;
2161 mysinfo
.si_pid
= getpid (); /* ?why? */
2162 mysinfo
.si_uid
= getuid (); /* ?why? */
2163 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2165 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2168 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2174 /* Return the general-purpose registers for the process or LWP
2175 corresponding to PI. Upon failure, return NULL. */
2177 static gdb_gregset_t
*
2178 proc_get_gregs (procinfo
*pi
)
2180 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2181 if (!proc_get_status (pi
))
2185 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2187 return &pi
->prstatus
.pr_reg
;
2191 /* Return the general-purpose registers for the process or LWP
2192 corresponding to PI. Upon failure, return NULL. */
2194 static gdb_fpregset_t
*
2195 proc_get_fpregs (procinfo
*pi
)
2198 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2199 if (!proc_get_status (pi
))
2202 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2204 #else /* not NEW_PROC_API */
2205 if (pi
->fpregs_valid
)
2206 return &pi
->fpregset
; /* Already got 'em. */
2209 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2218 tid_t pr_error_thread
;
2219 tfpregset_t thread_1
;
2222 thread_fpregs
.pr_count
= 1;
2223 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2226 && ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2228 pi
->fpregs_valid
= 1;
2229 return &pi
->fpregset
; /* Got 'em now! */
2231 else if (pi
->tid
!= 0
2232 && ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2234 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2235 sizeof (pi
->fpregset
));
2236 pi
->fpregs_valid
= 1;
2237 return &pi
->fpregset
; /* Got 'em now! */
2244 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2246 pi
->fpregs_valid
= 1;
2247 return &pi
->fpregset
; /* Got 'em now! */
2256 #endif /* NEW_PROC_API */
2259 /* Write the general-purpose registers back to the process or LWP
2260 corresponding to PI. Return non-zero for success, zero for
2264 proc_set_gregs (procinfo
*pi
)
2266 gdb_gregset_t
*gregs
;
2269 gregs
= proc_get_gregs (pi
);
2271 return 0; /* proc_get_regs has already warned. */
2273 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2282 /* Use char array to avoid alignment issues. */
2283 char gregs
[sizeof (gdb_gregset_t
)];
2287 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2288 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2290 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2294 /* Policy: writing the registers invalidates our cache. */
2295 pi
->gregs_valid
= 0;
2299 /* Write the floating-pointer registers back to the process or LWP
2300 corresponding to PI. Return non-zero for success, zero for
2304 proc_set_fpregs (procinfo
*pi
)
2306 gdb_fpregset_t
*fpregs
;
2309 fpregs
= proc_get_fpregs (pi
);
2311 return 0; /* proc_get_fpregs has already warned. */
2313 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2322 /* Use char array to avoid alignment issues. */
2323 char fpregs
[sizeof (gdb_fpregset_t
)];
2327 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2328 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2332 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2337 tid_t pr_error_thread
;
2338 tfpregset_t thread_1
;
2341 thread_fpregs
.pr_count
= 1;
2342 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2343 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2345 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2348 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2350 #endif /* NEW_PROC_API */
2353 /* Policy: writing the registers invalidates our cache. */
2354 pi
->fpregs_valid
= 0;
2358 /* Send a signal to the proc or lwp with the semantics of "kill()".
2359 Returns non-zero for success, zero for failure. */
2362 proc_kill (procinfo
*pi
, int signo
)
2366 /* We might conceivably apply this operation to an LWP, and the
2367 LWP's ctl file descriptor might not be open. */
2369 if (pi
->ctl_fd
== 0 &&
2370 open_procinfo_files (pi
, FD_CTL
) == 0)
2377 procfs_ctl_t cmd
[2];
2381 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2382 #else /* ioctl method */
2383 /* FIXME: do I need the Alpha OSF fixups present in
2384 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2385 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2392 /* Find the pid of the process that started this one. Returns the
2393 parent process pid, or zero. */
2396 proc_parent_pid (procinfo
*pi
)
2398 /* We should never have to apply this operation to any procinfo
2399 except the one for the main process. If that ever changes for
2400 any reason, then take out the following clause and replace it
2401 with one that makes sure the ctl_fd is open. */
2404 pi
= find_procinfo_or_die (pi
->pid
, 0);
2406 if (!pi
->status_valid
)
2407 if (!proc_get_status (pi
))
2410 return pi
->prstatus
.pr_ppid
;
2413 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
2414 (a.k.a void pointer)! */
2416 #if (defined (PCWATCH) || defined (PIOCSWATCH)) \
2417 && !(defined (PIOCOPENLWP))
2419 procfs_address_to_host_pointer (CORE_ADDR addr
)
2421 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
2424 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
2425 gdbarch_address_to_pointer (target_gdbarch (), ptr_type
,
2426 (gdb_byte
*) &ptr
, addr
);
2432 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
2434 #if !defined (PCWATCH) && !defined (PIOCSWATCH)
2435 /* If neither or these is defined, we can't support watchpoints.
2436 This just avoids possibly failing to compile the below on such
2440 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5. */
2441 #if defined (PIOCOPENLWP) /* Solaris 2.5: bail out. */
2446 char watch
[sizeof (prwatch_t
)];
2450 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
2451 convert a target address into something that can be stored in a
2452 native data structure. */
2453 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
2454 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
2456 pwatch
.pr_vaddr
= (caddr_t
) procfs_address_to_host_pointer (addr
);
2458 pwatch
.pr_size
= len
;
2459 pwatch
.pr_wflags
= wflags
;
2460 #if defined(NEW_PROC_API) && defined (PCWATCH)
2462 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
2463 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2465 #if defined (PIOCSWATCH)
2466 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, &pwatch
) >= 0);
2468 return 0; /* Fail */
2475 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
2477 #include <sys/sysi86.h>
2479 /* The KEY is actually the value of the lower 16 bits of the GS
2480 register for the LWP that we're interested in. Returns the
2481 matching ssh struct (LDT entry). */
2484 proc_get_LDT_entry (procinfo
*pi
, int key
)
2486 static struct ssd
*ldt_entry
= NULL
;
2488 char pathname
[MAX_PROC_NAME_SIZE
];
2489 struct cleanup
*old_chain
= NULL
;
2492 /* Allocate space for one LDT entry.
2493 This alloc must persist, because we return a pointer to it. */
2494 if (ldt_entry
== NULL
)
2495 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2497 /* Open the file descriptor for the LDT table. */
2498 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2499 if ((fd
= open_with_retry (pathname
, O_RDONLY
)) < 0)
2501 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2504 /* Make sure it gets closed again! */
2505 old_chain
= make_cleanup_close (fd
);
2507 /* Now 'read' thru the table, find a match and return it. */
2508 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2510 if (ldt_entry
->sel
== 0 &&
2511 ldt_entry
->bo
== 0 &&
2512 ldt_entry
->acc1
== 0 &&
2513 ldt_entry
->acc2
== 0)
2514 break; /* end of table */
2515 /* If key matches, return this entry. */
2516 if (ldt_entry
->sel
== key
)
2519 /* Loop ended, match not found. */
2523 static int nalloc
= 0;
2525 /* Get the number of LDT entries. */
2526 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2528 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2532 /* Allocate space for the number of LDT entries. */
2533 /* This alloc has to persist, 'cause we return a pointer to it. */
2536 ldt_entry
= (struct ssd
*)
2537 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2541 /* Read the whole table in one gulp. */
2542 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2544 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2548 /* Search the table and return the (first) entry matching 'key'. */
2549 for (i
= 0; i
< nldt
; i
++)
2550 if (ldt_entry
[i
].sel
== key
)
2551 return &ldt_entry
[i
];
2553 /* Loop ended, match not found. */
2558 /* Returns the pointer to the LDT entry of PTID. */
2561 procfs_find_LDT_entry (ptid_t ptid
)
2563 gdb_gregset_t
*gregs
;
2567 /* Find procinfo for the lwp. */
2568 if ((pi
= find_procinfo (ptid_get_pid (ptid
), ptid_get_lwp (ptid
))) == NULL
)
2570 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
2571 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
2574 /* get its general registers. */
2575 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2577 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
2578 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
2581 /* Now extract the GS register's lower 16 bits. */
2582 key
= (*gregs
)[GS
] & 0xffff;
2584 /* Find the matching entry and return it. */
2585 return proc_get_LDT_entry (pi
, key
);
2590 /* =============== END, non-thread part of /proc "MODULE" =============== */
2592 /* =================== Thread "MODULE" =================== */
2594 /* NOTE: you'll see more ifdefs and duplication of functions here,
2595 since there is a different way to do threads on every OS. */
2597 /* Returns the number of threads for the process. */
2599 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2602 proc_get_nthreads (procinfo
*pi
)
2606 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2607 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2613 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2614 /* Solaris version */
2616 proc_get_nthreads (procinfo
*pi
)
2618 if (!pi
->status_valid
)
2619 if (!proc_get_status (pi
))
2622 /* NEW_PROC_API: only works for the process procinfo, because the
2623 LWP procinfos do not get prstatus filled in. */
2625 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
2626 pi
= find_procinfo_or_die (pi
->pid
, 0);
2628 return pi
->prstatus
.pr_nlwp
;
2632 /* Default version */
2634 proc_get_nthreads (procinfo
*pi
)
2643 Return the ID of the thread that had an event of interest.
2644 (ie. the one that hit a breakpoint or other traced event). All
2645 other things being equal, this should be the ID of a thread that is
2646 currently executing. */
2648 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2649 /* Solaris version */
2651 proc_get_current_thread (procinfo
*pi
)
2653 /* Note: this should be applied to the root procinfo for the
2654 process, not to the procinfo for an LWP. If applied to the
2655 procinfo for an LWP, it will simply return that LWP's ID. In
2656 that case, find the parent process procinfo. */
2659 pi
= find_procinfo_or_die (pi
->pid
, 0);
2661 if (!pi
->status_valid
)
2662 if (!proc_get_status (pi
))
2666 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2668 return pi
->prstatus
.pr_who
;
2673 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2676 proc_get_current_thread (procinfo
*pi
)
2678 #if 0 /* FIXME: not ready for prime time? */
2679 return pi
->prstatus
.pr_tid
;
2686 /* Default version */
2688 proc_get_current_thread (procinfo
*pi
)
2696 /* Discover the IDs of all the threads within the process, and create
2697 a procinfo for each of them (chained to the parent). This
2698 unfortunately requires a different method on every OS. Returns
2699 non-zero for success, zero for failure. */
2702 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
2704 if (thread
&& parent
) /* sanity */
2706 thread
->status_valid
= 0;
2707 if (!proc_get_status (thread
))
2708 destroy_one_procinfo (&parent
->thread_list
, thread
);
2710 return 0; /* keep iterating */
2713 #if defined (PIOCLSTATUS)
2714 /* Solaris 2.5 (ioctl) version */
2716 proc_update_threads (procinfo
*pi
)
2718 gdb_prstatus_t
*prstatus
;
2719 struct cleanup
*old_chain
= NULL
;
2723 /* We should never have to apply this operation to any procinfo
2724 except the one for the main process. If that ever changes for
2725 any reason, then take out the following clause and replace it
2726 with one that makes sure the ctl_fd is open. */
2729 pi
= find_procinfo_or_die (pi
->pid
, 0);
2731 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2733 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2734 return 1; /* Process is not multi-threaded; nothing to do. */
2736 prstatus
= xmalloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1));
2738 old_chain
= make_cleanup (xfree
, prstatus
);
2739 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2740 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2742 /* Skip element zero, which represents the process as a whole. */
2743 for (i
= 1; i
< nlwp
+ 1; i
++)
2745 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
2746 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2748 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
2749 thread
->status_valid
= 1;
2751 pi
->threads_valid
= 1;
2752 do_cleanups (old_chain
);
2757 /* Solaris 6 (and later) version. */
2759 do_closedir_cleanup (void *dir
)
2765 proc_update_threads (procinfo
*pi
)
2767 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
2768 struct dirent
*direntry
;
2769 struct cleanup
*old_chain
= NULL
;
2774 /* We should never have to apply this operation to any procinfo
2775 except the one for the main process. If that ever changes for
2776 any reason, then take out the following clause and replace it
2777 with one that makes sure the ctl_fd is open. */
2780 pi
= find_procinfo_or_die (pi
->pid
, 0);
2782 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2784 /* Note: this brute-force method was originally devised for Unixware
2785 (support removed since), and will also work on Solaris 2.6 and
2786 2.7. The original comment mentioned the existence of a much
2787 simpler and more elegant way to do this on Solaris, but didn't
2788 point out what that was. */
2790 strcpy (pathname
, pi
->pathname
);
2791 strcat (pathname
, "/lwp");
2792 if ((dirp
= opendir (pathname
)) == NULL
)
2793 proc_error (pi
, "update_threads, opendir", __LINE__
);
2795 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
2796 while ((direntry
= readdir (dirp
)) != NULL
)
2797 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
2799 lwpid
= atoi (&direntry
->d_name
[0]);
2800 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
2801 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2803 pi
->threads_valid
= 1;
2804 do_cleanups (old_chain
);
2811 proc_update_threads (procinfo
*pi
)
2816 /* We should never have to apply this operation to any procinfo
2817 except the one for the main process. If that ever changes for
2818 any reason, then take out the following clause and replace it
2819 with one that makes sure the ctl_fd is open. */
2822 pi
= find_procinfo_or_die (pi
->pid
, 0);
2824 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2826 nthreads
= proc_get_nthreads (pi
);
2828 return 0; /* Nothing to do for 1 or fewer threads. */
2830 threads
= xmalloc (nthreads
* sizeof (tid_t
));
2832 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
2833 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
2835 for (i
= 0; i
< nthreads
; i
++)
2837 if (!find_procinfo (pi
->pid
, threads
[i
]))
2838 if (!create_procinfo (pi
->pid
, threads
[i
]))
2839 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2841 pi
->threads_valid
= 1;
2845 /* Default version */
2847 proc_update_threads (procinfo
*pi
)
2851 #endif /* OSF PIOCTLIST */
2852 #endif /* NEW_PROC_API */
2853 #endif /* SOL 2.5 PIOCLSTATUS */
2855 /* Given a pointer to a function, call that function once for each lwp
2856 in the procinfo list, until the function returns non-zero, in which
2857 event return the value returned by the function.
2859 Note: this function does NOT call update_threads. If you want to
2860 discover new threads first, you must call that function explicitly.
2861 This function just makes a quick pass over the currently-known
2864 PI is the parent process procinfo. FUNC is the per-thread
2865 function. PTR is an opaque parameter for function. Returns the
2866 first non-zero return value from the callee, or zero. */
2869 proc_iterate_over_threads (procinfo
*pi
,
2870 int (*func
) (procinfo
*, procinfo
*, void *),
2873 procinfo
*thread
, *next
;
2876 /* We should never have to apply this operation to any procinfo
2877 except the one for the main process. If that ever changes for
2878 any reason, then take out the following clause and replace it
2879 with one that makes sure the ctl_fd is open. */
2882 pi
= find_procinfo_or_die (pi
->pid
, 0);
2884 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
2886 next
= thread
->next
; /* In case thread is destroyed. */
2887 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
2894 /* =================== END, Thread "MODULE" =================== */
2896 /* =================== END, /proc "MODULE" =================== */
2898 /* =================== GDB "MODULE" =================== */
2900 /* Here are all of the gdb target vector functions and their
2903 static ptid_t
do_attach (ptid_t ptid
);
2904 static void do_detach (int signo
);
2905 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
2906 int entry_or_exit
, int mode
, int from_tty
);
2908 /* On mips-irix, we need to insert a breakpoint at __dbx_link during
2909 the startup phase. The following two variables are used to record
2910 the address of the breakpoint, and the code that was replaced by
2912 static int dbx_link_bpt_addr
= 0;
2913 static void *dbx_link_bpt
;
2915 /* Sets up the inferior to be debugged. Registers to trace signals,
2916 hardware faults, and syscalls. Note: does not set RLC flag: caller
2917 may want to customize that. Returns zero for success (note!
2918 unlike most functions in this module); on failure, returns the LINE
2919 NUMBER where it failed! */
2922 procfs_debug_inferior (procinfo
*pi
)
2924 fltset_t traced_faults
;
2925 gdb_sigset_t traced_signals
;
2926 sysset_t
*traced_syscall_entries
;
2927 sysset_t
*traced_syscall_exits
;
2930 #ifdef PROCFS_DONT_TRACE_FAULTS
2931 /* On some systems (OSF), we don't trace hardware faults.
2932 Apparently it's enough that we catch them as signals.
2933 Wonder why we don't just do that in general? */
2934 premptyset (&traced_faults
); /* don't trace faults. */
2936 /* Register to trace hardware faults in the child. */
2937 prfillset (&traced_faults
); /* trace all faults... */
2938 gdb_prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
2940 if (!proc_set_traced_faults (pi
, &traced_faults
))
2943 /* Initially, register to trace all signals in the child. */
2944 prfillset (&traced_signals
);
2945 if (!proc_set_traced_signals (pi
, &traced_signals
))
2949 /* Register to trace the 'exit' system call (on entry). */
2950 traced_syscall_entries
= sysset_t_alloc (pi
);
2951 gdb_premptysysset (traced_syscall_entries
);
2953 gdb_praddsysset (traced_syscall_entries
, SYS_exit
);
2956 gdb_praddsysset (traced_syscall_entries
, SYS_lwpexit
);/* And _lwp_exit... */
2959 gdb_praddsysset (traced_syscall_entries
, SYS_lwp_exit
);
2961 #ifdef DYNAMIC_SYSCALLS
2963 int callnum
= find_syscall (pi
, "_exit");
2966 gdb_praddsysset (traced_syscall_entries
, callnum
);
2970 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
2971 xfree (traced_syscall_entries
);
2975 #ifdef PRFS_STOPEXEC /* defined on OSF */
2976 /* OSF method for tracing exec syscalls. Quoting:
2977 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
2978 exits from exec system calls because of the user level loader. */
2979 /* FIXME: make nice and maybe move into an access function. */
2983 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
2986 prfs_flags
|= PRFS_STOPEXEC
;
2988 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
2991 #else /* not PRFS_STOPEXEC */
2992 /* Everyone else's (except OSF) method for tracing exec syscalls. */
2994 Not all systems with /proc have all the exec* syscalls with the same
2995 names. On the SGI, for example, there is no SYS_exec, but there
2996 *is* a SYS_execv. So, we try to account for that. */
2998 traced_syscall_exits
= sysset_t_alloc (pi
);
2999 gdb_premptysysset (traced_syscall_exits
);
3001 gdb_praddsysset (traced_syscall_exits
, SYS_exec
);
3004 gdb_praddsysset (traced_syscall_exits
, SYS_execve
);
3007 gdb_praddsysset (traced_syscall_exits
, SYS_execv
);
3010 #ifdef SYS_lwpcreate
3011 gdb_praddsysset (traced_syscall_exits
, SYS_lwpcreate
);
3012 gdb_praddsysset (traced_syscall_exits
, SYS_lwpexit
);
3015 #ifdef SYS_lwp_create /* FIXME: once only, please. */
3016 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_create
);
3017 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_exit
);
3020 #ifdef DYNAMIC_SYSCALLS
3022 int callnum
= find_syscall (pi
, "execve");
3025 gdb_praddsysset (traced_syscall_exits
, callnum
);
3026 callnum
= find_syscall (pi
, "ra_execve");
3028 gdb_praddsysset (traced_syscall_exits
, callnum
);
3032 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
3033 xfree (traced_syscall_exits
);
3037 #endif /* PRFS_STOPEXEC */
3042 procfs_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
3047 pid
= parse_pid_to_attach (args
);
3049 if (pid
== getpid ())
3050 error (_("Attaching GDB to itself is not a good idea..."));
3054 exec_file
= get_exec_file (0);
3057 printf_filtered (_("Attaching to program `%s', %s\n"),
3058 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
3060 printf_filtered (_("Attaching to %s\n"),
3061 target_pid_to_str (pid_to_ptid (pid
)));
3065 inferior_ptid
= do_attach (pid_to_ptid (pid
));
3066 if (!target_is_pushed (ops
))
3071 procfs_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
3074 int pid
= ptid_get_pid (inferior_ptid
);
3083 exec_file
= get_exec_file (0);
3084 if (exec_file
== NULL
)
3087 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
3088 target_pid_to_str (pid_to_ptid (pid
)));
3089 gdb_flush (gdb_stdout
);
3094 inferior_ptid
= null_ptid
;
3095 detach_inferior (pid
);
3096 inf_child_maybe_unpush_target (ops
);
3100 do_attach (ptid_t ptid
)
3103 struct inferior
*inf
;
3107 if ((pi
= create_procinfo (ptid_get_pid (ptid
), 0)) == NULL
)
3108 perror (_("procfs: out of memory in 'attach'"));
3110 if (!open_procinfo_files (pi
, FD_CTL
))
3112 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3113 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3114 ptid_get_pid (ptid
));
3115 dead_procinfo (pi
, errmsg
, NOKILL
);
3118 /* Stop the process (if it isn't already stopped). */
3119 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3121 pi
->was_stopped
= 1;
3122 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3126 pi
->was_stopped
= 0;
3127 /* Set the process to run again when we close it. */
3128 if (!proc_set_run_on_last_close (pi
))
3129 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3131 /* Now stop the process. */
3132 if (!proc_stop_process (pi
))
3133 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3134 pi
->ignore_next_sigstop
= 1;
3136 /* Save some of the /proc state to be restored if we detach. */
3137 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3138 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3139 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3140 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3141 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
3142 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3144 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
3145 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3147 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3148 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3150 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3151 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3153 inf
= current_inferior ();
3154 inferior_appeared (inf
, pi
->pid
);
3155 /* Let GDB know that the inferior was attached. */
3156 inf
->attach_flag
= 1;
3158 /* Create a procinfo for the current lwp. */
3159 lwpid
= proc_get_current_thread (pi
);
3160 create_procinfo (pi
->pid
, lwpid
);
3162 /* Add it to gdb's thread list. */
3163 ptid
= ptid_build (pi
->pid
, lwpid
, 0);
3170 do_detach (int signo
)
3174 /* Find procinfo for the main process. */
3175 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
),
3176 0); /* FIXME: threads */
3178 if (!proc_set_current_signal (pi
, signo
))
3179 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3181 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3182 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3184 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3185 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3187 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
3188 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3190 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
3191 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3193 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3194 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3196 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3197 if (signo
|| !(pi
->was_stopped
) ||
3198 query (_("Was stopped when attached, make it runnable again? ")))
3200 /* Clear any pending signal. */
3201 if (!proc_clear_current_fault (pi
))
3202 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3204 if (signo
== 0 && !proc_clear_current_signal (pi
))
3205 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
3207 if (!proc_set_run_on_last_close (pi
))
3208 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3211 destroy_procinfo (pi
);
3214 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
3217 ??? Is the following note still relevant? We can't get individual
3218 registers with the PT_GETREGS ptrace(2) request either, yet we
3219 don't bother with caching at all in that case.
3221 NOTE: Since the /proc interface cannot give us individual
3222 registers, we pay no attention to REGNUM, and just fetch them all.
3223 This results in the possibility that we will do unnecessarily many
3224 fetches, since we may be called repeatedly for individual
3225 registers. So we cache the results, and mark the cache invalid
3226 when the process is resumed. */
3229 procfs_fetch_registers (struct target_ops
*ops
,
3230 struct regcache
*regcache
, int regnum
)
3232 gdb_gregset_t
*gregs
;
3234 int pid
= ptid_get_pid (inferior_ptid
);
3235 int tid
= ptid_get_lwp (inferior_ptid
);
3236 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3238 pi
= find_procinfo_or_die (pid
, tid
);
3241 error (_("procfs: fetch_registers failed to find procinfo for %s"),
3242 target_pid_to_str (inferior_ptid
));
3244 gregs
= proc_get_gregs (pi
);
3246 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3248 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
3250 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3252 gdb_fpregset_t
*fpregs
;
3254 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3255 || regnum
== gdbarch_pc_regnum (gdbarch
)
3256 || regnum
== gdbarch_sp_regnum (gdbarch
))
3257 return; /* Not a floating point register. */
3259 fpregs
= proc_get_fpregs (pi
);
3261 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3263 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
3267 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
3268 this for all registers.
3270 NOTE: Since the /proc interface will not read individual registers,
3271 we will cache these requests until the process is resumed, and only
3272 then write them back to the inferior process.
3274 FIXME: is that a really bad idea? Have to think about cases where
3275 writing one register might affect the value of others, etc. */
3278 procfs_store_registers (struct target_ops
*ops
,
3279 struct regcache
*regcache
, int regnum
)
3281 gdb_gregset_t
*gregs
;
3283 int pid
= ptid_get_pid (inferior_ptid
);
3284 int tid
= ptid_get_lwp (inferior_ptid
);
3285 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3287 pi
= find_procinfo_or_die (pid
, tid
);
3290 error (_("procfs: store_registers: failed to find procinfo for %s"),
3291 target_pid_to_str (inferior_ptid
));
3293 gregs
= proc_get_gregs (pi
);
3295 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3297 fill_gregset (regcache
, gregs
, regnum
);
3298 if (!proc_set_gregs (pi
))
3299 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3301 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3303 gdb_fpregset_t
*fpregs
;
3305 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3306 || regnum
== gdbarch_pc_regnum (gdbarch
)
3307 || regnum
== gdbarch_sp_regnum (gdbarch
))
3308 return; /* Not a floating point register. */
3310 fpregs
= proc_get_fpregs (pi
);
3312 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3314 fill_fpregset (regcache
, fpregs
, regnum
);
3315 if (!proc_set_fpregs (pi
))
3316 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3321 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
3324 if (scall
== SYS_lwp_exit
)
3328 if (scall
== SYS_lwpexit
)
3335 syscall_is_exit (procinfo
*pi
, int scall
)
3338 if (scall
== SYS_exit
)
3341 #ifdef DYNAMIC_SYSCALLS
3342 if (find_syscall (pi
, "_exit") == scall
)
3349 syscall_is_exec (procinfo
*pi
, int scall
)
3352 if (scall
== SYS_exec
)
3356 if (scall
== SYS_execv
)
3360 if (scall
== SYS_execve
)
3363 #ifdef DYNAMIC_SYSCALLS
3364 if (find_syscall (pi
, "_execve"))
3366 if (find_syscall (pi
, "ra_execve"))
3373 syscall_is_lwp_create (procinfo
*pi
, int scall
)
3375 #ifdef SYS_lwp_create
3376 if (scall
== SYS_lwp_create
)
3379 #ifdef SYS_lwpcreate
3380 if (scall
== SYS_lwpcreate
)
3386 /* Remove the breakpoint that we inserted in __dbx_link().
3387 Does nothing if the breakpoint hasn't been inserted or has already
3391 remove_dbx_link_breakpoint (void)
3393 if (dbx_link_bpt_addr
== 0)
3396 if (deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt
) != 0)
3397 warning (_("Unable to remove __dbx_link breakpoint."));
3399 dbx_link_bpt_addr
= 0;
3400 dbx_link_bpt
= NULL
;
3404 /* Return the address of the __dbx_link() function in the file
3405 refernced by ABFD by scanning its symbol table. Return 0 if
3406 the symbol was not found. */
3409 dbx_link_addr (bfd
*abfd
)
3411 long storage_needed
;
3412 asymbol
**symbol_table
;
3413 long number_of_symbols
;
3416 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
3417 if (storage_needed
<= 0)
3420 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
3421 make_cleanup (xfree
, symbol_table
);
3423 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
3425 for (i
= 0; i
< number_of_symbols
; i
++)
3427 asymbol
*sym
= symbol_table
[i
];
3429 if ((sym
->flags
& BSF_GLOBAL
)
3430 && sym
->name
!= NULL
&& strcmp (sym
->name
, "__dbx_link") == 0)
3431 return (sym
->value
+ sym
->section
->vma
);
3434 /* Symbol not found, return NULL. */
3438 /* Search the symbol table of the file referenced by FD for a symbol
3439 named __dbx_link(). If found, then insert a breakpoint at this location,
3440 and return nonzero. Return zero otherwise. */
3443 insert_dbx_link_bpt_in_file (int fd
, CORE_ADDR ignored
)
3446 long storage_needed
;
3449 abfd
= gdb_bfd_fdopenr ("unamed", 0, fd
);
3452 warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
3456 if (!bfd_check_format (abfd
, bfd_object
))
3458 /* Not the correct format, so we can not possibly find the dbx_link
3460 gdb_bfd_unref (abfd
);
3464 sym_addr
= dbx_link_addr (abfd
);
3467 /* Insert the breakpoint. */
3468 dbx_link_bpt_addr
= sym_addr
;
3469 dbx_link_bpt
= deprecated_insert_raw_breakpoint (target_gdbarch (), NULL
,
3471 if (dbx_link_bpt
== NULL
)
3473 warning (_("Failed to insert dbx_link breakpoint."));
3474 gdb_bfd_unref (abfd
);
3477 gdb_bfd_unref (abfd
);
3481 gdb_bfd_unref (abfd
);
3485 /* Calls the supplied callback function once for each mapped address
3486 space in the process. The callback function receives an open file
3487 descriptor for the file corresponding to that mapped address space
3488 (if there is one), and the base address of the mapped space. Quit
3489 when the callback function returns a nonzero value, or at teh end
3490 of the mappings. Returns the first non-zero return value of the
3491 callback function, or zero. */
3494 solib_mappings_callback (struct prmap
*map
, int (*func
) (int, CORE_ADDR
),
3497 procinfo
*pi
= data
;
3501 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
3503 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
3504 return -1; /* sanity */
3506 if (map
->pr_mapname
[0] == 0)
3508 fd
= -1; /* no map file */
3512 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
3513 /* Note: caller's responsibility to close this fd! */
3514 fd
= open_with_retry (name
, O_RDONLY
);
3515 /* Note: we don't test the above call for failure;
3516 we just pass the FD on as given. Sometimes there is
3517 no file, so the open may return failure, but that's
3521 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
->pr_vaddr
);
3522 /* Note: we don't test the above call for failure;
3523 we just pass the FD on as given. Sometimes there is
3524 no file, so the ioctl may return failure, but that's
3527 return (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
);
3530 /* If the given memory region MAP contains a symbol named __dbx_link,
3531 insert a breakpoint at this location and return nonzero. Return
3535 insert_dbx_link_bpt_in_region (struct prmap
*map
,
3536 find_memory_region_ftype child_func
,
3539 procinfo
*pi
= (procinfo
*) data
;
3541 /* We know the symbol we're looking for is in a text region, so
3542 only look for it if the region is a text one. */
3543 if (map
->pr_mflags
& MA_EXEC
)
3544 return solib_mappings_callback (map
, insert_dbx_link_bpt_in_file
, pi
);
3549 /* Search all memory regions for a symbol named __dbx_link. If found,
3550 insert a breakpoint at its location, and return nonzero. Return zero
3554 insert_dbx_link_breakpoint (procinfo
*pi
)
3556 return iterate_over_mappings (pi
, NULL
, pi
, insert_dbx_link_bpt_in_region
);
3560 /* Retrieve the next stop event from the child process. If child has
3561 not stopped yet, wait for it to stop. Translate /proc eventcodes
3562 (or possibly wait eventcodes) into gdb internal event codes.
3563 Returns the id of process (and possibly thread) that incurred the
3564 event. Event codes are returned through a pointer parameter. */
3567 procfs_wait (struct target_ops
*ops
,
3568 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
3570 /* First cut: loosely based on original version 2.1. */
3574 ptid_t retval
, temp_ptid
;
3575 int why
, what
, flags
;
3582 retval
= pid_to_ptid (-1);
3584 /* Find procinfo for main process. */
3585 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
3588 /* We must assume that the status is stale now... */
3589 pi
->status_valid
= 0;
3590 pi
->gregs_valid
= 0;
3591 pi
->fpregs_valid
= 0;
3593 #if 0 /* just try this out... */
3594 flags
= proc_flags (pi
);
3595 why
= proc_why (pi
);
3596 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3597 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3599 /* If child is not stopped, wait for it to stop. */
3600 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3601 !proc_wait_for_stop (pi
))
3603 /* wait_for_stop failed: has the child terminated? */
3604 if (errno
== ENOENT
)
3608 /* /proc file not found; presumably child has terminated. */
3609 wait_retval
= wait (&wstat
); /* "wait" for the child's exit. */
3612 if (wait_retval
!= ptid_get_pid (inferior_ptid
))
3613 error (_("procfs: couldn't stop "
3614 "process %d: wait returned %d."),
3615 ptid_get_pid (inferior_ptid
), wait_retval
);
3616 /* FIXME: might I not just use waitpid?
3617 Or try find_procinfo to see if I know about this child? */
3618 retval
= pid_to_ptid (wait_retval
);
3620 else if (errno
== EINTR
)
3624 /* Unknown error from wait_for_stop. */
3625 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3630 /* This long block is reached if either:
3631 a) the child was already stopped, or
3632 b) we successfully waited for the child with wait_for_stop.
3633 This block will analyze the /proc status, and translate it
3634 into a waitstatus for GDB.
3636 If we actually had to call wait because the /proc file
3637 is gone (child terminated), then we skip this block,
3638 because we already have a waitstatus. */
3640 flags
= proc_flags (pi
);
3641 why
= proc_why (pi
);
3642 what
= proc_what (pi
);
3644 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3647 /* If it's running async (for single_thread control),
3648 set it back to normal again. */
3649 if (flags
& PR_ASYNC
)
3650 if (!proc_unset_async (pi
))
3651 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3655 proc_prettyprint_why (why
, what
, 1);
3657 /* The 'pid' we will return to GDB is composed of
3658 the process ID plus the lwp ID. */
3659 retval
= ptid_build (pi
->pid
, proc_get_current_thread (pi
), 0);
3663 wstat
= (what
<< 8) | 0177;
3666 if (syscall_is_lwp_exit (pi
, what
))
3668 if (print_thread_events
)
3669 printf_unfiltered (_("[%s exited]\n"),
3670 target_pid_to_str (retval
));
3671 delete_thread (retval
);
3672 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3675 else if (syscall_is_exit (pi
, what
))
3677 struct inferior
*inf
;
3679 /* Handle SYS_exit call only. */
3680 /* Stopped at entry to SYS_exit.
3681 Make it runnable, resume it, then use
3682 the wait system call to get its exit code.
3683 Proc_run_process always clears the current
3685 Then return its exit status. */
3686 pi
->status_valid
= 0;
3688 /* FIXME: what we should do is return
3689 TARGET_WAITKIND_SPURIOUS. */
3690 if (!proc_run_process (pi
, 0, 0))
3691 proc_error (pi
, "target_wait, run_process", __LINE__
);
3693 inf
= find_inferior_pid (pi
->pid
);
3694 if (inf
->attach_flag
)
3696 /* Don't call wait: simulate waiting for exit,
3697 return a "success" exit code. Bogus: what if
3698 it returns something else? */
3700 retval
= inferior_ptid
; /* ? ? ? */
3704 int temp
= wait (&wstat
);
3706 /* FIXME: shouldn't I make sure I get the right
3707 event from the right process? If (for
3708 instance) I have killed an earlier inferior
3709 process but failed to clean up after it
3710 somehow, I could get its termination event
3713 /* If wait returns -1, that's what we return
3716 retval
= pid_to_ptid (temp
);
3721 printf_filtered (_("procfs: trapped on entry to "));
3722 proc_prettyprint_syscall (proc_what (pi
), 0);
3723 printf_filtered ("\n");
3726 long i
, nsysargs
, *sysargs
;
3728 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3729 (sysargs
= proc_sysargs (pi
)) != NULL
)
3731 printf_filtered (_("%ld syscall arguments:\n"),
3733 for (i
= 0; i
< nsysargs
; i
++)
3734 printf_filtered ("#%ld: 0x%08lx\n",
3742 /* How to exit gracefully, returning "unknown
3744 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3745 return inferior_ptid
;
3749 /* How to keep going without returning to wfi: */
3750 target_resume (ptid
, 0, GDB_SIGNAL_0
);
3756 if (syscall_is_exec (pi
, what
))
3758 /* Hopefully this is our own "fork-child" execing
3759 the real child. Hoax this event into a trap, and
3760 GDB will see the child about to execute its start
3762 wstat
= (SIGTRAP
<< 8) | 0177;
3765 else if (what
== SYS_syssgi
)
3767 /* see if we can break on dbx_link(). If yes, then
3768 we no longer need the SYS_syssgi notifications. */
3769 if (insert_dbx_link_breakpoint (pi
))
3770 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
,
3773 /* This is an internal event and should be transparent
3774 to wfi, so resume the execution and wait again. See
3775 comment in procfs_init_inferior() for more details. */
3776 target_resume (ptid
, 0, GDB_SIGNAL_0
);
3780 else if (syscall_is_lwp_create (pi
, what
))
3782 /* This syscall is somewhat like fork/exec. We
3783 will get the event twice: once for the parent
3784 LWP, and once for the child. We should already
3785 know about the parent LWP, but the child will
3786 be new to us. So, whenever we get this event,
3787 if it represents a new thread, simply add the
3788 thread to the list. */
3790 /* If not in procinfo list, add it. */
3791 temp_tid
= proc_get_current_thread (pi
);
3792 if (!find_procinfo (pi
->pid
, temp_tid
))
3793 create_procinfo (pi
->pid
, temp_tid
);
3795 temp_ptid
= ptid_build (pi
->pid
, temp_tid
, 0);
3796 /* If not in GDB's thread list, add it. */
3797 if (!in_thread_list (temp_ptid
))
3798 add_thread (temp_ptid
);
3800 /* Return to WFI, but tell it to immediately resume. */
3801 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3802 return inferior_ptid
;
3804 else if (syscall_is_lwp_exit (pi
, what
))
3806 if (print_thread_events
)
3807 printf_unfiltered (_("[%s exited]\n"),
3808 target_pid_to_str (retval
));
3809 delete_thread (retval
);
3810 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3815 /* FIXME: Do we need to handle SYS_sproc,
3816 SYS_fork, or SYS_vfork here? The old procfs
3817 seemed to use this event to handle threads on
3818 older (non-LWP) systems, where I'm assuming
3819 that threads were actually separate processes.
3820 Irix, maybe? Anyway, low priority for now. */
3824 printf_filtered (_("procfs: trapped on exit from "));
3825 proc_prettyprint_syscall (proc_what (pi
), 0);
3826 printf_filtered ("\n");
3829 long i
, nsysargs
, *sysargs
;
3831 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3832 (sysargs
= proc_sysargs (pi
)) != NULL
)
3834 printf_filtered (_("%ld syscall arguments:\n"),
3836 for (i
= 0; i
< nsysargs
; i
++)
3837 printf_filtered ("#%ld: 0x%08lx\n",
3842 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3843 return inferior_ptid
;
3848 wstat
= (SIGSTOP
<< 8) | 0177;
3853 printf_filtered (_("Retry #%d:\n"), retry
);
3854 pi
->status_valid
= 0;
3859 /* If not in procinfo list, add it. */
3860 temp_tid
= proc_get_current_thread (pi
);
3861 if (!find_procinfo (pi
->pid
, temp_tid
))
3862 create_procinfo (pi
->pid
, temp_tid
);
3864 /* If not in GDB's thread list, add it. */
3865 temp_ptid
= ptid_build (pi
->pid
, temp_tid
, 0);
3866 if (!in_thread_list (temp_ptid
))
3867 add_thread (temp_ptid
);
3869 status
->kind
= TARGET_WAITKIND_STOPPED
;
3870 status
->value
.sig
= 0;
3875 wstat
= (what
<< 8) | 0177;
3881 wstat
= (SIGTRAP
<< 8) | 0177;
3886 wstat
= (SIGTRAP
<< 8) | 0177;
3889 /* FIXME: use si_signo where possible. */
3891 #if (FLTILL != FLTPRIV) /* Avoid "duplicate case" error. */
3894 wstat
= (SIGILL
<< 8) | 0177;
3897 #if (FLTTRACE != FLTBPT) /* Avoid "duplicate case" error. */
3900 /* If we hit our __dbx_link() internal breakpoint,
3901 then remove it. See comments in procfs_init_inferior()
3902 for more details. */
3903 if (dbx_link_bpt_addr
!= 0
3904 && dbx_link_bpt_addr
3905 == regcache_read_pc (get_current_regcache ()))
3906 remove_dbx_link_breakpoint ();
3908 wstat
= (SIGTRAP
<< 8) | 0177;
3912 #if (FLTBOUNDS != FLTSTACK) /* Avoid "duplicate case" error. */
3915 wstat
= (SIGSEGV
<< 8) | 0177;
3919 #if (FLTFPE != FLTIOVF) /* Avoid "duplicate case" error. */
3922 wstat
= (SIGFPE
<< 8) | 0177;
3924 case FLTPAGE
: /* Recoverable page fault */
3925 default: /* FIXME: use si_signo if possible for
3927 retval
= pid_to_ptid (-1);
3928 printf_filtered ("procfs:%d -- ", __LINE__
);
3929 printf_filtered (_("child stopped for unknown reason:\n"));
3930 proc_prettyprint_why (why
, what
, 1);
3931 error (_("... giving up..."));
3934 break; /* case PR_FAULTED: */
3935 default: /* switch (why) unmatched */
3936 printf_filtered ("procfs:%d -- ", __LINE__
);
3937 printf_filtered (_("child stopped for unknown reason:\n"));
3938 proc_prettyprint_why (why
, what
, 1);
3939 error (_("... giving up..."));
3942 /* Got this far without error: If retval isn't in the
3943 threads database, add it. */
3944 if (ptid_get_pid (retval
) > 0 &&
3945 !ptid_equal (retval
, inferior_ptid
) &&
3946 !in_thread_list (retval
))
3948 /* We have a new thread. We need to add it both to
3949 GDB's list and to our own. If we don't create a
3950 procinfo, resume may be unhappy later. */
3951 add_thread (retval
);
3952 if (find_procinfo (ptid_get_pid (retval
),
3953 ptid_get_lwp (retval
)) == NULL
)
3954 create_procinfo (ptid_get_pid (retval
),
3955 ptid_get_lwp (retval
));
3958 else /* Flags do not indicate STOPPED. */
3960 /* surely this can't happen... */
3961 printf_filtered ("procfs:%d -- process not stopped.\n",
3963 proc_prettyprint_flags (flags
, 1);
3964 error (_("procfs: ...giving up..."));
3969 store_waitstatus (status
, wstat
);
3975 /* Perform a partial transfer to/from the specified object. For
3976 memory transfers, fall back to the old memory xfer functions. */
3978 static enum target_xfer_status
3979 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3980 const char *annex
, gdb_byte
*readbuf
,
3981 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
3982 ULONGEST
*xfered_len
)
3986 case TARGET_OBJECT_MEMORY
:
3987 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3990 case TARGET_OBJECT_AUXV
:
3991 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
3992 offset
, len
, xfered_len
);
3996 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
3997 readbuf
, writebuf
, offset
, len
,
4002 /* Helper for procfs_xfer_partial that handles memory transfers.
4003 Arguments are like target_xfer_partial. */
4005 static enum target_xfer_status
4006 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
4007 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
4012 /* Find procinfo for main process. */
4013 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
4014 if (pi
->as_fd
== 0 &&
4015 open_procinfo_files (pi
, FD_AS
) == 0)
4017 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4018 return TARGET_XFER_E_IO
;
4021 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
4022 return TARGET_XFER_E_IO
;
4024 if (writebuf
!= NULL
)
4026 PROCFS_NOTE ("write memory:\n");
4027 nbytes
= write (pi
->as_fd
, writebuf
, len
);
4031 PROCFS_NOTE ("read memory:\n");
4032 nbytes
= read (pi
->as_fd
, readbuf
, len
);
4035 return TARGET_XFER_E_IO
;
4036 *xfered_len
= nbytes
;
4037 return TARGET_XFER_OK
;
4040 /* Called by target_resume before making child runnable. Mark cached
4041 registers and status's invalid. If there are "dirty" caches that
4042 need to be written back to the child process, do that.
4044 File descriptors are also cached. As they are a limited resource,
4045 we cannot hold onto them indefinitely. However, as they are
4046 expensive to open, we don't want to throw them away
4047 indescriminately either. As a compromise, we will keep the file
4048 descriptors for the parent process, but discard any file
4049 descriptors we may have accumulated for the threads.
4051 As this function is called by iterate_over_threads, it always
4052 returns zero (so that iterate_over_threads will keep
4056 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
4058 /* About to run the child; invalidate caches and do any other
4062 if (pi
->gregs_dirty
)
4063 if (parent
== NULL
||
4064 proc_get_current_thread (parent
) != pi
->tid
)
4065 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4066 proc_warn (pi
, "target_resume, set_gregs",
4068 if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
4069 if (pi
->fpregs_dirty
)
4070 if (parent
== NULL
||
4071 proc_get_current_thread (parent
) != pi
->tid
)
4072 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4073 proc_warn (pi
, "target_resume, set_fpregs",
4079 /* The presence of a parent indicates that this is an LWP.
4080 Close any file descriptors that it might have open.
4081 We don't do this to the master (parent) procinfo. */
4083 close_procinfo_files (pi
);
4085 pi
->gregs_valid
= 0;
4086 pi
->fpregs_valid
= 0;
4088 pi
->gregs_dirty
= 0;
4089 pi
->fpregs_dirty
= 0;
4091 pi
->status_valid
= 0;
4092 pi
->threads_valid
= 0;
4098 /* A callback function for iterate_over_threads. Find the
4099 asynchronous signal thread, and make it runnable. See if that
4100 helps matters any. */
4103 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
4106 if (proc_flags (pi
) & PR_ASLWP
)
4108 if (!proc_run_process (pi
, 0, -1))
4109 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4117 /* Make the child process runnable. Normally we will then call
4118 procfs_wait and wait for it to stop again (unless gdb is async).
4120 If STEP is true, then arrange for the child to stop again after
4121 executing a single instruction. If SIGNO is zero, then cancel any
4122 pending signal; if non-zero, then arrange for the indicated signal
4123 to be delivered to the child when it runs. If PID is -1, then
4124 allow any child thread to run; if non-zero, then allow only the
4125 indicated thread to run. (not implemented yet). */
4128 procfs_resume (struct target_ops
*ops
,
4129 ptid_t ptid
, int step
, enum gdb_signal signo
)
4131 procinfo
*pi
, *thread
;
4135 prrun.prflags |= PRSVADDR;
4136 prrun.pr_vaddr = $PC; set resume address
4137 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4138 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4139 prrun.prflags |= PRCFAULT; clear current fault.
4141 PRSTRACE and PRSFAULT can be done by other means
4142 (proc_trace_signals, proc_trace_faults)
4143 PRSVADDR is unnecessary.
4144 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4145 This basically leaves PRSTEP and PRCSIG.
4146 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4147 So basically PR_STEP is the sole argument that must be passed
4148 to proc_run_process (for use in the prrun struct by ioctl). */
4150 /* Find procinfo for main process. */
4151 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
4153 /* First cut: ignore pid argument. */
4156 /* Convert signal to host numbering. */
4158 (signo
== GDB_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4161 native_signo
= gdb_signal_to_host (signo
);
4163 pi
->ignore_next_sigstop
= 0;
4165 /* Running the process voids all cached registers and status. */
4166 /* Void the threads' caches first. */
4167 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4168 /* Void the process procinfo's caches. */
4169 invalidate_cache (NULL
, pi
, NULL
);
4171 if (ptid_get_pid (ptid
) != -1)
4173 /* Resume a specific thread, presumably suppressing the
4175 thread
= find_procinfo (ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
4178 if (thread
->tid
!= 0)
4180 /* We're to resume a specific thread, and not the
4181 others. Set the child process's PR_ASYNC flag. */
4183 if (!proc_set_async (pi
))
4184 proc_error (pi
, "target_resume, set_async", __LINE__
);
4187 proc_iterate_over_threads (pi
,
4188 make_signal_thread_runnable
,
4191 pi
= thread
; /* Substitute the thread's procinfo
4197 if (!proc_run_process (pi
, step
, native_signo
))
4200 warning (_("resume: target already running. "
4201 "Pretend to resume, and hope for the best!"));
4203 proc_error (pi
, "target_resume", __LINE__
);
4207 /* Set up to trace signals in the child process. */
4210 procfs_pass_signals (struct target_ops
*self
,
4211 int numsigs
, unsigned char *pass_signals
)
4213 gdb_sigset_t signals
;
4214 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
4217 prfillset (&signals
);
4219 for (signo
= 0; signo
< NSIG
; signo
++)
4221 int target_signo
= gdb_signal_from_host (signo
);
4222 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
4223 gdb_prdelset (&signals
, signo
);
4226 if (!proc_set_traced_signals (pi
, &signals
))
4227 proc_error (pi
, "pass_signals", __LINE__
);
4230 /* Print status information about the child process. */
4233 procfs_files_info (struct target_ops
*ignore
)
4235 struct inferior
*inf
= current_inferior ();
4237 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
4238 inf
->attach_flag
? "attached": "child",
4239 target_pid_to_str (inferior_ptid
));
4242 /* Stop the child process asynchronously, as when the gdb user types
4243 control-c or presses a "stop" button. Works by sending
4244 kill(SIGINT) to the child's process group. */
4247 procfs_stop (struct target_ops
*self
, ptid_t ptid
)
4249 kill (-inferior_process_group (), SIGINT
);
4252 /* Make it die. Wait for it to die. Clean up after it. Note: this
4253 should only be applied to the real process, not to an LWP, because
4254 of the check for parent-process. If we need this to work for an
4255 LWP, it needs some more logic. */
4258 unconditionally_kill_inferior (procinfo
*pi
)
4262 parent_pid
= proc_parent_pid (pi
);
4263 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4264 /* FIXME: use access functions. */
4265 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4266 before the PIOCKILL, otherwise it might generate a corrupted core
4267 file for the inferior. */
4268 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4270 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4273 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4274 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4275 to kill the inferior, otherwise it might remain stopped with a
4277 We do not check the result of the PIOCSSIG, the inferior might have
4280 gdb_siginfo_t newsiginfo
;
4282 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4283 newsiginfo
.si_signo
= SIGKILL
;
4284 newsiginfo
.si_code
= 0;
4285 newsiginfo
.si_errno
= 0;
4286 newsiginfo
.si_pid
= getpid ();
4287 newsiginfo
.si_uid
= getuid ();
4288 /* FIXME: use proc_set_current_signal. */
4289 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4291 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4292 if (!proc_kill (pi
, SIGKILL
))
4293 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4294 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4295 destroy_procinfo (pi
);
4297 /* If pi is GDB's child, wait for it to die. */
4298 if (parent_pid
== getpid ())
4299 /* FIXME: should we use waitpid to make sure we get the right event?
4300 Should we check the returned event? */
4305 ret
= waitpid (pi
->pid
, &status
, 0);
4312 /* We're done debugging it, and we want it to go away. Then we want
4313 GDB to forget all about it. */
4316 procfs_kill_inferior (struct target_ops
*ops
)
4318 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
4320 /* Find procinfo for main process. */
4321 procinfo
*pi
= find_procinfo (ptid_get_pid (inferior_ptid
), 0);
4324 unconditionally_kill_inferior (pi
);
4325 target_mourn_inferior ();
4329 /* Forget we ever debugged this thing! */
4332 procfs_mourn_inferior (struct target_ops
*ops
)
4336 if (!ptid_equal (inferior_ptid
, null_ptid
))
4338 /* Find procinfo for main process. */
4339 pi
= find_procinfo (ptid_get_pid (inferior_ptid
), 0);
4341 destroy_procinfo (pi
);
4344 generic_mourn_inferior ();
4346 if (dbx_link_bpt
!= NULL
)
4348 deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt
);
4349 dbx_link_bpt_addr
= 0;
4350 dbx_link_bpt
= NULL
;
4353 inf_child_maybe_unpush_target (ops
);
4356 /* When GDB forks to create a runnable inferior process, this function
4357 is called on the parent side of the fork. It's job is to do
4358 whatever is necessary to make the child ready to be debugged, and
4359 then wait for the child to synchronize. */
4362 procfs_init_inferior (struct target_ops
*ops
, int pid
)
4365 gdb_sigset_t signals
;
4369 /* This routine called on the parent side (GDB side)
4370 after GDB forks the inferior. */
4371 if (!target_is_pushed (ops
))
4374 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4375 perror (_("procfs: out of memory in 'init_inferior'"));
4377 if (!open_procinfo_files (pi
, FD_CTL
))
4378 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4382 open_procinfo_files // done
4385 procfs_notice_signals
4392 /* If not stopped yet, wait for it to stop. */
4393 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4394 !(proc_wait_for_stop (pi
)))
4395 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4397 /* Save some of the /proc state to be restored if we detach. */
4398 /* FIXME: Why? In case another debugger was debugging it?
4399 We're it's parent, for Ghu's sake! */
4400 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4401 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4402 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4403 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4404 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4405 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4406 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
4407 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4408 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
4409 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4411 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4412 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4414 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4415 and possibly even turning ON kill-on-last-close at this point. But
4416 I can't make that change without careful testing which I don't have
4417 time to do right now... */
4418 /* Turn on run-on-last-close flag so that the child
4419 will die if GDB goes away for some reason. */
4420 if (!proc_set_run_on_last_close (pi
))
4421 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4423 /* We now have have access to the lwpid of the main thread/lwp. */
4424 lwpid
= proc_get_current_thread (pi
);
4426 /* Create a procinfo for the main lwp. */
4427 create_procinfo (pid
, lwpid
);
4429 /* We already have a main thread registered in the thread table at
4430 this point, but it didn't have any lwp info yet. Notify the core
4431 about it. This changes inferior_ptid as well. */
4432 thread_change_ptid (pid_to_ptid (pid
),
4433 ptid_build (pid
, lwpid
, 0));
4435 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4438 /* On mips-irix, we need to stop the inferior early enough during
4439 the startup phase in order to be able to load the shared library
4440 symbols and insert the breakpoints that are located in these shared
4441 libraries. Stopping at the program entry point is not good enough
4442 because the -init code is executed before the execution reaches
4445 So what we need to do is to insert a breakpoint in the runtime
4446 loader (rld), more precisely in __dbx_link(). This procedure is
4447 called by rld once all shared libraries have been mapped, but before
4448 the -init code is executed. Unfortuantely, this is not straightforward,
4449 as rld is not part of the executable we are running, and thus we need
4450 the inferior to run until rld itself has been mapped in memory.
4452 For this, we trace all syssgi() syscall exit events. Each time
4453 we detect such an event, we iterate over each text memory maps,
4454 get its associated fd, and scan the symbol table for __dbx_link().
4455 When found, we know that rld has been mapped, and that we can insert
4456 the breakpoint at the symbol address. Once the dbx_link() breakpoint
4457 has been inserted, the syssgi() notifications are no longer necessary,
4458 so they should be canceled. */
4459 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
, FLAG_SET
, 0);
4463 /* When GDB forks to create a new process, this function is called on
4464 the child side of the fork before GDB exec's the user program. Its
4465 job is to make the child minimally debuggable, so that the parent
4466 GDB process can connect to the child and take over. This function
4467 should do only the minimum to make that possible, and to
4468 synchronize with the parent process. The parent process should
4469 take care of the details. */
4472 procfs_set_exec_trap (void)
4474 /* This routine called on the child side (inferior side)
4475 after GDB forks the inferior. It must use only local variables,
4476 because it may be sharing data space with its parent. */
4481 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4482 perror_with_name (_("procfs: create_procinfo failed in child."));
4484 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4486 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4487 gdb_flush (gdb_stderr
);
4488 /* No need to call "dead_procinfo", because we're going to
4493 #ifdef PRFS_STOPEXEC /* defined on OSF */
4494 /* OSF method for tracing exec syscalls. Quoting:
4495 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4496 exits from exec system calls because of the user level loader. */
4497 /* FIXME: make nice and maybe move into an access function. */
4501 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4503 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4504 gdb_flush (gdb_stderr
);
4507 prfs_flags
|= PRFS_STOPEXEC
;
4509 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4511 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4512 gdb_flush (gdb_stderr
);
4516 #else /* not PRFS_STOPEXEC */
4517 /* Everyone else's (except OSF) method for tracing exec syscalls. */
4519 Not all systems with /proc have all the exec* syscalls with the same
4520 names. On the SGI, for example, there is no SYS_exec, but there
4521 *is* a SYS_execv. So, we try to account for that. */
4523 exitset
= sysset_t_alloc (pi
);
4524 gdb_premptysysset (exitset
);
4526 gdb_praddsysset (exitset
, SYS_exec
);
4529 gdb_praddsysset (exitset
, SYS_execve
);
4532 gdb_praddsysset (exitset
, SYS_execv
);
4534 #ifdef DYNAMIC_SYSCALLS
4536 int callnum
= find_syscall (pi
, "execve");
4539 gdb_praddsysset (exitset
, callnum
);
4541 callnum
= find_syscall (pi
, "ra_execve");
4543 gdb_praddsysset (exitset
, callnum
);
4545 #endif /* DYNAMIC_SYSCALLS */
4547 if (!proc_set_traced_sysexit (pi
, exitset
))
4549 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4550 gdb_flush (gdb_stderr
);
4553 #endif /* PRFS_STOPEXEC */
4555 /* FIXME: should this be done in the parent instead? */
4556 /* Turn off inherit on fork flag so that all grand-children
4557 of gdb start with tracing flags cleared. */
4558 if (!proc_unset_inherit_on_fork (pi
))
4559 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4561 /* Turn off run on last close flag, so that the child process
4562 cannot run away just because we close our handle on it.
4563 We want it to wait for the parent to attach. */
4564 if (!proc_unset_run_on_last_close (pi
))
4565 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4567 /* FIXME: No need to destroy the procinfo --
4568 we have our own address space, and we're about to do an exec! */
4569 /*destroy_procinfo (pi);*/
4572 /* This function is called BEFORE gdb forks the inferior process. Its
4573 only real responsibility is to set things up for the fork, and tell
4574 GDB which two functions to call after the fork (one for the parent,
4575 and one for the child).
4577 This function does a complicated search for a unix shell program,
4578 which it then uses to parse arguments and environment variables to
4579 be sent to the child. I wonder whether this code could not be
4580 abstracted out and shared with other unix targets such as
4584 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
4585 char *allargs
, char **env
, int from_tty
)
4587 char *shell_file
= getenv ("SHELL");
4591 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4594 /* We will be looking down the PATH to find shell_file. If we
4595 just do this the normal way (via execlp, which operates by
4596 attempting an exec for each element of the PATH until it
4597 finds one which succeeds), then there will be an exec for
4598 each failed attempt, each of which will cause a PR_SYSEXIT
4599 stop, and we won't know how to distinguish the PR_SYSEXIT's
4600 for these failed execs with the ones for successful execs
4601 (whether the exec has succeeded is stored at that time in the
4602 carry bit or some such architecture-specific and
4603 non-ABI-specified place).
4605 So I can't think of anything better than to search the PATH
4606 now. This has several disadvantages: (1) There is a race
4607 condition; if we find a file now and it is deleted before we
4608 exec it, we lose, even if the deletion leaves a valid file
4609 further down in the PATH, (2) there is no way to know exactly
4610 what an executable (in the sense of "capable of being
4611 exec'd") file is. Using access() loses because it may lose
4612 if the caller is the superuser; failing to use it loses if
4613 there are ACLs or some such. */
4617 /* FIXME-maybe: might want "set path" command so user can change what
4618 path is used from within GDB. */
4619 char *path
= getenv ("PATH");
4621 struct stat statbuf
;
4624 path
= "/bin:/usr/bin";
4626 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4627 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4629 p1
= strchr (p
, ':');
4634 strncpy (tryname
, p
, len
);
4635 tryname
[len
] = '\0';
4636 strcat (tryname
, "/");
4637 strcat (tryname
, shell_file
);
4638 if (access (tryname
, X_OK
) < 0)
4640 if (stat (tryname
, &statbuf
) < 0)
4642 if (!S_ISREG (statbuf
.st_mode
))
4643 /* We certainly need to reject directories. I'm not quite
4644 as sure about FIFOs, sockets, etc., but I kind of doubt
4645 that people want to exec() these things. */
4650 /* Not found. This must be an error rather than merely passing
4651 the file to execlp(), because execlp() would try all the
4652 exec()s, causing GDB to get confused. */
4653 error (_("procfs:%d -- Can't find shell %s in PATH"),
4654 __LINE__
, shell_file
);
4656 shell_file
= tryname
;
4659 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4660 NULL
, NULL
, shell_file
, NULL
);
4662 procfs_init_inferior (ops
, pid
);
4665 /* An observer for the "inferior_created" event. */
4668 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
4671 /* Make sure to cancel the syssgi() syscall-exit notifications.
4672 They should normally have been removed by now, but they may still
4673 be activated if the inferior doesn't use shared libraries, or if
4674 we didn't locate __dbx_link, or if we never stopped in __dbx_link.
4675 See procfs_init_inferior() for more details.
4677 Since these notifications are only ever enabled when we spawned
4678 the inferior ourselves, there is nothing to do when the inferior
4679 was created by attaching to an already running process, or when
4680 debugging a core file. */
4681 if (current_inferior ()->attach_flag
|| !target_can_run (¤t_target
))
4684 proc_trace_syscalls_1 (find_procinfo_or_die (ptid_get_pid (inferior_ptid
),
4685 0), SYS_syssgi
, PR_SYSEXIT
, FLAG_RESET
, 0);
4689 /* Callback for find_new_threads. Calls "add_thread". */
4692 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
4694 ptid_t gdb_threadid
= ptid_build (pi
->pid
, thread
->tid
, 0);
4696 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
4697 add_thread (gdb_threadid
);
4702 /* Query all the threads that the target knows about, and give them
4703 back to GDB to add to its list. */
4706 procfs_find_new_threads (struct target_ops
*ops
)
4710 /* Find procinfo for main process. */
4711 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
4712 proc_update_threads (pi
);
4713 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4716 /* Return true if the thread is still 'alive'. This guy doesn't
4717 really seem to be doing his job. Got to investigate how to tell
4718 when a thread is really gone. */
4721 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4726 proc
= ptid_get_pid (ptid
);
4727 thread
= ptid_get_lwp (ptid
);
4728 /* If I don't know it, it ain't alive! */
4729 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4732 /* If I can't get its status, it ain't alive!
4733 What's more, I need to forget about it! */
4734 if (!proc_get_status (pi
))
4736 destroy_procinfo (pi
);
4739 /* I couldn't have got its status if it weren't alive, so it's
4744 /* Convert PTID to a string. Returns the string in a static
4748 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
4750 static char buf
[80];
4752 if (ptid_get_lwp (ptid
) == 0)
4753 sprintf (buf
, "process %d", ptid_get_pid (ptid
));
4755 sprintf (buf
, "LWP %ld", ptid_get_lwp (ptid
));
4760 /* Insert a watchpoint. */
4763 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
4770 pi
= find_procinfo_or_die (ptid_get_pid (ptid
) == -1 ?
4771 ptid_get_pid (inferior_ptid
) : ptid_get_pid (ptid
),
4774 /* Translate from GDB's flags to /proc's. */
4775 if (len
> 0) /* len == 0 means delete watchpoint. */
4777 switch (rwflag
) { /* FIXME: need an enum! */
4778 case hw_write
: /* default watchpoint (write) */
4779 pflags
= WRITE_WATCHFLAG
;
4781 case hw_read
: /* read watchpoint */
4782 pflags
= READ_WATCHFLAG
;
4784 case hw_access
: /* access watchpoint */
4785 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
4787 case hw_execute
: /* execution HW breakpoint */
4788 pflags
= EXEC_WATCHFLAG
;
4790 default: /* Something weird. Return error. */
4793 if (after
) /* Stop after r/w access is completed. */
4794 pflags
|= AFTER_WATCHFLAG
;
4797 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
4799 if (errno
== E2BIG
) /* Typical error for no resources. */
4800 return -1; /* fail */
4801 /* GDB may try to remove the same watchpoint twice.
4802 If a remove request returns no match, don't error. */
4803 if (errno
== ESRCH
&& len
== 0)
4804 return 0; /* ignore */
4805 proc_error (pi
, "set_watchpoint", __LINE__
);
4811 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
4812 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
4813 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
4816 Note: procfs_can_use_hw_breakpoint() is not yet used by all
4817 procfs.c targets due to the fact that some of them still define
4818 target_can_use_hardware_watchpoint. */
4821 procfs_can_use_hw_breakpoint (struct target_ops
*self
,
4822 int type
, int cnt
, int othertype
)
4824 /* Due to the way that proc_set_watchpoint() is implemented, host
4825 and target pointers must be of the same size. If they are not,
4826 we can't use hardware watchpoints. This limitation is due to the
4827 fact that proc_set_watchpoint() calls
4828 procfs_address_to_host_pointer(); a close inspection of
4829 procfs_address_to_host_pointer will reveal that an internal error
4830 will be generated when the host and target pointer sizes are
4832 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
4834 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
4837 /* Other tests here??? */
4842 /* Returns non-zero if process is stopped on a hardware watchpoint
4843 fault, else returns zero. */
4846 procfs_stopped_by_watchpoint (struct target_ops
*ops
)
4850 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
4852 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
4854 if (proc_why (pi
) == PR_FAULTED
)
4857 if (proc_what (pi
) == FLTWATCH
)
4861 if (proc_what (pi
) == FLTKWATCH
)
4869 /* Returns 1 if the OS knows the position of the triggered watchpoint,
4870 and sets *ADDR to that address. Returns 0 if OS cannot report that
4871 address. This function is only called if
4872 procfs_stopped_by_watchpoint returned 1, thus no further checks are
4873 done. The function also assumes that ADDR is not NULL. */
4876 procfs_stopped_data_address (struct target_ops
*targ
, CORE_ADDR
*addr
)
4880 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
4881 return proc_watchpoint_address (pi
, addr
);
4885 procfs_insert_watchpoint (struct target_ops
*self
,
4886 CORE_ADDR addr
, int len
, int type
,
4887 struct expression
*cond
)
4889 if (!target_have_steppable_watchpoint
4890 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
4892 /* When a hardware watchpoint fires off the PC will be left at
4893 the instruction following the one which caused the
4894 watchpoint. It will *NOT* be necessary for GDB to step over
4896 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
4900 /* When a hardware watchpoint fires off the PC will be left at
4901 the instruction which caused the watchpoint. It will be
4902 necessary for GDB to step over the watchpoint. */
4903 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
4908 procfs_remove_watchpoint (struct target_ops
*self
,
4909 CORE_ADDR addr
, int len
, int type
,
4910 struct expression
*cond
)
4912 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
4916 procfs_region_ok_for_hw_watchpoint (struct target_ops
*self
,
4917 CORE_ADDR addr
, int len
)
4919 /* The man page for proc(4) on Solaris 2.6 and up says that the
4920 system can support "thousands" of hardware watchpoints, but gives
4921 no method for finding out how many; It doesn't say anything about
4922 the allowed size for the watched area either. So we just tell
4928 procfs_use_watchpoints (struct target_ops
*t
)
4930 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
4931 t
->to_insert_watchpoint
= procfs_insert_watchpoint
;
4932 t
->to_remove_watchpoint
= procfs_remove_watchpoint
;
4933 t
->to_region_ok_for_hw_watchpoint
= procfs_region_ok_for_hw_watchpoint
;
4934 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
4935 t
->to_stopped_data_address
= procfs_stopped_data_address
;
4938 /* Memory Mappings Functions: */
4940 /* Call a callback function once for each mapping, passing it the
4941 mapping, an optional secondary callback function, and some optional
4942 opaque data. Quit and return the first non-zero value returned
4945 PI is the procinfo struct for the process to be mapped. FUNC is
4946 the callback function to be called by this iterator. DATA is the
4947 optional opaque data to be passed to the callback function.
4948 CHILD_FUNC is the optional secondary function pointer to be passed
4949 to the child function. Returns the first non-zero return value
4950 from the callback function, or zero. */
4953 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
4955 int (*func
) (struct prmap
*map
,
4956 find_memory_region_ftype child_func
,
4959 char pathname
[MAX_PROC_NAME_SIZE
];
4960 struct prmap
*prmaps
;
4961 struct prmap
*prmap
;
4965 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
4970 /* Get the number of mappings, allocate space,
4971 and read the mappings into prmaps. */
4974 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
4975 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
4976 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
4978 /* Make sure it gets closed again. */
4979 make_cleanup_close (map_fd
);
4981 /* Use stat to determine the file size, and compute
4982 the number of prmap_t objects it contains. */
4983 if (fstat (map_fd
, &sbuf
) != 0)
4984 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
4986 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
4987 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
4988 if (read (map_fd
, (char *) prmaps
, nmap
* sizeof (*prmaps
))
4989 != (nmap
* sizeof (*prmaps
)))
4990 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
4992 /* Use ioctl command PIOCNMAP to get number of mappings. */
4993 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmap
) != 0)
4994 proc_error (pi
, "iterate_over_mappings (PIOCNMAP)", __LINE__
);
4996 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
4997 if (ioctl (pi
->ctl_fd
, PIOCMAP
, prmaps
) != 0)
4998 proc_error (pi
, "iterate_over_mappings (PIOCMAP)", __LINE__
);
5001 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
5002 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
5004 do_cleanups (cleanups
);
5008 do_cleanups (cleanups
);
5012 /* Implements the to_find_memory_regions method. Calls an external
5013 function for each memory region.
5014 Returns the integer value returned by the callback. */
5017 find_memory_regions_callback (struct prmap
*map
,
5018 find_memory_region_ftype func
, void *data
)
5020 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
5022 (map
->pr_mflags
& MA_READ
) != 0,
5023 (map
->pr_mflags
& MA_WRITE
) != 0,
5024 (map
->pr_mflags
& MA_EXEC
) != 0,
5025 1, /* MODIFIED is unknown, pass it as true. */
5029 /* External interface. Calls a callback function once for each
5030 mapped memory region in the child process, passing as arguments:
5032 CORE_ADDR virtual_address,
5034 int read, TRUE if region is readable by the child
5035 int write, TRUE if region is writable by the child
5036 int execute TRUE if region is executable by the child.
5038 Stops iterating and returns the first non-zero value returned by
5042 proc_find_memory_regions (struct target_ops
*self
,
5043 find_memory_region_ftype func
, void *data
)
5045 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
5047 return iterate_over_mappings (pi
, func
, data
,
5048 find_memory_regions_callback
);
5051 /* Returns an ascii representation of a memory mapping's flags. */
5054 mappingflags (long flags
)
5056 static char asciiflags
[8];
5058 strcpy (asciiflags
, "-------");
5059 #if defined (MA_PHYS)
5060 if (flags
& MA_PHYS
)
5061 asciiflags
[0] = 'd';
5063 if (flags
& MA_STACK
)
5064 asciiflags
[1] = 's';
5065 if (flags
& MA_BREAK
)
5066 asciiflags
[2] = 'b';
5067 if (flags
& MA_SHARED
)
5068 asciiflags
[3] = 's';
5069 if (flags
& MA_READ
)
5070 asciiflags
[4] = 'r';
5071 if (flags
& MA_WRITE
)
5072 asciiflags
[5] = 'w';
5073 if (flags
& MA_EXEC
)
5074 asciiflags
[6] = 'x';
5075 return (asciiflags
);
5078 /* Callback function, does the actual work for 'info proc
5082 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
5085 unsigned int pr_off
;
5087 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
5088 pr_off
= (unsigned int) map
->pr_offset
;
5090 pr_off
= map
->pr_off
;
5093 if (gdbarch_addr_bit (target_gdbarch ()) == 32)
5094 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
5095 (unsigned long) map
->pr_vaddr
,
5096 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5097 (unsigned long) map
->pr_size
,
5099 mappingflags (map
->pr_mflags
));
5101 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
5102 (unsigned long) map
->pr_vaddr
,
5103 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5104 (unsigned long) map
->pr_size
,
5106 mappingflags (map
->pr_mflags
));
5111 /* Implement the "info proc mappings" subcommand. */
5114 info_proc_mappings (procinfo
*pi
, int summary
)
5117 return; /* No output for summary mode. */
5119 printf_filtered (_("Mapped address spaces:\n\n"));
5120 if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
5121 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
5128 printf_filtered (" %18s %18s %10s %10s %7s\n",
5135 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
5136 printf_filtered ("\n");
5139 /* Implement the "info proc" command. */
5142 procfs_info_proc (struct target_ops
*ops
, const char *args
,
5143 enum info_proc_what what
)
5145 struct cleanup
*old_chain
;
5146 procinfo
*process
= NULL
;
5147 procinfo
*thread
= NULL
;
5165 error (_("Not supported on this target."));
5168 old_chain
= make_cleanup (null_cleanup
, 0);
5171 argv
= gdb_buildargv (args
);
5172 make_cleanup_freeargv (argv
);
5174 while (argv
!= NULL
&& *argv
!= NULL
)
5176 if (isdigit (argv
[0][0]))
5178 pid
= strtoul (argv
[0], &tmp
, 10);
5180 tid
= strtoul (++tmp
, NULL
, 10);
5182 else if (argv
[0][0] == '/')
5184 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5189 pid
= ptid_get_pid (inferior_ptid
);
5191 error (_("No current process: you must name one."));
5194 /* Have pid, will travel.
5195 First see if it's a process we're already debugging. */
5196 process
= find_procinfo (pid
, 0);
5197 if (process
== NULL
)
5199 /* No. So open a procinfo for it, but
5200 remember to close it again when finished. */
5201 process
= create_procinfo (pid
, 0);
5202 make_cleanup (do_destroy_procinfo_cleanup
, process
);
5203 if (!open_procinfo_files (process
, FD_CTL
))
5204 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5208 thread
= create_procinfo (pid
, tid
);
5212 printf_filtered (_("process %d flags:\n"), process
->pid
);
5213 proc_prettyprint_flags (proc_flags (process
), 1);
5214 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5215 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5216 if (proc_get_nthreads (process
) > 1)
5217 printf_filtered ("Process has %d threads.\n",
5218 proc_get_nthreads (process
));
5222 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
5223 proc_prettyprint_flags (proc_flags (thread
), 1);
5224 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5225 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5230 info_proc_mappings (process
, 0);
5233 do_cleanups (old_chain
);
5236 /* Modify the status of the system call identified by SYSCALLNUM in
5237 the set of syscalls that are currently traced/debugged.
5239 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
5240 will be updated. Otherwise, the exit syscalls set will be updated.
5242 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
5243 will be disabled. */
5246 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
5247 int mode
, int from_tty
)
5251 if (entry_or_exit
== PR_SYSENTRY
)
5252 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5254 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5257 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5259 if (mode
== FLAG_SET
)
5260 gdb_praddsysset (sysset
, syscallnum
);
5262 gdb_prdelsysset (sysset
, syscallnum
);
5264 if (entry_or_exit
== PR_SYSENTRY
)
5266 if (!proc_set_traced_sysentry (pi
, sysset
))
5267 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5271 if (!proc_set_traced_sysexit (pi
, sysset
))
5272 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5277 proc_trace_syscalls (char *args
, int from_tty
, int entry_or_exit
, int mode
)
5281 if (ptid_get_pid (inferior_ptid
) <= 0)
5282 error (_("you must be debugging a process to use this command."));
5284 if (args
== NULL
|| args
[0] == 0)
5285 error_no_arg (_("system call to trace"));
5287 pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
5288 if (isdigit (args
[0]))
5290 const int syscallnum
= atoi (args
);
5292 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
5297 proc_trace_sysentry_cmd (char *args
, int from_tty
)
5299 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5303 proc_trace_sysexit_cmd (char *args
, int from_tty
)
5305 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5309 proc_untrace_sysentry_cmd (char *args
, int from_tty
)
5311 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5315 proc_untrace_sysexit_cmd (char *args
, int from_tty
)
5317 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5321 /* Provide a prototype to silence -Wmissing-prototypes. */
5322 extern void _initialize_procfs (void);
5325 _initialize_procfs (void)
5327 observer_attach_inferior_created (procfs_inferior_created
);
5329 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5330 _("Give a trace of entries into the syscall."));
5331 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5332 _("Give a trace of exits from the syscall."));
5333 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5334 _("Cancel a trace of entries into the syscall."));
5335 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5336 _("Cancel a trace of exits from the syscall."));
5339 /* =================== END, GDB "MODULE" =================== */
5343 /* miscellaneous stubs: */
5345 /* The following satisfy a few random symbols mostly created by the
5346 solaris threads implementation, which I will chase down later. */
5348 /* Return a pid for which we guarantee we will be able to find a
5352 procfs_first_available (void)
5354 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
5357 /* =================== GCORE .NOTE "MODULE" =================== */
5358 #if defined (PIOCOPENLWP) || defined (PCAGENT)
5359 /* gcore only implemented on solaris (so far) */
5362 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
5363 char *note_data
, int *note_size
,
5364 enum gdb_signal stop_signal
)
5366 struct regcache
*regcache
= get_thread_regcache (ptid
);
5367 gdb_gregset_t gregs
;
5368 gdb_fpregset_t fpregs
;
5369 unsigned long merged_pid
;
5370 struct cleanup
*old_chain
;
5372 merged_pid
= ptid_get_lwp (ptid
) << 16 | ptid_get_pid (ptid
);
5374 /* This part is the old method for fetching registers.
5375 It should be replaced by the newer one using regsets
5376 once it is implemented in this platform:
5377 gdbarch_regset_from_core_section() and regset->collect_regset(). */
5379 old_chain
= save_inferior_ptid ();
5380 inferior_ptid
= ptid
;
5381 target_fetch_registers (regcache
, -1);
5383 fill_gregset (regcache
, &gregs
, -1);
5384 #if defined (NEW_PROC_API)
5385 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
5392 note_data
= (char *) elfcore_write_prstatus (obfd
,
5399 fill_fpregset (regcache
, &fpregs
, -1);
5400 note_data
= (char *) elfcore_write_prfpreg (obfd
,
5406 do_cleanups (old_chain
);
5411 struct procfs_corefile_thread_data
{
5415 enum gdb_signal stop_signal
;
5419 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
5421 struct procfs_corefile_thread_data
*args
= data
;
5425 ptid_t ptid
= ptid_build (pi
->pid
, thread
->tid
, 0);
5427 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
5436 find_signalled_thread (struct thread_info
*info
, void *data
)
5438 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
5439 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
5445 static enum gdb_signal
5446 find_stop_signal (void)
5448 struct thread_info
*info
=
5449 iterate_over_threads (find_signalled_thread
, NULL
);
5452 return info
->suspend
.stop_signal
;
5454 return GDB_SIGNAL_0
;
5458 procfs_make_note_section (struct target_ops
*self
, bfd
*obfd
, int *note_size
)
5460 struct cleanup
*old_chain
;
5461 gdb_gregset_t gregs
;
5462 gdb_fpregset_t fpregs
;
5463 char fname
[16] = {'\0'};
5464 char psargs
[80] = {'\0'};
5465 procinfo
*pi
= find_procinfo_or_die (ptid_get_pid (inferior_ptid
), 0);
5466 char *note_data
= NULL
;
5468 struct procfs_corefile_thread_data thread_args
;
5471 enum gdb_signal stop_signal
;
5473 if (get_exec_file (0))
5475 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
5476 fname
[sizeof (fname
) - 1] = 0;
5477 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
5478 psargs
[sizeof (psargs
) - 1] = 0;
5480 inf_args
= get_inferior_args ();
5481 if (inf_args
&& *inf_args
&&
5482 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
5484 strncat (psargs
, " ",
5485 sizeof (psargs
) - strlen (psargs
));
5486 strncat (psargs
, inf_args
,
5487 sizeof (psargs
) - strlen (psargs
));
5491 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
5497 stop_signal
= find_stop_signal ();
5500 fill_gregset (get_current_regcache (), &gregs
, -1);
5501 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
5502 ptid_get_pid (inferior_ptid
),
5503 stop_signal
, &gregs
);
5506 thread_args
.obfd
= obfd
;
5507 thread_args
.note_data
= note_data
;
5508 thread_args
.note_size
= note_size
;
5509 thread_args
.stop_signal
= stop_signal
;
5510 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
5512 note_data
= thread_args
.note_data
;
5514 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
5518 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
5519 "CORE", NT_AUXV
, auxv
, auxv_len
);
5525 #else /* !Solaris */
5527 procfs_make_note_section (struct target_ops
*self
, bfd
*obfd
, int *note_size
)
5529 error (_("gcore not implemented for this host."));
5530 return NULL
; /* lint */
5532 #endif /* Solaris */
5533 /* =================== END GCORE .NOTE "MODULE" =================== */