1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 Written by Michael Snyder at Cygnus Solutions.
7 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 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>
49 #include "gdb_string.h"
50 #include "gdb_assert.h"
56 /* This module provides the interface between GDB and the
57 /proc file system, which is used on many versions of Unix
58 as a means for debuggers to control other processes.
60 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 "gdb_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 "gdb_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
*, char *, int);
114 static void procfs_detach (struct target_ops
*, char *, int);
115 static void procfs_resume (struct target_ops
*,
116 ptid_t
, int, enum target_signal
);
117 static void procfs_stop (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 (int, unsigned char *);
124 static void procfs_kill_inferior (struct target_ops
*ops
);
125 static void procfs_mourn_inferior (struct target_ops
*ops
);
126 static void procfs_create_inferior (struct target_ops
*, char *,
127 char *, char **, int);
128 static ptid_t
procfs_wait (struct target_ops
*,
129 ptid_t
, struct target_waitstatus
*, int);
130 static int procfs_xfer_memory (CORE_ADDR
, gdb_byte
*, int, int,
131 struct mem_attrib
*attrib
,
132 struct target_ops
*);
133 static LONGEST
procfs_xfer_partial (struct target_ops
*ops
,
134 enum target_object object
,
137 const gdb_byte
*writebuf
,
138 ULONGEST offset
, LONGEST len
);
140 static int procfs_thread_alive (struct target_ops
*ops
, ptid_t
);
142 void procfs_find_new_threads (struct target_ops
*ops
);
143 char *procfs_pid_to_str (struct target_ops
*, ptid_t
);
145 static int proc_find_memory_regions (int (*) (CORE_ADDR
,
151 static char * procfs_make_note_section (bfd
*, int *);
153 static int procfs_can_use_hw_breakpoint (int, int, int);
155 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
156 /* When GDB is built as 64-bit application on Solaris, the auxv data
157 is presented in 64-bit format. We need to provide a custom parser
160 procfs_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
161 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
163 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
164 gdb_byte
*ptr
= *readptr
;
169 if (endptr
- ptr
< 8 * 2)
172 *typep
= extract_unsigned_integer (ptr
, 4, byte_order
);
174 /* The size of data is always 64-bit. If the application is 32-bit,
175 it will be zero extended, as expected. */
176 *valp
= extract_unsigned_integer (ptr
, 8, byte_order
);
187 struct target_ops
*t
= inf_child_target ();
189 t
->to_shortname
= "procfs";
190 t
->to_longname
= "Unix /proc child process";
192 "Unix /proc child process (started by the \"run\" command).";
193 t
->to_create_inferior
= procfs_create_inferior
;
194 t
->to_kill
= procfs_kill_inferior
;
195 t
->to_mourn_inferior
= procfs_mourn_inferior
;
196 t
->to_attach
= procfs_attach
;
197 t
->to_detach
= procfs_detach
;
198 t
->to_wait
= procfs_wait
;
199 t
->to_resume
= procfs_resume
;
200 t
->to_fetch_registers
= procfs_fetch_registers
;
201 t
->to_store_registers
= procfs_store_registers
;
202 t
->to_xfer_partial
= procfs_xfer_partial
;
203 t
->deprecated_xfer_memory
= procfs_xfer_memory
;
204 t
->to_pass_signals
= procfs_pass_signals
;
205 t
->to_files_info
= procfs_files_info
;
206 t
->to_stop
= procfs_stop
;
208 t
->to_find_new_threads
= procfs_find_new_threads
;
209 t
->to_thread_alive
= procfs_thread_alive
;
210 t
->to_pid_to_str
= procfs_pid_to_str
;
212 t
->to_has_thread_control
= tc_schedlock
;
213 t
->to_find_memory_regions
= proc_find_memory_regions
;
214 t
->to_make_corefile_notes
= procfs_make_note_section
;
216 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
217 t
->to_auxv_parse
= procfs_auxv_parse
;
220 t
->to_magic
= OPS_MAGIC
;
225 /* =================== END, TARGET_OPS "MODULE" =================== */
227 /* World Unification:
229 Put any typedefs, defines etc. here that are required for the
230 unification of code that handles different versions of /proc. */
232 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
234 enum { READ_WATCHFLAG
= WA_READ
,
235 WRITE_WATCHFLAG
= WA_WRITE
,
236 EXEC_WATCHFLAG
= WA_EXEC
,
237 AFTER_WATCHFLAG
= WA_TRAPAFTER
240 #else /* Irix method for watchpoints */
241 enum { READ_WATCHFLAG
= MA_READ
,
242 WRITE_WATCHFLAG
= MA_WRITE
,
243 EXEC_WATCHFLAG
= MA_EXEC
,
244 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
249 #ifdef HAVE_PR_SIGSET_T
250 typedef pr_sigset_t gdb_sigset_t
;
252 typedef sigset_t gdb_sigset_t
;
256 #ifdef HAVE_PR_SIGACTION64_T
257 typedef pr_sigaction64_t gdb_sigaction_t
;
259 typedef struct sigaction gdb_sigaction_t
;
263 #ifdef HAVE_PR_SIGINFO64_T
264 typedef pr_siginfo64_t gdb_siginfo_t
;
266 typedef struct siginfo gdb_siginfo_t
;
269 /* On mips-irix, praddset and prdelset are defined in such a way that
270 they return a value, which causes GCC to emit a -Wunused error
271 because the returned value is not used. Prevent this warning
272 by casting the return value to void. On sparc-solaris, this issue
273 does not exist because the definition of these macros already include
274 that cast to void. */
275 #define gdb_praddset(sp, flag) ((void) praddset (sp, flag))
276 #define gdb_prdelset(sp, flag) ((void) prdelset (sp, flag))
278 /* gdb_premptysysset */
280 #define gdb_premptysysset premptysysset
282 #define gdb_premptysysset premptyset
287 #define gdb_praddsysset praddsysset
289 #define gdb_praddsysset gdb_praddset
294 #define gdb_prdelsysset prdelsysset
296 #define gdb_prdelsysset gdb_prdelset
299 /* prissyssetmember */
300 #ifdef prissyssetmember
301 #define gdb_pr_issyssetmember prissyssetmember
303 #define gdb_pr_issyssetmember prismember
306 /* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't
307 as intuitively descriptive as it could be, so we'll define
308 DYNAMIC_SYSCALLS to mean the same thing. Anyway, at the time of
309 this writing, this feature is only found on AIX5 systems and
310 basically means that the set of syscalls is not fixed. I.e,
311 there's no nice table that one can #include to get all of the
312 syscall numbers. Instead, they're stored in /proc/PID/sysent
313 for each process. We are at least guaranteed that they won't
314 change over the lifetime of the process. But each process could
315 (in theory) have different syscall numbers. */
316 #ifdef HAVE_PRSYSENT_T
317 #define DYNAMIC_SYSCALLS
322 /* =================== STRUCT PROCINFO "MODULE" =================== */
324 /* FIXME: this comment will soon be out of date W.R.T. threads. */
326 /* The procinfo struct is a wrapper to hold all the state information
327 concerning a /proc process. There should be exactly one procinfo
328 for each process, and since GDB currently can debug only one
329 process at a time, that means there should be only one procinfo.
330 All of the LWP's of a process can be accessed indirectly thru the
331 single process procinfo.
333 However, against the day when GDB may debug more than one process,
334 this data structure is kept in a list (which for now will hold no
335 more than one member), and many functions will have a pointer to a
336 procinfo as an argument.
338 There will be a separate procinfo structure for use by the (not yet
339 implemented) "info proc" command, so that we can print useful
340 information about any random process without interfering with the
341 inferior's procinfo information. */
344 /* format strings for /proc paths */
345 # ifndef CTL_PROC_NAME_FMT
346 # define MAIN_PROC_NAME_FMT "/proc/%d"
347 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
348 # define AS_PROC_NAME_FMT "/proc/%d/as"
349 # define MAP_PROC_NAME_FMT "/proc/%d/map"
350 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
351 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
353 /* the name of the proc status struct depends on the implementation */
354 typedef pstatus_t gdb_prstatus_t
;
355 typedef lwpstatus_t gdb_lwpstatus_t
;
356 #else /* ! NEW_PROC_API */
357 /* format strings for /proc paths */
358 # ifndef CTL_PROC_NAME_FMT
359 # define MAIN_PROC_NAME_FMT "/proc/%05d"
360 # define CTL_PROC_NAME_FMT "/proc/%05d"
361 # define AS_PROC_NAME_FMT "/proc/%05d"
362 # define MAP_PROC_NAME_FMT "/proc/%05d"
363 # define STATUS_PROC_NAME_FMT "/proc/%05d"
364 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
366 /* The name of the proc status struct depends on the implementation. */
367 typedef prstatus_t gdb_prstatus_t
;
368 typedef prstatus_t gdb_lwpstatus_t
;
369 #endif /* NEW_PROC_API */
371 typedef struct procinfo
{
372 struct procinfo
*next
;
373 int pid
; /* Process ID */
374 int tid
; /* Thread/LWP id */
378 int ignore_next_sigstop
;
380 /* The following four fd fields may be identical, or may contain
381 several different fd's, depending on the version of /proc
382 (old ioctl or new read/write). */
384 int ctl_fd
; /* File descriptor for /proc control file */
386 /* The next three file descriptors are actually only needed in the
387 read/write, multiple-file-descriptor implemenation
388 (NEW_PROC_API). However, to avoid a bunch of #ifdefs in the
389 code, we will use them uniformly by (in the case of the ioctl
390 single-file-descriptor implementation) filling them with copies
391 of the control fd. */
392 int status_fd
; /* File descriptor for /proc status file */
393 int as_fd
; /* File descriptor for /proc as file */
395 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
397 fltset_t saved_fltset
; /* Saved traced hardware fault set */
398 gdb_sigset_t saved_sigset
; /* Saved traced signal set */
399 gdb_sigset_t saved_sighold
; /* Saved held signal set */
400 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
401 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
403 gdb_prstatus_t prstatus
; /* Current process status info */
406 gdb_fpregset_t fpregset
; /* Current floating point registers */
409 #ifdef DYNAMIC_SYSCALLS
410 int num_syscalls
; /* Total number of syscalls */
411 char **syscall_names
; /* Syscall number to name map */
414 struct procinfo
*thread_list
;
416 int status_valid
: 1;
418 int fpregs_valid
: 1;
419 int threads_valid
: 1;
422 static char errmsg
[128]; /* shared error msg buffer */
424 /* Function prototypes for procinfo module: */
426 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
427 static procinfo
*find_procinfo (int pid
, int tid
);
428 static procinfo
*create_procinfo (int pid
, int tid
);
429 static void destroy_procinfo (procinfo
* p
);
430 static void do_destroy_procinfo_cleanup (void *);
431 static void dead_procinfo (procinfo
* p
, char *msg
, int killp
);
432 static int open_procinfo_files (procinfo
* p
, int which
);
433 static void close_procinfo_files (procinfo
* p
);
434 static int sysset_t_size (procinfo
*p
);
435 static sysset_t
*sysset_t_alloc (procinfo
* pi
);
436 #ifdef DYNAMIC_SYSCALLS
437 static void load_syscalls (procinfo
*pi
);
438 static void free_syscalls (procinfo
*pi
);
439 static int find_syscall (procinfo
*pi
, char *name
);
440 #endif /* DYNAMIC_SYSCALLS */
442 static int iterate_over_mappings
443 (procinfo
*pi
, find_memory_region_ftype child_func
, void *data
,
444 int (*func
) (struct prmap
*map
, find_memory_region_ftype child_func
,
447 /* The head of the procinfo list: */
448 static procinfo
* procinfo_list
;
450 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
454 find_procinfo (int pid
, int tid
)
458 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
465 /* Don't check threads_valid. If we're updating the
466 thread_list, we want to find whatever threads are already
467 here. This means that in general it is the caller's
468 responsibility to check threads_valid and update before
469 calling find_procinfo, if the caller wants to find a new
472 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
480 /* Calls find_procinfo, but errors on failure. */
483 find_procinfo_or_die (int pid
, int tid
)
485 procinfo
*pi
= find_procinfo (pid
, tid
);
490 error (_("procfs: couldn't find pid %d "
491 "(kernel thread %d) in procinfo list."),
494 error (_("procfs: couldn't find pid %d in procinfo list."), pid
);
499 /* Wrapper for `open'. The appropriate open call is attempted; if
500 unsuccessful, it will be retried as many times as needed for the
501 EAGAIN and EINTR conditions.
503 For other conditions, retry the open a limited number of times. In
504 addition, a short sleep is imposed prior to retrying the open. The
505 reason for this sleep is to give the kernel a chance to catch up
506 and create the file in question in the event that GDB "wins" the
507 race to open a file before the kernel has created it. */
510 open_with_retry (const char *pathname
, int flags
)
512 int retries_remaining
, status
;
514 retries_remaining
= 2;
518 status
= open (pathname
, flags
);
520 if (status
>= 0 || retries_remaining
== 0)
522 else if (errno
!= EINTR
&& errno
!= EAGAIN
)
532 /* Open the file descriptor for the process or LWP. If NEW_PROC_API
533 is defined, we only open the control file descriptor; the others
534 are opened lazily as needed. Otherwise (if not NEW_PROC_API),
535 there is only one real file descriptor, but we keep multiple copies
536 of it so that the code that uses them does not have to be #ifdef'd.
537 Returns the file descriptor, or zero for failure. */
539 enum { FD_CTL
, FD_STATUS
, FD_AS
};
542 open_procinfo_files (procinfo
*pi
, int which
)
545 char tmp
[MAX_PROC_NAME_SIZE
];
549 /* This function is getting ALMOST long enough to break up into
550 several. Here is some rationale:
552 NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
553 There are several file descriptors that may need to be open
554 for any given process or LWP. The ones we're intereted in are:
555 - control (ctl) write-only change the state
556 - status (status) read-only query the state
557 - address space (as) read/write access memory
558 - map (map) read-only virtual addr map
559 Most of these are opened lazily as they are needed.
560 The pathnames for the 'files' for an LWP look slightly
561 different from those of a first-class process:
562 Pathnames for a process (<proc-id>):
564 /proc/<proc-id>/status
567 Pathnames for an LWP (lwp-id):
568 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
569 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
570 An LWP has no map or address space file descriptor, since
571 the memory map and address space are shared by all LWPs.
573 Everyone else (Solaris 2.5, Irix, OSF)
574 There is only one file descriptor for each process or LWP.
575 For convenience, we copy the same file descriptor into all
576 three fields of the procinfo struct (ctl_fd, status_fd, and
577 as_fd, see NEW_PROC_API above) so that code that uses them
578 doesn't need any #ifdef's.
583 Each LWP has an independent file descriptor, but these
584 are not obtained via the 'open' system call like the rest:
585 instead, they're obtained thru an ioctl call (PIOCOPENLWP)
586 to the file descriptor of the parent process.
589 These do not even have their own independent file descriptor.
590 All operations are carried out on the file descriptor of the
591 parent process. Therefore we just call open again for each
592 thread, getting a new handle for the same 'file'. */
595 /* In this case, there are several different file descriptors that
596 we might be asked to open. The control file descriptor will be
597 opened early, but the others will be opened lazily as they are
600 strcpy (tmp
, pi
->pathname
);
601 switch (which
) { /* Which file descriptor to open? */
604 strcat (tmp
, "/lwpctl");
606 strcat (tmp
, "/ctl");
607 fd
= open_with_retry (tmp
, O_WRONLY
);
614 return 0; /* There is no 'as' file descriptor for an lwp. */
616 fd
= open_with_retry (tmp
, O_RDWR
);
623 strcat (tmp
, "/lwpstatus");
625 strcat (tmp
, "/status");
626 fd
= open_with_retry (tmp
, O_RDONLY
);
632 return 0; /* unknown file descriptor */
634 #else /* not NEW_PROC_API */
635 /* In this case, there is only one file descriptor for each procinfo
636 (ie. each process or LWP). In fact, only the file descriptor for
637 the process can actually be opened by an 'open' system call. The
638 ones for the LWPs have to be obtained thru an IOCTL call on the
639 process's file descriptor.
641 For convenience, we copy each procinfo's single file descriptor
642 into all of the fields occupied by the several file descriptors
643 of the NEW_PROC_API implementation. That way, the code that uses
644 them can be written without ifdefs. */
647 #ifdef PIOCTSTATUS /* OSF */
648 /* Only one FD; just open it. */
649 if ((fd
= open_with_retry (pi
->pathname
, O_RDWR
)) < 0)
651 #else /* Sol 2.5, Irix, other? */
652 if (pi
->tid
== 0) /* Master procinfo for the process */
654 fd
= open_with_retry (pi
->pathname
, O_RDWR
);
658 else /* LWP thread procinfo */
660 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
664 /* Find the procinfo for the entire process. */
665 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
668 /* Now obtain the file descriptor for the LWP. */
669 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) < 0)
671 #else /* Irix, other? */
672 return 0; /* Don't know how to open threads. */
673 #endif /* Sol 2.5 PIOCOPENLWP */
675 #endif /* OSF PIOCTSTATUS */
676 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
677 #endif /* NEW_PROC_API */
679 return 1; /* success */
682 /* Allocate a data structure and link it into the procinfo list.
683 First tries to find a pre-existing one (FIXME: why?). Returns the
684 pointer to new procinfo struct. */
687 create_procinfo (int pid
, int tid
)
689 procinfo
*pi
, *parent
= NULL
;
691 if ((pi
= find_procinfo (pid
, tid
)))
692 return pi
; /* Already exists, nothing to do. */
694 /* Find parent before doing malloc, to save having to cleanup. */
696 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
698 doesn't exist yet? */
700 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
701 memset (pi
, 0, sizeof (procinfo
));
705 #ifdef DYNAMIC_SYSCALLS
709 pi
->saved_entryset
= sysset_t_alloc (pi
);
710 pi
->saved_exitset
= sysset_t_alloc (pi
);
712 /* Chain into list. */
715 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
716 pi
->next
= procinfo_list
;
722 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
724 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
726 pi
->next
= parent
->thread_list
;
727 parent
->thread_list
= pi
;
732 /* Close all file descriptors associated with the procinfo. */
735 close_procinfo_files (procinfo
*pi
)
742 if (pi
->status_fd
> 0)
743 close (pi
->status_fd
);
745 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
748 /* Destructor function. Close, unlink and deallocate the object. */
751 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
755 /* Step one: unlink the procinfo from its list. */
759 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
762 ptr
->next
= pi
->next
;
766 /* Step two: close any open file descriptors. */
767 close_procinfo_files (pi
);
769 /* Step three: free the memory. */
770 #ifdef DYNAMIC_SYSCALLS
773 xfree (pi
->saved_entryset
);
774 xfree (pi
->saved_exitset
);
779 destroy_procinfo (procinfo
*pi
)
783 if (pi
->tid
!= 0) /* Destroy a thread procinfo. */
785 tmp
= find_procinfo (pi
->pid
, 0); /* Find the parent process. */
786 destroy_one_procinfo (&tmp
->thread_list
, pi
);
788 else /* Destroy a process procinfo and all its threads. */
790 /* First destroy the children, if any; */
791 while (pi
->thread_list
!= NULL
)
792 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
793 /* Then destroy the parent. Genocide!!! */
794 destroy_one_procinfo (&procinfo_list
, pi
);
799 do_destroy_procinfo_cleanup (void *pi
)
801 destroy_procinfo (pi
);
804 enum { NOKILL
, KILL
};
806 /* To be called on a non_recoverable error for a procinfo. Prints
807 error messages, optionally sends a SIGKILL to the process, then
808 destroys the data structure. */
811 dead_procinfo (procinfo
*pi
, char *msg
, int kill_p
)
817 print_sys_errmsg (pi
->pathname
, errno
);
821 sprintf (procfile
, "process %d", pi
->pid
);
822 print_sys_errmsg (procfile
, errno
);
825 kill (pi
->pid
, SIGKILL
);
827 destroy_procinfo (pi
);
831 /* Returns the (complete) size of a sysset_t struct. Normally, this
832 is just sizeof (sysset_t), but in the case of Monterey/64, the
833 actual size of sysset_t isn't known until runtime. */
836 sysset_t_size (procinfo
* pi
)
838 #ifndef DYNAMIC_SYSCALLS
839 return sizeof (sysset_t
);
841 return sizeof (sysset_t
) - sizeof (uint64_t)
842 + sizeof (uint64_t) * ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
843 / (8 * sizeof (uint64_t)));
847 /* Allocate and (partially) initialize a sysset_t struct. */
850 sysset_t_alloc (procinfo
* pi
)
853 int size
= sysset_t_size (pi
);
855 ret
= xmalloc (size
);
856 #ifdef DYNAMIC_SYSCALLS
857 ret
->pr_size
= ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
858 / (8 * sizeof (uint64_t)));
863 #ifdef DYNAMIC_SYSCALLS
865 /* Extract syscall numbers and names from /proc/<pid>/sysent. Initialize
866 pi->num_syscalls with the number of syscalls and pi->syscall_names
867 with the names. (Certain numbers may be skipped in which case the
868 names for these numbers will be left as NULL.) */
870 #define MAX_SYSCALL_NAME_LENGTH 256
871 #define MAX_SYSCALLS 65536
874 load_syscalls (procinfo
*pi
)
876 char pathname
[MAX_PROC_NAME_SIZE
];
879 prsyscall_t
*syscalls
;
880 int i
, size
, maxcall
;
881 struct cleanup
*cleanups
;
883 pi
->num_syscalls
= 0;
884 pi
->syscall_names
= 0;
886 /* Open the file descriptor for the sysent file. */
887 sprintf (pathname
, "/proc/%d/sysent", pi
->pid
);
888 sysent_fd
= open_with_retry (pathname
, O_RDONLY
);
891 error (_("load_syscalls: Can't open /proc/%d/sysent"), pi
->pid
);
893 cleanups
= make_cleanup_close (sysent_fd
);
895 size
= sizeof header
- sizeof (prsyscall_t
);
896 if (read (sysent_fd
, &header
, size
) != size
)
898 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
901 if (header
.pr_nsyscalls
== 0)
903 error (_("load_syscalls: /proc/%d/sysent contains no syscalls!"),
907 size
= header
.pr_nsyscalls
* sizeof (prsyscall_t
);
908 syscalls
= xmalloc (size
);
909 make_cleanup (free_current_contents
, &syscalls
);
911 if (read (sysent_fd
, syscalls
, size
) != size
)
912 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
914 /* Find maximum syscall number. This may not be the same as
915 pr_nsyscalls since that value refers to the number of entries
916 in the table. (Also, the docs indicate that some system
917 call numbers may be skipped.) */
919 maxcall
= syscalls
[0].pr_number
;
921 for (i
= 1; i
< header
.pr_nsyscalls
; i
++)
922 if (syscalls
[i
].pr_number
> maxcall
923 && syscalls
[i
].pr_nameoff
> 0
924 && syscalls
[i
].pr_number
< MAX_SYSCALLS
)
925 maxcall
= syscalls
[i
].pr_number
;
927 pi
->num_syscalls
= maxcall
+1;
928 pi
->syscall_names
= xmalloc (pi
->num_syscalls
* sizeof (char *));
930 for (i
= 0; i
< pi
->num_syscalls
; i
++)
931 pi
->syscall_names
[i
] = NULL
;
933 /* Read the syscall names in. */
934 for (i
= 0; i
< header
.pr_nsyscalls
; i
++)
936 char namebuf
[MAX_SYSCALL_NAME_LENGTH
];
940 if (syscalls
[i
].pr_number
>= MAX_SYSCALLS
941 || syscalls
[i
].pr_number
< 0
942 || syscalls
[i
].pr_nameoff
<= 0
943 || (lseek (sysent_fd
, (off_t
) syscalls
[i
].pr_nameoff
, SEEK_SET
)
944 != (off_t
) syscalls
[i
].pr_nameoff
))
947 nread
= read (sysent_fd
, namebuf
, sizeof namebuf
);
951 callnum
= syscalls
[i
].pr_number
;
953 if (pi
->syscall_names
[callnum
] != NULL
)
955 /* FIXME: Generate warning. */
959 namebuf
[nread
-1] = '\0';
960 size
= strlen (namebuf
) + 1;
961 pi
->syscall_names
[callnum
] = xmalloc (size
);
962 strncpy (pi
->syscall_names
[callnum
], namebuf
, size
-1);
963 pi
->syscall_names
[callnum
][size
-1] = '\0';
966 do_cleanups (cleanups
);
969 /* Free the space allocated for the syscall names from the procinfo
973 free_syscalls (procinfo
*pi
)
975 if (pi
->syscall_names
)
979 for (i
= 0; i
< pi
->num_syscalls
; i
++)
980 if (pi
->syscall_names
[i
] != NULL
)
981 xfree (pi
->syscall_names
[i
]);
983 xfree (pi
->syscall_names
);
984 pi
->syscall_names
= 0;
988 /* Given a name, look up (and return) the corresponding syscall number.
989 If no match is found, return -1. */
992 find_syscall (procinfo
*pi
, char *name
)
996 for (i
= 0; i
< pi
->num_syscalls
; i
++)
998 if (pi
->syscall_names
[i
] && strcmp (name
, pi
->syscall_names
[i
]) == 0)
1005 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
1007 /* =================== /proc "MODULE" =================== */
1009 /* This "module" is the interface layer between the /proc system API
1010 and the gdb target vector functions. This layer consists of access
1011 functions that encapsulate each of the basic operations that we
1012 need to use from the /proc API.
1014 The main motivation for this layer is to hide the fact that there
1015 are two very different implementations of the /proc API. Rather
1016 than have a bunch of #ifdefs all thru the gdb target vector
1017 functions, we do our best to hide them all in here. */
1019 int proc_get_status (procinfo
* pi
);
1020 long proc_flags (procinfo
* pi
);
1021 int proc_why (procinfo
* pi
);
1022 int proc_what (procinfo
* pi
);
1023 int proc_set_run_on_last_close (procinfo
* pi
);
1024 int proc_unset_run_on_last_close (procinfo
* pi
);
1025 int proc_set_inherit_on_fork (procinfo
* pi
);
1026 int proc_unset_inherit_on_fork (procinfo
* pi
);
1027 int proc_set_async (procinfo
* pi
);
1028 int proc_unset_async (procinfo
* pi
);
1029 int proc_stop_process (procinfo
* pi
);
1030 int proc_trace_signal (procinfo
* pi
, int signo
);
1031 int proc_ignore_signal (procinfo
* pi
, int signo
);
1032 int proc_clear_current_fault (procinfo
* pi
);
1033 int proc_set_current_signal (procinfo
* pi
, int signo
);
1034 int proc_clear_current_signal (procinfo
* pi
);
1035 int proc_set_gregs (procinfo
* pi
);
1036 int proc_set_fpregs (procinfo
* pi
);
1037 int proc_wait_for_stop (procinfo
* pi
);
1038 int proc_run_process (procinfo
* pi
, int step
, int signo
);
1039 int proc_kill (procinfo
* pi
, int signo
);
1040 int proc_parent_pid (procinfo
* pi
);
1041 int proc_get_nthreads (procinfo
* pi
);
1042 int proc_get_current_thread (procinfo
* pi
);
1043 int proc_set_held_signals (procinfo
* pi
, gdb_sigset_t
* sighold
);
1044 int proc_set_traced_sysexit (procinfo
* pi
, sysset_t
* sysset
);
1045 int proc_set_traced_sysentry (procinfo
* pi
, sysset_t
* sysset
);
1046 int proc_set_traced_faults (procinfo
* pi
, fltset_t
* fltset
);
1047 int proc_set_traced_signals (procinfo
* pi
, gdb_sigset_t
* sigset
);
1049 int proc_update_threads (procinfo
* pi
);
1050 int proc_iterate_over_threads (procinfo
* pi
,
1051 int (*func
) (procinfo
*, procinfo
*, void *),
1054 gdb_gregset_t
*proc_get_gregs (procinfo
* pi
);
1055 gdb_fpregset_t
*proc_get_fpregs (procinfo
* pi
);
1056 sysset_t
*proc_get_traced_sysexit (procinfo
* pi
, sysset_t
* save
);
1057 sysset_t
*proc_get_traced_sysentry (procinfo
* pi
, sysset_t
* save
);
1058 fltset_t
*proc_get_traced_faults (procinfo
* pi
, fltset_t
* save
);
1059 gdb_sigset_t
*proc_get_traced_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1060 gdb_sigset_t
*proc_get_held_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1061 gdb_sigset_t
*proc_get_pending_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1062 gdb_sigaction_t
*proc_get_signal_actions (procinfo
* pi
,
1063 gdb_sigaction_t
*save
);
1065 void proc_warn (procinfo
* pi
, char *func
, int line
);
1066 void proc_error (procinfo
* pi
, char *func
, int line
);
1069 proc_warn (procinfo
*pi
, char *func
, int line
)
1071 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1072 print_sys_errmsg (errmsg
, errno
);
1076 proc_error (procinfo
*pi
, char *func
, int line
)
1078 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1079 perror_with_name (errmsg
);
1082 /* Updates the status struct in the procinfo. There is a 'valid'
1083 flag, to let other functions know when this function needs to be
1084 called (so the status is only read when it is needed). The status
1085 file descriptor is also only opened when it is needed. Returns
1086 non-zero for success, zero for failure. */
1089 proc_get_status (procinfo
*pi
)
1091 /* Status file descriptor is opened "lazily". */
1092 if (pi
->status_fd
== 0 &&
1093 open_procinfo_files (pi
, FD_STATUS
) == 0)
1095 pi
->status_valid
= 0;
1100 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
1101 pi
->status_valid
= 0; /* fail */
1104 /* Sigh... I have to read a different data structure,
1105 depending on whether this is a main process or an LWP. */
1107 pi
->status_valid
= (read (pi
->status_fd
,
1108 (char *) &pi
->prstatus
.pr_lwp
,
1109 sizeof (lwpstatus_t
))
1110 == sizeof (lwpstatus_t
));
1113 pi
->status_valid
= (read (pi
->status_fd
,
1114 (char *) &pi
->prstatus
,
1115 sizeof (gdb_prstatus_t
))
1116 == sizeof (gdb_prstatus_t
));
1117 #if 0 /*def UNIXWARE*/
1118 if (pi
->status_valid
&&
1119 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
1120 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
1121 /* Unixware peculiarity -- read the damn thing again! */
1122 pi
->status_valid
= (read (pi
->status_fd
,
1123 (char *) &pi
->prstatus
,
1124 sizeof (gdb_prstatus_t
))
1125 == sizeof (gdb_prstatus_t
));
1126 #endif /* UNIXWARE */
1129 #else /* ioctl method */
1130 #ifdef PIOCTSTATUS /* osf */
1131 if (pi
->tid
== 0) /* main process */
1133 /* Just read the danged status. Now isn't that simple? */
1135 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1142 tid_t pr_error_thread
;
1143 struct prstatus status
;
1146 thread_status
.pr_count
= 1;
1147 thread_status
.status
.pr_tid
= pi
->tid
;
1148 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
1151 memcpy (&pi
->prstatus
, &thread_status
.status
,
1152 sizeof (pi
->prstatus
));
1153 pi
->status_valid
= 1;
1157 /* Just read the danged status. Now isn't that simple? */
1158 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1162 if (pi
->status_valid
)
1164 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1167 proc_get_current_thread (pi
));
1170 /* The status struct includes general regs, so mark them valid too. */
1171 pi
->gregs_valid
= pi
->status_valid
;
1173 /* In the read/write multiple-fd model, the status struct includes
1174 the fp regs too, so mark them valid too. */
1175 pi
->fpregs_valid
= pi
->status_valid
;
1177 return pi
->status_valid
; /* True if success, false if failure. */
1180 /* Returns the process flags (pr_flags field). */
1183 proc_flags (procinfo
*pi
)
1185 if (!pi
->status_valid
)
1186 if (!proc_get_status (pi
))
1187 return 0; /* FIXME: not a good failure value (but what is?) */
1191 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
1192 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
1193 The two sets of flags don't overlap. */
1194 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
1196 return pi
->prstatus
.pr_lwp
.pr_flags
;
1199 return pi
->prstatus
.pr_flags
;
1203 /* Returns the pr_why field (why the process stopped). */
1206 proc_why (procinfo
*pi
)
1208 if (!pi
->status_valid
)
1209 if (!proc_get_status (pi
))
1210 return 0; /* FIXME: not a good failure value (but what is?) */
1213 return pi
->prstatus
.pr_lwp
.pr_why
;
1215 return pi
->prstatus
.pr_why
;
1219 /* Returns the pr_what field (details of why the process stopped). */
1222 proc_what (procinfo
*pi
)
1224 if (!pi
->status_valid
)
1225 if (!proc_get_status (pi
))
1226 return 0; /* FIXME: not a good failure value (but what is?) */
1229 return pi
->prstatus
.pr_lwp
.pr_what
;
1231 return pi
->prstatus
.pr_what
;
1235 /* This function is only called when PI is stopped by a watchpoint.
1236 Assuming the OS supports it, write to *ADDR the data address which
1237 triggered it and return 1. Return 0 if it is not possible to know
1241 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
1243 if (!pi
->status_valid
)
1244 if (!proc_get_status (pi
))
1248 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch
,
1249 builtin_type (target_gdbarch
)->builtin_data_ptr
,
1250 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
1252 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch
,
1253 builtin_type (target_gdbarch
)->builtin_data_ptr
,
1254 (gdb_byte
*) &pi
->prstatus
.pr_info
.si_addr
);
1259 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1261 /* Returns the pr_nsysarg field (number of args to the current
1265 proc_nsysarg (procinfo
*pi
)
1267 if (!pi
->status_valid
)
1268 if (!proc_get_status (pi
))
1272 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1274 return pi
->prstatus
.pr_nsysarg
;
1278 /* Returns the pr_sysarg field (pointer to the arguments of current
1282 proc_sysargs (procinfo
*pi
)
1284 if (!pi
->status_valid
)
1285 if (!proc_get_status (pi
))
1289 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1291 return (long *) &pi
->prstatus
.pr_sysarg
;
1295 /* Returns the pr_syscall field (id of current syscall if we are in
1299 proc_syscall (procinfo
*pi
)
1301 if (!pi
->status_valid
)
1302 if (!proc_get_status (pi
))
1306 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1308 return pi
->prstatus
.pr_syscall
;
1311 #endif /* PIOCSSPCACT */
1313 /* Returns the pr_cursig field (current signal). */
1316 proc_cursig (struct procinfo
*pi
)
1318 if (!pi
->status_valid
)
1319 if (!proc_get_status (pi
))
1320 return 0; /* FIXME: not a good failure value (but what is?) */
1323 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1325 return pi
->prstatus
.pr_cursig
;
1329 /* === I appologize for the messiness of this function.
1330 === This is an area where the different versions of
1331 === /proc are more inconsistent than usual.
1333 Set or reset any of the following process flags:
1334 PR_FORK -- forked child will inherit trace flags
1335 PR_RLC -- traced process runs when last /proc file closed.
1336 PR_KLC -- traced process is killed when last /proc file closed.
1337 PR_ASYNC -- LWP's get to run/stop independently.
1339 There are three methods for doing this function:
1340 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1342 2) Middle: PIOCSET/PIOCRESET
1344 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1347 Note: Irix does not define PR_ASYNC.
1348 Note: OSF does not define PR_KLC.
1349 Note: OSF is the only one that can ONLY use the oldest method.
1353 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1354 mode -- 1 for set, 0 for reset.
1356 Returns non-zero for success, zero for failure. */
1358 enum { FLAG_RESET
, FLAG_SET
};
1361 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
1363 long win
= 0; /* default to fail */
1365 /* These operations affect the process as a whole, and applying them
1366 to an individual LWP has the same meaning as applying them to the
1367 main process. Therefore, if we're ever called with a pointer to
1368 an LWP's procinfo, let's substitute the process's procinfo and
1369 avoid opening the LWP's file descriptor unnecessarily. */
1372 pi
= find_procinfo_or_die (pi
->pid
, 0);
1374 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii. */
1375 /* First normalize the PCUNSET/PCRESET command opcode
1376 (which for no obvious reason has a different definition
1377 from one operating system to the next...) */
1379 #define GDBRESET PCUNSET
1382 #define GDBRESET PCRESET
1386 procfs_ctl_t arg
[2];
1388 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
1390 else /* Reset the flag. */
1394 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1397 #ifdef PIOCSET /* Irix/Sol5 method */
1398 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC). */
1400 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1402 else /* Reset the flag. */
1404 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1408 #ifdef PIOCSRLC /* Oldest method: OSF */
1411 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1413 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1415 else /* Clear run-on-last-close */
1417 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1421 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1423 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1425 else /* Clear inherit-on-fork */
1427 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1431 win
= 0; /* Fail -- unknown flag (can't do PR_ASYNC). */
1438 /* The above operation renders the procinfo's cached pstatus
1440 pi
->status_valid
= 0;
1443 warning (_("procfs: modify_flag failed to turn %s %s"),
1444 flag
== PR_FORK
? "PR_FORK" :
1445 flag
== PR_RLC
? "PR_RLC" :
1447 flag
== PR_ASYNC
? "PR_ASYNC" :
1450 flag
== PR_KLC
? "PR_KLC" :
1453 mode
== FLAG_RESET
? "off" : "on");
1458 /* Set the run_on_last_close flag. Process with all threads will
1459 become runnable when debugger closes all /proc fds. Returns
1460 non-zero for success, zero for failure. */
1463 proc_set_run_on_last_close (procinfo
*pi
)
1465 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1468 /* Reset the run_on_last_close flag. The process will NOT become
1469 runnable when debugger closes its file handles. Returns non-zero
1470 for success, zero for failure. */
1473 proc_unset_run_on_last_close (procinfo
*pi
)
1475 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1479 /* Set the kill_on_last_close flag. Process with all threads will be
1480 killed when debugger closes all /proc fds (or debugger exits or
1481 dies). Returns non-zero for success, zero for failure. */
1484 proc_set_kill_on_last_close (procinfo
*pi
)
1486 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1489 /* Reset the kill_on_last_close flag. Process will NOT be killed when
1490 debugger closes its file handles (or exits or dies). Returns
1491 non-zero for success, zero for failure. */
1494 proc_unset_kill_on_last_close (procinfo
*pi
)
1496 return proc_modify_flag (pi
, PR_KLC
, FLAG_RESET
);
1500 /* Set inherit_on_fork flag. If the process forks a child while we
1501 are registered for events in the parent, then we will also recieve
1502 events from the child. Returns non-zero for success, zero for
1506 proc_set_inherit_on_fork (procinfo
*pi
)
1508 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1511 /* Reset inherit_on_fork flag. If the process forks a child while we
1512 are registered for events in the parent, then we will NOT recieve
1513 events from the child. Returns non-zero for success, zero for
1517 proc_unset_inherit_on_fork (procinfo
*pi
)
1519 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1523 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
1524 (signal etc.), the remaining LWPs will continue to run. Returns
1525 non-zero for success, zero for failure. */
1528 proc_set_async (procinfo
*pi
)
1530 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1533 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
1534 (signal etc.), then all other LWPs will stop as well. Returns
1535 non-zero for success, zero for failure. */
1538 proc_unset_async (procinfo
*pi
)
1540 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1542 #endif /* PR_ASYNC */
1544 /* Request the process/LWP to stop. Does not wait. Returns non-zero
1545 for success, zero for failure. */
1548 proc_stop_process (procinfo
*pi
)
1552 /* We might conceivably apply this operation to an LWP, and the
1553 LWP's ctl file descriptor might not be open. */
1555 if (pi
->ctl_fd
== 0 &&
1556 open_procinfo_files (pi
, FD_CTL
) == 0)
1561 procfs_ctl_t cmd
= PCSTOP
;
1563 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1564 #else /* ioctl method */
1565 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1566 /* Note: the call also reads the prstatus. */
1569 pi
->status_valid
= 1;
1570 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1573 proc_get_current_thread (pi
));
1581 /* Wait for the process or LWP to stop (block until it does). Returns
1582 non-zero for success, zero for failure. */
1585 proc_wait_for_stop (procinfo
*pi
)
1589 /* We should never have to apply this operation to any procinfo
1590 except the one for the main process. If that ever changes for
1591 any reason, then take out the following clause and replace it
1592 with one that makes sure the ctl_fd is open. */
1595 pi
= find_procinfo_or_die (pi
->pid
, 0);
1599 procfs_ctl_t cmd
= PCWSTOP
;
1601 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1602 /* We been runnin' and we stopped -- need to update status. */
1603 pi
->status_valid
= 0;
1605 #else /* ioctl method */
1606 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1607 /* Above call also refreshes the prstatus. */
1610 pi
->status_valid
= 1;
1611 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1614 proc_get_current_thread (pi
));
1621 /* Make the process or LWP runnable.
1623 Options (not all are implemented):
1625 - clear current fault
1626 - clear current signal
1627 - abort the current system call
1628 - stop as soon as finished with system call
1629 - (ioctl): set traced signal set
1630 - (ioctl): set held signal set
1631 - (ioctl): set traced fault set
1632 - (ioctl): set start pc (vaddr)
1634 Always clears the current fault. PI is the process or LWP to
1635 operate on. If STEP is true, set the process or LWP to trap after
1636 one instruction. If SIGNO is zero, clear the current signal if
1637 any; if non-zero, set the current signal to this one. Returns
1638 non-zero for success, zero for failure. */
1641 proc_run_process (procinfo
*pi
, int step
, int signo
)
1646 /* We will probably have to apply this operation to individual
1647 threads, so make sure the control file descriptor is open. */
1649 if (pi
->ctl_fd
== 0 &&
1650 open_procinfo_files (pi
, FD_CTL
) == 0)
1655 runflags
= PRCFAULT
; /* Always clear current fault. */
1660 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
1661 proc_set_current_signal (pi
, signo
);
1665 procfs_ctl_t cmd
[2];
1669 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1671 #else /* ioctl method */
1675 memset (&prrun
, 0, sizeof (prrun
));
1676 prrun
.pr_flags
= runflags
;
1677 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1684 /* Register to trace signals in the process or LWP. Returns non-zero
1685 for success, zero for failure. */
1688 proc_set_traced_signals (procinfo
*pi
, gdb_sigset_t
*sigset
)
1692 /* We should never have to apply this operation to any procinfo
1693 except the one for the main process. If that ever changes for
1694 any reason, then take out the following clause and replace it
1695 with one that makes sure the ctl_fd is open. */
1698 pi
= find_procinfo_or_die (pi
->pid
, 0);
1704 /* Use char array to avoid alignment issues. */
1705 char sigset
[sizeof (gdb_sigset_t
)];
1709 memcpy (&arg
.sigset
, sigset
, sizeof (gdb_sigset_t
));
1711 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1713 #else /* ioctl method */
1714 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1716 /* The above operation renders the procinfo's cached pstatus obsolete. */
1717 pi
->status_valid
= 0;
1720 warning (_("procfs: set_traced_signals failed"));
1724 /* Register to trace hardware faults in the process or LWP. Returns
1725 non-zero for success, zero for failure. */
1728 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1732 /* We should never have to apply this operation to any procinfo
1733 except the one for the main process. If that ever changes for
1734 any reason, then take out the following clause and replace it
1735 with one that makes sure the ctl_fd is open. */
1738 pi
= find_procinfo_or_die (pi
->pid
, 0);
1744 /* Use char array to avoid alignment issues. */
1745 char fltset
[sizeof (fltset_t
)];
1749 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1751 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1753 #else /* ioctl method */
1754 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1756 /* The above operation renders the procinfo's cached pstatus obsolete. */
1757 pi
->status_valid
= 0;
1762 /* Register to trace entry to system calls in the process or LWP.
1763 Returns non-zero for success, zero for failure. */
1766 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1770 /* We should never have to apply this operation to any procinfo
1771 except the one for the main process. If that ever changes for
1772 any reason, then take out the following clause and replace it
1773 with one that makes sure the ctl_fd is open. */
1776 pi
= find_procinfo_or_die (pi
->pid
, 0);
1780 struct gdb_proc_ctl_pcsentry
{
1782 /* Use char array to avoid alignment issues. */
1783 char sysset
[sizeof (sysset_t
)];
1785 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
)
1787 + sysset_t_size (pi
);
1789 argp
= xmalloc (argp_size
);
1791 argp
->cmd
= PCSENTRY
;
1792 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1794 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1797 #else /* ioctl method */
1798 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1800 /* The above operation renders the procinfo's cached pstatus
1802 pi
->status_valid
= 0;
1807 /* Register to trace exit from system calls in the process or LWP.
1808 Returns non-zero for success, zero for failure. */
1811 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1815 /* We should never have to apply this operation to any procinfo
1816 except the one for the main process. If that ever changes for
1817 any reason, then take out the following clause and replace it
1818 with one that makes sure the ctl_fd is open. */
1821 pi
= find_procinfo_or_die (pi
->pid
, 0);
1825 struct gdb_proc_ctl_pcsexit
{
1827 /* Use char array to avoid alignment issues. */
1828 char sysset
[sizeof (sysset_t
)];
1830 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
)
1832 + sysset_t_size (pi
);
1834 argp
= xmalloc (argp_size
);
1836 argp
->cmd
= PCSEXIT
;
1837 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1839 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1842 #else /* ioctl method */
1843 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1845 /* The above operation renders the procinfo's cached pstatus
1847 pi
->status_valid
= 0;
1852 /* Specify the set of blocked / held signals in the process or LWP.
1853 Returns non-zero for success, zero for failure. */
1856 proc_set_held_signals (procinfo
*pi
, gdb_sigset_t
*sighold
)
1860 /* We should never have to apply this operation to any procinfo
1861 except the one for the main process. If that ever changes for
1862 any reason, then take out the following clause and replace it
1863 with one that makes sure the ctl_fd is open. */
1866 pi
= find_procinfo_or_die (pi
->pid
, 0);
1872 /* Use char array to avoid alignment issues. */
1873 char hold
[sizeof (gdb_sigset_t
)];
1877 memcpy (&arg
.hold
, sighold
, sizeof (gdb_sigset_t
));
1878 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1881 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1883 /* The above operation renders the procinfo's cached pstatus
1885 pi
->status_valid
= 0;
1890 /* Returns the set of signals that are pending in the process or LWP.
1891 Will also copy the sigset if SAVE is non-zero. */
1894 proc_get_pending_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1896 gdb_sigset_t
*ret
= NULL
;
1898 /* We should never have to apply this operation to any procinfo
1899 except the one for the main process. If that ever changes for
1900 any reason, then take out the following clause and replace it
1901 with one that makes sure the ctl_fd is open. */
1904 pi
= find_procinfo_or_die (pi
->pid
, 0);
1906 if (!pi
->status_valid
)
1907 if (!proc_get_status (pi
))
1911 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
1913 ret
= &pi
->prstatus
.pr_sigpend
;
1916 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1921 /* Returns the set of signal actions. Will also copy the sigactionset
1922 if SAVE is non-zero. */
1925 proc_get_signal_actions (procinfo
*pi
, gdb_sigaction_t
*save
)
1927 gdb_sigaction_t
*ret
= NULL
;
1929 /* We should never have to apply this operation to any procinfo
1930 except the one for the main process. If that ever changes for
1931 any reason, then take out the following clause and replace it
1932 with one that makes sure the ctl_fd is open. */
1935 pi
= find_procinfo_or_die (pi
->pid
, 0);
1937 if (!pi
->status_valid
)
1938 if (!proc_get_status (pi
))
1942 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
1944 ret
= &pi
->prstatus
.pr_action
;
1947 memcpy (save
, ret
, sizeof (gdb_sigaction_t
));
1952 /* Returns the set of signals that are held / blocked. Will also copy
1953 the sigset if SAVE is non-zero. */
1956 proc_get_held_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1958 gdb_sigset_t
*ret
= NULL
;
1960 /* We should never have to apply this operation to any procinfo
1961 except the one for the main process. If that ever changes for
1962 any reason, then take out the following clause and replace it
1963 with one that makes sure the ctl_fd is open. */
1966 pi
= find_procinfo_or_die (pi
->pid
, 0);
1969 if (!pi
->status_valid
)
1970 if (!proc_get_status (pi
))
1974 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1976 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1977 #endif /* UNIXWARE */
1978 #else /* not NEW_PROC_API */
1980 static gdb_sigset_t sigheld
;
1982 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1985 #endif /* NEW_PROC_API */
1987 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1992 /* Returns the set of signals that are traced / debugged. Will also
1993 copy the sigset if SAVE is non-zero. */
1996 proc_get_traced_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1998 gdb_sigset_t
*ret
= NULL
;
2000 /* We should never have to apply this operation to any procinfo
2001 except the one for the main process. If that ever changes for
2002 any reason, then take out the following clause and replace it
2003 with one that makes sure the ctl_fd is open. */
2006 pi
= find_procinfo_or_die (pi
->pid
, 0);
2009 if (!pi
->status_valid
)
2010 if (!proc_get_status (pi
))
2013 ret
= &pi
->prstatus
.pr_sigtrace
;
2016 static gdb_sigset_t sigtrace
;
2018 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
2023 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
2028 /* Add SIGNO to the set of signals that are traced. Returns non-zero
2029 for success, zero for failure. */
2032 proc_trace_signal (procinfo
*pi
, int signo
)
2036 /* We should never have to apply this operation to any procinfo
2037 except the one for the main process. If that ever changes for
2038 any reason, then take out the following clause and replace it
2039 with one that makes sure the ctl_fd is open. */
2042 pi
= find_procinfo_or_die (pi
->pid
, 0);
2046 if (proc_get_traced_signals (pi
, &temp
))
2048 gdb_praddset (&temp
, signo
);
2049 return proc_set_traced_signals (pi
, &temp
);
2053 return 0; /* failure */
2056 /* Remove SIGNO from the set of signals that are traced. Returns
2057 non-zero for success, zero for failure. */
2060 proc_ignore_signal (procinfo
*pi
, int signo
)
2064 /* We should never have to apply this operation to any procinfo
2065 except the one for the main process. If that ever changes for
2066 any reason, then take out the following clause and replace it
2067 with one that makes sure the ctl_fd is open. */
2070 pi
= find_procinfo_or_die (pi
->pid
, 0);
2074 if (proc_get_traced_signals (pi
, &temp
))
2076 gdb_prdelset (&temp
, signo
);
2077 return proc_set_traced_signals (pi
, &temp
);
2081 return 0; /* failure */
2084 /* Returns the set of hardware faults that are traced /debugged. Will
2085 also copy the faultset if SAVE is non-zero. */
2088 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
2090 fltset_t
*ret
= NULL
;
2092 /* We should never have to apply this operation to any procinfo
2093 except the one for the main process. If that ever changes for
2094 any reason, then take out the following clause and replace it
2095 with one that makes sure the ctl_fd is open. */
2098 pi
= find_procinfo_or_die (pi
->pid
, 0);
2101 if (!pi
->status_valid
)
2102 if (!proc_get_status (pi
))
2105 ret
= &pi
->prstatus
.pr_flttrace
;
2108 static fltset_t flttrace
;
2110 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
2115 memcpy (save
, ret
, sizeof (fltset_t
));
2120 /* Returns the set of syscalls that are traced /debugged on entry.
2121 Will also copy the syscall set if SAVE is non-zero. */
2124 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
2126 sysset_t
*ret
= NULL
;
2128 /* We should never have to apply this operation to any procinfo
2129 except the one for the main process. If that ever changes for
2130 any reason, then take out the following clause and replace it
2131 with one that makes sure the ctl_fd is open. */
2134 pi
= find_procinfo_or_die (pi
->pid
, 0);
2137 if (!pi
->status_valid
)
2138 if (!proc_get_status (pi
))
2141 #ifndef DYNAMIC_SYSCALLS
2142 ret
= &pi
->prstatus
.pr_sysentry
;
2143 #else /* DYNAMIC_SYSCALLS */
2145 static sysset_t
*sysentry
;
2149 sysentry
= sysset_t_alloc (pi
);
2151 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2153 if (pi
->prstatus
.pr_sysentry_offset
== 0)
2155 gdb_premptysysset (sysentry
);
2161 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysentry_offset
,
2163 != (off_t
) pi
->prstatus
.pr_sysentry_offset
)
2165 size
= sysset_t_size (pi
);
2166 gdb_premptysysset (sysentry
);
2167 rsize
= read (pi
->status_fd
, sysentry
, size
);
2172 #endif /* DYNAMIC_SYSCALLS */
2173 #else /* !NEW_PROC_API */
2175 static sysset_t sysentry
;
2177 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
2180 #endif /* NEW_PROC_API */
2182 memcpy (save
, ret
, sysset_t_size (pi
));
2187 /* Returns the set of syscalls that are traced /debugged on exit.
2188 Will also copy the syscall set if SAVE is non-zero. */
2191 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
2193 sysset_t
* ret
= NULL
;
2195 /* We should never have to apply this operation to any procinfo
2196 except the one for the main process. If that ever changes for
2197 any reason, then take out the following clause and replace it
2198 with one that makes sure the ctl_fd is open. */
2201 pi
= find_procinfo_or_die (pi
->pid
, 0);
2204 if (!pi
->status_valid
)
2205 if (!proc_get_status (pi
))
2208 #ifndef DYNAMIC_SYSCALLS
2209 ret
= &pi
->prstatus
.pr_sysexit
;
2210 #else /* DYNAMIC_SYSCALLS */
2212 static sysset_t
*sysexit
;
2216 sysexit
= sysset_t_alloc (pi
);
2218 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2220 if (pi
->prstatus
.pr_sysexit_offset
== 0)
2222 gdb_premptysysset (sysexit
);
2228 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysexit_offset
,
2230 != (off_t
) pi
->prstatus
.pr_sysexit_offset
)
2232 size
= sysset_t_size (pi
);
2233 gdb_premptysysset (sysexit
);
2234 rsize
= read (pi
->status_fd
, sysexit
, size
);
2239 #endif /* DYNAMIC_SYSCALLS */
2242 static sysset_t sysexit
;
2244 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2249 memcpy (save
, ret
, sysset_t_size (pi
));
2254 /* The current fault (if any) is cleared; the associated signal will
2255 not be sent to the process or LWP when it resumes. Returns
2256 non-zero for success, zero for failure. */
2259 proc_clear_current_fault (procinfo
*pi
)
2263 /* We should never have to apply this operation to any procinfo
2264 except the one for the main process. If that ever changes for
2265 any reason, then take out the following clause and replace it
2266 with one that makes sure the ctl_fd is open. */
2269 pi
= find_procinfo_or_die (pi
->pid
, 0);
2273 procfs_ctl_t cmd
= PCCFAULT
;
2275 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2278 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2284 /* Set the "current signal" that will be delivered next to the
2285 process. NOTE: semantics are different from those of KILL. This
2286 signal will be delivered to the process or LWP immediately when it
2287 is resumed (even if the signal is held/blocked); it will NOT
2288 immediately cause another event of interest, and will NOT first
2289 trap back to the debugger. Returns non-zero for success, zero for
2293 proc_set_current_signal (procinfo
*pi
, int signo
)
2298 /* Use char array to avoid alignment issues. */
2299 char sinfo
[sizeof (gdb_siginfo_t
)];
2301 gdb_siginfo_t mysinfo
;
2303 struct target_waitstatus wait_status
;
2305 /* We should never have to apply this operation to any procinfo
2306 except the one for the main process. If that ever changes for
2307 any reason, then take out the following clause and replace it
2308 with one that makes sure the ctl_fd is open. */
2311 pi
= find_procinfo_or_die (pi
->pid
, 0);
2313 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2314 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2315 receives a PIOCSSIG with a signal identical to the current
2316 signal, it messes up the current signal. Work around the kernel
2319 signo
== proc_cursig (pi
))
2320 return 1; /* I assume this is a success? */
2323 /* The pointer is just a type alias. */
2324 get_last_target_status (&wait_ptid
, &wait_status
);
2325 if (ptid_equal (wait_ptid
, inferior_ptid
)
2326 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
2327 && wait_status
.value
.sig
== target_signal_from_host (signo
)
2328 && proc_get_status (pi
)
2330 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
2332 && pi
->prstatus
.pr_info
.si_signo
== signo
2335 /* Use the siginfo associated with the signal being
2338 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (gdb_siginfo_t
));
2340 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_info
, sizeof (gdb_siginfo_t
));
2344 mysinfo
.si_signo
= signo
;
2345 mysinfo
.si_code
= 0;
2346 mysinfo
.si_pid
= getpid (); /* ?why? */
2347 mysinfo
.si_uid
= getuid (); /* ?why? */
2348 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2353 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2355 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2361 /* The current signal (if any) is cleared, and is not sent to the
2362 process or LWP when it resumes. Returns non-zero for success, zero
2366 proc_clear_current_signal (procinfo
*pi
)
2370 /* We should never have to apply this operation to any procinfo
2371 except the one for the main process. If that ever changes for
2372 any reason, then take out the following clause and replace it
2373 with one that makes sure the ctl_fd is open. */
2376 pi
= find_procinfo_or_die (pi
->pid
, 0);
2382 /* Use char array to avoid alignment issues. */
2383 char sinfo
[sizeof (gdb_siginfo_t
)];
2385 gdb_siginfo_t mysinfo
;
2388 /* The pointer is just a type alias. */
2389 mysinfo
.si_signo
= 0;
2390 mysinfo
.si_code
= 0;
2391 mysinfo
.si_errno
= 0;
2392 mysinfo
.si_pid
= getpid (); /* ?why? */
2393 mysinfo
.si_uid
= getuid (); /* ?why? */
2394 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2396 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2399 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2405 /* Return the general-purpose registers for the process or LWP
2406 corresponding to PI. Upon failure, return NULL. */
2409 proc_get_gregs (procinfo
*pi
)
2411 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2412 if (!proc_get_status (pi
))
2415 /* OK, sorry about the ifdef's. There's three cases instead of two,
2416 because in this case Unixware and Solaris/RW differ. */
2419 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2420 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2422 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2425 return &pi
->prstatus
.pr_reg
;
2429 /* Return the general-purpose registers for the process or LWP
2430 corresponding to PI. Upon failure, return NULL. */
2433 proc_get_fpregs (procinfo
*pi
)
2436 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2437 if (!proc_get_status (pi
))
2440 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2441 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2443 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2446 #else /* not NEW_PROC_API */
2447 if (pi
->fpregs_valid
)
2448 return &pi
->fpregset
; /* Already got 'em. */
2451 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2460 tid_t pr_error_thread
;
2461 tfpregset_t thread_1
;
2464 thread_fpregs
.pr_count
= 1;
2465 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2468 && ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2470 pi
->fpregs_valid
= 1;
2471 return &pi
->fpregset
; /* Got 'em now! */
2473 else if (pi
->tid
!= 0
2474 && ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2476 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2477 sizeof (pi
->fpregset
));
2478 pi
->fpregs_valid
= 1;
2479 return &pi
->fpregset
; /* Got 'em now! */
2486 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2488 pi
->fpregs_valid
= 1;
2489 return &pi
->fpregset
; /* Got 'em now! */
2498 #endif /* NEW_PROC_API */
2501 /* Write the general-purpose registers back to the process or LWP
2502 corresponding to PI. Return non-zero for success, zero for
2506 proc_set_gregs (procinfo
*pi
)
2508 gdb_gregset_t
*gregs
;
2511 gregs
= proc_get_gregs (pi
);
2513 return 0; /* proc_get_regs has already warned. */
2515 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2524 /* Use char array to avoid alignment issues. */
2525 char gregs
[sizeof (gdb_gregset_t
)];
2529 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2530 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2532 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2536 /* Policy: writing the registers invalidates our cache. */
2537 pi
->gregs_valid
= 0;
2541 /* Write the floating-pointer registers back to the process or LWP
2542 corresponding to PI. Return non-zero for success, zero for
2546 proc_set_fpregs (procinfo
*pi
)
2548 gdb_fpregset_t
*fpregs
;
2551 fpregs
= proc_get_fpregs (pi
);
2553 return 0; /* proc_get_fpregs has already warned. */
2555 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2564 /* Use char array to avoid alignment issues. */
2565 char fpregs
[sizeof (gdb_fpregset_t
)];
2569 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2570 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2574 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2579 tid_t pr_error_thread
;
2580 tfpregset_t thread_1
;
2583 thread_fpregs
.pr_count
= 1;
2584 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2585 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2587 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2590 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2592 #endif /* NEW_PROC_API */
2595 /* Policy: writing the registers invalidates our cache. */
2596 pi
->fpregs_valid
= 0;
2600 /* Send a signal to the proc or lwp with the semantics of "kill()".
2601 Returns non-zero for success, zero for failure. */
2604 proc_kill (procinfo
*pi
, int signo
)
2608 /* We might conceivably apply this operation to an LWP, and the
2609 LWP's ctl file descriptor might not be open. */
2611 if (pi
->ctl_fd
== 0 &&
2612 open_procinfo_files (pi
, FD_CTL
) == 0)
2619 procfs_ctl_t cmd
[2];
2623 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2624 #else /* ioctl method */
2625 /* FIXME: do I need the Alpha OSF fixups present in
2626 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2627 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2634 /* Find the pid of the process that started this one. Returns the
2635 parent process pid, or zero. */
2638 proc_parent_pid (procinfo
*pi
)
2640 /* We should never have to apply this operation to any procinfo
2641 except the one for the main process. If that ever changes for
2642 any reason, then take out the following clause and replace it
2643 with one that makes sure the ctl_fd is open. */
2646 pi
= find_procinfo_or_die (pi
->pid
, 0);
2648 if (!pi
->status_valid
)
2649 if (!proc_get_status (pi
))
2652 return pi
->prstatus
.pr_ppid
;
2655 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
2656 (a.k.a void pointer)! */
2658 #if (defined (PCWATCH) || defined (PIOCSWATCH)) \
2659 && !(defined (PIOCOPENLWP) || defined (UNIXWARE))
2661 procfs_address_to_host_pointer (CORE_ADDR addr
)
2663 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
2666 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
2667 gdbarch_address_to_pointer (target_gdbarch
, ptr_type
,
2668 (gdb_byte
*) &ptr
, addr
);
2674 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
2676 #if !defined (PCWATCH) && !defined (PIOCSWATCH)
2677 /* If neither or these is defined, we can't support watchpoints.
2678 This just avoids possibly failing to compile the below on such
2682 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5. */
2683 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out. */
2688 char watch
[sizeof (prwatch_t
)];
2692 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
2693 convert a target address into something that can be stored in a
2694 native data structure. */
2695 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
2696 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
2698 pwatch
.pr_vaddr
= (caddr_t
) procfs_address_to_host_pointer (addr
);
2700 pwatch
.pr_size
= len
;
2701 pwatch
.pr_wflags
= wflags
;
2702 #if defined(NEW_PROC_API) && defined (PCWATCH)
2704 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
2705 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2707 #if defined (PIOCSWATCH)
2708 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, &pwatch
) >= 0);
2710 return 0; /* Fail */
2717 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
2719 #include <sys/sysi86.h>
2721 /* The KEY is actually the value of the lower 16 bits of the GS
2722 register for the LWP that we're interested in. Returns the
2723 matching ssh struct (LDT entry). */
2726 proc_get_LDT_entry (procinfo
*pi
, int key
)
2728 static struct ssd
*ldt_entry
= NULL
;
2730 char pathname
[MAX_PROC_NAME_SIZE
];
2731 struct cleanup
*old_chain
= NULL
;
2734 /* Allocate space for one LDT entry.
2735 This alloc must persist, because we return a pointer to it. */
2736 if (ldt_entry
== NULL
)
2737 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2739 /* Open the file descriptor for the LDT table. */
2740 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2741 if ((fd
= open_with_retry (pathname
, O_RDONLY
)) < 0)
2743 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2746 /* Make sure it gets closed again! */
2747 old_chain
= make_cleanup_close (fd
);
2749 /* Now 'read' thru the table, find a match and return it. */
2750 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2752 if (ldt_entry
->sel
== 0 &&
2753 ldt_entry
->bo
== 0 &&
2754 ldt_entry
->acc1
== 0 &&
2755 ldt_entry
->acc2
== 0)
2756 break; /* end of table */
2757 /* If key matches, return this entry. */
2758 if (ldt_entry
->sel
== key
)
2761 /* Loop ended, match not found. */
2765 static int nalloc
= 0;
2767 /* Get the number of LDT entries. */
2768 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2770 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2774 /* Allocate space for the number of LDT entries. */
2775 /* This alloc has to persist, 'cause we return a pointer to it. */
2778 ldt_entry
= (struct ssd
*)
2779 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2783 /* Read the whole table in one gulp. */
2784 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2786 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2790 /* Search the table and return the (first) entry matching 'key'. */
2791 for (i
= 0; i
< nldt
; i
++)
2792 if (ldt_entry
[i
].sel
== key
)
2793 return &ldt_entry
[i
];
2795 /* Loop ended, match not found. */
2800 /* Returns the pointer to the LDT entry of PTID. */
2803 procfs_find_LDT_entry (ptid_t ptid
)
2805 gdb_gregset_t
*gregs
;
2809 /* Find procinfo for the lwp. */
2810 if ((pi
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
))) == NULL
)
2812 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
2813 PIDGET (ptid
), TIDGET (ptid
));
2816 /* get its general registers. */
2817 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2819 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
2820 PIDGET (ptid
), TIDGET (ptid
));
2823 /* Now extract the GS register's lower 16 bits. */
2824 key
= (*gregs
)[GS
] & 0xffff;
2826 /* Find the matching entry and return it. */
2827 return proc_get_LDT_entry (pi
, key
);
2832 /* =============== END, non-thread part of /proc "MODULE" =============== */
2834 /* =================== Thread "MODULE" =================== */
2836 /* NOTE: you'll see more ifdefs and duplication of functions here,
2837 since there is a different way to do threads on every OS. */
2839 /* Returns the number of threads for the process. */
2841 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2844 proc_get_nthreads (procinfo
*pi
)
2848 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2849 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2855 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2856 /* Solaris and Unixware version */
2858 proc_get_nthreads (procinfo
*pi
)
2860 if (!pi
->status_valid
)
2861 if (!proc_get_status (pi
))
2864 /* NEW_PROC_API: only works for the process procinfo, because the
2865 LWP procinfos do not get prstatus filled in. */
2867 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
2868 pi
= find_procinfo_or_die (pi
->pid
, 0);
2870 return pi
->prstatus
.pr_nlwp
;
2874 /* Default version */
2876 proc_get_nthreads (procinfo
*pi
)
2885 Return the ID of the thread that had an event of interest.
2886 (ie. the one that hit a breakpoint or other traced event). All
2887 other things being equal, this should be the ID of a thread that is
2888 currently executing. */
2890 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2891 /* Solaris and Unixware version */
2893 proc_get_current_thread (procinfo
*pi
)
2895 /* Note: this should be applied to the root procinfo for the
2896 process, not to the procinfo for an LWP. If applied to the
2897 procinfo for an LWP, it will simply return that LWP's ID. In
2898 that case, find the parent process procinfo. */
2901 pi
= find_procinfo_or_die (pi
->pid
, 0);
2903 if (!pi
->status_valid
)
2904 if (!proc_get_status (pi
))
2908 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2910 return pi
->prstatus
.pr_who
;
2915 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2918 proc_get_current_thread (procinfo
*pi
)
2920 #if 0 /* FIXME: not ready for prime time? */
2921 return pi
->prstatus
.pr_tid
;
2928 /* Default version */
2930 proc_get_current_thread (procinfo
*pi
)
2938 /* Discover the IDs of all the threads within the process, and create
2939 a procinfo for each of them (chained to the parent). This
2940 unfortunately requires a different method on every OS. Returns
2941 non-zero for success, zero for failure. */
2944 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
2946 if (thread
&& parent
) /* sanity */
2948 thread
->status_valid
= 0;
2949 if (!proc_get_status (thread
))
2950 destroy_one_procinfo (&parent
->thread_list
, thread
);
2952 return 0; /* keep iterating */
2955 #if defined (PIOCLSTATUS)
2956 /* Solaris 2.5 (ioctl) version */
2958 proc_update_threads (procinfo
*pi
)
2960 gdb_prstatus_t
*prstatus
;
2961 struct cleanup
*old_chain
= NULL
;
2965 /* We should never have to apply this operation to any procinfo
2966 except the one for the main process. If that ever changes for
2967 any reason, then take out the following clause and replace it
2968 with one that makes sure the ctl_fd is open. */
2971 pi
= find_procinfo_or_die (pi
->pid
, 0);
2973 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2975 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2976 return 1; /* Process is not multi-threaded; nothing to do. */
2978 prstatus
= xmalloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1));
2980 old_chain
= make_cleanup (xfree
, prstatus
);
2981 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2982 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2984 /* Skip element zero, which represents the process as a whole. */
2985 for (i
= 1; i
< nlwp
+ 1; i
++)
2987 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
2988 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2990 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
2991 thread
->status_valid
= 1;
2993 pi
->threads_valid
= 1;
2994 do_cleanups (old_chain
);
2999 /* Unixware and Solaris 6 (and later) version. */
3001 do_closedir_cleanup (void *dir
)
3007 proc_update_threads (procinfo
*pi
)
3009 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3010 struct dirent
*direntry
;
3011 struct cleanup
*old_chain
= NULL
;
3016 /* We should never have to apply this operation to any procinfo
3017 except the one for the main process. If that ever changes for
3018 any reason, then take out the following clause and replace it
3019 with one that makes sure the ctl_fd is open. */
3022 pi
= find_procinfo_or_die (pi
->pid
, 0);
3024 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3028 Note: this brute-force method is the only way I know of to
3029 accomplish this task on Unixware. This method will also work on
3030 Solaris 2.6 and 2.7. There is a much simpler and more elegant
3031 way to do this on Solaris, but the margins of this manuscript are
3032 too small to write it here... ;-) */
3034 strcpy (pathname
, pi
->pathname
);
3035 strcat (pathname
, "/lwp");
3036 if ((dirp
= opendir (pathname
)) == NULL
)
3037 proc_error (pi
, "update_threads, opendir", __LINE__
);
3039 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
3040 while ((direntry
= readdir (dirp
)) != NULL
)
3041 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3043 lwpid
= atoi (&direntry
->d_name
[0]);
3044 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3045 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3047 pi
->threads_valid
= 1;
3048 do_cleanups (old_chain
);
3055 proc_update_threads (procinfo
*pi
)
3060 /* We should never have to apply this operation to any procinfo
3061 except the one for the main process. If that ever changes for
3062 any reason, then take out the following clause and replace it
3063 with one that makes sure the ctl_fd is open. */
3066 pi
= find_procinfo_or_die (pi
->pid
, 0);
3068 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3070 nthreads
= proc_get_nthreads (pi
);
3072 return 0; /* Nothing to do for 1 or fewer threads. */
3074 threads
= xmalloc (nthreads
* sizeof (tid_t
));
3076 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3077 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3079 for (i
= 0; i
< nthreads
; i
++)
3081 if (!find_procinfo (pi
->pid
, threads
[i
]))
3082 if (!create_procinfo (pi
->pid
, threads
[i
]))
3083 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3085 pi
->threads_valid
= 1;
3089 /* Default version */
3091 proc_update_threads (procinfo
*pi
)
3095 #endif /* OSF PIOCTLIST */
3096 #endif /* NEW_PROC_API */
3097 #endif /* SOL 2.5 PIOCLSTATUS */
3099 /* Given a pointer to a function, call that function once for each lwp
3100 in the procinfo list, until the function returns non-zero, in which
3101 event return the value returned by the function.
3103 Note: this function does NOT call update_threads. If you want to
3104 discover new threads first, you must call that function explicitly.
3105 This function just makes a quick pass over the currently-known
3108 PI is the parent process procinfo. FUNC is the per-thread
3109 function. PTR is an opaque parameter for function. Returns the
3110 first non-zero return value from the callee, or zero. */
3113 proc_iterate_over_threads (procinfo
*pi
,
3114 int (*func
) (procinfo
*, procinfo
*, void *),
3117 procinfo
*thread
, *next
;
3120 /* We should never have to apply this operation to any procinfo
3121 except the one for the main process. If that ever changes for
3122 any reason, then take out the following clause and replace it
3123 with one that makes sure the ctl_fd is open. */
3126 pi
= find_procinfo_or_die (pi
->pid
, 0);
3128 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3130 next
= thread
->next
; /* In case thread is destroyed. */
3131 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3138 /* =================== END, Thread "MODULE" =================== */
3140 /* =================== END, /proc "MODULE" =================== */
3142 /* =================== GDB "MODULE" =================== */
3144 /* Here are all of the gdb target vector functions and their
3147 static ptid_t
do_attach (ptid_t ptid
);
3148 static void do_detach (int signo
);
3149 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
3150 int entry_or_exit
, int mode
, int from_tty
);
3152 /* On mips-irix, we need to insert a breakpoint at __dbx_link during
3153 the startup phase. The following two variables are used to record
3154 the address of the breakpoint, and the code that was replaced by
3156 static int dbx_link_bpt_addr
= 0;
3157 static void *dbx_link_bpt
;
3159 /* Sets up the inferior to be debugged. Registers to trace signals,
3160 hardware faults, and syscalls. Note: does not set RLC flag: caller
3161 may want to customize that. Returns zero for success (note!
3162 unlike most functions in this module); on failure, returns the LINE
3163 NUMBER where it failed! */
3166 procfs_debug_inferior (procinfo
*pi
)
3168 fltset_t traced_faults
;
3169 gdb_sigset_t traced_signals
;
3170 sysset_t
*traced_syscall_entries
;
3171 sysset_t
*traced_syscall_exits
;
3174 #ifdef PROCFS_DONT_TRACE_FAULTS
3175 /* On some systems (OSF), we don't trace hardware faults.
3176 Apparently it's enough that we catch them as signals.
3177 Wonder why we don't just do that in general? */
3178 premptyset (&traced_faults
); /* don't trace faults. */
3180 /* Register to trace hardware faults in the child. */
3181 prfillset (&traced_faults
); /* trace all faults... */
3182 gdb_prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3184 if (!proc_set_traced_faults (pi
, &traced_faults
))
3187 /* Initially, register to trace all signals in the child. */
3188 prfillset (&traced_signals
);
3189 if (!proc_set_traced_signals (pi
, &traced_signals
))
3193 /* Register to trace the 'exit' system call (on entry). */
3194 traced_syscall_entries
= sysset_t_alloc (pi
);
3195 gdb_premptysysset (traced_syscall_entries
);
3197 gdb_praddsysset (traced_syscall_entries
, SYS_exit
);
3200 gdb_praddsysset (traced_syscall_entries
, SYS_lwpexit
);/* And _lwp_exit... */
3203 gdb_praddsysset (traced_syscall_entries
, SYS_lwp_exit
);
3205 #ifdef DYNAMIC_SYSCALLS
3207 int callnum
= find_syscall (pi
, "_exit");
3210 gdb_praddsysset (traced_syscall_entries
, callnum
);
3214 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
3215 xfree (traced_syscall_entries
);
3219 #ifdef PRFS_STOPEXEC /* defined on OSF */
3220 /* OSF method for tracing exec syscalls. Quoting:
3221 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3222 exits from exec system calls because of the user level loader. */
3223 /* FIXME: make nice and maybe move into an access function. */
3227 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3230 prfs_flags
|= PRFS_STOPEXEC
;
3232 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3235 #else /* not PRFS_STOPEXEC */
3236 /* Everyone else's (except OSF) method for tracing exec syscalls. */
3238 Not all systems with /proc have all the exec* syscalls with the same
3239 names. On the SGI, for example, there is no SYS_exec, but there
3240 *is* a SYS_execv. So, we try to account for that. */
3242 traced_syscall_exits
= sysset_t_alloc (pi
);
3243 gdb_premptysysset (traced_syscall_exits
);
3245 gdb_praddsysset (traced_syscall_exits
, SYS_exec
);
3248 gdb_praddsysset (traced_syscall_exits
, SYS_execve
);
3251 gdb_praddsysset (traced_syscall_exits
, SYS_execv
);
3254 #ifdef SYS_lwpcreate
3255 gdb_praddsysset (traced_syscall_exits
, SYS_lwpcreate
);
3256 gdb_praddsysset (traced_syscall_exits
, SYS_lwpexit
);
3259 #ifdef SYS_lwp_create /* FIXME: once only, please. */
3260 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_create
);
3261 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_exit
);
3264 #ifdef DYNAMIC_SYSCALLS
3266 int callnum
= find_syscall (pi
, "execve");
3269 gdb_praddsysset (traced_syscall_exits
, callnum
);
3270 callnum
= find_syscall (pi
, "ra_execve");
3272 gdb_praddsysset (traced_syscall_exits
, callnum
);
3276 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
3277 xfree (traced_syscall_exits
);
3281 #endif /* PRFS_STOPEXEC */
3286 procfs_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3291 pid
= parse_pid_to_attach (args
);
3293 if (pid
== getpid ())
3294 error (_("Attaching GDB to itself is not a good idea..."));
3298 exec_file
= get_exec_file (0);
3301 printf_filtered (_("Attaching to program `%s', %s\n"),
3302 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
3304 printf_filtered (_("Attaching to %s\n"),
3305 target_pid_to_str (pid_to_ptid (pid
)));
3309 inferior_ptid
= do_attach (pid_to_ptid (pid
));
3314 procfs_detach (struct target_ops
*ops
, char *args
, int from_tty
)
3317 int pid
= PIDGET (inferior_ptid
);
3326 exec_file
= get_exec_file (0);
3327 if (exec_file
== NULL
)
3330 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
3331 target_pid_to_str (pid_to_ptid (pid
)));
3332 gdb_flush (gdb_stdout
);
3337 inferior_ptid
= null_ptid
;
3338 detach_inferior (pid
);
3339 unpush_target (ops
);
3343 do_attach (ptid_t ptid
)
3346 struct inferior
*inf
;
3350 if ((pi
= create_procinfo (PIDGET (ptid
), 0)) == NULL
)
3351 perror (_("procfs: out of memory in 'attach'"));
3353 if (!open_procinfo_files (pi
, FD_CTL
))
3355 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3356 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3358 dead_procinfo (pi
, errmsg
, NOKILL
);
3361 /* Stop the process (if it isn't already stopped). */
3362 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3364 pi
->was_stopped
= 1;
3365 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3369 pi
->was_stopped
= 0;
3370 /* Set the process to run again when we close it. */
3371 if (!proc_set_run_on_last_close (pi
))
3372 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3374 /* Now stop the process. */
3375 if (!proc_stop_process (pi
))
3376 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3377 pi
->ignore_next_sigstop
= 1;
3379 /* Save some of the /proc state to be restored if we detach. */
3380 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3381 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3382 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3383 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3384 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
3385 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3387 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
3388 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3390 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3391 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3393 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3394 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3396 inf
= current_inferior ();
3397 inferior_appeared (inf
, pi
->pid
);
3398 /* Let GDB know that the inferior was attached. */
3399 inf
->attach_flag
= 1;
3401 /* Create a procinfo for the current lwp. */
3402 lwpid
= proc_get_current_thread (pi
);
3403 create_procinfo (pi
->pid
, lwpid
);
3405 /* Add it to gdb's thread list. */
3406 ptid
= MERGEPID (pi
->pid
, lwpid
);
3413 do_detach (int signo
)
3417 /* Find procinfo for the main process. */
3418 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0); /* FIXME: threads */
3420 if (!proc_set_current_signal (pi
, signo
))
3421 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3423 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3424 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3426 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3427 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3429 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
3430 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3432 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
3433 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3435 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3436 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3438 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3439 if (signo
|| !(pi
->was_stopped
) ||
3440 query (_("Was stopped when attached, make it runnable again? ")))
3442 /* Clear any pending signal. */
3443 if (!proc_clear_current_fault (pi
))
3444 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3446 if (signo
== 0 && !proc_clear_current_signal (pi
))
3447 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
3449 if (!proc_set_run_on_last_close (pi
))
3450 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3453 destroy_procinfo (pi
);
3456 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
3459 ??? Is the following note still relevant? We can't get individual
3460 registers with the PT_GETREGS ptrace(2) request either, yet we
3461 don't bother with caching at all in that case.
3463 NOTE: Since the /proc interface cannot give us individual
3464 registers, we pay no attention to REGNUM, and just fetch them all.
3465 This results in the possibility that we will do unnecessarily many
3466 fetches, since we may be called repeatedly for individual
3467 registers. So we cache the results, and mark the cache invalid
3468 when the process is resumed. */
3471 procfs_fetch_registers (struct target_ops
*ops
,
3472 struct regcache
*regcache
, int regnum
)
3474 gdb_gregset_t
*gregs
;
3476 int pid
= PIDGET (inferior_ptid
);
3477 int tid
= TIDGET (inferior_ptid
);
3478 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3480 pi
= find_procinfo_or_die (pid
, tid
);
3483 error (_("procfs: fetch_registers failed to find procinfo for %s"),
3484 target_pid_to_str (inferior_ptid
));
3486 gregs
= proc_get_gregs (pi
);
3488 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3490 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
3492 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3494 gdb_fpregset_t
*fpregs
;
3496 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3497 || regnum
== gdbarch_pc_regnum (gdbarch
)
3498 || regnum
== gdbarch_sp_regnum (gdbarch
))
3499 return; /* Not a floating point register. */
3501 fpregs
= proc_get_fpregs (pi
);
3503 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3505 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
3509 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
3510 this for all registers.
3512 NOTE: Since the /proc interface will not read individual registers,
3513 we will cache these requests until the process is resumed, and only
3514 then write them back to the inferior process.
3516 FIXME: is that a really bad idea? Have to think about cases where
3517 writing one register might affect the value of others, etc. */
3520 procfs_store_registers (struct target_ops
*ops
,
3521 struct regcache
*regcache
, int regnum
)
3523 gdb_gregset_t
*gregs
;
3525 int pid
= PIDGET (inferior_ptid
);
3526 int tid
= TIDGET (inferior_ptid
);
3527 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3529 pi
= find_procinfo_or_die (pid
, tid
);
3532 error (_("procfs: store_registers: failed to find procinfo for %s"),
3533 target_pid_to_str (inferior_ptid
));
3535 gregs
= proc_get_gregs (pi
);
3537 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3539 fill_gregset (regcache
, gregs
, regnum
);
3540 if (!proc_set_gregs (pi
))
3541 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3543 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3545 gdb_fpregset_t
*fpregs
;
3547 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3548 || regnum
== gdbarch_pc_regnum (gdbarch
)
3549 || regnum
== gdbarch_sp_regnum (gdbarch
))
3550 return; /* Not a floating point register. */
3552 fpregs
= proc_get_fpregs (pi
);
3554 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3556 fill_fpregset (regcache
, fpregs
, regnum
);
3557 if (!proc_set_fpregs (pi
))
3558 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3563 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
3566 if (scall
== SYS_lwp_exit
)
3570 if (scall
== SYS_lwpexit
)
3577 syscall_is_exit (procinfo
*pi
, int scall
)
3580 if (scall
== SYS_exit
)
3583 #ifdef DYNAMIC_SYSCALLS
3584 if (find_syscall (pi
, "_exit") == scall
)
3591 syscall_is_exec (procinfo
*pi
, int scall
)
3594 if (scall
== SYS_exec
)
3598 if (scall
== SYS_execv
)
3602 if (scall
== SYS_execve
)
3605 #ifdef DYNAMIC_SYSCALLS
3606 if (find_syscall (pi
, "_execve"))
3608 if (find_syscall (pi
, "ra_execve"))
3615 syscall_is_lwp_create (procinfo
*pi
, int scall
)
3617 #ifdef SYS_lwp_create
3618 if (scall
== SYS_lwp_create
)
3621 #ifdef SYS_lwpcreate
3622 if (scall
== SYS_lwpcreate
)
3628 /* Remove the breakpoint that we inserted in __dbx_link().
3629 Does nothing if the breakpoint hasn't been inserted or has already
3633 remove_dbx_link_breakpoint (void)
3635 if (dbx_link_bpt_addr
== 0)
3638 if (deprecated_remove_raw_breakpoint (target_gdbarch
, dbx_link_bpt
) != 0)
3639 warning (_("Unable to remove __dbx_link breakpoint."));
3641 dbx_link_bpt_addr
= 0;
3642 dbx_link_bpt
= NULL
;
3646 /* Return the address of the __dbx_link() function in the file
3647 refernced by ABFD by scanning its symbol table. Return 0 if
3648 the symbol was not found. */
3651 dbx_link_addr (bfd
*abfd
)
3653 long storage_needed
;
3654 asymbol
**symbol_table
;
3655 long number_of_symbols
;
3658 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
3659 if (storage_needed
<= 0)
3662 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
3663 make_cleanup (xfree
, symbol_table
);
3665 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
3667 for (i
= 0; i
< number_of_symbols
; i
++)
3669 asymbol
*sym
= symbol_table
[i
];
3671 if ((sym
->flags
& BSF_GLOBAL
)
3672 && sym
->name
!= NULL
&& strcmp (sym
->name
, "__dbx_link") == 0)
3673 return (sym
->value
+ sym
->section
->vma
);
3676 /* Symbol not found, return NULL. */
3680 /* Search the symbol table of the file referenced by FD for a symbol
3681 named __dbx_link(). If found, then insert a breakpoint at this location,
3682 and return nonzero. Return zero otherwise. */
3685 insert_dbx_link_bpt_in_file (int fd
, CORE_ADDR ignored
)
3688 long storage_needed
;
3691 abfd
= bfd_fdopenr ("unamed", 0, fd
);
3694 warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
3698 if (!bfd_check_format (abfd
, bfd_object
))
3700 /* Not the correct format, so we can not possibly find the dbx_link
3706 sym_addr
= dbx_link_addr (abfd
);
3709 /* Insert the breakpoint. */
3710 dbx_link_bpt_addr
= sym_addr
;
3711 dbx_link_bpt
= deprecated_insert_raw_breakpoint (target_gdbarch
, NULL
,
3713 if (dbx_link_bpt
== NULL
)
3715 warning (_("Failed to insert dbx_link breakpoint."));
3727 /* Calls the supplied callback function once for each mapped address
3728 space in the process. The callback function receives an open file
3729 descriptor for the file corresponding to that mapped address space
3730 (if there is one), and the base address of the mapped space. Quit
3731 when the callback function returns a nonzero value, or at teh end
3732 of the mappings. Returns the first non-zero return value of the
3733 callback function, or zero. */
3736 solib_mappings_callback (struct prmap
*map
, int (*func
) (int, CORE_ADDR
),
3739 procinfo
*pi
= data
;
3743 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
3745 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
3746 return -1; /* sanity */
3748 if (map
->pr_mapname
[0] == 0)
3750 fd
= -1; /* no map file */
3754 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
3755 /* Note: caller's responsibility to close this fd! */
3756 fd
= open_with_retry (name
, O_RDONLY
);
3757 /* Note: we don't test the above call for failure;
3758 we just pass the FD on as given. Sometimes there is
3759 no file, so the open may return failure, but that's
3763 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
->pr_vaddr
);
3764 /* Note: we don't test the above call for failure;
3765 we just pass the FD on as given. Sometimes there is
3766 no file, so the ioctl may return failure, but that's
3769 return (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
);
3772 /* If the given memory region MAP contains a symbol named __dbx_link,
3773 insert a breakpoint at this location and return nonzero. Return
3777 insert_dbx_link_bpt_in_region (struct prmap
*map
,
3778 find_memory_region_ftype child_func
,
3781 procinfo
*pi
= (procinfo
*) data
;
3783 /* We know the symbol we're looking for is in a text region, so
3784 only look for it if the region is a text one. */
3785 if (map
->pr_mflags
& MA_EXEC
)
3786 return solib_mappings_callback (map
, insert_dbx_link_bpt_in_file
, pi
);
3791 /* Search all memory regions for a symbol named __dbx_link. If found,
3792 insert a breakpoint at its location, and return nonzero. Return zero
3796 insert_dbx_link_breakpoint (procinfo
*pi
)
3798 return iterate_over_mappings (pi
, NULL
, pi
, insert_dbx_link_bpt_in_region
);
3802 /* Retrieve the next stop event from the child process. If child has
3803 not stopped yet, wait for it to stop. Translate /proc eventcodes
3804 (or possibly wait eventcodes) into gdb internal event codes.
3805 Returns the id of process (and possibly thread) that incurred the
3806 event. Event codes are returned through a pointer parameter. */
3809 procfs_wait (struct target_ops
*ops
,
3810 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
3812 /* First cut: loosely based on original version 2.1. */
3816 ptid_t retval
, temp_ptid
;
3817 int why
, what
, flags
;
3824 retval
= pid_to_ptid (-1);
3826 /* Find procinfo for main process. */
3827 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
3830 /* We must assume that the status is stale now... */
3831 pi
->status_valid
= 0;
3832 pi
->gregs_valid
= 0;
3833 pi
->fpregs_valid
= 0;
3835 #if 0 /* just try this out... */
3836 flags
= proc_flags (pi
);
3837 why
= proc_why (pi
);
3838 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3839 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3841 /* If child is not stopped, wait for it to stop. */
3842 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3843 !proc_wait_for_stop (pi
))
3845 /* wait_for_stop failed: has the child terminated? */
3846 if (errno
== ENOENT
)
3850 /* /proc file not found; presumably child has terminated. */
3851 wait_retval
= wait (&wstat
); /* "wait" for the child's exit. */
3853 if (wait_retval
!= PIDGET (inferior_ptid
)) /* wrong child? */
3854 error (_("procfs: couldn't stop "
3855 "process %d: wait returned %d."),
3856 PIDGET (inferior_ptid
), wait_retval
);
3857 /* FIXME: might I not just use waitpid?
3858 Or try find_procinfo to see if I know about this child? */
3859 retval
= pid_to_ptid (wait_retval
);
3861 else if (errno
== EINTR
)
3865 /* Unknown error from wait_for_stop. */
3866 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3871 /* This long block is reached if either:
3872 a) the child was already stopped, or
3873 b) we successfully waited for the child with wait_for_stop.
3874 This block will analyze the /proc status, and translate it
3875 into a waitstatus for GDB.
3877 If we actually had to call wait because the /proc file
3878 is gone (child terminated), then we skip this block,
3879 because we already have a waitstatus. */
3881 flags
= proc_flags (pi
);
3882 why
= proc_why (pi
);
3883 what
= proc_what (pi
);
3885 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3888 /* If it's running async (for single_thread control),
3889 set it back to normal again. */
3890 if (flags
& PR_ASYNC
)
3891 if (!proc_unset_async (pi
))
3892 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3896 proc_prettyprint_why (why
, what
, 1);
3898 /* The 'pid' we will return to GDB is composed of
3899 the process ID plus the lwp ID. */
3900 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3904 wstat
= (what
<< 8) | 0177;
3907 if (syscall_is_lwp_exit (pi
, what
))
3909 if (print_thread_events
)
3910 printf_unfiltered (_("[%s exited]\n"),
3911 target_pid_to_str (retval
));
3912 delete_thread (retval
);
3913 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3916 else if (syscall_is_exit (pi
, what
))
3918 struct inferior
*inf
;
3920 /* Handle SYS_exit call only. */
3921 /* Stopped at entry to SYS_exit.
3922 Make it runnable, resume it, then use
3923 the wait system call to get its exit code.
3924 Proc_run_process always clears the current
3926 Then return its exit status. */
3927 pi
->status_valid
= 0;
3929 /* FIXME: what we should do is return
3930 TARGET_WAITKIND_SPURIOUS. */
3931 if (!proc_run_process (pi
, 0, 0))
3932 proc_error (pi
, "target_wait, run_process", __LINE__
);
3934 inf
= find_inferior_pid (pi
->pid
);
3935 if (inf
->attach_flag
)
3937 /* Don't call wait: simulate waiting for exit,
3938 return a "success" exit code. Bogus: what if
3939 it returns something else? */
3941 retval
= inferior_ptid
; /* ? ? ? */
3945 int temp
= wait (&wstat
);
3947 /* FIXME: shouldn't I make sure I get the right
3948 event from the right process? If (for
3949 instance) I have killed an earlier inferior
3950 process but failed to clean up after it
3951 somehow, I could get its termination event
3954 /* If wait returns -1, that's what we return
3957 retval
= pid_to_ptid (temp
);
3962 printf_filtered (_("procfs: trapped on entry to "));
3963 proc_prettyprint_syscall (proc_what (pi
), 0);
3964 printf_filtered ("\n");
3967 long i
, nsysargs
, *sysargs
;
3969 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3970 (sysargs
= proc_sysargs (pi
)) != NULL
)
3972 printf_filtered (_("%ld syscall arguments:\n"),
3974 for (i
= 0; i
< nsysargs
; i
++)
3975 printf_filtered ("#%ld: 0x%08lx\n",
3983 /* How to exit gracefully, returning "unknown
3985 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3986 return inferior_ptid
;
3990 /* How to keep going without returning to wfi: */
3991 target_resume (ptid
, 0, TARGET_SIGNAL_0
);
3997 if (syscall_is_exec (pi
, what
))
3999 /* Hopefully this is our own "fork-child" execing
4000 the real child. Hoax this event into a trap, and
4001 GDB will see the child about to execute its start
4003 wstat
= (SIGTRAP
<< 8) | 0177;
4006 else if (what
== SYS_syssgi
)
4008 /* see if we can break on dbx_link(). If yes, then
4009 we no longer need the SYS_syssgi notifications. */
4010 if (insert_dbx_link_breakpoint (pi
))
4011 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
,
4014 /* This is an internal event and should be transparent
4015 to wfi, so resume the execution and wait again. See
4016 comment in procfs_init_inferior() for more details. */
4017 target_resume (ptid
, 0, TARGET_SIGNAL_0
);
4021 else if (syscall_is_lwp_create (pi
, what
))
4023 /* This syscall is somewhat like fork/exec. We
4024 will get the event twice: once for the parent
4025 LWP, and once for the child. We should already
4026 know about the parent LWP, but the child will
4027 be new to us. So, whenever we get this event,
4028 if it represents a new thread, simply add the
4029 thread to the list. */
4031 /* If not in procinfo list, add it. */
4032 temp_tid
= proc_get_current_thread (pi
);
4033 if (!find_procinfo (pi
->pid
, temp_tid
))
4034 create_procinfo (pi
->pid
, temp_tid
);
4036 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
4037 /* If not in GDB's thread list, add it. */
4038 if (!in_thread_list (temp_ptid
))
4039 add_thread (temp_ptid
);
4041 /* Return to WFI, but tell it to immediately resume. */
4042 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4043 return inferior_ptid
;
4045 else if (syscall_is_lwp_exit (pi
, what
))
4047 if (print_thread_events
)
4048 printf_unfiltered (_("[%s exited]\n"),
4049 target_pid_to_str (retval
));
4050 delete_thread (retval
);
4051 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4056 /* FIXME: Do we need to handle SYS_sproc,
4057 SYS_fork, or SYS_vfork here? The old procfs
4058 seemed to use this event to handle threads on
4059 older (non-LWP) systems, where I'm assuming
4060 that threads were actually separate processes.
4061 Irix, maybe? Anyway, low priority for now. */
4065 printf_filtered (_("procfs: trapped on exit from "));
4066 proc_prettyprint_syscall (proc_what (pi
), 0);
4067 printf_filtered ("\n");
4070 long i
, nsysargs
, *sysargs
;
4072 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
4073 (sysargs
= proc_sysargs (pi
)) != NULL
)
4075 printf_filtered (_("%ld syscall arguments:\n"),
4077 for (i
= 0; i
< nsysargs
; i
++)
4078 printf_filtered ("#%ld: 0x%08lx\n",
4083 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4084 return inferior_ptid
;
4089 wstat
= (SIGSTOP
<< 8) | 0177;
4094 printf_filtered (_("Retry #%d:\n"), retry
);
4095 pi
->status_valid
= 0;
4100 /* If not in procinfo list, add it. */
4101 temp_tid
= proc_get_current_thread (pi
);
4102 if (!find_procinfo (pi
->pid
, temp_tid
))
4103 create_procinfo (pi
->pid
, temp_tid
);
4105 /* If not in GDB's thread list, add it. */
4106 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
4107 if (!in_thread_list (temp_ptid
))
4108 add_thread (temp_ptid
);
4110 status
->kind
= TARGET_WAITKIND_STOPPED
;
4111 status
->value
.sig
= 0;
4116 wstat
= (what
<< 8) | 0177;
4122 wstat
= (SIGTRAP
<< 8) | 0177;
4127 wstat
= (SIGTRAP
<< 8) | 0177;
4130 /* FIXME: use si_signo where possible. */
4132 #if (FLTILL != FLTPRIV) /* Avoid "duplicate case" error. */
4135 wstat
= (SIGILL
<< 8) | 0177;
4138 #if (FLTTRACE != FLTBPT) /* Avoid "duplicate case" error. */
4141 /* If we hit our __dbx_link() internal breakpoint,
4142 then remove it. See comments in procfs_init_inferior()
4143 for more details. */
4144 if (dbx_link_bpt_addr
!= 0
4145 && dbx_link_bpt_addr
4146 == regcache_read_pc (get_current_regcache ()))
4147 remove_dbx_link_breakpoint ();
4149 wstat
= (SIGTRAP
<< 8) | 0177;
4153 #if (FLTBOUNDS != FLTSTACK) /* Avoid "duplicate case" error. */
4156 wstat
= (SIGSEGV
<< 8) | 0177;
4160 #if (FLTFPE != FLTIOVF) /* Avoid "duplicate case" error. */
4163 wstat
= (SIGFPE
<< 8) | 0177;
4165 case FLTPAGE
: /* Recoverable page fault */
4166 default: /* FIXME: use si_signo if possible for
4168 retval
= pid_to_ptid (-1);
4169 printf_filtered ("procfs:%d -- ", __LINE__
);
4170 printf_filtered (_("child stopped for unknown reason:\n"));
4171 proc_prettyprint_why (why
, what
, 1);
4172 error (_("... giving up..."));
4175 break; /* case PR_FAULTED: */
4176 default: /* switch (why) unmatched */
4177 printf_filtered ("procfs:%d -- ", __LINE__
);
4178 printf_filtered (_("child stopped for unknown reason:\n"));
4179 proc_prettyprint_why (why
, what
, 1);
4180 error (_("... giving up..."));
4183 /* Got this far without error: If retval isn't in the
4184 threads database, add it. */
4185 if (PIDGET (retval
) > 0 &&
4186 !ptid_equal (retval
, inferior_ptid
) &&
4187 !in_thread_list (retval
))
4189 /* We have a new thread. We need to add it both to
4190 GDB's list and to our own. If we don't create a
4191 procinfo, resume may be unhappy later. */
4192 add_thread (retval
);
4193 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
4194 create_procinfo (PIDGET (retval
), TIDGET (retval
));
4197 else /* Flags do not indicate STOPPED. */
4199 /* surely this can't happen... */
4200 printf_filtered ("procfs:%d -- process not stopped.\n",
4202 proc_prettyprint_flags (flags
, 1);
4203 error (_("procfs: ...giving up..."));
4208 store_waitstatus (status
, wstat
);
4214 /* Perform a partial transfer to/from the specified object. For
4215 memory transfers, fall back to the old memory xfer functions. */
4218 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4219 const char *annex
, gdb_byte
*readbuf
,
4220 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4224 case TARGET_OBJECT_MEMORY
:
4226 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
4227 len
, 0/*read*/, NULL
, ops
);
4229 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
4230 len
, 1/*write*/, NULL
, ops
);
4234 case TARGET_OBJECT_AUXV
:
4235 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
4240 if (ops
->beneath
!= NULL
)
4241 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
4242 readbuf
, writebuf
, offset
, len
);
4248 /* Transfer LEN bytes between GDB address MYADDR and target address
4249 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
4250 otherwise transfer them from the target. TARGET is unused.
4252 The return value is 0 if an error occurred or no bytes were
4253 transferred. Otherwise, it will be a positive value which
4254 indicates the number of bytes transferred between gdb and the
4255 target. (Note that the interface also makes provisions for
4256 negative values, but this capability isn't implemented here.) */
4259 procfs_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int dowrite
,
4260 struct mem_attrib
*attrib
, struct target_ops
*target
)
4265 /* Find procinfo for main process. */
4266 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4267 if (pi
->as_fd
== 0 &&
4268 open_procinfo_files (pi
, FD_AS
) == 0)
4270 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4274 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4279 PROCFS_NOTE ("write memory:\n");
4281 PROCFS_NOTE ("write memory:\n");
4283 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4287 PROCFS_NOTE ("read memory:\n");
4288 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4298 /* Called by target_resume before making child runnable. Mark cached
4299 registers and status's invalid. If there are "dirty" caches that
4300 need to be written back to the child process, do that.
4302 File descriptors are also cached. As they are a limited resource,
4303 we cannot hold onto them indefinitely. However, as they are
4304 expensive to open, we don't want to throw them away
4305 indescriminately either. As a compromise, we will keep the file
4306 descriptors for the parent process, but discard any file
4307 descriptors we may have accumulated for the threads.
4309 As this function is called by iterate_over_threads, it always
4310 returns zero (so that iterate_over_threads will keep
4314 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
4316 /* About to run the child; invalidate caches and do any other
4320 if (pi
->gregs_dirty
)
4321 if (parent
== NULL
||
4322 proc_get_current_thread (parent
) != pi
->tid
)
4323 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4324 proc_warn (pi
, "target_resume, set_gregs",
4326 if (gdbarch_fp0_regnum (target_gdbarch
) >= 0)
4327 if (pi
->fpregs_dirty
)
4328 if (parent
== NULL
||
4329 proc_get_current_thread (parent
) != pi
->tid
)
4330 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4331 proc_warn (pi
, "target_resume, set_fpregs",
4337 /* The presence of a parent indicates that this is an LWP.
4338 Close any file descriptors that it might have open.
4339 We don't do this to the master (parent) procinfo. */
4341 close_procinfo_files (pi
);
4343 pi
->gregs_valid
= 0;
4344 pi
->fpregs_valid
= 0;
4346 pi
->gregs_dirty
= 0;
4347 pi
->fpregs_dirty
= 0;
4349 pi
->status_valid
= 0;
4350 pi
->threads_valid
= 0;
4356 /* A callback function for iterate_over_threads. Find the
4357 asynchronous signal thread, and make it runnable. See if that
4358 helps matters any. */
4361 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
4364 if (proc_flags (pi
) & PR_ASLWP
)
4366 if (!proc_run_process (pi
, 0, -1))
4367 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4375 /* Make the child process runnable. Normally we will then call
4376 procfs_wait and wait for it to stop again (unless gdb is async).
4378 If STEP is true, then arrange for the child to stop again after
4379 executing a single instruction. If SIGNO is zero, then cancel any
4380 pending signal; if non-zero, then arrange for the indicated signal
4381 to be delivered to the child when it runs. If PID is -1, then
4382 allow any child thread to run; if non-zero, then allow only the
4383 indicated thread to run. (not implemented yet). */
4386 procfs_resume (struct target_ops
*ops
,
4387 ptid_t ptid
, int step
, enum target_signal signo
)
4389 procinfo
*pi
, *thread
;
4393 prrun.prflags |= PRSVADDR;
4394 prrun.pr_vaddr = $PC; set resume address
4395 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4396 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4397 prrun.prflags |= PRCFAULT; clear current fault.
4399 PRSTRACE and PRSFAULT can be done by other means
4400 (proc_trace_signals, proc_trace_faults)
4401 PRSVADDR is unnecessary.
4402 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4403 This basically leaves PRSTEP and PRCSIG.
4404 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4405 So basically PR_STEP is the sole argument that must be passed
4406 to proc_run_process (for use in the prrun struct by ioctl). */
4408 /* Find procinfo for main process. */
4409 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4411 /* First cut: ignore pid argument. */
4414 /* Convert signal to host numbering. */
4416 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4419 native_signo
= target_signal_to_host (signo
);
4421 pi
->ignore_next_sigstop
= 0;
4423 /* Running the process voids all cached registers and status. */
4424 /* Void the threads' caches first. */
4425 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4426 /* Void the process procinfo's caches. */
4427 invalidate_cache (NULL
, pi
, NULL
);
4429 if (PIDGET (ptid
) != -1)
4431 /* Resume a specific thread, presumably suppressing the
4433 thread
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
));
4436 if (thread
->tid
!= 0)
4438 /* We're to resume a specific thread, and not the
4439 others. Set the child process's PR_ASYNC flag. */
4441 if (!proc_set_async (pi
))
4442 proc_error (pi
, "target_resume, set_async", __LINE__
);
4445 proc_iterate_over_threads (pi
,
4446 make_signal_thread_runnable
,
4449 pi
= thread
; /* Substitute the thread's procinfo
4455 if (!proc_run_process (pi
, step
, native_signo
))
4458 warning (_("resume: target already running. "
4459 "Pretend to resume, and hope for the best!"));
4461 proc_error (pi
, "target_resume", __LINE__
);
4465 /* Set up to trace signals in the child process. */
4468 procfs_pass_signals (int numsigs
, unsigned char *pass_signals
)
4470 gdb_sigset_t signals
;
4471 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4474 prfillset (&signals
);
4476 for (signo
= 0; signo
< NSIG
; signo
++)
4478 int target_signo
= target_signal_from_host (signo
);
4479 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
4480 gdb_prdelset (&signals
, signo
);
4483 if (!proc_set_traced_signals (pi
, &signals
))
4484 proc_error (pi
, "pass_signals", __LINE__
);
4487 /* Print status information about the child process. */
4490 procfs_files_info (struct target_ops
*ignore
)
4492 struct inferior
*inf
= current_inferior ();
4494 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
4495 inf
->attach_flag
? "attached": "child",
4496 target_pid_to_str (inferior_ptid
));
4499 /* Stop the child process asynchronously, as when the gdb user types
4500 control-c or presses a "stop" button. Works by sending
4501 kill(SIGINT) to the child's process group. */
4504 procfs_stop (ptid_t ptid
)
4506 kill (-inferior_process_group (), SIGINT
);
4509 /* Make it die. Wait for it to die. Clean up after it. Note: this
4510 should only be applied to the real process, not to an LWP, because
4511 of the check for parent-process. If we need this to work for an
4512 LWP, it needs some more logic. */
4515 unconditionally_kill_inferior (procinfo
*pi
)
4519 parent_pid
= proc_parent_pid (pi
);
4520 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4521 /* FIXME: use access functions. */
4522 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4523 before the PIOCKILL, otherwise it might generate a corrupted core
4524 file for the inferior. */
4525 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4527 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4530 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4531 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4532 to kill the inferior, otherwise it might remain stopped with a
4534 We do not check the result of the PIOCSSIG, the inferior might have
4537 gdb_siginfo_t newsiginfo
;
4539 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4540 newsiginfo
.si_signo
= SIGKILL
;
4541 newsiginfo
.si_code
= 0;
4542 newsiginfo
.si_errno
= 0;
4543 newsiginfo
.si_pid
= getpid ();
4544 newsiginfo
.si_uid
= getuid ();
4545 /* FIXME: use proc_set_current_signal. */
4546 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4548 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4549 if (!proc_kill (pi
, SIGKILL
))
4550 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4551 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4552 destroy_procinfo (pi
);
4554 /* If pi is GDB's child, wait for it to die. */
4555 if (parent_pid
== getpid ())
4556 /* FIXME: should we use waitpid to make sure we get the right event?
4557 Should we check the returned event? */
4562 ret
= waitpid (pi
->pid
, &status
, 0);
4569 /* We're done debugging it, and we want it to go away. Then we want
4570 GDB to forget all about it. */
4573 procfs_kill_inferior (struct target_ops
*ops
)
4575 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
4577 /* Find procinfo for main process. */
4578 procinfo
*pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4581 unconditionally_kill_inferior (pi
);
4582 target_mourn_inferior ();
4586 /* Forget we ever debugged this thing! */
4589 procfs_mourn_inferior (struct target_ops
*ops
)
4593 if (!ptid_equal (inferior_ptid
, null_ptid
))
4595 /* Find procinfo for main process. */
4596 pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4598 destroy_procinfo (pi
);
4600 unpush_target (ops
);
4602 if (dbx_link_bpt
!= NULL
)
4604 deprecated_remove_raw_breakpoint (target_gdbarch
, dbx_link_bpt
);
4605 dbx_link_bpt_addr
= 0;
4606 dbx_link_bpt
= NULL
;
4609 generic_mourn_inferior ();
4612 /* When GDB forks to create a runnable inferior process, this function
4613 is called on the parent side of the fork. It's job is to do
4614 whatever is necessary to make the child ready to be debugged, and
4615 then wait for the child to synchronize. */
4618 procfs_init_inferior (struct target_ops
*ops
, int pid
)
4621 gdb_sigset_t signals
;
4625 /* This routine called on the parent side (GDB side)
4626 after GDB forks the inferior. */
4629 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4630 perror (_("procfs: out of memory in 'init_inferior'"));
4632 if (!open_procinfo_files (pi
, FD_CTL
))
4633 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4637 open_procinfo_files // done
4640 procfs_notice_signals
4647 /* If not stopped yet, wait for it to stop. */
4648 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4649 !(proc_wait_for_stop (pi
)))
4650 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4652 /* Save some of the /proc state to be restored if we detach. */
4653 /* FIXME: Why? In case another debugger was debugging it?
4654 We're it's parent, for Ghu's sake! */
4655 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4656 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4657 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4658 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4659 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4660 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4661 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
4662 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4663 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
4664 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4666 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4667 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4669 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4670 and possibly even turning ON kill-on-last-close at this point. But
4671 I can't make that change without careful testing which I don't have
4672 time to do right now... */
4673 /* Turn on run-on-last-close flag so that the child
4674 will die if GDB goes away for some reason. */
4675 if (!proc_set_run_on_last_close (pi
))
4676 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4678 /* We now have have access to the lwpid of the main thread/lwp. */
4679 lwpid
= proc_get_current_thread (pi
);
4681 /* Create a procinfo for the main lwp. */
4682 create_procinfo (pid
, lwpid
);
4684 /* We already have a main thread registered in the thread table at
4685 this point, but it didn't have any lwp info yet. Notify the core
4686 about it. This changes inferior_ptid as well. */
4687 thread_change_ptid (pid_to_ptid (pid
),
4688 MERGEPID (pid
, lwpid
));
4690 /* Typically two, one trap to exec the shell, one to exec the
4691 program being debugged. Defined by "inferior.h". */
4692 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4695 /* On mips-irix, we need to stop the inferior early enough during
4696 the startup phase in order to be able to load the shared library
4697 symbols and insert the breakpoints that are located in these shared
4698 libraries. Stopping at the program entry point is not good enough
4699 because the -init code is executed before the execution reaches
4702 So what we need to do is to insert a breakpoint in the runtime
4703 loader (rld), more precisely in __dbx_link(). This procedure is
4704 called by rld once all shared libraries have been mapped, but before
4705 the -init code is executed. Unfortuantely, this is not straightforward,
4706 as rld is not part of the executable we are running, and thus we need
4707 the inferior to run until rld itself has been mapped in memory.
4709 For this, we trace all syssgi() syscall exit events. Each time
4710 we detect such an event, we iterate over each text memory maps,
4711 get its associated fd, and scan the symbol table for __dbx_link().
4712 When found, we know that rld has been mapped, and that we can insert
4713 the breakpoint at the symbol address. Once the dbx_link() breakpoint
4714 has been inserted, the syssgi() notifications are no longer necessary,
4715 so they should be canceled. */
4716 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
, FLAG_SET
, 0);
4720 /* When GDB forks to create a new process, this function is called on
4721 the child side of the fork before GDB exec's the user program. Its
4722 job is to make the child minimally debuggable, so that the parent
4723 GDB process can connect to the child and take over. This function
4724 should do only the minimum to make that possible, and to
4725 synchronize with the parent process. The parent process should
4726 take care of the details. */
4729 procfs_set_exec_trap (void)
4731 /* This routine called on the child side (inferior side)
4732 after GDB forks the inferior. It must use only local variables,
4733 because it may be sharing data space with its parent. */
4738 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4739 perror_with_name (_("procfs: create_procinfo failed in child."));
4741 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4743 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4744 gdb_flush (gdb_stderr
);
4745 /* No need to call "dead_procinfo", because we're going to
4750 #ifdef PRFS_STOPEXEC /* defined on OSF */
4751 /* OSF method for tracing exec syscalls. Quoting:
4752 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4753 exits from exec system calls because of the user level loader. */
4754 /* FIXME: make nice and maybe move into an access function. */
4758 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4760 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4761 gdb_flush (gdb_stderr
);
4764 prfs_flags
|= PRFS_STOPEXEC
;
4766 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4768 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4769 gdb_flush (gdb_stderr
);
4773 #else /* not PRFS_STOPEXEC */
4774 /* Everyone else's (except OSF) method for tracing exec syscalls. */
4776 Not all systems with /proc have all the exec* syscalls with the same
4777 names. On the SGI, for example, there is no SYS_exec, but there
4778 *is* a SYS_execv. So, we try to account for that. */
4780 exitset
= sysset_t_alloc (pi
);
4781 gdb_premptysysset (exitset
);
4783 gdb_praddsysset (exitset
, SYS_exec
);
4786 gdb_praddsysset (exitset
, SYS_execve
);
4789 gdb_praddsysset (exitset
, SYS_execv
);
4791 #ifdef DYNAMIC_SYSCALLS
4793 int callnum
= find_syscall (pi
, "execve");
4796 gdb_praddsysset (exitset
, callnum
);
4798 callnum
= find_syscall (pi
, "ra_execve");
4800 gdb_praddsysset (exitset
, callnum
);
4802 #endif /* DYNAMIC_SYSCALLS */
4804 if (!proc_set_traced_sysexit (pi
, exitset
))
4806 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4807 gdb_flush (gdb_stderr
);
4810 #endif /* PRFS_STOPEXEC */
4812 /* FIXME: should this be done in the parent instead? */
4813 /* Turn off inherit on fork flag so that all grand-children
4814 of gdb start with tracing flags cleared. */
4815 if (!proc_unset_inherit_on_fork (pi
))
4816 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4818 /* Turn off run on last close flag, so that the child process
4819 cannot run away just because we close our handle on it.
4820 We want it to wait for the parent to attach. */
4821 if (!proc_unset_run_on_last_close (pi
))
4822 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4824 /* FIXME: No need to destroy the procinfo --
4825 we have our own address space, and we're about to do an exec! */
4826 /*destroy_procinfo (pi);*/
4829 /* This function is called BEFORE gdb forks the inferior process. Its
4830 only real responsibility is to set things up for the fork, and tell
4831 GDB which two functions to call after the fork (one for the parent,
4832 and one for the child).
4834 This function does a complicated search for a unix shell program,
4835 which it then uses to parse arguments and environment variables to
4836 be sent to the child. I wonder whether this code could not be
4837 abstracted out and shared with other unix targets such as
4841 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
4842 char *allargs
, char **env
, int from_tty
)
4844 char *shell_file
= getenv ("SHELL");
4848 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4851 /* We will be looking down the PATH to find shell_file. If we
4852 just do this the normal way (via execlp, which operates by
4853 attempting an exec for each element of the PATH until it
4854 finds one which succeeds), then there will be an exec for
4855 each failed attempt, each of which will cause a PR_SYSEXIT
4856 stop, and we won't know how to distinguish the PR_SYSEXIT's
4857 for these failed execs with the ones for successful execs
4858 (whether the exec has succeeded is stored at that time in the
4859 carry bit or some such architecture-specific and
4860 non-ABI-specified place).
4862 So I can't think of anything better than to search the PATH
4863 now. This has several disadvantages: (1) There is a race
4864 condition; if we find a file now and it is deleted before we
4865 exec it, we lose, even if the deletion leaves a valid file
4866 further down in the PATH, (2) there is no way to know exactly
4867 what an executable (in the sense of "capable of being
4868 exec'd") file is. Using access() loses because it may lose
4869 if the caller is the superuser; failing to use it loses if
4870 there are ACLs or some such. */
4874 /* FIXME-maybe: might want "set path" command so user can change what
4875 path is used from within GDB. */
4876 char *path
= getenv ("PATH");
4878 struct stat statbuf
;
4881 path
= "/bin:/usr/bin";
4883 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4884 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4886 p1
= strchr (p
, ':');
4891 strncpy (tryname
, p
, len
);
4892 tryname
[len
] = '\0';
4893 strcat (tryname
, "/");
4894 strcat (tryname
, shell_file
);
4895 if (access (tryname
, X_OK
) < 0)
4897 if (stat (tryname
, &statbuf
) < 0)
4899 if (!S_ISREG (statbuf
.st_mode
))
4900 /* We certainly need to reject directories. I'm not quite
4901 as sure about FIFOs, sockets, etc., but I kind of doubt
4902 that people want to exec() these things. */
4907 /* Not found. This must be an error rather than merely passing
4908 the file to execlp(), because execlp() would try all the
4909 exec()s, causing GDB to get confused. */
4910 error (_("procfs:%d -- Can't find shell %s in PATH"),
4911 __LINE__
, shell_file
);
4913 shell_file
= tryname
;
4916 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4917 NULL
, NULL
, shell_file
, NULL
);
4919 procfs_init_inferior (ops
, pid
);
4922 /* An observer for the "inferior_created" event. */
4925 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
4928 /* Make sure to cancel the syssgi() syscall-exit notifications.
4929 They should normally have been removed by now, but they may still
4930 be activated if the inferior doesn't use shared libraries, or if
4931 we didn't locate __dbx_link, or if we never stopped in __dbx_link.
4932 See procfs_init_inferior() for more details.
4934 Since these notifications are only ever enabled when we spawned
4935 the inferior ourselves, there is nothing to do when the inferior
4936 was created by attaching to an already running process, or when
4937 debugging a core file. */
4938 if (current_inferior ()->attach_flag
|| !target_can_run (¤t_target
))
4941 proc_trace_syscalls_1 (find_procinfo_or_die (PIDGET (inferior_ptid
), 0),
4942 SYS_syssgi
, PR_SYSEXIT
, FLAG_RESET
, 0);
4946 /* Callback for find_new_threads. Calls "add_thread". */
4949 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
4951 ptid_t gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4953 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
4954 add_thread (gdb_threadid
);
4959 /* Query all the threads that the target knows about, and give them
4960 back to GDB to add to its list. */
4963 procfs_find_new_threads (struct target_ops
*ops
)
4967 /* Find procinfo for main process. */
4968 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4969 proc_update_threads (pi
);
4970 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4973 /* Return true if the thread is still 'alive'. This guy doesn't
4974 really seem to be doing his job. Got to investigate how to tell
4975 when a thread is really gone. */
4978 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4983 proc
= PIDGET (ptid
);
4984 thread
= TIDGET (ptid
);
4985 /* If I don't know it, it ain't alive! */
4986 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4989 /* If I can't get its status, it ain't alive!
4990 What's more, I need to forget about it! */
4991 if (!proc_get_status (pi
))
4993 destroy_procinfo (pi
);
4996 /* I couldn't have got its status if it weren't alive, so it's
5001 /* Convert PTID to a string. Returns the string in a static
5005 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
5007 static char buf
[80];
5009 if (TIDGET (ptid
) == 0)
5010 sprintf (buf
, "process %d", PIDGET (ptid
));
5012 sprintf (buf
, "LWP %ld", TIDGET (ptid
));
5017 /* Insert a watchpoint. */
5020 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
5028 pi
= find_procinfo_or_die (PIDGET (ptid
) == -1 ?
5029 PIDGET (inferior_ptid
) : PIDGET (ptid
), 0);
5031 /* Translate from GDB's flags to /proc's. */
5032 if (len
> 0) /* len == 0 means delete watchpoint. */
5034 switch (rwflag
) { /* FIXME: need an enum! */
5035 case hw_write
: /* default watchpoint (write) */
5036 pflags
= WRITE_WATCHFLAG
;
5038 case hw_read
: /* read watchpoint */
5039 pflags
= READ_WATCHFLAG
;
5041 case hw_access
: /* access watchpoint */
5042 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
5044 case hw_execute
: /* execution HW breakpoint */
5045 pflags
= EXEC_WATCHFLAG
;
5047 default: /* Something weird. Return error. */
5050 if (after
) /* Stop after r/w access is completed. */
5051 pflags
|= AFTER_WATCHFLAG
;
5054 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
5056 if (errno
== E2BIG
) /* Typical error for no resources. */
5057 return -1; /* fail */
5058 /* GDB may try to remove the same watchpoint twice.
5059 If a remove request returns no match, don't error. */
5060 if (errno
== ESRCH
&& len
== 0)
5061 return 0; /* ignore */
5062 proc_error (pi
, "set_watchpoint", __LINE__
);
5065 #endif /* UNIXWARE */
5069 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
5070 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
5071 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
5074 Note: procfs_can_use_hw_breakpoint() is not yet used by all
5075 procfs.c targets due to the fact that some of them still define
5076 target_can_use_hardware_watchpoint. */
5079 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
5081 /* Due to the way that proc_set_watchpoint() is implemented, host
5082 and target pointers must be of the same size. If they are not,
5083 we can't use hardware watchpoints. This limitation is due to the
5084 fact that proc_set_watchpoint() calls
5085 procfs_address_to_host_pointer(); a close inspection of
5086 procfs_address_to_host_pointer will reveal that an internal error
5087 will be generated when the host and target pointer sizes are
5089 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
5091 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
5094 /* Other tests here??? */
5099 /* Returns non-zero if process is stopped on a hardware watchpoint
5100 fault, else returns zero. */
5103 procfs_stopped_by_watchpoint (void)
5107 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5109 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
5111 if (proc_why (pi
) == PR_FAULTED
)
5114 if (proc_what (pi
) == FLTWATCH
)
5118 if (proc_what (pi
) == FLTKWATCH
)
5126 /* Returns 1 if the OS knows the position of the triggered watchpoint,
5127 and sets *ADDR to that address. Returns 0 if OS cannot report that
5128 address. This function is only called if
5129 procfs_stopped_by_watchpoint returned 1, thus no further checks are
5130 done. The function also assumes that ADDR is not NULL. */
5133 procfs_stopped_data_address (struct target_ops
*targ
, CORE_ADDR
*addr
)
5137 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5138 return proc_watchpoint_address (pi
, addr
);
5142 procfs_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
5143 struct expression
*cond
)
5145 if (!target_have_steppable_watchpoint
5146 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch
))
5148 /* When a hardware watchpoint fires off the PC will be left at
5149 the instruction following the one which caused the
5150 watchpoint. It will *NOT* be necessary for GDB to step over
5152 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
5156 /* When a hardware watchpoint fires off the PC will be left at
5157 the instruction which caused the watchpoint. It will be
5158 necessary for GDB to step over the watchpoint. */
5159 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
5164 procfs_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
5165 struct expression
*cond
)
5167 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
5171 procfs_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
5173 /* The man page for proc(4) on Solaris 2.6 and up says that the
5174 system can support "thousands" of hardware watchpoints, but gives
5175 no method for finding out how many; It doesn't say anything about
5176 the allowed size for the watched area either. So we just tell
5182 procfs_use_watchpoints (struct target_ops
*t
)
5184 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
5185 t
->to_insert_watchpoint
= procfs_insert_watchpoint
;
5186 t
->to_remove_watchpoint
= procfs_remove_watchpoint
;
5187 t
->to_region_ok_for_hw_watchpoint
= procfs_region_ok_for_hw_watchpoint
;
5188 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
5189 t
->to_stopped_data_address
= procfs_stopped_data_address
;
5192 /* Memory Mappings Functions: */
5194 /* Call a callback function once for each mapping, passing it the
5195 mapping, an optional secondary callback function, and some optional
5196 opaque data. Quit and return the first non-zero value returned
5199 PI is the procinfo struct for the process to be mapped. FUNC is
5200 the callback function to be called by this iterator. DATA is the
5201 optional opaque data to be passed to the callback function.
5202 CHILD_FUNC is the optional secondary function pointer to be passed
5203 to the child function. Returns the first non-zero return value
5204 from the callback function, or zero. */
5207 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
5209 int (*func
) (struct prmap
*map
,
5210 find_memory_region_ftype child_func
,
5213 char pathname
[MAX_PROC_NAME_SIZE
];
5214 struct prmap
*prmaps
;
5215 struct prmap
*prmap
;
5219 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
5224 /* Get the number of mappings, allocate space,
5225 and read the mappings into prmaps. */
5228 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
5229 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
5230 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
5232 /* Make sure it gets closed again. */
5233 make_cleanup_close (map_fd
);
5235 /* Use stat to determine the file size, and compute
5236 the number of prmap_t objects it contains. */
5237 if (fstat (map_fd
, &sbuf
) != 0)
5238 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
5240 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
5241 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5242 if (read (map_fd
, (char *) prmaps
, nmap
* sizeof (*prmaps
))
5243 != (nmap
* sizeof (*prmaps
)))
5244 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
5246 /* Use ioctl command PIOCNMAP to get number of mappings. */
5247 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmap
) != 0)
5248 proc_error (pi
, "iterate_over_mappings (PIOCNMAP)", __LINE__
);
5250 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5251 if (ioctl (pi
->ctl_fd
, PIOCMAP
, prmaps
) != 0)
5252 proc_error (pi
, "iterate_over_mappings (PIOCMAP)", __LINE__
);
5255 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
5256 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
5258 do_cleanups (cleanups
);
5262 do_cleanups (cleanups
);
5266 /* Implements the to_find_memory_regions method. Calls an external
5267 function for each memory region.
5268 Returns the integer value returned by the callback. */
5271 find_memory_regions_callback (struct prmap
*map
,
5272 find_memory_region_ftype func
, void *data
)
5274 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
5276 (map
->pr_mflags
& MA_READ
) != 0,
5277 (map
->pr_mflags
& MA_WRITE
) != 0,
5278 (map
->pr_mflags
& MA_EXEC
) != 0,
5282 /* External interface. Calls a callback function once for each
5283 mapped memory region in the child process, passing as arguments:
5285 CORE_ADDR virtual_address,
5287 int read, TRUE if region is readable by the child
5288 int write, TRUE if region is writable by the child
5289 int execute TRUE if region is executable by the child.
5291 Stops iterating and returns the first non-zero value returned by
5295 proc_find_memory_regions (find_memory_region_ftype func
, void *data
)
5297 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5299 return iterate_over_mappings (pi
, func
, data
,
5300 find_memory_regions_callback
);
5303 /* Returns an ascii representation of a memory mapping's flags. */
5306 mappingflags (long flags
)
5308 static char asciiflags
[8];
5310 strcpy (asciiflags
, "-------");
5311 #if defined (MA_PHYS)
5312 if (flags
& MA_PHYS
)
5313 asciiflags
[0] = 'd';
5315 if (flags
& MA_STACK
)
5316 asciiflags
[1] = 's';
5317 if (flags
& MA_BREAK
)
5318 asciiflags
[2] = 'b';
5319 if (flags
& MA_SHARED
)
5320 asciiflags
[3] = 's';
5321 if (flags
& MA_READ
)
5322 asciiflags
[4] = 'r';
5323 if (flags
& MA_WRITE
)
5324 asciiflags
[5] = 'w';
5325 if (flags
& MA_EXEC
)
5326 asciiflags
[6] = 'x';
5327 return (asciiflags
);
5330 /* Callback function, does the actual work for 'info proc
5334 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
5337 unsigned int pr_off
;
5339 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
5340 pr_off
= (unsigned int) map
->pr_offset
;
5342 pr_off
= map
->pr_off
;
5345 if (gdbarch_addr_bit (target_gdbarch
) == 32)
5346 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
5347 (unsigned long) map
->pr_vaddr
,
5348 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5349 (unsigned long) map
->pr_size
,
5351 mappingflags (map
->pr_mflags
));
5353 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
5354 (unsigned long) map
->pr_vaddr
,
5355 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5356 (unsigned long) map
->pr_size
,
5358 mappingflags (map
->pr_mflags
));
5363 /* Implement the "info proc mappings" subcommand. */
5366 info_proc_mappings (procinfo
*pi
, int summary
)
5369 return; /* No output for summary mode. */
5371 printf_filtered (_("Mapped address spaces:\n\n"));
5372 if (gdbarch_ptr_bit (target_gdbarch
) == 32)
5373 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
5380 printf_filtered (" %18s %18s %10s %10s %7s\n",
5387 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
5388 printf_filtered ("\n");
5391 /* Implement the "info proc" command. */
5394 info_proc_cmd (char *args
, int from_tty
)
5396 struct cleanup
*old_chain
;
5397 procinfo
*process
= NULL
;
5398 procinfo
*thread
= NULL
;
5405 old_chain
= make_cleanup (null_cleanup
, 0);
5408 argv
= gdb_buildargv (args
);
5409 make_cleanup_freeargv (argv
);
5411 while (argv
!= NULL
&& *argv
!= NULL
)
5413 if (isdigit (argv
[0][0]))
5415 pid
= strtoul (argv
[0], &tmp
, 10);
5417 tid
= strtoul (++tmp
, NULL
, 10);
5419 else if (argv
[0][0] == '/')
5421 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5423 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
5434 pid
= PIDGET (inferior_ptid
);
5436 error (_("No current process: you must name one."));
5439 /* Have pid, will travel.
5440 First see if it's a process we're already debugging. */
5441 process
= find_procinfo (pid
, 0);
5442 if (process
== NULL
)
5444 /* No. So open a procinfo for it, but
5445 remember to close it again when finished. */
5446 process
= create_procinfo (pid
, 0);
5447 make_cleanup (do_destroy_procinfo_cleanup
, process
);
5448 if (!open_procinfo_files (process
, FD_CTL
))
5449 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5453 thread
= create_procinfo (pid
, tid
);
5457 printf_filtered (_("process %d flags:\n"), process
->pid
);
5458 proc_prettyprint_flags (proc_flags (process
), 1);
5459 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5460 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5461 if (proc_get_nthreads (process
) > 1)
5462 printf_filtered ("Process has %d threads.\n",
5463 proc_get_nthreads (process
));
5467 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
5468 proc_prettyprint_flags (proc_flags (thread
), 1);
5469 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5470 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5475 info_proc_mappings (process
, 0);
5478 do_cleanups (old_chain
);
5481 /* Modify the status of the system call identified by SYSCALLNUM in
5482 the set of syscalls that are currently traced/debugged.
5484 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
5485 will be updated. Otherwise, the exit syscalls set will be updated.
5487 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
5488 will be disabled. */
5491 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
5492 int mode
, int from_tty
)
5496 if (entry_or_exit
== PR_SYSENTRY
)
5497 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5499 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5502 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5504 if (mode
== FLAG_SET
)
5505 gdb_praddsysset (sysset
, syscallnum
);
5507 gdb_prdelsysset (sysset
, syscallnum
);
5509 if (entry_or_exit
== PR_SYSENTRY
)
5511 if (!proc_set_traced_sysentry (pi
, sysset
))
5512 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5516 if (!proc_set_traced_sysexit (pi
, sysset
))
5517 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5522 proc_trace_syscalls (char *args
, int from_tty
, int entry_or_exit
, int mode
)
5526 if (PIDGET (inferior_ptid
) <= 0)
5527 error (_("you must be debugging a process to use this command."));
5529 if (args
== NULL
|| args
[0] == 0)
5530 error_no_arg (_("system call to trace"));
5532 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5533 if (isdigit (args
[0]))
5535 const int syscallnum
= atoi (args
);
5537 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
5542 proc_trace_sysentry_cmd (char *args
, int from_tty
)
5544 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5548 proc_trace_sysexit_cmd (char *args
, int from_tty
)
5550 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5554 proc_untrace_sysentry_cmd (char *args
, int from_tty
)
5556 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5560 proc_untrace_sysexit_cmd (char *args
, int from_tty
)
5562 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5567 _initialize_procfs (void)
5569 observer_attach_inferior_created (procfs_inferior_created
);
5571 add_info ("proc", info_proc_cmd
, _("\
5572 Show /proc process information about any running process.\n\
5573 Specify process id, or use the program being debugged by default.\n\
5574 Specify keyword 'mappings' for detailed info on memory mappings."));
5575 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5576 _("Give a trace of entries into the syscall."));
5577 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5578 _("Give a trace of exits from the syscall."));
5579 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5580 _("Cancel a trace of entries into the syscall."));
5581 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5582 _("Cancel a trace of exits from the syscall."));
5585 /* =================== END, GDB "MODULE" =================== */
5589 /* miscellaneous stubs: */
5591 /* The following satisfy a few random symbols mostly created by the
5592 solaris threads implementation, which I will chase down later. */
5594 /* Return a pid for which we guarantee we will be able to find a
5598 procfs_first_available (void)
5600 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
5603 /* =================== GCORE .NOTE "MODULE" =================== */
5604 #if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT)
5605 /* gcore only implemented on solaris and unixware (so far) */
5608 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
5609 char *note_data
, int *note_size
,
5610 enum target_signal stop_signal
)
5612 struct regcache
*regcache
= get_thread_regcache (ptid
);
5613 gdb_gregset_t gregs
;
5614 gdb_fpregset_t fpregs
;
5615 unsigned long merged_pid
;
5616 struct cleanup
*old_chain
;
5618 merged_pid
= TIDGET (ptid
) << 16 | PIDGET (ptid
);
5620 /* This part is the old method for fetching registers.
5621 It should be replaced by the newer one using regsets
5622 once it is implemented in this platform:
5623 gdbarch_regset_from_core_section() and regset->collect_regset(). */
5625 old_chain
= save_inferior_ptid ();
5626 inferior_ptid
= ptid
;
5627 target_fetch_registers (regcache
, -1);
5629 fill_gregset (regcache
, &gregs
, -1);
5630 #if defined (NEW_PROC_API)
5631 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
5638 note_data
= (char *) elfcore_write_prstatus (obfd
,
5645 fill_fpregset (regcache
, &fpregs
, -1);
5646 note_data
= (char *) elfcore_write_prfpreg (obfd
,
5652 do_cleanups (old_chain
);
5657 struct procfs_corefile_thread_data
{
5661 enum target_signal stop_signal
;
5665 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
5667 struct procfs_corefile_thread_data
*args
= data
;
5671 ptid_t ptid
= MERGEPID (pi
->pid
, thread
->tid
);
5673 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
5682 find_signalled_thread (struct thread_info
*info
, void *data
)
5684 if (info
->suspend
.stop_signal
!= TARGET_SIGNAL_0
5685 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
5691 static enum target_signal
5692 find_stop_signal (void)
5694 struct thread_info
*info
=
5695 iterate_over_threads (find_signalled_thread
, NULL
);
5698 return info
->suspend
.stop_signal
;
5700 return TARGET_SIGNAL_0
;
5704 procfs_make_note_section (bfd
*obfd
, int *note_size
)
5706 struct cleanup
*old_chain
;
5707 gdb_gregset_t gregs
;
5708 gdb_fpregset_t fpregs
;
5709 char fname
[16] = {'\0'};
5710 char psargs
[80] = {'\0'};
5711 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5712 char *note_data
= NULL
;
5714 struct procfs_corefile_thread_data thread_args
;
5717 enum target_signal stop_signal
;
5719 if (get_exec_file (0))
5721 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
5722 strncpy (psargs
, get_exec_file (0),
5725 inf_args
= get_inferior_args ();
5726 if (inf_args
&& *inf_args
&&
5727 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
5729 strncat (psargs
, " ",
5730 sizeof (psargs
) - strlen (psargs
));
5731 strncat (psargs
, inf_args
,
5732 sizeof (psargs
) - strlen (psargs
));
5736 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
5742 stop_signal
= find_stop_signal ();
5745 fill_gregset (get_current_regcache (), &gregs
, -1);
5746 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
5747 PIDGET (inferior_ptid
),
5748 stop_signal
, &gregs
);
5751 thread_args
.obfd
= obfd
;
5752 thread_args
.note_data
= note_data
;
5753 thread_args
.note_size
= note_size
;
5754 thread_args
.stop_signal
= stop_signal
;
5755 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
5758 /* There should be always at least one thread. */
5759 gdb_assert (thread_args
.note_data
!= note_data
);
5760 note_data
= thread_args
.note_data
;
5762 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
5766 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
5767 "CORE", NT_AUXV
, auxv
, auxv_len
);
5771 make_cleanup (xfree
, note_data
);
5774 #else /* !(Solaris or Unixware) */
5776 procfs_make_note_section (bfd
*obfd
, int *note_size
)
5778 error (_("gcore not implemented for this host."));
5779 return NULL
; /* lint */
5781 #endif /* Solaris or Unixware */
5782 /* =================== END GCORE .NOTE "MODULE" =================== */