1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
3 Copyright (C) 1999-2003, 2006-2012 Free Software Foundation, Inc.
5 Written by Michael Snyder at Cygnus Solutions.
6 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "elf-bfd.h" /* for elfcore_write_* */
29 #include "gdbthread.h"
31 #include "inf-child.h"
33 #if defined (NEW_PROC_API)
34 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
37 #include <sys/procfs.h>
38 #ifdef HAVE_SYS_FAULT_H
39 #include <sys/fault.h>
41 #ifdef HAVE_SYS_SYSCALL_H
42 #include <sys/syscall.h>
44 #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 gdb_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 static void procfs_find_new_threads (struct target_ops
*ops
);
143 static 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 static void procfs_info_proc (struct target_ops
*, char *,
156 enum info_proc_what
);
158 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
159 /* When GDB is built as 64-bit application on Solaris, the auxv data
160 is presented in 64-bit format. We need to provide a custom parser
163 procfs_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
164 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
166 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
167 gdb_byte
*ptr
= *readptr
;
172 if (endptr
- ptr
< 8 * 2)
175 *typep
= extract_unsigned_integer (ptr
, 4, byte_order
);
177 /* The size of data is always 64-bit. If the application is 32-bit,
178 it will be zero extended, as expected. */
179 *valp
= extract_unsigned_integer (ptr
, 8, byte_order
);
190 struct target_ops
*t
= inf_child_target ();
192 t
->to_shortname
= "procfs";
193 t
->to_longname
= "Unix /proc child process";
195 "Unix /proc child process (started by the \"run\" command).";
196 t
->to_create_inferior
= procfs_create_inferior
;
197 t
->to_kill
= procfs_kill_inferior
;
198 t
->to_mourn_inferior
= procfs_mourn_inferior
;
199 t
->to_attach
= procfs_attach
;
200 t
->to_detach
= procfs_detach
;
201 t
->to_wait
= procfs_wait
;
202 t
->to_resume
= procfs_resume
;
203 t
->to_fetch_registers
= procfs_fetch_registers
;
204 t
->to_store_registers
= procfs_store_registers
;
205 t
->to_xfer_partial
= procfs_xfer_partial
;
206 t
->deprecated_xfer_memory
= procfs_xfer_memory
;
207 t
->to_pass_signals
= procfs_pass_signals
;
208 t
->to_files_info
= procfs_files_info
;
209 t
->to_stop
= procfs_stop
;
211 t
->to_find_new_threads
= procfs_find_new_threads
;
212 t
->to_thread_alive
= procfs_thread_alive
;
213 t
->to_pid_to_str
= procfs_pid_to_str
;
215 t
->to_has_thread_control
= tc_schedlock
;
216 t
->to_find_memory_regions
= proc_find_memory_regions
;
217 t
->to_make_corefile_notes
= procfs_make_note_section
;
218 t
->to_info_proc
= procfs_info_proc
;
220 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
221 t
->to_auxv_parse
= procfs_auxv_parse
;
224 t
->to_magic
= OPS_MAGIC
;
229 /* =================== END, TARGET_OPS "MODULE" =================== */
231 /* World Unification:
233 Put any typedefs, defines etc. here that are required for the
234 unification of code that handles different versions of /proc. */
236 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
238 enum { READ_WATCHFLAG
= WA_READ
,
239 WRITE_WATCHFLAG
= WA_WRITE
,
240 EXEC_WATCHFLAG
= WA_EXEC
,
241 AFTER_WATCHFLAG
= WA_TRAPAFTER
244 #else /* Irix method for watchpoints */
245 enum { READ_WATCHFLAG
= MA_READ
,
246 WRITE_WATCHFLAG
= MA_WRITE
,
247 EXEC_WATCHFLAG
= MA_EXEC
,
248 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
253 #ifdef HAVE_PR_SIGSET_T
254 typedef pr_sigset_t gdb_sigset_t
;
256 typedef sigset_t gdb_sigset_t
;
260 #ifdef HAVE_PR_SIGACTION64_T
261 typedef pr_sigaction64_t gdb_sigaction_t
;
263 typedef struct sigaction gdb_sigaction_t
;
267 #ifdef HAVE_PR_SIGINFO64_T
268 typedef pr_siginfo64_t gdb_siginfo_t
;
270 typedef siginfo_t gdb_siginfo_t
;
273 /* On mips-irix, praddset and prdelset are defined in such a way that
274 they return a value, which causes GCC to emit a -Wunused error
275 because the returned value is not used. Prevent this warning
276 by casting the return value to void. On sparc-solaris, this issue
277 does not exist because the definition of these macros already include
278 that cast to void. */
279 #define gdb_praddset(sp, flag) ((void) praddset (sp, flag))
280 #define gdb_prdelset(sp, flag) ((void) prdelset (sp, flag))
282 /* gdb_premptysysset */
284 #define gdb_premptysysset premptysysset
286 #define gdb_premptysysset premptyset
291 #define gdb_praddsysset praddsysset
293 #define gdb_praddsysset gdb_praddset
298 #define gdb_prdelsysset prdelsysset
300 #define gdb_prdelsysset gdb_prdelset
303 /* prissyssetmember */
304 #ifdef prissyssetmember
305 #define gdb_pr_issyssetmember prissyssetmember
307 #define gdb_pr_issyssetmember prismember
310 /* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't
311 as intuitively descriptive as it could be, so we'll define
312 DYNAMIC_SYSCALLS to mean the same thing. Anyway, at the time of
313 this writing, this feature is only found on AIX5 systems and
314 basically means that the set of syscalls is not fixed. I.e,
315 there's no nice table that one can #include to get all of the
316 syscall numbers. Instead, they're stored in /proc/PID/sysent
317 for each process. We are at least guaranteed that they won't
318 change over the lifetime of the process. But each process could
319 (in theory) have different syscall numbers. */
320 #ifdef HAVE_PRSYSENT_T
321 #define DYNAMIC_SYSCALLS
326 /* =================== STRUCT PROCINFO "MODULE" =================== */
328 /* FIXME: this comment will soon be out of date W.R.T. threads. */
330 /* The procinfo struct is a wrapper to hold all the state information
331 concerning a /proc process. There should be exactly one procinfo
332 for each process, and since GDB currently can debug only one
333 process at a time, that means there should be only one procinfo.
334 All of the LWP's of a process can be accessed indirectly thru the
335 single process procinfo.
337 However, against the day when GDB may debug more than one process,
338 this data structure is kept in a list (which for now will hold no
339 more than one member), and many functions will have a pointer to a
340 procinfo as an argument.
342 There will be a separate procinfo structure for use by the (not yet
343 implemented) "info proc" command, so that we can print useful
344 information about any random process without interfering with the
345 inferior's procinfo information. */
348 /* format strings for /proc paths */
349 # ifndef CTL_PROC_NAME_FMT
350 # define MAIN_PROC_NAME_FMT "/proc/%d"
351 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
352 # define AS_PROC_NAME_FMT "/proc/%d/as"
353 # define MAP_PROC_NAME_FMT "/proc/%d/map"
354 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
355 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
357 /* the name of the proc status struct depends on the implementation */
358 typedef pstatus_t gdb_prstatus_t
;
359 typedef lwpstatus_t gdb_lwpstatus_t
;
360 #else /* ! NEW_PROC_API */
361 /* format strings for /proc paths */
362 # ifndef CTL_PROC_NAME_FMT
363 # define MAIN_PROC_NAME_FMT "/proc/%05d"
364 # define CTL_PROC_NAME_FMT "/proc/%05d"
365 # define AS_PROC_NAME_FMT "/proc/%05d"
366 # define MAP_PROC_NAME_FMT "/proc/%05d"
367 # define STATUS_PROC_NAME_FMT "/proc/%05d"
368 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
370 /* The name of the proc status struct depends on the implementation. */
371 typedef prstatus_t gdb_prstatus_t
;
372 typedef prstatus_t gdb_lwpstatus_t
;
373 #endif /* NEW_PROC_API */
375 typedef struct procinfo
{
376 struct procinfo
*next
;
377 int pid
; /* Process ID */
378 int tid
; /* Thread/LWP id */
382 int ignore_next_sigstop
;
384 /* The following four fd fields may be identical, or may contain
385 several different fd's, depending on the version of /proc
386 (old ioctl or new read/write). */
388 int ctl_fd
; /* File descriptor for /proc control file */
390 /* The next three file descriptors are actually only needed in the
391 read/write, multiple-file-descriptor implemenation
392 (NEW_PROC_API). However, to avoid a bunch of #ifdefs in the
393 code, we will use them uniformly by (in the case of the ioctl
394 single-file-descriptor implementation) filling them with copies
395 of the control fd. */
396 int status_fd
; /* File descriptor for /proc status file */
397 int as_fd
; /* File descriptor for /proc as file */
399 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
401 fltset_t saved_fltset
; /* Saved traced hardware fault set */
402 gdb_sigset_t saved_sigset
; /* Saved traced signal set */
403 gdb_sigset_t saved_sighold
; /* Saved held signal set */
404 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
405 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
407 gdb_prstatus_t prstatus
; /* Current process status info */
410 gdb_fpregset_t fpregset
; /* Current floating point registers */
413 #ifdef DYNAMIC_SYSCALLS
414 int num_syscalls
; /* Total number of syscalls */
415 char **syscall_names
; /* Syscall number to name map */
418 struct procinfo
*thread_list
;
420 int status_valid
: 1;
422 int fpregs_valid
: 1;
423 int threads_valid
: 1;
426 static char errmsg
[128]; /* shared error msg buffer */
428 /* Function prototypes for procinfo module: */
430 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
431 static procinfo
*find_procinfo (int pid
, int tid
);
432 static procinfo
*create_procinfo (int pid
, int tid
);
433 static void destroy_procinfo (procinfo
* p
);
434 static void do_destroy_procinfo_cleanup (void *);
435 static void dead_procinfo (procinfo
* p
, char *msg
, int killp
);
436 static int open_procinfo_files (procinfo
* p
, int which
);
437 static void close_procinfo_files (procinfo
* p
);
438 static int sysset_t_size (procinfo
*p
);
439 static sysset_t
*sysset_t_alloc (procinfo
* pi
);
440 #ifdef DYNAMIC_SYSCALLS
441 static void load_syscalls (procinfo
*pi
);
442 static void free_syscalls (procinfo
*pi
);
443 static int find_syscall (procinfo
*pi
, char *name
);
444 #endif /* DYNAMIC_SYSCALLS */
446 static int iterate_over_mappings
447 (procinfo
*pi
, find_memory_region_ftype child_func
, void *data
,
448 int (*func
) (struct prmap
*map
, find_memory_region_ftype child_func
,
451 /* The head of the procinfo list: */
452 static procinfo
* procinfo_list
;
454 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
458 find_procinfo (int pid
, int tid
)
462 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
469 /* Don't check threads_valid. If we're updating the
470 thread_list, we want to find whatever threads are already
471 here. This means that in general it is the caller's
472 responsibility to check threads_valid and update before
473 calling find_procinfo, if the caller wants to find a new
476 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
484 /* Calls find_procinfo, but errors on failure. */
487 find_procinfo_or_die (int pid
, int tid
)
489 procinfo
*pi
= find_procinfo (pid
, tid
);
494 error (_("procfs: couldn't find pid %d "
495 "(kernel thread %d) in procinfo list."),
498 error (_("procfs: couldn't find pid %d in procinfo list."), pid
);
503 /* Wrapper for `open'. The appropriate open call is attempted; if
504 unsuccessful, it will be retried as many times as needed for the
505 EAGAIN and EINTR conditions.
507 For other conditions, retry the open a limited number of times. In
508 addition, a short sleep is imposed prior to retrying the open. The
509 reason for this sleep is to give the kernel a chance to catch up
510 and create the file in question in the event that GDB "wins" the
511 race to open a file before the kernel has created it. */
514 open_with_retry (const char *pathname
, int flags
)
516 int retries_remaining
, status
;
518 retries_remaining
= 2;
522 status
= open (pathname
, flags
);
524 if (status
>= 0 || retries_remaining
== 0)
526 else if (errno
!= EINTR
&& errno
!= EAGAIN
)
536 /* Open the file descriptor for the process or LWP. If NEW_PROC_API
537 is defined, we only open the control file descriptor; the others
538 are opened lazily as needed. Otherwise (if not NEW_PROC_API),
539 there is only one real file descriptor, but we keep multiple copies
540 of it so that the code that uses them does not have to be #ifdef'd.
541 Returns the file descriptor, or zero for failure. */
543 enum { FD_CTL
, FD_STATUS
, FD_AS
};
546 open_procinfo_files (procinfo
*pi
, int which
)
549 char tmp
[MAX_PROC_NAME_SIZE
];
553 /* This function is getting ALMOST long enough to break up into
554 several. Here is some rationale:
556 NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
557 There are several file descriptors that may need to be open
558 for any given process or LWP. The ones we're intereted in are:
559 - control (ctl) write-only change the state
560 - status (status) read-only query the state
561 - address space (as) read/write access memory
562 - map (map) read-only virtual addr map
563 Most of these are opened lazily as they are needed.
564 The pathnames for the 'files' for an LWP look slightly
565 different from those of a first-class process:
566 Pathnames for a process (<proc-id>):
568 /proc/<proc-id>/status
571 Pathnames for an LWP (lwp-id):
572 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
573 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
574 An LWP has no map or address space file descriptor, since
575 the memory map and address space are shared by all LWPs.
577 Everyone else (Solaris 2.5, Irix, OSF)
578 There is only one file descriptor for each process or LWP.
579 For convenience, we copy the same file descriptor into all
580 three fields of the procinfo struct (ctl_fd, status_fd, and
581 as_fd, see NEW_PROC_API above) so that code that uses them
582 doesn't need any #ifdef's.
587 Each LWP has an independent file descriptor, but these
588 are not obtained via the 'open' system call like the rest:
589 instead, they're obtained thru an ioctl call (PIOCOPENLWP)
590 to the file descriptor of the parent process.
593 These do not even have their own independent file descriptor.
594 All operations are carried out on the file descriptor of the
595 parent process. Therefore we just call open again for each
596 thread, getting a new handle for the same 'file'. */
599 /* In this case, there are several different file descriptors that
600 we might be asked to open. The control file descriptor will be
601 opened early, but the others will be opened lazily as they are
604 strcpy (tmp
, pi
->pathname
);
605 switch (which
) { /* Which file descriptor to open? */
608 strcat (tmp
, "/lwpctl");
610 strcat (tmp
, "/ctl");
611 fd
= open_with_retry (tmp
, O_WRONLY
);
618 return 0; /* There is no 'as' file descriptor for an lwp. */
620 fd
= open_with_retry (tmp
, O_RDWR
);
627 strcat (tmp
, "/lwpstatus");
629 strcat (tmp
, "/status");
630 fd
= open_with_retry (tmp
, O_RDONLY
);
636 return 0; /* unknown file descriptor */
638 #else /* not NEW_PROC_API */
639 /* In this case, there is only one file descriptor for each procinfo
640 (ie. each process or LWP). In fact, only the file descriptor for
641 the process can actually be opened by an 'open' system call. The
642 ones for the LWPs have to be obtained thru an IOCTL call on the
643 process's file descriptor.
645 For convenience, we copy each procinfo's single file descriptor
646 into all of the fields occupied by the several file descriptors
647 of the NEW_PROC_API implementation. That way, the code that uses
648 them can be written without ifdefs. */
651 #ifdef PIOCTSTATUS /* OSF */
652 /* Only one FD; just open it. */
653 if ((fd
= open_with_retry (pi
->pathname
, O_RDWR
)) < 0)
655 #else /* Sol 2.5, Irix, other? */
656 if (pi
->tid
== 0) /* Master procinfo for the process */
658 fd
= open_with_retry (pi
->pathname
, O_RDWR
);
662 else /* LWP thread procinfo */
664 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
668 /* Find the procinfo for the entire process. */
669 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
672 /* Now obtain the file descriptor for the LWP. */
673 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) < 0)
675 #else /* Irix, other? */
676 return 0; /* Don't know how to open threads. */
677 #endif /* Sol 2.5 PIOCOPENLWP */
679 #endif /* OSF PIOCTSTATUS */
680 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
681 #endif /* NEW_PROC_API */
683 return 1; /* success */
686 /* Allocate a data structure and link it into the procinfo list.
687 First tries to find a pre-existing one (FIXME: why?). Returns the
688 pointer to new procinfo struct. */
691 create_procinfo (int pid
, int tid
)
693 procinfo
*pi
, *parent
= NULL
;
695 if ((pi
= find_procinfo (pid
, tid
)))
696 return pi
; /* Already exists, nothing to do. */
698 /* Find parent before doing malloc, to save having to cleanup. */
700 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
702 doesn't exist yet? */
704 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
705 memset (pi
, 0, sizeof (procinfo
));
709 #ifdef DYNAMIC_SYSCALLS
713 pi
->saved_entryset
= sysset_t_alloc (pi
);
714 pi
->saved_exitset
= sysset_t_alloc (pi
);
716 /* Chain into list. */
719 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
720 pi
->next
= procinfo_list
;
726 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
728 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
730 pi
->next
= parent
->thread_list
;
731 parent
->thread_list
= pi
;
736 /* Close all file descriptors associated with the procinfo. */
739 close_procinfo_files (procinfo
*pi
)
746 if (pi
->status_fd
> 0)
747 close (pi
->status_fd
);
749 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
752 /* Destructor function. Close, unlink and deallocate the object. */
755 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
759 /* Step one: unlink the procinfo from its list. */
763 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
766 ptr
->next
= pi
->next
;
770 /* Step two: close any open file descriptors. */
771 close_procinfo_files (pi
);
773 /* Step three: free the memory. */
774 #ifdef DYNAMIC_SYSCALLS
777 xfree (pi
->saved_entryset
);
778 xfree (pi
->saved_exitset
);
783 destroy_procinfo (procinfo
*pi
)
787 if (pi
->tid
!= 0) /* Destroy a thread procinfo. */
789 tmp
= find_procinfo (pi
->pid
, 0); /* Find the parent process. */
790 destroy_one_procinfo (&tmp
->thread_list
, pi
);
792 else /* Destroy a process procinfo and all its threads. */
794 /* First destroy the children, if any; */
795 while (pi
->thread_list
!= NULL
)
796 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
797 /* Then destroy the parent. Genocide!!! */
798 destroy_one_procinfo (&procinfo_list
, pi
);
803 do_destroy_procinfo_cleanup (void *pi
)
805 destroy_procinfo (pi
);
808 enum { NOKILL
, KILL
};
810 /* To be called on a non_recoverable error for a procinfo. Prints
811 error messages, optionally sends a SIGKILL to the process, then
812 destroys the data structure. */
815 dead_procinfo (procinfo
*pi
, char *msg
, int kill_p
)
821 print_sys_errmsg (pi
->pathname
, errno
);
825 sprintf (procfile
, "process %d", pi
->pid
);
826 print_sys_errmsg (procfile
, errno
);
829 kill (pi
->pid
, SIGKILL
);
831 destroy_procinfo (pi
);
835 /* Returns the (complete) size of a sysset_t struct. Normally, this
836 is just sizeof (sysset_t), but in the case of Monterey/64, the
837 actual size of sysset_t isn't known until runtime. */
840 sysset_t_size (procinfo
* pi
)
842 #ifndef DYNAMIC_SYSCALLS
843 return sizeof (sysset_t
);
845 return sizeof (sysset_t
) - sizeof (uint64_t)
846 + sizeof (uint64_t) * ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
847 / (8 * sizeof (uint64_t)));
851 /* Allocate and (partially) initialize a sysset_t struct. */
854 sysset_t_alloc (procinfo
* pi
)
857 int size
= sysset_t_size (pi
);
859 ret
= xmalloc (size
);
860 #ifdef DYNAMIC_SYSCALLS
861 ret
->pr_size
= ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
862 / (8 * sizeof (uint64_t)));
867 #ifdef DYNAMIC_SYSCALLS
869 /* Extract syscall numbers and names from /proc/<pid>/sysent. Initialize
870 pi->num_syscalls with the number of syscalls and pi->syscall_names
871 with the names. (Certain numbers may be skipped in which case the
872 names for these numbers will be left as NULL.) */
874 #define MAX_SYSCALL_NAME_LENGTH 256
875 #define MAX_SYSCALLS 65536
878 load_syscalls (procinfo
*pi
)
880 char pathname
[MAX_PROC_NAME_SIZE
];
883 prsyscall_t
*syscalls
;
884 int i
, size
, maxcall
;
885 struct cleanup
*cleanups
;
887 pi
->num_syscalls
= 0;
888 pi
->syscall_names
= 0;
890 /* Open the file descriptor for the sysent file. */
891 sprintf (pathname
, "/proc/%d/sysent", pi
->pid
);
892 sysent_fd
= open_with_retry (pathname
, O_RDONLY
);
895 error (_("load_syscalls: Can't open /proc/%d/sysent"), pi
->pid
);
897 cleanups
= make_cleanup_close (sysent_fd
);
899 size
= sizeof header
- sizeof (prsyscall_t
);
900 if (read (sysent_fd
, &header
, size
) != size
)
902 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
905 if (header
.pr_nsyscalls
== 0)
907 error (_("load_syscalls: /proc/%d/sysent contains no syscalls!"),
911 size
= header
.pr_nsyscalls
* sizeof (prsyscall_t
);
912 syscalls
= xmalloc (size
);
913 make_cleanup (free_current_contents
, &syscalls
);
915 if (read (sysent_fd
, syscalls
, size
) != size
)
916 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
918 /* Find maximum syscall number. This may not be the same as
919 pr_nsyscalls since that value refers to the number of entries
920 in the table. (Also, the docs indicate that some system
921 call numbers may be skipped.) */
923 maxcall
= syscalls
[0].pr_number
;
925 for (i
= 1; i
< header
.pr_nsyscalls
; i
++)
926 if (syscalls
[i
].pr_number
> maxcall
927 && syscalls
[i
].pr_nameoff
> 0
928 && syscalls
[i
].pr_number
< MAX_SYSCALLS
)
929 maxcall
= syscalls
[i
].pr_number
;
931 pi
->num_syscalls
= maxcall
+1;
932 pi
->syscall_names
= xmalloc (pi
->num_syscalls
* sizeof (char *));
934 for (i
= 0; i
< pi
->num_syscalls
; i
++)
935 pi
->syscall_names
[i
] = NULL
;
937 /* Read the syscall names in. */
938 for (i
= 0; i
< header
.pr_nsyscalls
; i
++)
940 char namebuf
[MAX_SYSCALL_NAME_LENGTH
];
944 if (syscalls
[i
].pr_number
>= MAX_SYSCALLS
945 || syscalls
[i
].pr_number
< 0
946 || syscalls
[i
].pr_nameoff
<= 0
947 || (lseek (sysent_fd
, (off_t
) syscalls
[i
].pr_nameoff
, SEEK_SET
)
948 != (off_t
) syscalls
[i
].pr_nameoff
))
951 nread
= read (sysent_fd
, namebuf
, sizeof namebuf
);
955 callnum
= syscalls
[i
].pr_number
;
957 if (pi
->syscall_names
[callnum
] != NULL
)
959 /* FIXME: Generate warning. */
963 namebuf
[nread
-1] = '\0';
964 size
= strlen (namebuf
) + 1;
965 pi
->syscall_names
[callnum
] = xmalloc (size
);
966 strncpy (pi
->syscall_names
[callnum
], namebuf
, size
-1);
967 pi
->syscall_names
[callnum
][size
-1] = '\0';
970 do_cleanups (cleanups
);
973 /* Free the space allocated for the syscall names from the procinfo
977 free_syscalls (procinfo
*pi
)
979 if (pi
->syscall_names
)
983 for (i
= 0; i
< pi
->num_syscalls
; i
++)
984 if (pi
->syscall_names
[i
] != NULL
)
985 xfree (pi
->syscall_names
[i
]);
987 xfree (pi
->syscall_names
);
988 pi
->syscall_names
= 0;
992 /* Given a name, look up (and return) the corresponding syscall number.
993 If no match is found, return -1. */
996 find_syscall (procinfo
*pi
, char *name
)
1000 for (i
= 0; i
< pi
->num_syscalls
; i
++)
1002 if (pi
->syscall_names
[i
] && strcmp (name
, pi
->syscall_names
[i
]) == 0)
1009 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
1011 /* =================== /proc "MODULE" =================== */
1013 /* This "module" is the interface layer between the /proc system API
1014 and the gdb target vector functions. This layer consists of access
1015 functions that encapsulate each of the basic operations that we
1016 need to use from the /proc API.
1018 The main motivation for this layer is to hide the fact that there
1019 are two very different implementations of the /proc API. Rather
1020 than have a bunch of #ifdefs all thru the gdb target vector
1021 functions, we do our best to hide them all in here. */
1023 static long proc_flags (procinfo
* pi
);
1024 static int proc_why (procinfo
* pi
);
1025 static int proc_what (procinfo
* pi
);
1026 static int proc_set_current_signal (procinfo
* pi
, int signo
);
1027 static int proc_get_current_thread (procinfo
* pi
);
1028 static int proc_iterate_over_threads
1030 int (*func
) (procinfo
*, procinfo
*, void *),
1034 proc_warn (procinfo
*pi
, char *func
, int line
)
1036 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1037 print_sys_errmsg (errmsg
, errno
);
1041 proc_error (procinfo
*pi
, char *func
, int line
)
1043 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1044 perror_with_name (errmsg
);
1047 /* Updates the status struct in the procinfo. There is a 'valid'
1048 flag, to let other functions know when this function needs to be
1049 called (so the status is only read when it is needed). The status
1050 file descriptor is also only opened when it is needed. Returns
1051 non-zero for success, zero for failure. */
1054 proc_get_status (procinfo
*pi
)
1056 /* Status file descriptor is opened "lazily". */
1057 if (pi
->status_fd
== 0 &&
1058 open_procinfo_files (pi
, FD_STATUS
) == 0)
1060 pi
->status_valid
= 0;
1065 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
1066 pi
->status_valid
= 0; /* fail */
1069 /* Sigh... I have to read a different data structure,
1070 depending on whether this is a main process or an LWP. */
1072 pi
->status_valid
= (read (pi
->status_fd
,
1073 (char *) &pi
->prstatus
.pr_lwp
,
1074 sizeof (lwpstatus_t
))
1075 == sizeof (lwpstatus_t
));
1078 pi
->status_valid
= (read (pi
->status_fd
,
1079 (char *) &pi
->prstatus
,
1080 sizeof (gdb_prstatus_t
))
1081 == sizeof (gdb_prstatus_t
));
1082 #if 0 /*def UNIXWARE*/
1083 if (pi
->status_valid
&&
1084 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
1085 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
1086 /* Unixware peculiarity -- read the damn thing again! */
1087 pi
->status_valid
= (read (pi
->status_fd
,
1088 (char *) &pi
->prstatus
,
1089 sizeof (gdb_prstatus_t
))
1090 == sizeof (gdb_prstatus_t
));
1091 #endif /* UNIXWARE */
1094 #else /* ioctl method */
1095 #ifdef PIOCTSTATUS /* osf */
1096 if (pi
->tid
== 0) /* main process */
1098 /* Just read the danged status. Now isn't that simple? */
1100 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1107 tid_t pr_error_thread
;
1108 struct prstatus status
;
1111 thread_status
.pr_count
= 1;
1112 thread_status
.status
.pr_tid
= pi
->tid
;
1113 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
1116 memcpy (&pi
->prstatus
, &thread_status
.status
,
1117 sizeof (pi
->prstatus
));
1118 pi
->status_valid
= 1;
1122 /* Just read the danged status. Now isn't that simple? */
1123 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1127 if (pi
->status_valid
)
1129 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1132 proc_get_current_thread (pi
));
1135 /* The status struct includes general regs, so mark them valid too. */
1136 pi
->gregs_valid
= pi
->status_valid
;
1138 /* In the read/write multiple-fd model, the status struct includes
1139 the fp regs too, so mark them valid too. */
1140 pi
->fpregs_valid
= pi
->status_valid
;
1142 return pi
->status_valid
; /* True if success, false if failure. */
1145 /* Returns the process flags (pr_flags field). */
1148 proc_flags (procinfo
*pi
)
1150 if (!pi
->status_valid
)
1151 if (!proc_get_status (pi
))
1152 return 0; /* FIXME: not a good failure value (but what is?) */
1156 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
1157 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
1158 The two sets of flags don't overlap. */
1159 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
1161 return pi
->prstatus
.pr_lwp
.pr_flags
;
1164 return pi
->prstatus
.pr_flags
;
1168 /* Returns the pr_why field (why the process stopped). */
1171 proc_why (procinfo
*pi
)
1173 if (!pi
->status_valid
)
1174 if (!proc_get_status (pi
))
1175 return 0; /* FIXME: not a good failure value (but what is?) */
1178 return pi
->prstatus
.pr_lwp
.pr_why
;
1180 return pi
->prstatus
.pr_why
;
1184 /* Returns the pr_what field (details of why the process stopped). */
1187 proc_what (procinfo
*pi
)
1189 if (!pi
->status_valid
)
1190 if (!proc_get_status (pi
))
1191 return 0; /* FIXME: not a good failure value (but what is?) */
1194 return pi
->prstatus
.pr_lwp
.pr_what
;
1196 return pi
->prstatus
.pr_what
;
1200 /* This function is only called when PI is stopped by a watchpoint.
1201 Assuming the OS supports it, write to *ADDR the data address which
1202 triggered it and return 1. Return 0 if it is not possible to know
1206 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
1208 if (!pi
->status_valid
)
1209 if (!proc_get_status (pi
))
1213 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch
,
1214 builtin_type (target_gdbarch
)->builtin_data_ptr
,
1215 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
1217 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch
,
1218 builtin_type (target_gdbarch
)->builtin_data_ptr
,
1219 (gdb_byte
*) &pi
->prstatus
.pr_info
.si_addr
);
1224 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1226 /* Returns the pr_nsysarg field (number of args to the current
1230 proc_nsysarg (procinfo
*pi
)
1232 if (!pi
->status_valid
)
1233 if (!proc_get_status (pi
))
1237 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1239 return pi
->prstatus
.pr_nsysarg
;
1243 /* Returns the pr_sysarg field (pointer to the arguments of current
1247 proc_sysargs (procinfo
*pi
)
1249 if (!pi
->status_valid
)
1250 if (!proc_get_status (pi
))
1254 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1256 return (long *) &pi
->prstatus
.pr_sysarg
;
1259 #endif /* PIOCSSPCACT */
1261 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
1262 /* Returns the pr_cursig field (current signal). */
1265 proc_cursig (struct procinfo
*pi
)
1267 if (!pi
->status_valid
)
1268 if (!proc_get_status (pi
))
1269 return 0; /* FIXME: not a good failure value (but what is?) */
1272 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1274 return pi
->prstatus
.pr_cursig
;
1277 #endif /* PROCFS_DONT_PIOCSSIG_CURSIG */
1279 /* === I appologize for the messiness of this function.
1280 === This is an area where the different versions of
1281 === /proc are more inconsistent than usual.
1283 Set or reset any of the following process flags:
1284 PR_FORK -- forked child will inherit trace flags
1285 PR_RLC -- traced process runs when last /proc file closed.
1286 PR_KLC -- traced process is killed when last /proc file closed.
1287 PR_ASYNC -- LWP's get to run/stop independently.
1289 There are three methods for doing this function:
1290 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1292 2) Middle: PIOCSET/PIOCRESET
1294 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1297 Note: Irix does not define PR_ASYNC.
1298 Note: OSF does not define PR_KLC.
1299 Note: OSF is the only one that can ONLY use the oldest method.
1303 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1304 mode -- 1 for set, 0 for reset.
1306 Returns non-zero for success, zero for failure. */
1308 enum { FLAG_RESET
, FLAG_SET
};
1311 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
1313 long win
= 0; /* default to fail */
1315 /* These operations affect the process as a whole, and applying them
1316 to an individual LWP has the same meaning as applying them to the
1317 main process. Therefore, if we're ever called with a pointer to
1318 an LWP's procinfo, let's substitute the process's procinfo and
1319 avoid opening the LWP's file descriptor unnecessarily. */
1322 pi
= find_procinfo_or_die (pi
->pid
, 0);
1324 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii. */
1325 /* First normalize the PCUNSET/PCRESET command opcode
1326 (which for no obvious reason has a different definition
1327 from one operating system to the next...) */
1329 #define GDBRESET PCUNSET
1332 #define GDBRESET PCRESET
1336 procfs_ctl_t arg
[2];
1338 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
1340 else /* Reset the flag. */
1344 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1347 #ifdef PIOCSET /* Irix/Sol5 method */
1348 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC). */
1350 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1352 else /* Reset the flag. */
1354 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1358 #ifdef PIOCSRLC /* Oldest method: OSF */
1361 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1363 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1365 else /* Clear run-on-last-close */
1367 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1371 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1373 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1375 else /* Clear inherit-on-fork */
1377 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1381 win
= 0; /* Fail -- unknown flag (can't do PR_ASYNC). */
1388 /* The above operation renders the procinfo's cached pstatus
1390 pi
->status_valid
= 0;
1393 warning (_("procfs: modify_flag failed to turn %s %s"),
1394 flag
== PR_FORK
? "PR_FORK" :
1395 flag
== PR_RLC
? "PR_RLC" :
1397 flag
== PR_ASYNC
? "PR_ASYNC" :
1400 flag
== PR_KLC
? "PR_KLC" :
1403 mode
== FLAG_RESET
? "off" : "on");
1408 /* Set the run_on_last_close flag. Process with all threads will
1409 become runnable when debugger closes all /proc fds. Returns
1410 non-zero for success, zero for failure. */
1413 proc_set_run_on_last_close (procinfo
*pi
)
1415 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1418 /* Reset the run_on_last_close flag. The process will NOT become
1419 runnable when debugger closes its file handles. Returns non-zero
1420 for success, zero for failure. */
1423 proc_unset_run_on_last_close (procinfo
*pi
)
1425 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1428 /* Reset inherit_on_fork flag. If the process forks a child while we
1429 are registered for events in the parent, then we will NOT recieve
1430 events from the child. Returns non-zero for success, zero for
1434 proc_unset_inherit_on_fork (procinfo
*pi
)
1436 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1440 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
1441 (signal etc.), the remaining LWPs will continue to run. Returns
1442 non-zero for success, zero for failure. */
1445 proc_set_async (procinfo
*pi
)
1447 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1450 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
1451 (signal etc.), then all other LWPs will stop as well. Returns
1452 non-zero for success, zero for failure. */
1455 proc_unset_async (procinfo
*pi
)
1457 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1459 #endif /* PR_ASYNC */
1461 /* Request the process/LWP to stop. Does not wait. Returns non-zero
1462 for success, zero for failure. */
1465 proc_stop_process (procinfo
*pi
)
1469 /* We might conceivably apply this operation to an LWP, and the
1470 LWP's ctl file descriptor might not be open. */
1472 if (pi
->ctl_fd
== 0 &&
1473 open_procinfo_files (pi
, FD_CTL
) == 0)
1478 procfs_ctl_t cmd
= PCSTOP
;
1480 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1481 #else /* ioctl method */
1482 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1483 /* Note: the call also reads the prstatus. */
1486 pi
->status_valid
= 1;
1487 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1490 proc_get_current_thread (pi
));
1498 /* Wait for the process or LWP to stop (block until it does). Returns
1499 non-zero for success, zero for failure. */
1502 proc_wait_for_stop (procinfo
*pi
)
1506 /* We should never have to apply this operation to any procinfo
1507 except the one for the main process. If that ever changes for
1508 any reason, then take out the following clause and replace it
1509 with one that makes sure the ctl_fd is open. */
1512 pi
= find_procinfo_or_die (pi
->pid
, 0);
1516 procfs_ctl_t cmd
= PCWSTOP
;
1518 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1519 /* We been runnin' and we stopped -- need to update status. */
1520 pi
->status_valid
= 0;
1522 #else /* ioctl method */
1523 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1524 /* Above call also refreshes the prstatus. */
1527 pi
->status_valid
= 1;
1528 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1531 proc_get_current_thread (pi
));
1538 /* Make the process or LWP runnable.
1540 Options (not all are implemented):
1542 - clear current fault
1543 - clear current signal
1544 - abort the current system call
1545 - stop as soon as finished with system call
1546 - (ioctl): set traced signal set
1547 - (ioctl): set held signal set
1548 - (ioctl): set traced fault set
1549 - (ioctl): set start pc (vaddr)
1551 Always clears the current fault. PI is the process or LWP to
1552 operate on. If STEP is true, set the process or LWP to trap after
1553 one instruction. If SIGNO is zero, clear the current signal if
1554 any; if non-zero, set the current signal to this one. Returns
1555 non-zero for success, zero for failure. */
1558 proc_run_process (procinfo
*pi
, int step
, int signo
)
1563 /* We will probably have to apply this operation to individual
1564 threads, so make sure the control file descriptor is open. */
1566 if (pi
->ctl_fd
== 0 &&
1567 open_procinfo_files (pi
, FD_CTL
) == 0)
1572 runflags
= PRCFAULT
; /* Always clear current fault. */
1577 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
1578 proc_set_current_signal (pi
, signo
);
1582 procfs_ctl_t cmd
[2];
1586 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1588 #else /* ioctl method */
1592 memset (&prrun
, 0, sizeof (prrun
));
1593 prrun
.pr_flags
= runflags
;
1594 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1601 /* Register to trace signals in the process or LWP. Returns non-zero
1602 for success, zero for failure. */
1605 proc_set_traced_signals (procinfo
*pi
, gdb_sigset_t
*sigset
)
1609 /* We should never have to apply this operation to any procinfo
1610 except the one for the main process. If that ever changes for
1611 any reason, then take out the following clause and replace it
1612 with one that makes sure the ctl_fd is open. */
1615 pi
= find_procinfo_or_die (pi
->pid
, 0);
1621 /* Use char array to avoid alignment issues. */
1622 char sigset
[sizeof (gdb_sigset_t
)];
1626 memcpy (&arg
.sigset
, sigset
, sizeof (gdb_sigset_t
));
1628 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1630 #else /* ioctl method */
1631 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1633 /* The above operation renders the procinfo's cached pstatus obsolete. */
1634 pi
->status_valid
= 0;
1637 warning (_("procfs: set_traced_signals failed"));
1641 /* Register to trace hardware faults in the process or LWP. Returns
1642 non-zero for success, zero for failure. */
1645 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1649 /* We should never have to apply this operation to any procinfo
1650 except the one for the main process. If that ever changes for
1651 any reason, then take out the following clause and replace it
1652 with one that makes sure the ctl_fd is open. */
1655 pi
= find_procinfo_or_die (pi
->pid
, 0);
1661 /* Use char array to avoid alignment issues. */
1662 char fltset
[sizeof (fltset_t
)];
1666 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1668 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1670 #else /* ioctl method */
1671 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1673 /* The above operation renders the procinfo's cached pstatus obsolete. */
1674 pi
->status_valid
= 0;
1679 /* Register to trace entry to system calls in the process or LWP.
1680 Returns non-zero for success, zero for failure. */
1683 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1687 /* We should never have to apply this operation to any procinfo
1688 except the one for the main process. If that ever changes for
1689 any reason, then take out the following clause and replace it
1690 with one that makes sure the ctl_fd is open. */
1693 pi
= find_procinfo_or_die (pi
->pid
, 0);
1697 struct gdb_proc_ctl_pcsentry
{
1699 /* Use char array to avoid alignment issues. */
1700 char sysset
[sizeof (sysset_t
)];
1702 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
)
1704 + sysset_t_size (pi
);
1706 argp
= xmalloc (argp_size
);
1708 argp
->cmd
= PCSENTRY
;
1709 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1711 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1714 #else /* ioctl method */
1715 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1717 /* The above operation renders the procinfo's cached pstatus
1719 pi
->status_valid
= 0;
1724 /* Register to trace exit from system calls in the process or LWP.
1725 Returns non-zero for success, zero for failure. */
1728 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
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);
1742 struct gdb_proc_ctl_pcsexit
{
1744 /* Use char array to avoid alignment issues. */
1745 char sysset
[sizeof (sysset_t
)];
1747 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
)
1749 + sysset_t_size (pi
);
1751 argp
= xmalloc (argp_size
);
1753 argp
->cmd
= PCSEXIT
;
1754 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1756 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1759 #else /* ioctl method */
1760 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1762 /* The above operation renders the procinfo's cached pstatus
1764 pi
->status_valid
= 0;
1769 /* Specify the set of blocked / held signals in the process or LWP.
1770 Returns non-zero for success, zero for failure. */
1773 proc_set_held_signals (procinfo
*pi
, gdb_sigset_t
*sighold
)
1777 /* We should never have to apply this operation to any procinfo
1778 except the one for the main process. If that ever changes for
1779 any reason, then take out the following clause and replace it
1780 with one that makes sure the ctl_fd is open. */
1783 pi
= find_procinfo_or_die (pi
->pid
, 0);
1789 /* Use char array to avoid alignment issues. */
1790 char hold
[sizeof (gdb_sigset_t
)];
1794 memcpy (&arg
.hold
, sighold
, sizeof (gdb_sigset_t
));
1795 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1798 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1800 /* The above operation renders the procinfo's cached pstatus
1802 pi
->status_valid
= 0;
1807 /* Returns the set of signals that are held / blocked. Will also copy
1808 the sigset if SAVE is non-zero. */
1810 static gdb_sigset_t
*
1811 proc_get_held_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1813 gdb_sigset_t
*ret
= NULL
;
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);
1824 if (!pi
->status_valid
)
1825 if (!proc_get_status (pi
))
1829 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1831 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1832 #endif /* UNIXWARE */
1833 #else /* not NEW_PROC_API */
1835 static gdb_sigset_t sigheld
;
1837 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1840 #endif /* NEW_PROC_API */
1842 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1847 /* Returns the set of signals that are traced / debugged. Will also
1848 copy the sigset if SAVE is non-zero. */
1850 static gdb_sigset_t
*
1851 proc_get_traced_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1853 gdb_sigset_t
*ret
= NULL
;
1855 /* We should never have to apply this operation to any procinfo
1856 except the one for the main process. If that ever changes for
1857 any reason, then take out the following clause and replace it
1858 with one that makes sure the ctl_fd is open. */
1861 pi
= find_procinfo_or_die (pi
->pid
, 0);
1864 if (!pi
->status_valid
)
1865 if (!proc_get_status (pi
))
1868 ret
= &pi
->prstatus
.pr_sigtrace
;
1871 static gdb_sigset_t sigtrace
;
1873 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
1878 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1883 /* Returns the set of hardware faults that are traced /debugged. Will
1884 also copy the faultset if SAVE is non-zero. */
1887 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
1889 fltset_t
*ret
= NULL
;
1891 /* We should never have to apply this operation to any procinfo
1892 except the one for the main process. If that ever changes for
1893 any reason, then take out the following clause and replace it
1894 with one that makes sure the ctl_fd is open. */
1897 pi
= find_procinfo_or_die (pi
->pid
, 0);
1900 if (!pi
->status_valid
)
1901 if (!proc_get_status (pi
))
1904 ret
= &pi
->prstatus
.pr_flttrace
;
1907 static fltset_t flttrace
;
1909 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
1914 memcpy (save
, ret
, sizeof (fltset_t
));
1919 /* Returns the set of syscalls that are traced /debugged on entry.
1920 Will also copy the syscall set if SAVE is non-zero. */
1923 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
1925 sysset_t
*ret
= NULL
;
1927 /* We should never have to apply this operation to any procinfo
1928 except the one for the main process. If that ever changes for
1929 any reason, then take out the following clause and replace it
1930 with one that makes sure the ctl_fd is open. */
1933 pi
= find_procinfo_or_die (pi
->pid
, 0);
1936 if (!pi
->status_valid
)
1937 if (!proc_get_status (pi
))
1940 #ifndef DYNAMIC_SYSCALLS
1941 ret
= &pi
->prstatus
.pr_sysentry
;
1942 #else /* DYNAMIC_SYSCALLS */
1944 static sysset_t
*sysentry
;
1948 sysentry
= sysset_t_alloc (pi
);
1950 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
1952 if (pi
->prstatus
.pr_sysentry_offset
== 0)
1954 gdb_premptysysset (sysentry
);
1960 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysentry_offset
,
1962 != (off_t
) pi
->prstatus
.pr_sysentry_offset
)
1964 size
= sysset_t_size (pi
);
1965 gdb_premptysysset (sysentry
);
1966 rsize
= read (pi
->status_fd
, sysentry
, size
);
1971 #endif /* DYNAMIC_SYSCALLS */
1972 #else /* !NEW_PROC_API */
1974 static sysset_t sysentry
;
1976 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
1979 #endif /* NEW_PROC_API */
1981 memcpy (save
, ret
, sysset_t_size (pi
));
1986 /* Returns the set of syscalls that are traced /debugged on exit.
1987 Will also copy the syscall set if SAVE is non-zero. */
1990 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
1992 sysset_t
* ret
= NULL
;
1994 /* We should never have to apply this operation to any procinfo
1995 except the one for the main process. If that ever changes for
1996 any reason, then take out the following clause and replace it
1997 with one that makes sure the ctl_fd is open. */
2000 pi
= find_procinfo_or_die (pi
->pid
, 0);
2003 if (!pi
->status_valid
)
2004 if (!proc_get_status (pi
))
2007 #ifndef DYNAMIC_SYSCALLS
2008 ret
= &pi
->prstatus
.pr_sysexit
;
2009 #else /* DYNAMIC_SYSCALLS */
2011 static sysset_t
*sysexit
;
2015 sysexit
= sysset_t_alloc (pi
);
2017 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2019 if (pi
->prstatus
.pr_sysexit_offset
== 0)
2021 gdb_premptysysset (sysexit
);
2027 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysexit_offset
,
2029 != (off_t
) pi
->prstatus
.pr_sysexit_offset
)
2031 size
= sysset_t_size (pi
);
2032 gdb_premptysysset (sysexit
);
2033 rsize
= read (pi
->status_fd
, sysexit
, size
);
2038 #endif /* DYNAMIC_SYSCALLS */
2041 static sysset_t sysexit
;
2043 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2048 memcpy (save
, ret
, sysset_t_size (pi
));
2053 /* The current fault (if any) is cleared; the associated signal will
2054 not be sent to the process or LWP when it resumes. Returns
2055 non-zero for success, zero for failure. */
2058 proc_clear_current_fault (procinfo
*pi
)
2062 /* We should never have to apply this operation to any procinfo
2063 except the one for the main process. If that ever changes for
2064 any reason, then take out the following clause and replace it
2065 with one that makes sure the ctl_fd is open. */
2068 pi
= find_procinfo_or_die (pi
->pid
, 0);
2072 procfs_ctl_t cmd
= PCCFAULT
;
2074 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2077 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2083 /* Set the "current signal" that will be delivered next to the
2084 process. NOTE: semantics are different from those of KILL. This
2085 signal will be delivered to the process or LWP immediately when it
2086 is resumed (even if the signal is held/blocked); it will NOT
2087 immediately cause another event of interest, and will NOT first
2088 trap back to the debugger. Returns non-zero for success, zero for
2092 proc_set_current_signal (procinfo
*pi
, int signo
)
2097 /* Use char array to avoid alignment issues. */
2098 char sinfo
[sizeof (gdb_siginfo_t
)];
2100 gdb_siginfo_t mysinfo
;
2102 struct target_waitstatus wait_status
;
2104 /* We should never have to apply this operation to any procinfo
2105 except the one for the main process. If that ever changes for
2106 any reason, then take out the following clause and replace it
2107 with one that makes sure the ctl_fd is open. */
2110 pi
= find_procinfo_or_die (pi
->pid
, 0);
2112 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2113 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2114 receives a PIOCSSIG with a signal identical to the current
2115 signal, it messes up the current signal. Work around the kernel
2118 signo
== proc_cursig (pi
))
2119 return 1; /* I assume this is a success? */
2122 /* The pointer is just a type alias. */
2123 get_last_target_status (&wait_ptid
, &wait_status
);
2124 if (ptid_equal (wait_ptid
, inferior_ptid
)
2125 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
2126 && wait_status
.value
.sig
== gdb_signal_from_host (signo
)
2127 && proc_get_status (pi
)
2129 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
2131 && pi
->prstatus
.pr_info
.si_signo
== signo
2134 /* Use the siginfo associated with the signal being
2137 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (gdb_siginfo_t
));
2139 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_info
, sizeof (gdb_siginfo_t
));
2143 mysinfo
.si_signo
= signo
;
2144 mysinfo
.si_code
= 0;
2145 mysinfo
.si_pid
= getpid (); /* ?why? */
2146 mysinfo
.si_uid
= getuid (); /* ?why? */
2147 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2152 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2154 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2160 /* The current signal (if any) is cleared, and is not sent to the
2161 process or LWP when it resumes. Returns non-zero for success, zero
2165 proc_clear_current_signal (procinfo
*pi
)
2169 /* We should never have to apply this operation to any procinfo
2170 except the one for the main process. If that ever changes for
2171 any reason, then take out the following clause and replace it
2172 with one that makes sure the ctl_fd is open. */
2175 pi
= find_procinfo_or_die (pi
->pid
, 0);
2181 /* Use char array to avoid alignment issues. */
2182 char sinfo
[sizeof (gdb_siginfo_t
)];
2184 gdb_siginfo_t mysinfo
;
2187 /* The pointer is just a type alias. */
2188 mysinfo
.si_signo
= 0;
2189 mysinfo
.si_code
= 0;
2190 mysinfo
.si_errno
= 0;
2191 mysinfo
.si_pid
= getpid (); /* ?why? */
2192 mysinfo
.si_uid
= getuid (); /* ?why? */
2193 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2195 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2198 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2204 /* Return the general-purpose registers for the process or LWP
2205 corresponding to PI. Upon failure, return NULL. */
2207 static gdb_gregset_t
*
2208 proc_get_gregs (procinfo
*pi
)
2210 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2211 if (!proc_get_status (pi
))
2214 /* OK, sorry about the ifdef's. There's three cases instead of two,
2215 because in this case Unixware and Solaris/RW differ. */
2218 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2219 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2221 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2224 return &pi
->prstatus
.pr_reg
;
2228 /* Return the general-purpose registers for the process or LWP
2229 corresponding to PI. Upon failure, return NULL. */
2231 static gdb_fpregset_t
*
2232 proc_get_fpregs (procinfo
*pi
)
2235 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2236 if (!proc_get_status (pi
))
2239 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2240 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2242 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2245 #else /* not NEW_PROC_API */
2246 if (pi
->fpregs_valid
)
2247 return &pi
->fpregset
; /* Already got 'em. */
2250 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2259 tid_t pr_error_thread
;
2260 tfpregset_t thread_1
;
2263 thread_fpregs
.pr_count
= 1;
2264 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2267 && ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2269 pi
->fpregs_valid
= 1;
2270 return &pi
->fpregset
; /* Got 'em now! */
2272 else if (pi
->tid
!= 0
2273 && ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2275 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2276 sizeof (pi
->fpregset
));
2277 pi
->fpregs_valid
= 1;
2278 return &pi
->fpregset
; /* Got 'em now! */
2285 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2287 pi
->fpregs_valid
= 1;
2288 return &pi
->fpregset
; /* Got 'em now! */
2297 #endif /* NEW_PROC_API */
2300 /* Write the general-purpose registers back to the process or LWP
2301 corresponding to PI. Return non-zero for success, zero for
2305 proc_set_gregs (procinfo
*pi
)
2307 gdb_gregset_t
*gregs
;
2310 gregs
= proc_get_gregs (pi
);
2312 return 0; /* proc_get_regs has already warned. */
2314 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2323 /* Use char array to avoid alignment issues. */
2324 char gregs
[sizeof (gdb_gregset_t
)];
2328 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2329 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2331 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2335 /* Policy: writing the registers invalidates our cache. */
2336 pi
->gregs_valid
= 0;
2340 /* Write the floating-pointer registers back to the process or LWP
2341 corresponding to PI. Return non-zero for success, zero for
2345 proc_set_fpregs (procinfo
*pi
)
2347 gdb_fpregset_t
*fpregs
;
2350 fpregs
= proc_get_fpregs (pi
);
2352 return 0; /* proc_get_fpregs has already warned. */
2354 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2363 /* Use char array to avoid alignment issues. */
2364 char fpregs
[sizeof (gdb_fpregset_t
)];
2368 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2369 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2373 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2378 tid_t pr_error_thread
;
2379 tfpregset_t thread_1
;
2382 thread_fpregs
.pr_count
= 1;
2383 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2384 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2386 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2389 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2391 #endif /* NEW_PROC_API */
2394 /* Policy: writing the registers invalidates our cache. */
2395 pi
->fpregs_valid
= 0;
2399 /* Send a signal to the proc or lwp with the semantics of "kill()".
2400 Returns non-zero for success, zero for failure. */
2403 proc_kill (procinfo
*pi
, int signo
)
2407 /* We might conceivably apply this operation to an LWP, and the
2408 LWP's ctl file descriptor might not be open. */
2410 if (pi
->ctl_fd
== 0 &&
2411 open_procinfo_files (pi
, FD_CTL
) == 0)
2418 procfs_ctl_t cmd
[2];
2422 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2423 #else /* ioctl method */
2424 /* FIXME: do I need the Alpha OSF fixups present in
2425 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2426 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2433 /* Find the pid of the process that started this one. Returns the
2434 parent process pid, or zero. */
2437 proc_parent_pid (procinfo
*pi
)
2439 /* We should never have to apply this operation to any procinfo
2440 except the one for the main process. If that ever changes for
2441 any reason, then take out the following clause and replace it
2442 with one that makes sure the ctl_fd is open. */
2445 pi
= find_procinfo_or_die (pi
->pid
, 0);
2447 if (!pi
->status_valid
)
2448 if (!proc_get_status (pi
))
2451 return pi
->prstatus
.pr_ppid
;
2454 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
2455 (a.k.a void pointer)! */
2457 #if (defined (PCWATCH) || defined (PIOCSWATCH)) \
2458 && !(defined (PIOCOPENLWP) || defined (UNIXWARE))
2460 procfs_address_to_host_pointer (CORE_ADDR addr
)
2462 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
2465 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
2466 gdbarch_address_to_pointer (target_gdbarch
, ptr_type
,
2467 (gdb_byte
*) &ptr
, addr
);
2473 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
2475 #if !defined (PCWATCH) && !defined (PIOCSWATCH)
2476 /* If neither or these is defined, we can't support watchpoints.
2477 This just avoids possibly failing to compile the below on such
2481 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5. */
2482 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out. */
2487 char watch
[sizeof (prwatch_t
)];
2491 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
2492 convert a target address into something that can be stored in a
2493 native data structure. */
2494 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
2495 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
2497 pwatch
.pr_vaddr
= (caddr_t
) procfs_address_to_host_pointer (addr
);
2499 pwatch
.pr_size
= len
;
2500 pwatch
.pr_wflags
= wflags
;
2501 #if defined(NEW_PROC_API) && defined (PCWATCH)
2503 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
2504 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2506 #if defined (PIOCSWATCH)
2507 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, &pwatch
) >= 0);
2509 return 0; /* Fail */
2516 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
2518 #include <sys/sysi86.h>
2520 /* The KEY is actually the value of the lower 16 bits of the GS
2521 register for the LWP that we're interested in. Returns the
2522 matching ssh struct (LDT entry). */
2525 proc_get_LDT_entry (procinfo
*pi
, int key
)
2527 static struct ssd
*ldt_entry
= NULL
;
2529 char pathname
[MAX_PROC_NAME_SIZE
];
2530 struct cleanup
*old_chain
= NULL
;
2533 /* Allocate space for one LDT entry.
2534 This alloc must persist, because we return a pointer to it. */
2535 if (ldt_entry
== NULL
)
2536 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2538 /* Open the file descriptor for the LDT table. */
2539 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2540 if ((fd
= open_with_retry (pathname
, O_RDONLY
)) < 0)
2542 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2545 /* Make sure it gets closed again! */
2546 old_chain
= make_cleanup_close (fd
);
2548 /* Now 'read' thru the table, find a match and return it. */
2549 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2551 if (ldt_entry
->sel
== 0 &&
2552 ldt_entry
->bo
== 0 &&
2553 ldt_entry
->acc1
== 0 &&
2554 ldt_entry
->acc2
== 0)
2555 break; /* end of table */
2556 /* If key matches, return this entry. */
2557 if (ldt_entry
->sel
== key
)
2560 /* Loop ended, match not found. */
2564 static int nalloc
= 0;
2566 /* Get the number of LDT entries. */
2567 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2569 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2573 /* Allocate space for the number of LDT entries. */
2574 /* This alloc has to persist, 'cause we return a pointer to it. */
2577 ldt_entry
= (struct ssd
*)
2578 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2582 /* Read the whole table in one gulp. */
2583 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2585 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2589 /* Search the table and return the (first) entry matching 'key'. */
2590 for (i
= 0; i
< nldt
; i
++)
2591 if (ldt_entry
[i
].sel
== key
)
2592 return &ldt_entry
[i
];
2594 /* Loop ended, match not found. */
2599 /* Returns the pointer to the LDT entry of PTID. */
2602 procfs_find_LDT_entry (ptid_t ptid
)
2604 gdb_gregset_t
*gregs
;
2608 /* Find procinfo for the lwp. */
2609 if ((pi
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
))) == NULL
)
2611 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
2612 PIDGET (ptid
), TIDGET (ptid
));
2615 /* get its general registers. */
2616 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2618 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
2619 PIDGET (ptid
), TIDGET (ptid
));
2622 /* Now extract the GS register's lower 16 bits. */
2623 key
= (*gregs
)[GS
] & 0xffff;
2625 /* Find the matching entry and return it. */
2626 return proc_get_LDT_entry (pi
, key
);
2631 /* =============== END, non-thread part of /proc "MODULE" =============== */
2633 /* =================== Thread "MODULE" =================== */
2635 /* NOTE: you'll see more ifdefs and duplication of functions here,
2636 since there is a different way to do threads on every OS. */
2638 /* Returns the number of threads for the process. */
2640 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2643 proc_get_nthreads (procinfo
*pi
)
2647 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2648 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2654 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2655 /* Solaris and Unixware version */
2657 proc_get_nthreads (procinfo
*pi
)
2659 if (!pi
->status_valid
)
2660 if (!proc_get_status (pi
))
2663 /* NEW_PROC_API: only works for the process procinfo, because the
2664 LWP procinfos do not get prstatus filled in. */
2666 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
2667 pi
= find_procinfo_or_die (pi
->pid
, 0);
2669 return pi
->prstatus
.pr_nlwp
;
2673 /* Default version */
2675 proc_get_nthreads (procinfo
*pi
)
2684 Return the ID of the thread that had an event of interest.
2685 (ie. the one that hit a breakpoint or other traced event). All
2686 other things being equal, this should be the ID of a thread that is
2687 currently executing. */
2689 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2690 /* Solaris and Unixware version */
2692 proc_get_current_thread (procinfo
*pi
)
2694 /* Note: this should be applied to the root procinfo for the
2695 process, not to the procinfo for an LWP. If applied to the
2696 procinfo for an LWP, it will simply return that LWP's ID. In
2697 that case, find the parent process procinfo. */
2700 pi
= find_procinfo_or_die (pi
->pid
, 0);
2702 if (!pi
->status_valid
)
2703 if (!proc_get_status (pi
))
2707 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2709 return pi
->prstatus
.pr_who
;
2714 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2717 proc_get_current_thread (procinfo
*pi
)
2719 #if 0 /* FIXME: not ready for prime time? */
2720 return pi
->prstatus
.pr_tid
;
2727 /* Default version */
2729 proc_get_current_thread (procinfo
*pi
)
2737 /* Discover the IDs of all the threads within the process, and create
2738 a procinfo for each of them (chained to the parent). This
2739 unfortunately requires a different method on every OS. Returns
2740 non-zero for success, zero for failure. */
2743 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
2745 if (thread
&& parent
) /* sanity */
2747 thread
->status_valid
= 0;
2748 if (!proc_get_status (thread
))
2749 destroy_one_procinfo (&parent
->thread_list
, thread
);
2751 return 0; /* keep iterating */
2754 #if defined (PIOCLSTATUS)
2755 /* Solaris 2.5 (ioctl) version */
2757 proc_update_threads (procinfo
*pi
)
2759 gdb_prstatus_t
*prstatus
;
2760 struct cleanup
*old_chain
= NULL
;
2764 /* We should never have to apply this operation to any procinfo
2765 except the one for the main process. If that ever changes for
2766 any reason, then take out the following clause and replace it
2767 with one that makes sure the ctl_fd is open. */
2770 pi
= find_procinfo_or_die (pi
->pid
, 0);
2772 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2774 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2775 return 1; /* Process is not multi-threaded; nothing to do. */
2777 prstatus
= xmalloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1));
2779 old_chain
= make_cleanup (xfree
, prstatus
);
2780 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2781 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2783 /* Skip element zero, which represents the process as a whole. */
2784 for (i
= 1; i
< nlwp
+ 1; i
++)
2786 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
2787 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2789 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
2790 thread
->status_valid
= 1;
2792 pi
->threads_valid
= 1;
2793 do_cleanups (old_chain
);
2798 /* Unixware and Solaris 6 (and later) version. */
2800 do_closedir_cleanup (void *dir
)
2806 proc_update_threads (procinfo
*pi
)
2808 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
2809 struct dirent
*direntry
;
2810 struct cleanup
*old_chain
= NULL
;
2815 /* We should never have to apply this operation to any procinfo
2816 except the one for the main process. If that ever changes for
2817 any reason, then take out the following clause and replace it
2818 with one that makes sure the ctl_fd is open. */
2821 pi
= find_procinfo_or_die (pi
->pid
, 0);
2823 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2827 Note: this brute-force method is the only way I know of to
2828 accomplish this task on Unixware. This method will also work on
2829 Solaris 2.6 and 2.7. There is a much simpler and more elegant
2830 way to do this on Solaris, but the margins of this manuscript are
2831 too small to write it here... ;-) */
2833 strcpy (pathname
, pi
->pathname
);
2834 strcat (pathname
, "/lwp");
2835 if ((dirp
= opendir (pathname
)) == NULL
)
2836 proc_error (pi
, "update_threads, opendir", __LINE__
);
2838 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
2839 while ((direntry
= readdir (dirp
)) != NULL
)
2840 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
2842 lwpid
= atoi (&direntry
->d_name
[0]);
2843 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
2844 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2846 pi
->threads_valid
= 1;
2847 do_cleanups (old_chain
);
2854 proc_update_threads (procinfo
*pi
)
2859 /* We should never have to apply this operation to any procinfo
2860 except the one for the main process. If that ever changes for
2861 any reason, then take out the following clause and replace it
2862 with one that makes sure the ctl_fd is open. */
2865 pi
= find_procinfo_or_die (pi
->pid
, 0);
2867 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2869 nthreads
= proc_get_nthreads (pi
);
2871 return 0; /* Nothing to do for 1 or fewer threads. */
2873 threads
= xmalloc (nthreads
* sizeof (tid_t
));
2875 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
2876 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
2878 for (i
= 0; i
< nthreads
; i
++)
2880 if (!find_procinfo (pi
->pid
, threads
[i
]))
2881 if (!create_procinfo (pi
->pid
, threads
[i
]))
2882 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2884 pi
->threads_valid
= 1;
2888 /* Default version */
2890 proc_update_threads (procinfo
*pi
)
2894 #endif /* OSF PIOCTLIST */
2895 #endif /* NEW_PROC_API */
2896 #endif /* SOL 2.5 PIOCLSTATUS */
2898 /* Given a pointer to a function, call that function once for each lwp
2899 in the procinfo list, until the function returns non-zero, in which
2900 event return the value returned by the function.
2902 Note: this function does NOT call update_threads. If you want to
2903 discover new threads first, you must call that function explicitly.
2904 This function just makes a quick pass over the currently-known
2907 PI is the parent process procinfo. FUNC is the per-thread
2908 function. PTR is an opaque parameter for function. Returns the
2909 first non-zero return value from the callee, or zero. */
2912 proc_iterate_over_threads (procinfo
*pi
,
2913 int (*func
) (procinfo
*, procinfo
*, void *),
2916 procinfo
*thread
, *next
;
2919 /* We should never have to apply this operation to any procinfo
2920 except the one for the main process. If that ever changes for
2921 any reason, then take out the following clause and replace it
2922 with one that makes sure the ctl_fd is open. */
2925 pi
= find_procinfo_or_die (pi
->pid
, 0);
2927 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
2929 next
= thread
->next
; /* In case thread is destroyed. */
2930 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
2937 /* =================== END, Thread "MODULE" =================== */
2939 /* =================== END, /proc "MODULE" =================== */
2941 /* =================== GDB "MODULE" =================== */
2943 /* Here are all of the gdb target vector functions and their
2946 static ptid_t
do_attach (ptid_t ptid
);
2947 static void do_detach (int signo
);
2948 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
2949 int entry_or_exit
, int mode
, int from_tty
);
2951 /* On mips-irix, we need to insert a breakpoint at __dbx_link during
2952 the startup phase. The following two variables are used to record
2953 the address of the breakpoint, and the code that was replaced by
2955 static int dbx_link_bpt_addr
= 0;
2956 static void *dbx_link_bpt
;
2958 /* Sets up the inferior to be debugged. Registers to trace signals,
2959 hardware faults, and syscalls. Note: does not set RLC flag: caller
2960 may want to customize that. Returns zero for success (note!
2961 unlike most functions in this module); on failure, returns the LINE
2962 NUMBER where it failed! */
2965 procfs_debug_inferior (procinfo
*pi
)
2967 fltset_t traced_faults
;
2968 gdb_sigset_t traced_signals
;
2969 sysset_t
*traced_syscall_entries
;
2970 sysset_t
*traced_syscall_exits
;
2973 #ifdef PROCFS_DONT_TRACE_FAULTS
2974 /* On some systems (OSF), we don't trace hardware faults.
2975 Apparently it's enough that we catch them as signals.
2976 Wonder why we don't just do that in general? */
2977 premptyset (&traced_faults
); /* don't trace faults. */
2979 /* Register to trace hardware faults in the child. */
2980 prfillset (&traced_faults
); /* trace all faults... */
2981 gdb_prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
2983 if (!proc_set_traced_faults (pi
, &traced_faults
))
2986 /* Initially, register to trace all signals in the child. */
2987 prfillset (&traced_signals
);
2988 if (!proc_set_traced_signals (pi
, &traced_signals
))
2992 /* Register to trace the 'exit' system call (on entry). */
2993 traced_syscall_entries
= sysset_t_alloc (pi
);
2994 gdb_premptysysset (traced_syscall_entries
);
2996 gdb_praddsysset (traced_syscall_entries
, SYS_exit
);
2999 gdb_praddsysset (traced_syscall_entries
, SYS_lwpexit
);/* And _lwp_exit... */
3002 gdb_praddsysset (traced_syscall_entries
, SYS_lwp_exit
);
3004 #ifdef DYNAMIC_SYSCALLS
3006 int callnum
= find_syscall (pi
, "_exit");
3009 gdb_praddsysset (traced_syscall_entries
, callnum
);
3013 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
3014 xfree (traced_syscall_entries
);
3018 #ifdef PRFS_STOPEXEC /* defined on OSF */
3019 /* OSF method for tracing exec syscalls. Quoting:
3020 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3021 exits from exec system calls because of the user level loader. */
3022 /* FIXME: make nice and maybe move into an access function. */
3026 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3029 prfs_flags
|= PRFS_STOPEXEC
;
3031 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3034 #else /* not PRFS_STOPEXEC */
3035 /* Everyone else's (except OSF) method for tracing exec syscalls. */
3037 Not all systems with /proc have all the exec* syscalls with the same
3038 names. On the SGI, for example, there is no SYS_exec, but there
3039 *is* a SYS_execv. So, we try to account for that. */
3041 traced_syscall_exits
= sysset_t_alloc (pi
);
3042 gdb_premptysysset (traced_syscall_exits
);
3044 gdb_praddsysset (traced_syscall_exits
, SYS_exec
);
3047 gdb_praddsysset (traced_syscall_exits
, SYS_execve
);
3050 gdb_praddsysset (traced_syscall_exits
, SYS_execv
);
3053 #ifdef SYS_lwpcreate
3054 gdb_praddsysset (traced_syscall_exits
, SYS_lwpcreate
);
3055 gdb_praddsysset (traced_syscall_exits
, SYS_lwpexit
);
3058 #ifdef SYS_lwp_create /* FIXME: once only, please. */
3059 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_create
);
3060 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_exit
);
3063 #ifdef DYNAMIC_SYSCALLS
3065 int callnum
= find_syscall (pi
, "execve");
3068 gdb_praddsysset (traced_syscall_exits
, callnum
);
3069 callnum
= find_syscall (pi
, "ra_execve");
3071 gdb_praddsysset (traced_syscall_exits
, callnum
);
3075 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
3076 xfree (traced_syscall_exits
);
3080 #endif /* PRFS_STOPEXEC */
3085 procfs_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3090 pid
= parse_pid_to_attach (args
);
3092 if (pid
== getpid ())
3093 error (_("Attaching GDB to itself is not a good idea..."));
3097 exec_file
= get_exec_file (0);
3100 printf_filtered (_("Attaching to program `%s', %s\n"),
3101 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
3103 printf_filtered (_("Attaching to %s\n"),
3104 target_pid_to_str (pid_to_ptid (pid
)));
3108 inferior_ptid
= do_attach (pid_to_ptid (pid
));
3113 procfs_detach (struct target_ops
*ops
, char *args
, int from_tty
)
3116 int pid
= PIDGET (inferior_ptid
);
3125 exec_file
= get_exec_file (0);
3126 if (exec_file
== NULL
)
3129 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
3130 target_pid_to_str (pid_to_ptid (pid
)));
3131 gdb_flush (gdb_stdout
);
3136 inferior_ptid
= null_ptid
;
3137 detach_inferior (pid
);
3138 unpush_target (ops
);
3142 do_attach (ptid_t ptid
)
3145 struct inferior
*inf
;
3149 if ((pi
= create_procinfo (PIDGET (ptid
), 0)) == NULL
)
3150 perror (_("procfs: out of memory in 'attach'"));
3152 if (!open_procinfo_files (pi
, FD_CTL
))
3154 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3155 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3157 dead_procinfo (pi
, errmsg
, NOKILL
);
3160 /* Stop the process (if it isn't already stopped). */
3161 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3163 pi
->was_stopped
= 1;
3164 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3168 pi
->was_stopped
= 0;
3169 /* Set the process to run again when we close it. */
3170 if (!proc_set_run_on_last_close (pi
))
3171 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3173 /* Now stop the process. */
3174 if (!proc_stop_process (pi
))
3175 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3176 pi
->ignore_next_sigstop
= 1;
3178 /* Save some of the /proc state to be restored if we detach. */
3179 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3180 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3181 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3182 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3183 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
3184 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3186 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
3187 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3189 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3190 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3192 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3193 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3195 inf
= current_inferior ();
3196 inferior_appeared (inf
, pi
->pid
);
3197 /* Let GDB know that the inferior was attached. */
3198 inf
->attach_flag
= 1;
3200 /* Create a procinfo for the current lwp. */
3201 lwpid
= proc_get_current_thread (pi
);
3202 create_procinfo (pi
->pid
, lwpid
);
3204 /* Add it to gdb's thread list. */
3205 ptid
= MERGEPID (pi
->pid
, lwpid
);
3212 do_detach (int signo
)
3216 /* Find procinfo for the main process. */
3217 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0); /* FIXME: threads */
3219 if (!proc_set_current_signal (pi
, signo
))
3220 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3222 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3223 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3225 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3226 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3228 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
3229 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3231 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
3232 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3234 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3235 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3237 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3238 if (signo
|| !(pi
->was_stopped
) ||
3239 query (_("Was stopped when attached, make it runnable again? ")))
3241 /* Clear any pending signal. */
3242 if (!proc_clear_current_fault (pi
))
3243 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3245 if (signo
== 0 && !proc_clear_current_signal (pi
))
3246 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
3248 if (!proc_set_run_on_last_close (pi
))
3249 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3252 destroy_procinfo (pi
);
3255 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
3258 ??? Is the following note still relevant? We can't get individual
3259 registers with the PT_GETREGS ptrace(2) request either, yet we
3260 don't bother with caching at all in that case.
3262 NOTE: Since the /proc interface cannot give us individual
3263 registers, we pay no attention to REGNUM, and just fetch them all.
3264 This results in the possibility that we will do unnecessarily many
3265 fetches, since we may be called repeatedly for individual
3266 registers. So we cache the results, and mark the cache invalid
3267 when the process is resumed. */
3270 procfs_fetch_registers (struct target_ops
*ops
,
3271 struct regcache
*regcache
, int regnum
)
3273 gdb_gregset_t
*gregs
;
3275 int pid
= PIDGET (inferior_ptid
);
3276 int tid
= TIDGET (inferior_ptid
);
3277 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3279 pi
= find_procinfo_or_die (pid
, tid
);
3282 error (_("procfs: fetch_registers failed to find procinfo for %s"),
3283 target_pid_to_str (inferior_ptid
));
3285 gregs
= proc_get_gregs (pi
);
3287 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3289 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
3291 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3293 gdb_fpregset_t
*fpregs
;
3295 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3296 || regnum
== gdbarch_pc_regnum (gdbarch
)
3297 || regnum
== gdbarch_sp_regnum (gdbarch
))
3298 return; /* Not a floating point register. */
3300 fpregs
= proc_get_fpregs (pi
);
3302 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3304 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
3308 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
3309 this for all registers.
3311 NOTE: Since the /proc interface will not read individual registers,
3312 we will cache these requests until the process is resumed, and only
3313 then write them back to the inferior process.
3315 FIXME: is that a really bad idea? Have to think about cases where
3316 writing one register might affect the value of others, etc. */
3319 procfs_store_registers (struct target_ops
*ops
,
3320 struct regcache
*regcache
, int regnum
)
3322 gdb_gregset_t
*gregs
;
3324 int pid
= PIDGET (inferior_ptid
);
3325 int tid
= TIDGET (inferior_ptid
);
3326 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3328 pi
= find_procinfo_or_die (pid
, tid
);
3331 error (_("procfs: store_registers: failed to find procinfo for %s"),
3332 target_pid_to_str (inferior_ptid
));
3334 gregs
= proc_get_gregs (pi
);
3336 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3338 fill_gregset (regcache
, gregs
, regnum
);
3339 if (!proc_set_gregs (pi
))
3340 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3342 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3344 gdb_fpregset_t
*fpregs
;
3346 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3347 || regnum
== gdbarch_pc_regnum (gdbarch
)
3348 || regnum
== gdbarch_sp_regnum (gdbarch
))
3349 return; /* Not a floating point register. */
3351 fpregs
= proc_get_fpregs (pi
);
3353 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3355 fill_fpregset (regcache
, fpregs
, regnum
);
3356 if (!proc_set_fpregs (pi
))
3357 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3362 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
3365 if (scall
== SYS_lwp_exit
)
3369 if (scall
== SYS_lwpexit
)
3376 syscall_is_exit (procinfo
*pi
, int scall
)
3379 if (scall
== SYS_exit
)
3382 #ifdef DYNAMIC_SYSCALLS
3383 if (find_syscall (pi
, "_exit") == scall
)
3390 syscall_is_exec (procinfo
*pi
, int scall
)
3393 if (scall
== SYS_exec
)
3397 if (scall
== SYS_execv
)
3401 if (scall
== SYS_execve
)
3404 #ifdef DYNAMIC_SYSCALLS
3405 if (find_syscall (pi
, "_execve"))
3407 if (find_syscall (pi
, "ra_execve"))
3414 syscall_is_lwp_create (procinfo
*pi
, int scall
)
3416 #ifdef SYS_lwp_create
3417 if (scall
== SYS_lwp_create
)
3420 #ifdef SYS_lwpcreate
3421 if (scall
== SYS_lwpcreate
)
3427 /* Remove the breakpoint that we inserted in __dbx_link().
3428 Does nothing if the breakpoint hasn't been inserted or has already
3432 remove_dbx_link_breakpoint (void)
3434 if (dbx_link_bpt_addr
== 0)
3437 if (deprecated_remove_raw_breakpoint (target_gdbarch
, dbx_link_bpt
) != 0)
3438 warning (_("Unable to remove __dbx_link breakpoint."));
3440 dbx_link_bpt_addr
= 0;
3441 dbx_link_bpt
= NULL
;
3445 /* Return the address of the __dbx_link() function in the file
3446 refernced by ABFD by scanning its symbol table. Return 0 if
3447 the symbol was not found. */
3450 dbx_link_addr (bfd
*abfd
)
3452 long storage_needed
;
3453 asymbol
**symbol_table
;
3454 long number_of_symbols
;
3457 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
3458 if (storage_needed
<= 0)
3461 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
3462 make_cleanup (xfree
, symbol_table
);
3464 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
3466 for (i
= 0; i
< number_of_symbols
; i
++)
3468 asymbol
*sym
= symbol_table
[i
];
3470 if ((sym
->flags
& BSF_GLOBAL
)
3471 && sym
->name
!= NULL
&& strcmp (sym
->name
, "__dbx_link") == 0)
3472 return (sym
->value
+ sym
->section
->vma
);
3475 /* Symbol not found, return NULL. */
3479 /* Search the symbol table of the file referenced by FD for a symbol
3480 named __dbx_link(). If found, then insert a breakpoint at this location,
3481 and return nonzero. Return zero otherwise. */
3484 insert_dbx_link_bpt_in_file (int fd
, CORE_ADDR ignored
)
3487 long storage_needed
;
3490 abfd
= gdb_bfd_fdopenr ("unamed", 0, fd
);
3493 warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
3497 if (!bfd_check_format (abfd
, bfd_object
))
3499 /* Not the correct format, so we can not possibly find the dbx_link
3501 gdb_bfd_unref (abfd
);
3505 sym_addr
= dbx_link_addr (abfd
);
3508 /* Insert the breakpoint. */
3509 dbx_link_bpt_addr
= sym_addr
;
3510 dbx_link_bpt
= deprecated_insert_raw_breakpoint (target_gdbarch
, NULL
,
3512 if (dbx_link_bpt
== NULL
)
3514 warning (_("Failed to insert dbx_link breakpoint."));
3515 gdb_bfd_unref (abfd
);
3518 gdb_bfd_unref (abfd
);
3522 gdb_bfd_unref (abfd
);
3526 /* Calls the supplied callback function once for each mapped address
3527 space in the process. The callback function receives an open file
3528 descriptor for the file corresponding to that mapped address space
3529 (if there is one), and the base address of the mapped space. Quit
3530 when the callback function returns a nonzero value, or at teh end
3531 of the mappings. Returns the first non-zero return value of the
3532 callback function, or zero. */
3535 solib_mappings_callback (struct prmap
*map
, int (*func
) (int, CORE_ADDR
),
3538 procinfo
*pi
= data
;
3542 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
3544 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
3545 return -1; /* sanity */
3547 if (map
->pr_mapname
[0] == 0)
3549 fd
= -1; /* no map file */
3553 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
3554 /* Note: caller's responsibility to close this fd! */
3555 fd
= open_with_retry (name
, O_RDONLY
);
3556 /* Note: we don't test the above call for failure;
3557 we just pass the FD on as given. Sometimes there is
3558 no file, so the open may return failure, but that's
3562 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
->pr_vaddr
);
3563 /* Note: we don't test the above call for failure;
3564 we just pass the FD on as given. Sometimes there is
3565 no file, so the ioctl may return failure, but that's
3568 return (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
);
3571 /* If the given memory region MAP contains a symbol named __dbx_link,
3572 insert a breakpoint at this location and return nonzero. Return
3576 insert_dbx_link_bpt_in_region (struct prmap
*map
,
3577 find_memory_region_ftype child_func
,
3580 procinfo
*pi
= (procinfo
*) data
;
3582 /* We know the symbol we're looking for is in a text region, so
3583 only look for it if the region is a text one. */
3584 if (map
->pr_mflags
& MA_EXEC
)
3585 return solib_mappings_callback (map
, insert_dbx_link_bpt_in_file
, pi
);
3590 /* Search all memory regions for a symbol named __dbx_link. If found,
3591 insert a breakpoint at its location, and return nonzero. Return zero
3595 insert_dbx_link_breakpoint (procinfo
*pi
)
3597 return iterate_over_mappings (pi
, NULL
, pi
, insert_dbx_link_bpt_in_region
);
3601 /* Retrieve the next stop event from the child process. If child has
3602 not stopped yet, wait for it to stop. Translate /proc eventcodes
3603 (or possibly wait eventcodes) into gdb internal event codes.
3604 Returns the id of process (and possibly thread) that incurred the
3605 event. Event codes are returned through a pointer parameter. */
3608 procfs_wait (struct target_ops
*ops
,
3609 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
3611 /* First cut: loosely based on original version 2.1. */
3615 ptid_t retval
, temp_ptid
;
3616 int why
, what
, flags
;
3623 retval
= pid_to_ptid (-1);
3625 /* Find procinfo for main process. */
3626 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
3629 /* We must assume that the status is stale now... */
3630 pi
->status_valid
= 0;
3631 pi
->gregs_valid
= 0;
3632 pi
->fpregs_valid
= 0;
3634 #if 0 /* just try this out... */
3635 flags
= proc_flags (pi
);
3636 why
= proc_why (pi
);
3637 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3638 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3640 /* If child is not stopped, wait for it to stop. */
3641 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3642 !proc_wait_for_stop (pi
))
3644 /* wait_for_stop failed: has the child terminated? */
3645 if (errno
== ENOENT
)
3649 /* /proc file not found; presumably child has terminated. */
3650 wait_retval
= wait (&wstat
); /* "wait" for the child's exit. */
3652 if (wait_retval
!= PIDGET (inferior_ptid
)) /* wrong child? */
3653 error (_("procfs: couldn't stop "
3654 "process %d: wait returned %d."),
3655 PIDGET (inferior_ptid
), wait_retval
);
3656 /* FIXME: might I not just use waitpid?
3657 Or try find_procinfo to see if I know about this child? */
3658 retval
= pid_to_ptid (wait_retval
);
3660 else if (errno
== EINTR
)
3664 /* Unknown error from wait_for_stop. */
3665 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3670 /* This long block is reached if either:
3671 a) the child was already stopped, or
3672 b) we successfully waited for the child with wait_for_stop.
3673 This block will analyze the /proc status, and translate it
3674 into a waitstatus for GDB.
3676 If we actually had to call wait because the /proc file
3677 is gone (child terminated), then we skip this block,
3678 because we already have a waitstatus. */
3680 flags
= proc_flags (pi
);
3681 why
= proc_why (pi
);
3682 what
= proc_what (pi
);
3684 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3687 /* If it's running async (for single_thread control),
3688 set it back to normal again. */
3689 if (flags
& PR_ASYNC
)
3690 if (!proc_unset_async (pi
))
3691 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3695 proc_prettyprint_why (why
, what
, 1);
3697 /* The 'pid' we will return to GDB is composed of
3698 the process ID plus the lwp ID. */
3699 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3703 wstat
= (what
<< 8) | 0177;
3706 if (syscall_is_lwp_exit (pi
, what
))
3708 if (print_thread_events
)
3709 printf_unfiltered (_("[%s exited]\n"),
3710 target_pid_to_str (retval
));
3711 delete_thread (retval
);
3712 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3715 else if (syscall_is_exit (pi
, what
))
3717 struct inferior
*inf
;
3719 /* Handle SYS_exit call only. */
3720 /* Stopped at entry to SYS_exit.
3721 Make it runnable, resume it, then use
3722 the wait system call to get its exit code.
3723 Proc_run_process always clears the current
3725 Then return its exit status. */
3726 pi
->status_valid
= 0;
3728 /* FIXME: what we should do is return
3729 TARGET_WAITKIND_SPURIOUS. */
3730 if (!proc_run_process (pi
, 0, 0))
3731 proc_error (pi
, "target_wait, run_process", __LINE__
);
3733 inf
= find_inferior_pid (pi
->pid
);
3734 if (inf
->attach_flag
)
3736 /* Don't call wait: simulate waiting for exit,
3737 return a "success" exit code. Bogus: what if
3738 it returns something else? */
3740 retval
= inferior_ptid
; /* ? ? ? */
3744 int temp
= wait (&wstat
);
3746 /* FIXME: shouldn't I make sure I get the right
3747 event from the right process? If (for
3748 instance) I have killed an earlier inferior
3749 process but failed to clean up after it
3750 somehow, I could get its termination event
3753 /* If wait returns -1, that's what we return
3756 retval
= pid_to_ptid (temp
);
3761 printf_filtered (_("procfs: trapped on entry to "));
3762 proc_prettyprint_syscall (proc_what (pi
), 0);
3763 printf_filtered ("\n");
3766 long i
, nsysargs
, *sysargs
;
3768 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3769 (sysargs
= proc_sysargs (pi
)) != NULL
)
3771 printf_filtered (_("%ld syscall arguments:\n"),
3773 for (i
= 0; i
< nsysargs
; i
++)
3774 printf_filtered ("#%ld: 0x%08lx\n",
3782 /* How to exit gracefully, returning "unknown
3784 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3785 return inferior_ptid
;
3789 /* How to keep going without returning to wfi: */
3790 target_resume (ptid
, 0, GDB_SIGNAL_0
);
3796 if (syscall_is_exec (pi
, what
))
3798 /* Hopefully this is our own "fork-child" execing
3799 the real child. Hoax this event into a trap, and
3800 GDB will see the child about to execute its start
3802 wstat
= (SIGTRAP
<< 8) | 0177;
3805 else if (what
== SYS_syssgi
)
3807 /* see if we can break on dbx_link(). If yes, then
3808 we no longer need the SYS_syssgi notifications. */
3809 if (insert_dbx_link_breakpoint (pi
))
3810 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
,
3813 /* This is an internal event and should be transparent
3814 to wfi, so resume the execution and wait again. See
3815 comment in procfs_init_inferior() for more details. */
3816 target_resume (ptid
, 0, GDB_SIGNAL_0
);
3820 else if (syscall_is_lwp_create (pi
, what
))
3822 /* This syscall is somewhat like fork/exec. We
3823 will get the event twice: once for the parent
3824 LWP, and once for the child. We should already
3825 know about the parent LWP, but the child will
3826 be new to us. So, whenever we get this event,
3827 if it represents a new thread, simply add the
3828 thread to the list. */
3830 /* If not in procinfo list, add it. */
3831 temp_tid
= proc_get_current_thread (pi
);
3832 if (!find_procinfo (pi
->pid
, temp_tid
))
3833 create_procinfo (pi
->pid
, temp_tid
);
3835 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
3836 /* If not in GDB's thread list, add it. */
3837 if (!in_thread_list (temp_ptid
))
3838 add_thread (temp_ptid
);
3840 /* Return to WFI, but tell it to immediately resume. */
3841 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3842 return inferior_ptid
;
3844 else if (syscall_is_lwp_exit (pi
, what
))
3846 if (print_thread_events
)
3847 printf_unfiltered (_("[%s exited]\n"),
3848 target_pid_to_str (retval
));
3849 delete_thread (retval
);
3850 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3855 /* FIXME: Do we need to handle SYS_sproc,
3856 SYS_fork, or SYS_vfork here? The old procfs
3857 seemed to use this event to handle threads on
3858 older (non-LWP) systems, where I'm assuming
3859 that threads were actually separate processes.
3860 Irix, maybe? Anyway, low priority for now. */
3864 printf_filtered (_("procfs: trapped on exit from "));
3865 proc_prettyprint_syscall (proc_what (pi
), 0);
3866 printf_filtered ("\n");
3869 long i
, nsysargs
, *sysargs
;
3871 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3872 (sysargs
= proc_sysargs (pi
)) != NULL
)
3874 printf_filtered (_("%ld syscall arguments:\n"),
3876 for (i
= 0; i
< nsysargs
; i
++)
3877 printf_filtered ("#%ld: 0x%08lx\n",
3882 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3883 return inferior_ptid
;
3888 wstat
= (SIGSTOP
<< 8) | 0177;
3893 printf_filtered (_("Retry #%d:\n"), retry
);
3894 pi
->status_valid
= 0;
3899 /* If not in procinfo list, add it. */
3900 temp_tid
= proc_get_current_thread (pi
);
3901 if (!find_procinfo (pi
->pid
, temp_tid
))
3902 create_procinfo (pi
->pid
, temp_tid
);
3904 /* If not in GDB's thread list, add it. */
3905 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
3906 if (!in_thread_list (temp_ptid
))
3907 add_thread (temp_ptid
);
3909 status
->kind
= TARGET_WAITKIND_STOPPED
;
3910 status
->value
.sig
= 0;
3915 wstat
= (what
<< 8) | 0177;
3921 wstat
= (SIGTRAP
<< 8) | 0177;
3926 wstat
= (SIGTRAP
<< 8) | 0177;
3929 /* FIXME: use si_signo where possible. */
3931 #if (FLTILL != FLTPRIV) /* Avoid "duplicate case" error. */
3934 wstat
= (SIGILL
<< 8) | 0177;
3937 #if (FLTTRACE != FLTBPT) /* Avoid "duplicate case" error. */
3940 /* If we hit our __dbx_link() internal breakpoint,
3941 then remove it. See comments in procfs_init_inferior()
3942 for more details. */
3943 if (dbx_link_bpt_addr
!= 0
3944 && dbx_link_bpt_addr
3945 == regcache_read_pc (get_current_regcache ()))
3946 remove_dbx_link_breakpoint ();
3948 wstat
= (SIGTRAP
<< 8) | 0177;
3952 #if (FLTBOUNDS != FLTSTACK) /* Avoid "duplicate case" error. */
3955 wstat
= (SIGSEGV
<< 8) | 0177;
3959 #if (FLTFPE != FLTIOVF) /* Avoid "duplicate case" error. */
3962 wstat
= (SIGFPE
<< 8) | 0177;
3964 case FLTPAGE
: /* Recoverable page fault */
3965 default: /* FIXME: use si_signo if possible for
3967 retval
= pid_to_ptid (-1);
3968 printf_filtered ("procfs:%d -- ", __LINE__
);
3969 printf_filtered (_("child stopped for unknown reason:\n"));
3970 proc_prettyprint_why (why
, what
, 1);
3971 error (_("... giving up..."));
3974 break; /* case PR_FAULTED: */
3975 default: /* switch (why) unmatched */
3976 printf_filtered ("procfs:%d -- ", __LINE__
);
3977 printf_filtered (_("child stopped for unknown reason:\n"));
3978 proc_prettyprint_why (why
, what
, 1);
3979 error (_("... giving up..."));
3982 /* Got this far without error: If retval isn't in the
3983 threads database, add it. */
3984 if (PIDGET (retval
) > 0 &&
3985 !ptid_equal (retval
, inferior_ptid
) &&
3986 !in_thread_list (retval
))
3988 /* We have a new thread. We need to add it both to
3989 GDB's list and to our own. If we don't create a
3990 procinfo, resume may be unhappy later. */
3991 add_thread (retval
);
3992 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
3993 create_procinfo (PIDGET (retval
), TIDGET (retval
));
3996 else /* Flags do not indicate STOPPED. */
3998 /* surely this can't happen... */
3999 printf_filtered ("procfs:%d -- process not stopped.\n",
4001 proc_prettyprint_flags (flags
, 1);
4002 error (_("procfs: ...giving up..."));
4007 store_waitstatus (status
, wstat
);
4013 /* Perform a partial transfer to/from the specified object. For
4014 memory transfers, fall back to the old memory xfer functions. */
4017 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4018 const char *annex
, gdb_byte
*readbuf
,
4019 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4023 case TARGET_OBJECT_MEMORY
:
4025 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
4026 len
, 0/*read*/, NULL
, ops
);
4028 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
4029 len
, 1/*write*/, NULL
, ops
);
4033 case TARGET_OBJECT_AUXV
:
4034 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
4039 if (ops
->beneath
!= NULL
)
4040 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
4041 readbuf
, writebuf
, offset
, len
);
4047 /* Transfer LEN bytes between GDB address MYADDR and target address
4048 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
4049 otherwise transfer them from the target. TARGET is unused.
4051 The return value is 0 if an error occurred or no bytes were
4052 transferred. Otherwise, it will be a positive value which
4053 indicates the number of bytes transferred between gdb and the
4054 target. (Note that the interface also makes provisions for
4055 negative values, but this capability isn't implemented here.) */
4058 procfs_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int dowrite
,
4059 struct mem_attrib
*attrib
, struct target_ops
*target
)
4064 /* Find procinfo for main process. */
4065 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4066 if (pi
->as_fd
== 0 &&
4067 open_procinfo_files (pi
, FD_AS
) == 0)
4069 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4073 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4078 PROCFS_NOTE ("write memory:\n");
4080 PROCFS_NOTE ("write memory:\n");
4082 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4086 PROCFS_NOTE ("read memory:\n");
4087 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4097 /* Called by target_resume before making child runnable. Mark cached
4098 registers and status's invalid. If there are "dirty" caches that
4099 need to be written back to the child process, do that.
4101 File descriptors are also cached. As they are a limited resource,
4102 we cannot hold onto them indefinitely. However, as they are
4103 expensive to open, we don't want to throw them away
4104 indescriminately either. As a compromise, we will keep the file
4105 descriptors for the parent process, but discard any file
4106 descriptors we may have accumulated for the threads.
4108 As this function is called by iterate_over_threads, it always
4109 returns zero (so that iterate_over_threads will keep
4113 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
4115 /* About to run the child; invalidate caches and do any other
4119 if (pi
->gregs_dirty
)
4120 if (parent
== NULL
||
4121 proc_get_current_thread (parent
) != pi
->tid
)
4122 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4123 proc_warn (pi
, "target_resume, set_gregs",
4125 if (gdbarch_fp0_regnum (target_gdbarch
) >= 0)
4126 if (pi
->fpregs_dirty
)
4127 if (parent
== NULL
||
4128 proc_get_current_thread (parent
) != pi
->tid
)
4129 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4130 proc_warn (pi
, "target_resume, set_fpregs",
4136 /* The presence of a parent indicates that this is an LWP.
4137 Close any file descriptors that it might have open.
4138 We don't do this to the master (parent) procinfo. */
4140 close_procinfo_files (pi
);
4142 pi
->gregs_valid
= 0;
4143 pi
->fpregs_valid
= 0;
4145 pi
->gregs_dirty
= 0;
4146 pi
->fpregs_dirty
= 0;
4148 pi
->status_valid
= 0;
4149 pi
->threads_valid
= 0;
4155 /* A callback function for iterate_over_threads. Find the
4156 asynchronous signal thread, and make it runnable. See if that
4157 helps matters any. */
4160 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
4163 if (proc_flags (pi
) & PR_ASLWP
)
4165 if (!proc_run_process (pi
, 0, -1))
4166 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4174 /* Make the child process runnable. Normally we will then call
4175 procfs_wait and wait for it to stop again (unless gdb is async).
4177 If STEP is true, then arrange for the child to stop again after
4178 executing a single instruction. If SIGNO is zero, then cancel any
4179 pending signal; if non-zero, then arrange for the indicated signal
4180 to be delivered to the child when it runs. If PID is -1, then
4181 allow any child thread to run; if non-zero, then allow only the
4182 indicated thread to run. (not implemented yet). */
4185 procfs_resume (struct target_ops
*ops
,
4186 ptid_t ptid
, int step
, enum gdb_signal signo
)
4188 procinfo
*pi
, *thread
;
4192 prrun.prflags |= PRSVADDR;
4193 prrun.pr_vaddr = $PC; set resume address
4194 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4195 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4196 prrun.prflags |= PRCFAULT; clear current fault.
4198 PRSTRACE and PRSFAULT can be done by other means
4199 (proc_trace_signals, proc_trace_faults)
4200 PRSVADDR is unnecessary.
4201 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4202 This basically leaves PRSTEP and PRCSIG.
4203 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4204 So basically PR_STEP is the sole argument that must be passed
4205 to proc_run_process (for use in the prrun struct by ioctl). */
4207 /* Find procinfo for main process. */
4208 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4210 /* First cut: ignore pid argument. */
4213 /* Convert signal to host numbering. */
4215 (signo
== GDB_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4218 native_signo
= gdb_signal_to_host (signo
);
4220 pi
->ignore_next_sigstop
= 0;
4222 /* Running the process voids all cached registers and status. */
4223 /* Void the threads' caches first. */
4224 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4225 /* Void the process procinfo's caches. */
4226 invalidate_cache (NULL
, pi
, NULL
);
4228 if (PIDGET (ptid
) != -1)
4230 /* Resume a specific thread, presumably suppressing the
4232 thread
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
));
4235 if (thread
->tid
!= 0)
4237 /* We're to resume a specific thread, and not the
4238 others. Set the child process's PR_ASYNC flag. */
4240 if (!proc_set_async (pi
))
4241 proc_error (pi
, "target_resume, set_async", __LINE__
);
4244 proc_iterate_over_threads (pi
,
4245 make_signal_thread_runnable
,
4248 pi
= thread
; /* Substitute the thread's procinfo
4254 if (!proc_run_process (pi
, step
, native_signo
))
4257 warning (_("resume: target already running. "
4258 "Pretend to resume, and hope for the best!"));
4260 proc_error (pi
, "target_resume", __LINE__
);
4264 /* Set up to trace signals in the child process. */
4267 procfs_pass_signals (int numsigs
, unsigned char *pass_signals
)
4269 gdb_sigset_t signals
;
4270 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4273 prfillset (&signals
);
4275 for (signo
= 0; signo
< NSIG
; signo
++)
4277 int target_signo
= gdb_signal_from_host (signo
);
4278 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
4279 gdb_prdelset (&signals
, signo
);
4282 if (!proc_set_traced_signals (pi
, &signals
))
4283 proc_error (pi
, "pass_signals", __LINE__
);
4286 /* Print status information about the child process. */
4289 procfs_files_info (struct target_ops
*ignore
)
4291 struct inferior
*inf
= current_inferior ();
4293 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
4294 inf
->attach_flag
? "attached": "child",
4295 target_pid_to_str (inferior_ptid
));
4298 /* Stop the child process asynchronously, as when the gdb user types
4299 control-c or presses a "stop" button. Works by sending
4300 kill(SIGINT) to the child's process group. */
4303 procfs_stop (ptid_t ptid
)
4305 kill (-inferior_process_group (), SIGINT
);
4308 /* Make it die. Wait for it to die. Clean up after it. Note: this
4309 should only be applied to the real process, not to an LWP, because
4310 of the check for parent-process. If we need this to work for an
4311 LWP, it needs some more logic. */
4314 unconditionally_kill_inferior (procinfo
*pi
)
4318 parent_pid
= proc_parent_pid (pi
);
4319 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4320 /* FIXME: use access functions. */
4321 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4322 before the PIOCKILL, otherwise it might generate a corrupted core
4323 file for the inferior. */
4324 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4326 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4329 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4330 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4331 to kill the inferior, otherwise it might remain stopped with a
4333 We do not check the result of the PIOCSSIG, the inferior might have
4336 gdb_siginfo_t newsiginfo
;
4338 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4339 newsiginfo
.si_signo
= SIGKILL
;
4340 newsiginfo
.si_code
= 0;
4341 newsiginfo
.si_errno
= 0;
4342 newsiginfo
.si_pid
= getpid ();
4343 newsiginfo
.si_uid
= getuid ();
4344 /* FIXME: use proc_set_current_signal. */
4345 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4347 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4348 if (!proc_kill (pi
, SIGKILL
))
4349 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4350 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4351 destroy_procinfo (pi
);
4353 /* If pi is GDB's child, wait for it to die. */
4354 if (parent_pid
== getpid ())
4355 /* FIXME: should we use waitpid to make sure we get the right event?
4356 Should we check the returned event? */
4361 ret
= waitpid (pi
->pid
, &status
, 0);
4368 /* We're done debugging it, and we want it to go away. Then we want
4369 GDB to forget all about it. */
4372 procfs_kill_inferior (struct target_ops
*ops
)
4374 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
4376 /* Find procinfo for main process. */
4377 procinfo
*pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4380 unconditionally_kill_inferior (pi
);
4381 target_mourn_inferior ();
4385 /* Forget we ever debugged this thing! */
4388 procfs_mourn_inferior (struct target_ops
*ops
)
4392 if (!ptid_equal (inferior_ptid
, null_ptid
))
4394 /* Find procinfo for main process. */
4395 pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4397 destroy_procinfo (pi
);
4399 unpush_target (ops
);
4401 if (dbx_link_bpt
!= NULL
)
4403 deprecated_remove_raw_breakpoint (target_gdbarch
, dbx_link_bpt
);
4404 dbx_link_bpt_addr
= 0;
4405 dbx_link_bpt
= NULL
;
4408 generic_mourn_inferior ();
4411 /* When GDB forks to create a runnable inferior process, this function
4412 is called on the parent side of the fork. It's job is to do
4413 whatever is necessary to make the child ready to be debugged, and
4414 then wait for the child to synchronize. */
4417 procfs_init_inferior (struct target_ops
*ops
, int pid
)
4420 gdb_sigset_t signals
;
4424 /* This routine called on the parent side (GDB side)
4425 after GDB forks the inferior. */
4428 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4429 perror (_("procfs: out of memory in 'init_inferior'"));
4431 if (!open_procinfo_files (pi
, FD_CTL
))
4432 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4436 open_procinfo_files // done
4439 procfs_notice_signals
4446 /* If not stopped yet, wait for it to stop. */
4447 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4448 !(proc_wait_for_stop (pi
)))
4449 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4451 /* Save some of the /proc state to be restored if we detach. */
4452 /* FIXME: Why? In case another debugger was debugging it?
4453 We're it's parent, for Ghu's sake! */
4454 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4455 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4456 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4457 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4458 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4459 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4460 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
4461 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4462 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
4463 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4465 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4466 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4468 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4469 and possibly even turning ON kill-on-last-close at this point. But
4470 I can't make that change without careful testing which I don't have
4471 time to do right now... */
4472 /* Turn on run-on-last-close flag so that the child
4473 will die if GDB goes away for some reason. */
4474 if (!proc_set_run_on_last_close (pi
))
4475 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4477 /* We now have have access to the lwpid of the main thread/lwp. */
4478 lwpid
= proc_get_current_thread (pi
);
4480 /* Create a procinfo for the main lwp. */
4481 create_procinfo (pid
, lwpid
);
4483 /* We already have a main thread registered in the thread table at
4484 this point, but it didn't have any lwp info yet. Notify the core
4485 about it. This changes inferior_ptid as well. */
4486 thread_change_ptid (pid_to_ptid (pid
),
4487 MERGEPID (pid
, lwpid
));
4489 /* Typically two, one trap to exec the shell, one to exec the
4490 program being debugged. Defined by "inferior.h". */
4491 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4494 /* On mips-irix, we need to stop the inferior early enough during
4495 the startup phase in order to be able to load the shared library
4496 symbols and insert the breakpoints that are located in these shared
4497 libraries. Stopping at the program entry point is not good enough
4498 because the -init code is executed before the execution reaches
4501 So what we need to do is to insert a breakpoint in the runtime
4502 loader (rld), more precisely in __dbx_link(). This procedure is
4503 called by rld once all shared libraries have been mapped, but before
4504 the -init code is executed. Unfortuantely, this is not straightforward,
4505 as rld is not part of the executable we are running, and thus we need
4506 the inferior to run until rld itself has been mapped in memory.
4508 For this, we trace all syssgi() syscall exit events. Each time
4509 we detect such an event, we iterate over each text memory maps,
4510 get its associated fd, and scan the symbol table for __dbx_link().
4511 When found, we know that rld has been mapped, and that we can insert
4512 the breakpoint at the symbol address. Once the dbx_link() breakpoint
4513 has been inserted, the syssgi() notifications are no longer necessary,
4514 so they should be canceled. */
4515 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
, FLAG_SET
, 0);
4519 /* When GDB forks to create a new process, this function is called on
4520 the child side of the fork before GDB exec's the user program. Its
4521 job is to make the child minimally debuggable, so that the parent
4522 GDB process can connect to the child and take over. This function
4523 should do only the minimum to make that possible, and to
4524 synchronize with the parent process. The parent process should
4525 take care of the details. */
4528 procfs_set_exec_trap (void)
4530 /* This routine called on the child side (inferior side)
4531 after GDB forks the inferior. It must use only local variables,
4532 because it may be sharing data space with its parent. */
4537 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4538 perror_with_name (_("procfs: create_procinfo failed in child."));
4540 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4542 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4543 gdb_flush (gdb_stderr
);
4544 /* No need to call "dead_procinfo", because we're going to
4549 #ifdef PRFS_STOPEXEC /* defined on OSF */
4550 /* OSF method for tracing exec syscalls. Quoting:
4551 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4552 exits from exec system calls because of the user level loader. */
4553 /* FIXME: make nice and maybe move into an access function. */
4557 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4559 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4560 gdb_flush (gdb_stderr
);
4563 prfs_flags
|= PRFS_STOPEXEC
;
4565 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4567 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4568 gdb_flush (gdb_stderr
);
4572 #else /* not PRFS_STOPEXEC */
4573 /* Everyone else's (except OSF) method for tracing exec syscalls. */
4575 Not all systems with /proc have all the exec* syscalls with the same
4576 names. On the SGI, for example, there is no SYS_exec, but there
4577 *is* a SYS_execv. So, we try to account for that. */
4579 exitset
= sysset_t_alloc (pi
);
4580 gdb_premptysysset (exitset
);
4582 gdb_praddsysset (exitset
, SYS_exec
);
4585 gdb_praddsysset (exitset
, SYS_execve
);
4588 gdb_praddsysset (exitset
, SYS_execv
);
4590 #ifdef DYNAMIC_SYSCALLS
4592 int callnum
= find_syscall (pi
, "execve");
4595 gdb_praddsysset (exitset
, callnum
);
4597 callnum
= find_syscall (pi
, "ra_execve");
4599 gdb_praddsysset (exitset
, callnum
);
4601 #endif /* DYNAMIC_SYSCALLS */
4603 if (!proc_set_traced_sysexit (pi
, exitset
))
4605 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4606 gdb_flush (gdb_stderr
);
4609 #endif /* PRFS_STOPEXEC */
4611 /* FIXME: should this be done in the parent instead? */
4612 /* Turn off inherit on fork flag so that all grand-children
4613 of gdb start with tracing flags cleared. */
4614 if (!proc_unset_inherit_on_fork (pi
))
4615 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4617 /* Turn off run on last close flag, so that the child process
4618 cannot run away just because we close our handle on it.
4619 We want it to wait for the parent to attach. */
4620 if (!proc_unset_run_on_last_close (pi
))
4621 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4623 /* FIXME: No need to destroy the procinfo --
4624 we have our own address space, and we're about to do an exec! */
4625 /*destroy_procinfo (pi);*/
4628 /* This function is called BEFORE gdb forks the inferior process. Its
4629 only real responsibility is to set things up for the fork, and tell
4630 GDB which two functions to call after the fork (one for the parent,
4631 and one for the child).
4633 This function does a complicated search for a unix shell program,
4634 which it then uses to parse arguments and environment variables to
4635 be sent to the child. I wonder whether this code could not be
4636 abstracted out and shared with other unix targets such as
4640 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
4641 char *allargs
, char **env
, int from_tty
)
4643 char *shell_file
= getenv ("SHELL");
4647 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4650 /* We will be looking down the PATH to find shell_file. If we
4651 just do this the normal way (via execlp, which operates by
4652 attempting an exec for each element of the PATH until it
4653 finds one which succeeds), then there will be an exec for
4654 each failed attempt, each of which will cause a PR_SYSEXIT
4655 stop, and we won't know how to distinguish the PR_SYSEXIT's
4656 for these failed execs with the ones for successful execs
4657 (whether the exec has succeeded is stored at that time in the
4658 carry bit or some such architecture-specific and
4659 non-ABI-specified place).
4661 So I can't think of anything better than to search the PATH
4662 now. This has several disadvantages: (1) There is a race
4663 condition; if we find a file now and it is deleted before we
4664 exec it, we lose, even if the deletion leaves a valid file
4665 further down in the PATH, (2) there is no way to know exactly
4666 what an executable (in the sense of "capable of being
4667 exec'd") file is. Using access() loses because it may lose
4668 if the caller is the superuser; failing to use it loses if
4669 there are ACLs or some such. */
4673 /* FIXME-maybe: might want "set path" command so user can change what
4674 path is used from within GDB. */
4675 char *path
= getenv ("PATH");
4677 struct stat statbuf
;
4680 path
= "/bin:/usr/bin";
4682 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4683 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4685 p1
= strchr (p
, ':');
4690 strncpy (tryname
, p
, len
);
4691 tryname
[len
] = '\0';
4692 strcat (tryname
, "/");
4693 strcat (tryname
, shell_file
);
4694 if (access (tryname
, X_OK
) < 0)
4696 if (stat (tryname
, &statbuf
) < 0)
4698 if (!S_ISREG (statbuf
.st_mode
))
4699 /* We certainly need to reject directories. I'm not quite
4700 as sure about FIFOs, sockets, etc., but I kind of doubt
4701 that people want to exec() these things. */
4706 /* Not found. This must be an error rather than merely passing
4707 the file to execlp(), because execlp() would try all the
4708 exec()s, causing GDB to get confused. */
4709 error (_("procfs:%d -- Can't find shell %s in PATH"),
4710 __LINE__
, shell_file
);
4712 shell_file
= tryname
;
4715 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4716 NULL
, NULL
, shell_file
, NULL
);
4718 procfs_init_inferior (ops
, pid
);
4721 /* An observer for the "inferior_created" event. */
4724 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
4727 /* Make sure to cancel the syssgi() syscall-exit notifications.
4728 They should normally have been removed by now, but they may still
4729 be activated if the inferior doesn't use shared libraries, or if
4730 we didn't locate __dbx_link, or if we never stopped in __dbx_link.
4731 See procfs_init_inferior() for more details.
4733 Since these notifications are only ever enabled when we spawned
4734 the inferior ourselves, there is nothing to do when the inferior
4735 was created by attaching to an already running process, or when
4736 debugging a core file. */
4737 if (current_inferior ()->attach_flag
|| !target_can_run (¤t_target
))
4740 proc_trace_syscalls_1 (find_procinfo_or_die (PIDGET (inferior_ptid
), 0),
4741 SYS_syssgi
, PR_SYSEXIT
, FLAG_RESET
, 0);
4745 /* Callback for find_new_threads. Calls "add_thread". */
4748 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
4750 ptid_t gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4752 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
4753 add_thread (gdb_threadid
);
4758 /* Query all the threads that the target knows about, and give them
4759 back to GDB to add to its list. */
4762 procfs_find_new_threads (struct target_ops
*ops
)
4766 /* Find procinfo for main process. */
4767 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4768 proc_update_threads (pi
);
4769 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4772 /* Return true if the thread is still 'alive'. This guy doesn't
4773 really seem to be doing his job. Got to investigate how to tell
4774 when a thread is really gone. */
4777 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4782 proc
= PIDGET (ptid
);
4783 thread
= TIDGET (ptid
);
4784 /* If I don't know it, it ain't alive! */
4785 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4788 /* If I can't get its status, it ain't alive!
4789 What's more, I need to forget about it! */
4790 if (!proc_get_status (pi
))
4792 destroy_procinfo (pi
);
4795 /* I couldn't have got its status if it weren't alive, so it's
4800 /* Convert PTID to a string. Returns the string in a static
4804 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
4806 static char buf
[80];
4808 if (TIDGET (ptid
) == 0)
4809 sprintf (buf
, "process %d", PIDGET (ptid
));
4811 sprintf (buf
, "LWP %ld", TIDGET (ptid
));
4816 /* Insert a watchpoint. */
4819 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
4827 pi
= find_procinfo_or_die (PIDGET (ptid
) == -1 ?
4828 PIDGET (inferior_ptid
) : PIDGET (ptid
), 0);
4830 /* Translate from GDB's flags to /proc's. */
4831 if (len
> 0) /* len == 0 means delete watchpoint. */
4833 switch (rwflag
) { /* FIXME: need an enum! */
4834 case hw_write
: /* default watchpoint (write) */
4835 pflags
= WRITE_WATCHFLAG
;
4837 case hw_read
: /* read watchpoint */
4838 pflags
= READ_WATCHFLAG
;
4840 case hw_access
: /* access watchpoint */
4841 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
4843 case hw_execute
: /* execution HW breakpoint */
4844 pflags
= EXEC_WATCHFLAG
;
4846 default: /* Something weird. Return error. */
4849 if (after
) /* Stop after r/w access is completed. */
4850 pflags
|= AFTER_WATCHFLAG
;
4853 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
4855 if (errno
== E2BIG
) /* Typical error for no resources. */
4856 return -1; /* fail */
4857 /* GDB may try to remove the same watchpoint twice.
4858 If a remove request returns no match, don't error. */
4859 if (errno
== ESRCH
&& len
== 0)
4860 return 0; /* ignore */
4861 proc_error (pi
, "set_watchpoint", __LINE__
);
4864 #endif /* UNIXWARE */
4868 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
4869 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
4870 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
4873 Note: procfs_can_use_hw_breakpoint() is not yet used by all
4874 procfs.c targets due to the fact that some of them still define
4875 target_can_use_hardware_watchpoint. */
4878 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
4880 /* Due to the way that proc_set_watchpoint() is implemented, host
4881 and target pointers must be of the same size. If they are not,
4882 we can't use hardware watchpoints. This limitation is due to the
4883 fact that proc_set_watchpoint() calls
4884 procfs_address_to_host_pointer(); a close inspection of
4885 procfs_address_to_host_pointer will reveal that an internal error
4886 will be generated when the host and target pointer sizes are
4888 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
4890 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
4893 /* Other tests here??? */
4898 /* Returns non-zero if process is stopped on a hardware watchpoint
4899 fault, else returns zero. */
4902 procfs_stopped_by_watchpoint (void)
4906 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4908 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
4910 if (proc_why (pi
) == PR_FAULTED
)
4913 if (proc_what (pi
) == FLTWATCH
)
4917 if (proc_what (pi
) == FLTKWATCH
)
4925 /* Returns 1 if the OS knows the position of the triggered watchpoint,
4926 and sets *ADDR to that address. Returns 0 if OS cannot report that
4927 address. This function is only called if
4928 procfs_stopped_by_watchpoint returned 1, thus no further checks are
4929 done. The function also assumes that ADDR is not NULL. */
4932 procfs_stopped_data_address (struct target_ops
*targ
, CORE_ADDR
*addr
)
4936 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4937 return proc_watchpoint_address (pi
, addr
);
4941 procfs_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
4942 struct expression
*cond
)
4944 if (!target_have_steppable_watchpoint
4945 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch
))
4947 /* When a hardware watchpoint fires off the PC will be left at
4948 the instruction following the one which caused the
4949 watchpoint. It will *NOT* be necessary for GDB to step over
4951 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
4955 /* When a hardware watchpoint fires off the PC will be left at
4956 the instruction which caused the watchpoint. It will be
4957 necessary for GDB to step over the watchpoint. */
4958 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
4963 procfs_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
4964 struct expression
*cond
)
4966 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
4970 procfs_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
4972 /* The man page for proc(4) on Solaris 2.6 and up says that the
4973 system can support "thousands" of hardware watchpoints, but gives
4974 no method for finding out how many; It doesn't say anything about
4975 the allowed size for the watched area either. So we just tell
4981 procfs_use_watchpoints (struct target_ops
*t
)
4983 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
4984 t
->to_insert_watchpoint
= procfs_insert_watchpoint
;
4985 t
->to_remove_watchpoint
= procfs_remove_watchpoint
;
4986 t
->to_region_ok_for_hw_watchpoint
= procfs_region_ok_for_hw_watchpoint
;
4987 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
4988 t
->to_stopped_data_address
= procfs_stopped_data_address
;
4991 /* Memory Mappings Functions: */
4993 /* Call a callback function once for each mapping, passing it the
4994 mapping, an optional secondary callback function, and some optional
4995 opaque data. Quit and return the first non-zero value returned
4998 PI is the procinfo struct for the process to be mapped. FUNC is
4999 the callback function to be called by this iterator. DATA is the
5000 optional opaque data to be passed to the callback function.
5001 CHILD_FUNC is the optional secondary function pointer to be passed
5002 to the child function. Returns the first non-zero return value
5003 from the callback function, or zero. */
5006 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
5008 int (*func
) (struct prmap
*map
,
5009 find_memory_region_ftype child_func
,
5012 char pathname
[MAX_PROC_NAME_SIZE
];
5013 struct prmap
*prmaps
;
5014 struct prmap
*prmap
;
5018 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
5023 /* Get the number of mappings, allocate space,
5024 and read the mappings into prmaps. */
5027 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
5028 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
5029 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
5031 /* Make sure it gets closed again. */
5032 make_cleanup_close (map_fd
);
5034 /* Use stat to determine the file size, and compute
5035 the number of prmap_t objects it contains. */
5036 if (fstat (map_fd
, &sbuf
) != 0)
5037 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
5039 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
5040 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5041 if (read (map_fd
, (char *) prmaps
, nmap
* sizeof (*prmaps
))
5042 != (nmap
* sizeof (*prmaps
)))
5043 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
5045 /* Use ioctl command PIOCNMAP to get number of mappings. */
5046 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmap
) != 0)
5047 proc_error (pi
, "iterate_over_mappings (PIOCNMAP)", __LINE__
);
5049 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5050 if (ioctl (pi
->ctl_fd
, PIOCMAP
, prmaps
) != 0)
5051 proc_error (pi
, "iterate_over_mappings (PIOCMAP)", __LINE__
);
5054 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
5055 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
5057 do_cleanups (cleanups
);
5061 do_cleanups (cleanups
);
5065 /* Implements the to_find_memory_regions method. Calls an external
5066 function for each memory region.
5067 Returns the integer value returned by the callback. */
5070 find_memory_regions_callback (struct prmap
*map
,
5071 find_memory_region_ftype func
, void *data
)
5073 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
5075 (map
->pr_mflags
& MA_READ
) != 0,
5076 (map
->pr_mflags
& MA_WRITE
) != 0,
5077 (map
->pr_mflags
& MA_EXEC
) != 0,
5078 1, /* MODIFIED is unknown, pass it as true. */
5082 /* External interface. Calls a callback function once for each
5083 mapped memory region in the child process, passing as arguments:
5085 CORE_ADDR virtual_address,
5087 int read, TRUE if region is readable by the child
5088 int write, TRUE if region is writable by the child
5089 int execute TRUE if region is executable by the child.
5091 Stops iterating and returns the first non-zero value returned by
5095 proc_find_memory_regions (find_memory_region_ftype func
, void *data
)
5097 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5099 return iterate_over_mappings (pi
, func
, data
,
5100 find_memory_regions_callback
);
5103 /* Returns an ascii representation of a memory mapping's flags. */
5106 mappingflags (long flags
)
5108 static char asciiflags
[8];
5110 strcpy (asciiflags
, "-------");
5111 #if defined (MA_PHYS)
5112 if (flags
& MA_PHYS
)
5113 asciiflags
[0] = 'd';
5115 if (flags
& MA_STACK
)
5116 asciiflags
[1] = 's';
5117 if (flags
& MA_BREAK
)
5118 asciiflags
[2] = 'b';
5119 if (flags
& MA_SHARED
)
5120 asciiflags
[3] = 's';
5121 if (flags
& MA_READ
)
5122 asciiflags
[4] = 'r';
5123 if (flags
& MA_WRITE
)
5124 asciiflags
[5] = 'w';
5125 if (flags
& MA_EXEC
)
5126 asciiflags
[6] = 'x';
5127 return (asciiflags
);
5130 /* Callback function, does the actual work for 'info proc
5134 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
5137 unsigned int pr_off
;
5139 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
5140 pr_off
= (unsigned int) map
->pr_offset
;
5142 pr_off
= map
->pr_off
;
5145 if (gdbarch_addr_bit (target_gdbarch
) == 32)
5146 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
5147 (unsigned long) map
->pr_vaddr
,
5148 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5149 (unsigned long) map
->pr_size
,
5151 mappingflags (map
->pr_mflags
));
5153 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
5154 (unsigned long) map
->pr_vaddr
,
5155 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5156 (unsigned long) map
->pr_size
,
5158 mappingflags (map
->pr_mflags
));
5163 /* Implement the "info proc mappings" subcommand. */
5166 info_proc_mappings (procinfo
*pi
, int summary
)
5169 return; /* No output for summary mode. */
5171 printf_filtered (_("Mapped address spaces:\n\n"));
5172 if (gdbarch_ptr_bit (target_gdbarch
) == 32)
5173 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
5180 printf_filtered (" %18s %18s %10s %10s %7s\n",
5187 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
5188 printf_filtered ("\n");
5191 /* Implement the "info proc" command. */
5194 procfs_info_proc (struct target_ops
*ops
, char *args
,
5195 enum info_proc_what what
)
5197 struct cleanup
*old_chain
;
5198 procinfo
*process
= NULL
;
5199 procinfo
*thread
= NULL
;
5217 error (_("Not supported on this target."));
5220 old_chain
= make_cleanup (null_cleanup
, 0);
5223 argv
= gdb_buildargv (args
);
5224 make_cleanup_freeargv (argv
);
5226 while (argv
!= NULL
&& *argv
!= NULL
)
5228 if (isdigit (argv
[0][0]))
5230 pid
= strtoul (argv
[0], &tmp
, 10);
5232 tid
= strtoul (++tmp
, NULL
, 10);
5234 else if (argv
[0][0] == '/')
5236 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5241 pid
= PIDGET (inferior_ptid
);
5243 error (_("No current process: you must name one."));
5246 /* Have pid, will travel.
5247 First see if it's a process we're already debugging. */
5248 process
= find_procinfo (pid
, 0);
5249 if (process
== NULL
)
5251 /* No. So open a procinfo for it, but
5252 remember to close it again when finished. */
5253 process
= create_procinfo (pid
, 0);
5254 make_cleanup (do_destroy_procinfo_cleanup
, process
);
5255 if (!open_procinfo_files (process
, FD_CTL
))
5256 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5260 thread
= create_procinfo (pid
, tid
);
5264 printf_filtered (_("process %d flags:\n"), process
->pid
);
5265 proc_prettyprint_flags (proc_flags (process
), 1);
5266 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5267 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5268 if (proc_get_nthreads (process
) > 1)
5269 printf_filtered ("Process has %d threads.\n",
5270 proc_get_nthreads (process
));
5274 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
5275 proc_prettyprint_flags (proc_flags (thread
), 1);
5276 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5277 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5282 info_proc_mappings (process
, 0);
5285 do_cleanups (old_chain
);
5288 /* Modify the status of the system call identified by SYSCALLNUM in
5289 the set of syscalls that are currently traced/debugged.
5291 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
5292 will be updated. Otherwise, the exit syscalls set will be updated.
5294 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
5295 will be disabled. */
5298 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
5299 int mode
, int from_tty
)
5303 if (entry_or_exit
== PR_SYSENTRY
)
5304 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5306 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5309 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5311 if (mode
== FLAG_SET
)
5312 gdb_praddsysset (sysset
, syscallnum
);
5314 gdb_prdelsysset (sysset
, syscallnum
);
5316 if (entry_or_exit
== PR_SYSENTRY
)
5318 if (!proc_set_traced_sysentry (pi
, sysset
))
5319 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5323 if (!proc_set_traced_sysexit (pi
, sysset
))
5324 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5329 proc_trace_syscalls (char *args
, int from_tty
, int entry_or_exit
, int mode
)
5333 if (PIDGET (inferior_ptid
) <= 0)
5334 error (_("you must be debugging a process to use this command."));
5336 if (args
== NULL
|| args
[0] == 0)
5337 error_no_arg (_("system call to trace"));
5339 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5340 if (isdigit (args
[0]))
5342 const int syscallnum
= atoi (args
);
5344 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
5349 proc_trace_sysentry_cmd (char *args
, int from_tty
)
5351 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5355 proc_trace_sysexit_cmd (char *args
, int from_tty
)
5357 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5361 proc_untrace_sysentry_cmd (char *args
, int from_tty
)
5363 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5367 proc_untrace_sysexit_cmd (char *args
, int from_tty
)
5369 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5373 /* Provide a prototype to silence -Wmissing-prototypes. */
5374 extern void _initialize_procfs (void);
5377 _initialize_procfs (void)
5379 observer_attach_inferior_created (procfs_inferior_created
);
5381 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5382 _("Give a trace of entries into the syscall."));
5383 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5384 _("Give a trace of exits from the syscall."));
5385 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5386 _("Cancel a trace of entries into the syscall."));
5387 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5388 _("Cancel a trace of exits from the syscall."));
5391 /* =================== END, GDB "MODULE" =================== */
5395 /* miscellaneous stubs: */
5397 /* The following satisfy a few random symbols mostly created by the
5398 solaris threads implementation, which I will chase down later. */
5400 /* Return a pid for which we guarantee we will be able to find a
5404 procfs_first_available (void)
5406 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
5409 /* =================== GCORE .NOTE "MODULE" =================== */
5410 #if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT)
5411 /* gcore only implemented on solaris and unixware (so far) */
5414 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
5415 char *note_data
, int *note_size
,
5416 enum gdb_signal stop_signal
)
5418 struct regcache
*regcache
= get_thread_regcache (ptid
);
5419 gdb_gregset_t gregs
;
5420 gdb_fpregset_t fpregs
;
5421 unsigned long merged_pid
;
5422 struct cleanup
*old_chain
;
5424 merged_pid
= TIDGET (ptid
) << 16 | PIDGET (ptid
);
5426 /* This part is the old method for fetching registers.
5427 It should be replaced by the newer one using regsets
5428 once it is implemented in this platform:
5429 gdbarch_regset_from_core_section() and regset->collect_regset(). */
5431 old_chain
= save_inferior_ptid ();
5432 inferior_ptid
= ptid
;
5433 target_fetch_registers (regcache
, -1);
5435 fill_gregset (regcache
, &gregs
, -1);
5436 #if defined (NEW_PROC_API)
5437 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
5444 note_data
= (char *) elfcore_write_prstatus (obfd
,
5451 fill_fpregset (regcache
, &fpregs
, -1);
5452 note_data
= (char *) elfcore_write_prfpreg (obfd
,
5458 do_cleanups (old_chain
);
5463 struct procfs_corefile_thread_data
{
5467 enum gdb_signal stop_signal
;
5471 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
5473 struct procfs_corefile_thread_data
*args
= data
;
5477 ptid_t ptid
= MERGEPID (pi
->pid
, thread
->tid
);
5479 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
5488 find_signalled_thread (struct thread_info
*info
, void *data
)
5490 if (info
->suspend
.stop_signal
!= GDB_SIGNAL_0
5491 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
5497 static enum gdb_signal
5498 find_stop_signal (void)
5500 struct thread_info
*info
=
5501 iterate_over_threads (find_signalled_thread
, NULL
);
5504 return info
->suspend
.stop_signal
;
5506 return GDB_SIGNAL_0
;
5510 procfs_make_note_section (bfd
*obfd
, int *note_size
)
5512 struct cleanup
*old_chain
;
5513 gdb_gregset_t gregs
;
5514 gdb_fpregset_t fpregs
;
5515 char fname
[16] = {'\0'};
5516 char psargs
[80] = {'\0'};
5517 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5518 char *note_data
= NULL
;
5520 struct procfs_corefile_thread_data thread_args
;
5523 enum gdb_signal stop_signal
;
5525 if (get_exec_file (0))
5527 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
5528 fname
[sizeof (fname
) - 1] = 0;
5529 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
5530 psargs
[sizeof (psargs
) - 1] = 0;
5532 inf_args
= get_inferior_args ();
5533 if (inf_args
&& *inf_args
&&
5534 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
5536 strncat (psargs
, " ",
5537 sizeof (psargs
) - strlen (psargs
));
5538 strncat (psargs
, inf_args
,
5539 sizeof (psargs
) - strlen (psargs
));
5543 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
5549 stop_signal
= find_stop_signal ();
5552 fill_gregset (get_current_regcache (), &gregs
, -1);
5553 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
5554 PIDGET (inferior_ptid
),
5555 stop_signal
, &gregs
);
5558 thread_args
.obfd
= obfd
;
5559 thread_args
.note_data
= note_data
;
5560 thread_args
.note_size
= note_size
;
5561 thread_args
.stop_signal
= stop_signal
;
5562 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
5565 /* There should be always at least one thread. */
5566 gdb_assert (thread_args
.note_data
!= note_data
);
5567 note_data
= thread_args
.note_data
;
5569 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
5573 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
5574 "CORE", NT_AUXV
, auxv
, auxv_len
);
5578 make_cleanup (xfree
, note_data
);
5581 #else /* !(Solaris or Unixware) */
5583 procfs_make_note_section (bfd
*obfd
, int *note_size
)
5585 error (_("gcore not implemented for this host."));
5586 return NULL
; /* lint */
5588 #endif /* Solaris or Unixware */
5589 /* =================== END GCORE .NOTE "MODULE" =================== */