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>
48 #include "gdb_string.h"
49 #include "gdb_assert.h"
55 /* This module provides the interface between GDB and the
56 /proc file system, which is used on many versions of Unix
57 as a means for debuggers to control other processes.
59 Examples of the systems that use this interface are:
67 /proc works by imitating a file system: you open a simulated file
68 that represents the process you wish to interact with, and perform
69 operations on that "file" in order to examine or change the state
72 The most important thing to know about /proc and this module is
73 that there are two very different interfaces to /proc:
75 One that uses the ioctl system call, and another that uses read
76 and write system calls.
78 This module has to support both /proc interfaces. This means that
79 there are two different ways of doing every basic operation.
81 In order to keep most of the code simple and clean, I have defined
82 an interface "layer" which hides all these system calls. An ifdef
83 (NEW_PROC_API) determines which interface we are using, and most or
84 all occurrances of this ifdef should be confined to this interface
87 /* Determine which /proc API we are using: The ioctl API defines
88 PIOCSTATUS, while the read/write (multiple fd) API never does. */
91 #include <sys/types.h>
92 #include "gdb_dirent.h" /* opendir/readdir, for listing the LWP's */
95 #include <fcntl.h> /* for O_RDONLY */
96 #include <unistd.h> /* for "X_OK" */
97 #include "gdb_stat.h" /* for struct stat */
99 /* Note: procfs-utils.h must be included after the above system header
100 files, because it redefines various system calls using macros.
101 This may be incompatible with the prototype declarations. */
103 #include "proc-utils.h"
105 /* Prototypes for supply_gregset etc. */
108 /* =================== TARGET_OPS "MODULE" =================== */
110 /* This module defines the GDB target vector and its methods. */
112 static void procfs_attach (struct target_ops
*, char *, int);
113 static void procfs_detach (struct target_ops
*, char *, int);
114 static void procfs_resume (struct target_ops
*,
115 ptid_t
, int, enum target_signal
);
116 static void procfs_stop (ptid_t
);
117 static void procfs_files_info (struct target_ops
*);
118 static void procfs_fetch_registers (struct target_ops
*,
119 struct regcache
*, int);
120 static void procfs_store_registers (struct target_ops
*,
121 struct regcache
*, int);
122 static void procfs_pass_signals (int, unsigned char *);
123 static void procfs_kill_inferior (struct target_ops
*ops
);
124 static void procfs_mourn_inferior (struct target_ops
*ops
);
125 static void procfs_create_inferior (struct target_ops
*, char *,
126 char *, char **, int);
127 static ptid_t
procfs_wait (struct target_ops
*,
128 ptid_t
, struct target_waitstatus
*, int);
129 static int procfs_xfer_memory (CORE_ADDR
, gdb_byte
*, int, int,
130 struct mem_attrib
*attrib
,
131 struct target_ops
*);
132 static LONGEST
procfs_xfer_partial (struct target_ops
*ops
,
133 enum target_object object
,
136 const gdb_byte
*writebuf
,
137 ULONGEST offset
, LONGEST len
);
139 static int procfs_thread_alive (struct target_ops
*ops
, ptid_t
);
141 void procfs_find_new_threads (struct target_ops
*ops
);
142 char *procfs_pid_to_str (struct target_ops
*, ptid_t
);
144 static int proc_find_memory_regions (int (*) (CORE_ADDR
,
150 static char * procfs_make_note_section (bfd
*, int *);
152 static int procfs_can_use_hw_breakpoint (int, int, int);
154 static void procfs_info_proc (struct target_ops
*, char *,
155 enum info_proc_what
);
157 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
158 /* When GDB is built as 64-bit application on Solaris, the auxv data
159 is presented in 64-bit format. We need to provide a custom parser
162 procfs_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
163 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
165 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
166 gdb_byte
*ptr
= *readptr
;
171 if (endptr
- ptr
< 8 * 2)
174 *typep
= extract_unsigned_integer (ptr
, 4, byte_order
);
176 /* The size of data is always 64-bit. If the application is 32-bit,
177 it will be zero extended, as expected. */
178 *valp
= extract_unsigned_integer (ptr
, 8, byte_order
);
189 struct target_ops
*t
= inf_child_target ();
191 t
->to_shortname
= "procfs";
192 t
->to_longname
= "Unix /proc child process";
194 "Unix /proc child process (started by the \"run\" command).";
195 t
->to_create_inferior
= procfs_create_inferior
;
196 t
->to_kill
= procfs_kill_inferior
;
197 t
->to_mourn_inferior
= procfs_mourn_inferior
;
198 t
->to_attach
= procfs_attach
;
199 t
->to_detach
= procfs_detach
;
200 t
->to_wait
= procfs_wait
;
201 t
->to_resume
= procfs_resume
;
202 t
->to_fetch_registers
= procfs_fetch_registers
;
203 t
->to_store_registers
= procfs_store_registers
;
204 t
->to_xfer_partial
= procfs_xfer_partial
;
205 t
->deprecated_xfer_memory
= procfs_xfer_memory
;
206 t
->to_pass_signals
= procfs_pass_signals
;
207 t
->to_files_info
= procfs_files_info
;
208 t
->to_stop
= procfs_stop
;
210 t
->to_find_new_threads
= procfs_find_new_threads
;
211 t
->to_thread_alive
= procfs_thread_alive
;
212 t
->to_pid_to_str
= procfs_pid_to_str
;
214 t
->to_has_thread_control
= tc_schedlock
;
215 t
->to_find_memory_regions
= proc_find_memory_regions
;
216 t
->to_make_corefile_notes
= procfs_make_note_section
;
217 t
->to_info_proc
= procfs_info_proc
;
219 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
220 t
->to_auxv_parse
= procfs_auxv_parse
;
223 t
->to_magic
= OPS_MAGIC
;
228 /* =================== END, TARGET_OPS "MODULE" =================== */
230 /* World Unification:
232 Put any typedefs, defines etc. here that are required for the
233 unification of code that handles different versions of /proc. */
235 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
237 enum { READ_WATCHFLAG
= WA_READ
,
238 WRITE_WATCHFLAG
= WA_WRITE
,
239 EXEC_WATCHFLAG
= WA_EXEC
,
240 AFTER_WATCHFLAG
= WA_TRAPAFTER
243 #else /* Irix method for watchpoints */
244 enum { READ_WATCHFLAG
= MA_READ
,
245 WRITE_WATCHFLAG
= MA_WRITE
,
246 EXEC_WATCHFLAG
= MA_EXEC
,
247 AFTER_WATCHFLAG
= 0 /* trapafter not implemented */
252 #ifdef HAVE_PR_SIGSET_T
253 typedef pr_sigset_t gdb_sigset_t
;
255 typedef sigset_t gdb_sigset_t
;
259 #ifdef HAVE_PR_SIGACTION64_T
260 typedef pr_sigaction64_t gdb_sigaction_t
;
262 typedef struct sigaction gdb_sigaction_t
;
266 #ifdef HAVE_PR_SIGINFO64_T
267 typedef pr_siginfo64_t gdb_siginfo_t
;
269 typedef struct siginfo gdb_siginfo_t
;
272 /* On mips-irix, praddset and prdelset are defined in such a way that
273 they return a value, which causes GCC to emit a -Wunused error
274 because the returned value is not used. Prevent this warning
275 by casting the return value to void. On sparc-solaris, this issue
276 does not exist because the definition of these macros already include
277 that cast to void. */
278 #define gdb_praddset(sp, flag) ((void) praddset (sp, flag))
279 #define gdb_prdelset(sp, flag) ((void) prdelset (sp, flag))
281 /* gdb_premptysysset */
283 #define gdb_premptysysset premptysysset
285 #define gdb_premptysysset premptyset
290 #define gdb_praddsysset praddsysset
292 #define gdb_praddsysset gdb_praddset
297 #define gdb_prdelsysset prdelsysset
299 #define gdb_prdelsysset gdb_prdelset
302 /* prissyssetmember */
303 #ifdef prissyssetmember
304 #define gdb_pr_issyssetmember prissyssetmember
306 #define gdb_pr_issyssetmember prismember
309 /* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't
310 as intuitively descriptive as it could be, so we'll define
311 DYNAMIC_SYSCALLS to mean the same thing. Anyway, at the time of
312 this writing, this feature is only found on AIX5 systems and
313 basically means that the set of syscalls is not fixed. I.e,
314 there's no nice table that one can #include to get all of the
315 syscall numbers. Instead, they're stored in /proc/PID/sysent
316 for each process. We are at least guaranteed that they won't
317 change over the lifetime of the process. But each process could
318 (in theory) have different syscall numbers. */
319 #ifdef HAVE_PRSYSENT_T
320 #define DYNAMIC_SYSCALLS
325 /* =================== STRUCT PROCINFO "MODULE" =================== */
327 /* FIXME: this comment will soon be out of date W.R.T. threads. */
329 /* The procinfo struct is a wrapper to hold all the state information
330 concerning a /proc process. There should be exactly one procinfo
331 for each process, and since GDB currently can debug only one
332 process at a time, that means there should be only one procinfo.
333 All of the LWP's of a process can be accessed indirectly thru the
334 single process procinfo.
336 However, against the day when GDB may debug more than one process,
337 this data structure is kept in a list (which for now will hold no
338 more than one member), and many functions will have a pointer to a
339 procinfo as an argument.
341 There will be a separate procinfo structure for use by the (not yet
342 implemented) "info proc" command, so that we can print useful
343 information about any random process without interfering with the
344 inferior's procinfo information. */
347 /* format strings for /proc paths */
348 # ifndef CTL_PROC_NAME_FMT
349 # define MAIN_PROC_NAME_FMT "/proc/%d"
350 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
351 # define AS_PROC_NAME_FMT "/proc/%d/as"
352 # define MAP_PROC_NAME_FMT "/proc/%d/map"
353 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
354 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
356 /* the name of the proc status struct depends on the implementation */
357 typedef pstatus_t gdb_prstatus_t
;
358 typedef lwpstatus_t gdb_lwpstatus_t
;
359 #else /* ! NEW_PROC_API */
360 /* format strings for /proc paths */
361 # ifndef CTL_PROC_NAME_FMT
362 # define MAIN_PROC_NAME_FMT "/proc/%05d"
363 # define CTL_PROC_NAME_FMT "/proc/%05d"
364 # define AS_PROC_NAME_FMT "/proc/%05d"
365 # define MAP_PROC_NAME_FMT "/proc/%05d"
366 # define STATUS_PROC_NAME_FMT "/proc/%05d"
367 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
369 /* The name of the proc status struct depends on the implementation. */
370 typedef prstatus_t gdb_prstatus_t
;
371 typedef prstatus_t gdb_lwpstatus_t
;
372 #endif /* NEW_PROC_API */
374 typedef struct procinfo
{
375 struct procinfo
*next
;
376 int pid
; /* Process ID */
377 int tid
; /* Thread/LWP id */
381 int ignore_next_sigstop
;
383 /* The following four fd fields may be identical, or may contain
384 several different fd's, depending on the version of /proc
385 (old ioctl or new read/write). */
387 int ctl_fd
; /* File descriptor for /proc control file */
389 /* The next three file descriptors are actually only needed in the
390 read/write, multiple-file-descriptor implemenation
391 (NEW_PROC_API). However, to avoid a bunch of #ifdefs in the
392 code, we will use them uniformly by (in the case of the ioctl
393 single-file-descriptor implementation) filling them with copies
394 of the control fd. */
395 int status_fd
; /* File descriptor for /proc status file */
396 int as_fd
; /* File descriptor for /proc as file */
398 char pathname
[MAX_PROC_NAME_SIZE
]; /* Pathname to /proc entry */
400 fltset_t saved_fltset
; /* Saved traced hardware fault set */
401 gdb_sigset_t saved_sigset
; /* Saved traced signal set */
402 gdb_sigset_t saved_sighold
; /* Saved held signal set */
403 sysset_t
*saved_exitset
; /* Saved traced system call exit set */
404 sysset_t
*saved_entryset
; /* Saved traced system call entry set */
406 gdb_prstatus_t prstatus
; /* Current process status info */
409 gdb_fpregset_t fpregset
; /* Current floating point registers */
412 #ifdef DYNAMIC_SYSCALLS
413 int num_syscalls
; /* Total number of syscalls */
414 char **syscall_names
; /* Syscall number to name map */
417 struct procinfo
*thread_list
;
419 int status_valid
: 1;
421 int fpregs_valid
: 1;
422 int threads_valid
: 1;
425 static char errmsg
[128]; /* shared error msg buffer */
427 /* Function prototypes for procinfo module: */
429 static procinfo
*find_procinfo_or_die (int pid
, int tid
);
430 static procinfo
*find_procinfo (int pid
, int tid
);
431 static procinfo
*create_procinfo (int pid
, int tid
);
432 static void destroy_procinfo (procinfo
* p
);
433 static void do_destroy_procinfo_cleanup (void *);
434 static void dead_procinfo (procinfo
* p
, char *msg
, int killp
);
435 static int open_procinfo_files (procinfo
* p
, int which
);
436 static void close_procinfo_files (procinfo
* p
);
437 static int sysset_t_size (procinfo
*p
);
438 static sysset_t
*sysset_t_alloc (procinfo
* pi
);
439 #ifdef DYNAMIC_SYSCALLS
440 static void load_syscalls (procinfo
*pi
);
441 static void free_syscalls (procinfo
*pi
);
442 static int find_syscall (procinfo
*pi
, char *name
);
443 #endif /* DYNAMIC_SYSCALLS */
445 static int iterate_over_mappings
446 (procinfo
*pi
, find_memory_region_ftype child_func
, void *data
,
447 int (*func
) (struct prmap
*map
, find_memory_region_ftype child_func
,
450 /* The head of the procinfo list: */
451 static procinfo
* procinfo_list
;
453 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
457 find_procinfo (int pid
, int tid
)
461 for (pi
= procinfo_list
; pi
; pi
= pi
->next
)
468 /* Don't check threads_valid. If we're updating the
469 thread_list, we want to find whatever threads are already
470 here. This means that in general it is the caller's
471 responsibility to check threads_valid and update before
472 calling find_procinfo, if the caller wants to find a new
475 for (pi
= pi
->thread_list
; pi
; pi
= pi
->next
)
483 /* Calls find_procinfo, but errors on failure. */
486 find_procinfo_or_die (int pid
, int tid
)
488 procinfo
*pi
= find_procinfo (pid
, tid
);
493 error (_("procfs: couldn't find pid %d "
494 "(kernel thread %d) in procinfo list."),
497 error (_("procfs: couldn't find pid %d in procinfo list."), pid
);
502 /* Wrapper for `open'. The appropriate open call is attempted; if
503 unsuccessful, it will be retried as many times as needed for the
504 EAGAIN and EINTR conditions.
506 For other conditions, retry the open a limited number of times. In
507 addition, a short sleep is imposed prior to retrying the open. The
508 reason for this sleep is to give the kernel a chance to catch up
509 and create the file in question in the event that GDB "wins" the
510 race to open a file before the kernel has created it. */
513 open_with_retry (const char *pathname
, int flags
)
515 int retries_remaining
, status
;
517 retries_remaining
= 2;
521 status
= open (pathname
, flags
);
523 if (status
>= 0 || retries_remaining
== 0)
525 else if (errno
!= EINTR
&& errno
!= EAGAIN
)
535 /* Open the file descriptor for the process or LWP. If NEW_PROC_API
536 is defined, we only open the control file descriptor; the others
537 are opened lazily as needed. Otherwise (if not NEW_PROC_API),
538 there is only one real file descriptor, but we keep multiple copies
539 of it so that the code that uses them does not have to be #ifdef'd.
540 Returns the file descriptor, or zero for failure. */
542 enum { FD_CTL
, FD_STATUS
, FD_AS
};
545 open_procinfo_files (procinfo
*pi
, int which
)
548 char tmp
[MAX_PROC_NAME_SIZE
];
552 /* This function is getting ALMOST long enough to break up into
553 several. Here is some rationale:
555 NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
556 There are several file descriptors that may need to be open
557 for any given process or LWP. The ones we're intereted in are:
558 - control (ctl) write-only change the state
559 - status (status) read-only query the state
560 - address space (as) read/write access memory
561 - map (map) read-only virtual addr map
562 Most of these are opened lazily as they are needed.
563 The pathnames for the 'files' for an LWP look slightly
564 different from those of a first-class process:
565 Pathnames for a process (<proc-id>):
567 /proc/<proc-id>/status
570 Pathnames for an LWP (lwp-id):
571 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
572 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
573 An LWP has no map or address space file descriptor, since
574 the memory map and address space are shared by all LWPs.
576 Everyone else (Solaris 2.5, Irix, OSF)
577 There is only one file descriptor for each process or LWP.
578 For convenience, we copy the same file descriptor into all
579 three fields of the procinfo struct (ctl_fd, status_fd, and
580 as_fd, see NEW_PROC_API above) so that code that uses them
581 doesn't need any #ifdef's.
586 Each LWP has an independent file descriptor, but these
587 are not obtained via the 'open' system call like the rest:
588 instead, they're obtained thru an ioctl call (PIOCOPENLWP)
589 to the file descriptor of the parent process.
592 These do not even have their own independent file descriptor.
593 All operations are carried out on the file descriptor of the
594 parent process. Therefore we just call open again for each
595 thread, getting a new handle for the same 'file'. */
598 /* In this case, there are several different file descriptors that
599 we might be asked to open. The control file descriptor will be
600 opened early, but the others will be opened lazily as they are
603 strcpy (tmp
, pi
->pathname
);
604 switch (which
) { /* Which file descriptor to open? */
607 strcat (tmp
, "/lwpctl");
609 strcat (tmp
, "/ctl");
610 fd
= open_with_retry (tmp
, O_WRONLY
);
617 return 0; /* There is no 'as' file descriptor for an lwp. */
619 fd
= open_with_retry (tmp
, O_RDWR
);
626 strcat (tmp
, "/lwpstatus");
628 strcat (tmp
, "/status");
629 fd
= open_with_retry (tmp
, O_RDONLY
);
635 return 0; /* unknown file descriptor */
637 #else /* not NEW_PROC_API */
638 /* In this case, there is only one file descriptor for each procinfo
639 (ie. each process or LWP). In fact, only the file descriptor for
640 the process can actually be opened by an 'open' system call. The
641 ones for the LWPs have to be obtained thru an IOCTL call on the
642 process's file descriptor.
644 For convenience, we copy each procinfo's single file descriptor
645 into all of the fields occupied by the several file descriptors
646 of the NEW_PROC_API implementation. That way, the code that uses
647 them can be written without ifdefs. */
650 #ifdef PIOCTSTATUS /* OSF */
651 /* Only one FD; just open it. */
652 if ((fd
= open_with_retry (pi
->pathname
, O_RDWR
)) < 0)
654 #else /* Sol 2.5, Irix, other? */
655 if (pi
->tid
== 0) /* Master procinfo for the process */
657 fd
= open_with_retry (pi
->pathname
, O_RDWR
);
661 else /* LWP thread procinfo */
663 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
667 /* Find the procinfo for the entire process. */
668 if ((process
= find_procinfo (pi
->pid
, 0)) == NULL
)
671 /* Now obtain the file descriptor for the LWP. */
672 if ((fd
= ioctl (process
->ctl_fd
, PIOCOPENLWP
, &lwpid
)) < 0)
674 #else /* Irix, other? */
675 return 0; /* Don't know how to open threads. */
676 #endif /* Sol 2.5 PIOCOPENLWP */
678 #endif /* OSF PIOCTSTATUS */
679 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= fd
;
680 #endif /* NEW_PROC_API */
682 return 1; /* success */
685 /* Allocate a data structure and link it into the procinfo list.
686 First tries to find a pre-existing one (FIXME: why?). Returns the
687 pointer to new procinfo struct. */
690 create_procinfo (int pid
, int tid
)
692 procinfo
*pi
, *parent
= NULL
;
694 if ((pi
= find_procinfo (pid
, tid
)))
695 return pi
; /* Already exists, nothing to do. */
697 /* Find parent before doing malloc, to save having to cleanup. */
699 parent
= find_procinfo_or_die (pid
, 0); /* FIXME: should I
701 doesn't exist yet? */
703 pi
= (procinfo
*) xmalloc (sizeof (procinfo
));
704 memset (pi
, 0, sizeof (procinfo
));
708 #ifdef DYNAMIC_SYSCALLS
712 pi
->saved_entryset
= sysset_t_alloc (pi
);
713 pi
->saved_exitset
= sysset_t_alloc (pi
);
715 /* Chain into list. */
718 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
719 pi
->next
= procinfo_list
;
725 sprintf (pi
->pathname
, "/proc/%05d/lwp/%d", pid
, tid
);
727 sprintf (pi
->pathname
, MAIN_PROC_NAME_FMT
, pid
);
729 pi
->next
= parent
->thread_list
;
730 parent
->thread_list
= pi
;
735 /* Close all file descriptors associated with the procinfo. */
738 close_procinfo_files (procinfo
*pi
)
745 if (pi
->status_fd
> 0)
746 close (pi
->status_fd
);
748 pi
->ctl_fd
= pi
->as_fd
= pi
->status_fd
= 0;
751 /* Destructor function. Close, unlink and deallocate the object. */
754 destroy_one_procinfo (procinfo
**list
, procinfo
*pi
)
758 /* Step one: unlink the procinfo from its list. */
762 for (ptr
= *list
; ptr
; ptr
= ptr
->next
)
765 ptr
->next
= pi
->next
;
769 /* Step two: close any open file descriptors. */
770 close_procinfo_files (pi
);
772 /* Step three: free the memory. */
773 #ifdef DYNAMIC_SYSCALLS
776 xfree (pi
->saved_entryset
);
777 xfree (pi
->saved_exitset
);
782 destroy_procinfo (procinfo
*pi
)
786 if (pi
->tid
!= 0) /* Destroy a thread procinfo. */
788 tmp
= find_procinfo (pi
->pid
, 0); /* Find the parent process. */
789 destroy_one_procinfo (&tmp
->thread_list
, pi
);
791 else /* Destroy a process procinfo and all its threads. */
793 /* First destroy the children, if any; */
794 while (pi
->thread_list
!= NULL
)
795 destroy_one_procinfo (&pi
->thread_list
, pi
->thread_list
);
796 /* Then destroy the parent. Genocide!!! */
797 destroy_one_procinfo (&procinfo_list
, pi
);
802 do_destroy_procinfo_cleanup (void *pi
)
804 destroy_procinfo (pi
);
807 enum { NOKILL
, KILL
};
809 /* To be called on a non_recoverable error for a procinfo. Prints
810 error messages, optionally sends a SIGKILL to the process, then
811 destroys the data structure. */
814 dead_procinfo (procinfo
*pi
, char *msg
, int kill_p
)
820 print_sys_errmsg (pi
->pathname
, errno
);
824 sprintf (procfile
, "process %d", pi
->pid
);
825 print_sys_errmsg (procfile
, errno
);
828 kill (pi
->pid
, SIGKILL
);
830 destroy_procinfo (pi
);
834 /* Returns the (complete) size of a sysset_t struct. Normally, this
835 is just sizeof (sysset_t), but in the case of Monterey/64, the
836 actual size of sysset_t isn't known until runtime. */
839 sysset_t_size (procinfo
* pi
)
841 #ifndef DYNAMIC_SYSCALLS
842 return sizeof (sysset_t
);
844 return sizeof (sysset_t
) - sizeof (uint64_t)
845 + sizeof (uint64_t) * ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
846 / (8 * sizeof (uint64_t)));
850 /* Allocate and (partially) initialize a sysset_t struct. */
853 sysset_t_alloc (procinfo
* pi
)
856 int size
= sysset_t_size (pi
);
858 ret
= xmalloc (size
);
859 #ifdef DYNAMIC_SYSCALLS
860 ret
->pr_size
= ((pi
->num_syscalls
+ (8 * sizeof (uint64_t) - 1))
861 / (8 * sizeof (uint64_t)));
866 #ifdef DYNAMIC_SYSCALLS
868 /* Extract syscall numbers and names from /proc/<pid>/sysent. Initialize
869 pi->num_syscalls with the number of syscalls and pi->syscall_names
870 with the names. (Certain numbers may be skipped in which case the
871 names for these numbers will be left as NULL.) */
873 #define MAX_SYSCALL_NAME_LENGTH 256
874 #define MAX_SYSCALLS 65536
877 load_syscalls (procinfo
*pi
)
879 char pathname
[MAX_PROC_NAME_SIZE
];
882 prsyscall_t
*syscalls
;
883 int i
, size
, maxcall
;
884 struct cleanup
*cleanups
;
886 pi
->num_syscalls
= 0;
887 pi
->syscall_names
= 0;
889 /* Open the file descriptor for the sysent file. */
890 sprintf (pathname
, "/proc/%d/sysent", pi
->pid
);
891 sysent_fd
= open_with_retry (pathname
, O_RDONLY
);
894 error (_("load_syscalls: Can't open /proc/%d/sysent"), pi
->pid
);
896 cleanups
= make_cleanup_close (sysent_fd
);
898 size
= sizeof header
- sizeof (prsyscall_t
);
899 if (read (sysent_fd
, &header
, size
) != size
)
901 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
904 if (header
.pr_nsyscalls
== 0)
906 error (_("load_syscalls: /proc/%d/sysent contains no syscalls!"),
910 size
= header
.pr_nsyscalls
* sizeof (prsyscall_t
);
911 syscalls
= xmalloc (size
);
912 make_cleanup (free_current_contents
, &syscalls
);
914 if (read (sysent_fd
, syscalls
, size
) != size
)
915 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi
->pid
);
917 /* Find maximum syscall number. This may not be the same as
918 pr_nsyscalls since that value refers to the number of entries
919 in the table. (Also, the docs indicate that some system
920 call numbers may be skipped.) */
922 maxcall
= syscalls
[0].pr_number
;
924 for (i
= 1; i
< header
.pr_nsyscalls
; i
++)
925 if (syscalls
[i
].pr_number
> maxcall
926 && syscalls
[i
].pr_nameoff
> 0
927 && syscalls
[i
].pr_number
< MAX_SYSCALLS
)
928 maxcall
= syscalls
[i
].pr_number
;
930 pi
->num_syscalls
= maxcall
+1;
931 pi
->syscall_names
= xmalloc (pi
->num_syscalls
* sizeof (char *));
933 for (i
= 0; i
< pi
->num_syscalls
; i
++)
934 pi
->syscall_names
[i
] = NULL
;
936 /* Read the syscall names in. */
937 for (i
= 0; i
< header
.pr_nsyscalls
; i
++)
939 char namebuf
[MAX_SYSCALL_NAME_LENGTH
];
943 if (syscalls
[i
].pr_number
>= MAX_SYSCALLS
944 || syscalls
[i
].pr_number
< 0
945 || syscalls
[i
].pr_nameoff
<= 0
946 || (lseek (sysent_fd
, (off_t
) syscalls
[i
].pr_nameoff
, SEEK_SET
)
947 != (off_t
) syscalls
[i
].pr_nameoff
))
950 nread
= read (sysent_fd
, namebuf
, sizeof namebuf
);
954 callnum
= syscalls
[i
].pr_number
;
956 if (pi
->syscall_names
[callnum
] != NULL
)
958 /* FIXME: Generate warning. */
962 namebuf
[nread
-1] = '\0';
963 size
= strlen (namebuf
) + 1;
964 pi
->syscall_names
[callnum
] = xmalloc (size
);
965 strncpy (pi
->syscall_names
[callnum
], namebuf
, size
-1);
966 pi
->syscall_names
[callnum
][size
-1] = '\0';
969 do_cleanups (cleanups
);
972 /* Free the space allocated for the syscall names from the procinfo
976 free_syscalls (procinfo
*pi
)
978 if (pi
->syscall_names
)
982 for (i
= 0; i
< pi
->num_syscalls
; i
++)
983 if (pi
->syscall_names
[i
] != NULL
)
984 xfree (pi
->syscall_names
[i
]);
986 xfree (pi
->syscall_names
);
987 pi
->syscall_names
= 0;
991 /* Given a name, look up (and return) the corresponding syscall number.
992 If no match is found, return -1. */
995 find_syscall (procinfo
*pi
, char *name
)
999 for (i
= 0; i
< pi
->num_syscalls
; i
++)
1001 if (pi
->syscall_names
[i
] && strcmp (name
, pi
->syscall_names
[i
]) == 0)
1008 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
1010 /* =================== /proc "MODULE" =================== */
1012 /* This "module" is the interface layer between the /proc system API
1013 and the gdb target vector functions. This layer consists of access
1014 functions that encapsulate each of the basic operations that we
1015 need to use from the /proc API.
1017 The main motivation for this layer is to hide the fact that there
1018 are two very different implementations of the /proc API. Rather
1019 than have a bunch of #ifdefs all thru the gdb target vector
1020 functions, we do our best to hide them all in here. */
1022 int proc_get_status (procinfo
* pi
);
1023 long proc_flags (procinfo
* pi
);
1024 int proc_why (procinfo
* pi
);
1025 int proc_what (procinfo
* pi
);
1026 int proc_set_run_on_last_close (procinfo
* pi
);
1027 int proc_unset_run_on_last_close (procinfo
* pi
);
1028 int proc_set_inherit_on_fork (procinfo
* pi
);
1029 int proc_unset_inherit_on_fork (procinfo
* pi
);
1030 int proc_set_async (procinfo
* pi
);
1031 int proc_unset_async (procinfo
* pi
);
1032 int proc_stop_process (procinfo
* pi
);
1033 int proc_trace_signal (procinfo
* pi
, int signo
);
1034 int proc_ignore_signal (procinfo
* pi
, int signo
);
1035 int proc_clear_current_fault (procinfo
* pi
);
1036 int proc_set_current_signal (procinfo
* pi
, int signo
);
1037 int proc_clear_current_signal (procinfo
* pi
);
1038 int proc_set_gregs (procinfo
* pi
);
1039 int proc_set_fpregs (procinfo
* pi
);
1040 int proc_wait_for_stop (procinfo
* pi
);
1041 int proc_run_process (procinfo
* pi
, int step
, int signo
);
1042 int proc_kill (procinfo
* pi
, int signo
);
1043 int proc_parent_pid (procinfo
* pi
);
1044 int proc_get_nthreads (procinfo
* pi
);
1045 int proc_get_current_thread (procinfo
* pi
);
1046 int proc_set_held_signals (procinfo
* pi
, gdb_sigset_t
* sighold
);
1047 int proc_set_traced_sysexit (procinfo
* pi
, sysset_t
* sysset
);
1048 int proc_set_traced_sysentry (procinfo
* pi
, sysset_t
* sysset
);
1049 int proc_set_traced_faults (procinfo
* pi
, fltset_t
* fltset
);
1050 int proc_set_traced_signals (procinfo
* pi
, gdb_sigset_t
* sigset
);
1052 int proc_update_threads (procinfo
* pi
);
1053 int proc_iterate_over_threads (procinfo
* pi
,
1054 int (*func
) (procinfo
*, procinfo
*, void *),
1057 gdb_gregset_t
*proc_get_gregs (procinfo
* pi
);
1058 gdb_fpregset_t
*proc_get_fpregs (procinfo
* pi
);
1059 sysset_t
*proc_get_traced_sysexit (procinfo
* pi
, sysset_t
* save
);
1060 sysset_t
*proc_get_traced_sysentry (procinfo
* pi
, sysset_t
* save
);
1061 fltset_t
*proc_get_traced_faults (procinfo
* pi
, fltset_t
* save
);
1062 gdb_sigset_t
*proc_get_traced_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1063 gdb_sigset_t
*proc_get_held_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1064 gdb_sigset_t
*proc_get_pending_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1065 gdb_sigaction_t
*proc_get_signal_actions (procinfo
* pi
,
1066 gdb_sigaction_t
*save
);
1068 void proc_warn (procinfo
* pi
, char *func
, int line
);
1069 void proc_error (procinfo
* pi
, char *func
, int line
);
1072 proc_warn (procinfo
*pi
, char *func
, int line
)
1074 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1075 print_sys_errmsg (errmsg
, errno
);
1079 proc_error (procinfo
*pi
, char *func
, int line
)
1081 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1082 perror_with_name (errmsg
);
1085 /* Updates the status struct in the procinfo. There is a 'valid'
1086 flag, to let other functions know when this function needs to be
1087 called (so the status is only read when it is needed). The status
1088 file descriptor is also only opened when it is needed. Returns
1089 non-zero for success, zero for failure. */
1092 proc_get_status (procinfo
*pi
)
1094 /* Status file descriptor is opened "lazily". */
1095 if (pi
->status_fd
== 0 &&
1096 open_procinfo_files (pi
, FD_STATUS
) == 0)
1098 pi
->status_valid
= 0;
1103 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
1104 pi
->status_valid
= 0; /* fail */
1107 /* Sigh... I have to read a different data structure,
1108 depending on whether this is a main process or an LWP. */
1110 pi
->status_valid
= (read (pi
->status_fd
,
1111 (char *) &pi
->prstatus
.pr_lwp
,
1112 sizeof (lwpstatus_t
))
1113 == sizeof (lwpstatus_t
));
1116 pi
->status_valid
= (read (pi
->status_fd
,
1117 (char *) &pi
->prstatus
,
1118 sizeof (gdb_prstatus_t
))
1119 == sizeof (gdb_prstatus_t
));
1120 #if 0 /*def UNIXWARE*/
1121 if (pi
->status_valid
&&
1122 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
1123 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
1124 /* Unixware peculiarity -- read the damn thing again! */
1125 pi
->status_valid
= (read (pi
->status_fd
,
1126 (char *) &pi
->prstatus
,
1127 sizeof (gdb_prstatus_t
))
1128 == sizeof (gdb_prstatus_t
));
1129 #endif /* UNIXWARE */
1132 #else /* ioctl method */
1133 #ifdef PIOCTSTATUS /* osf */
1134 if (pi
->tid
== 0) /* main process */
1136 /* Just read the danged status. Now isn't that simple? */
1138 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1145 tid_t pr_error_thread
;
1146 struct prstatus status
;
1149 thread_status
.pr_count
= 1;
1150 thread_status
.status
.pr_tid
= pi
->tid
;
1151 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
1154 memcpy (&pi
->prstatus
, &thread_status
.status
,
1155 sizeof (pi
->prstatus
));
1156 pi
->status_valid
= 1;
1160 /* Just read the danged status. Now isn't that simple? */
1161 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1165 if (pi
->status_valid
)
1167 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1170 proc_get_current_thread (pi
));
1173 /* The status struct includes general regs, so mark them valid too. */
1174 pi
->gregs_valid
= pi
->status_valid
;
1176 /* In the read/write multiple-fd model, the status struct includes
1177 the fp regs too, so mark them valid too. */
1178 pi
->fpregs_valid
= pi
->status_valid
;
1180 return pi
->status_valid
; /* True if success, false if failure. */
1183 /* Returns the process flags (pr_flags field). */
1186 proc_flags (procinfo
*pi
)
1188 if (!pi
->status_valid
)
1189 if (!proc_get_status (pi
))
1190 return 0; /* FIXME: not a good failure value (but what is?) */
1194 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
1195 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
1196 The two sets of flags don't overlap. */
1197 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
1199 return pi
->prstatus
.pr_lwp
.pr_flags
;
1202 return pi
->prstatus
.pr_flags
;
1206 /* Returns the pr_why field (why the process stopped). */
1209 proc_why (procinfo
*pi
)
1211 if (!pi
->status_valid
)
1212 if (!proc_get_status (pi
))
1213 return 0; /* FIXME: not a good failure value (but what is?) */
1216 return pi
->prstatus
.pr_lwp
.pr_why
;
1218 return pi
->prstatus
.pr_why
;
1222 /* Returns the pr_what field (details of why the process stopped). */
1225 proc_what (procinfo
*pi
)
1227 if (!pi
->status_valid
)
1228 if (!proc_get_status (pi
))
1229 return 0; /* FIXME: not a good failure value (but what is?) */
1232 return pi
->prstatus
.pr_lwp
.pr_what
;
1234 return pi
->prstatus
.pr_what
;
1238 /* This function is only called when PI is stopped by a watchpoint.
1239 Assuming the OS supports it, write to *ADDR the data address which
1240 triggered it and return 1. Return 0 if it is not possible to know
1244 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
1246 if (!pi
->status_valid
)
1247 if (!proc_get_status (pi
))
1251 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch
,
1252 builtin_type (target_gdbarch
)->builtin_data_ptr
,
1253 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
1255 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch
,
1256 builtin_type (target_gdbarch
)->builtin_data_ptr
,
1257 (gdb_byte
*) &pi
->prstatus
.pr_info
.si_addr
);
1262 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1264 /* Returns the pr_nsysarg field (number of args to the current
1268 proc_nsysarg (procinfo
*pi
)
1270 if (!pi
->status_valid
)
1271 if (!proc_get_status (pi
))
1275 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1277 return pi
->prstatus
.pr_nsysarg
;
1281 /* Returns the pr_sysarg field (pointer to the arguments of current
1285 proc_sysargs (procinfo
*pi
)
1287 if (!pi
->status_valid
)
1288 if (!proc_get_status (pi
))
1292 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1294 return (long *) &pi
->prstatus
.pr_sysarg
;
1298 /* Returns the pr_syscall field (id of current syscall if we are in
1302 proc_syscall (procinfo
*pi
)
1304 if (!pi
->status_valid
)
1305 if (!proc_get_status (pi
))
1309 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1311 return pi
->prstatus
.pr_syscall
;
1314 #endif /* PIOCSSPCACT */
1316 /* Returns the pr_cursig field (current signal). */
1319 proc_cursig (struct procinfo
*pi
)
1321 if (!pi
->status_valid
)
1322 if (!proc_get_status (pi
))
1323 return 0; /* FIXME: not a good failure value (but what is?) */
1326 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1328 return pi
->prstatus
.pr_cursig
;
1332 /* === I appologize for the messiness of this function.
1333 === This is an area where the different versions of
1334 === /proc are more inconsistent than usual.
1336 Set or reset any of the following process flags:
1337 PR_FORK -- forked child will inherit trace flags
1338 PR_RLC -- traced process runs when last /proc file closed.
1339 PR_KLC -- traced process is killed when last /proc file closed.
1340 PR_ASYNC -- LWP's get to run/stop independently.
1342 There are three methods for doing this function:
1343 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1345 2) Middle: PIOCSET/PIOCRESET
1347 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1350 Note: Irix does not define PR_ASYNC.
1351 Note: OSF does not define PR_KLC.
1352 Note: OSF is the only one that can ONLY use the oldest method.
1356 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1357 mode -- 1 for set, 0 for reset.
1359 Returns non-zero for success, zero for failure. */
1361 enum { FLAG_RESET
, FLAG_SET
};
1364 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
1366 long win
= 0; /* default to fail */
1368 /* These operations affect the process as a whole, and applying them
1369 to an individual LWP has the same meaning as applying them to the
1370 main process. Therefore, if we're ever called with a pointer to
1371 an LWP's procinfo, let's substitute the process's procinfo and
1372 avoid opening the LWP's file descriptor unnecessarily. */
1375 pi
= find_procinfo_or_die (pi
->pid
, 0);
1377 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii. */
1378 /* First normalize the PCUNSET/PCRESET command opcode
1379 (which for no obvious reason has a different definition
1380 from one operating system to the next...) */
1382 #define GDBRESET PCUNSET
1385 #define GDBRESET PCRESET
1389 procfs_ctl_t arg
[2];
1391 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
1393 else /* Reset the flag. */
1397 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1400 #ifdef PIOCSET /* Irix/Sol5 method */
1401 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC). */
1403 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1405 else /* Reset the flag. */
1407 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1411 #ifdef PIOCSRLC /* Oldest method: OSF */
1414 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1416 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1418 else /* Clear run-on-last-close */
1420 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1424 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1426 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1428 else /* Clear inherit-on-fork */
1430 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1434 win
= 0; /* Fail -- unknown flag (can't do PR_ASYNC). */
1441 /* The above operation renders the procinfo's cached pstatus
1443 pi
->status_valid
= 0;
1446 warning (_("procfs: modify_flag failed to turn %s %s"),
1447 flag
== PR_FORK
? "PR_FORK" :
1448 flag
== PR_RLC
? "PR_RLC" :
1450 flag
== PR_ASYNC
? "PR_ASYNC" :
1453 flag
== PR_KLC
? "PR_KLC" :
1456 mode
== FLAG_RESET
? "off" : "on");
1461 /* Set the run_on_last_close flag. Process with all threads will
1462 become runnable when debugger closes all /proc fds. Returns
1463 non-zero for success, zero for failure. */
1466 proc_set_run_on_last_close (procinfo
*pi
)
1468 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1471 /* Reset the run_on_last_close flag. The process will NOT become
1472 runnable when debugger closes its file handles. Returns non-zero
1473 for success, zero for failure. */
1476 proc_unset_run_on_last_close (procinfo
*pi
)
1478 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1482 /* Set the kill_on_last_close flag. Process with all threads will be
1483 killed when debugger closes all /proc fds (or debugger exits or
1484 dies). Returns non-zero for success, zero for failure. */
1487 proc_set_kill_on_last_close (procinfo
*pi
)
1489 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1492 /* Reset the kill_on_last_close flag. Process will NOT be killed when
1493 debugger closes its file handles (or exits or dies). Returns
1494 non-zero for success, zero for failure. */
1497 proc_unset_kill_on_last_close (procinfo
*pi
)
1499 return proc_modify_flag (pi
, PR_KLC
, FLAG_RESET
);
1503 /* Set inherit_on_fork flag. If the process forks a child while we
1504 are registered for events in the parent, then we will also recieve
1505 events from the child. Returns non-zero for success, zero for
1509 proc_set_inherit_on_fork (procinfo
*pi
)
1511 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1514 /* Reset inherit_on_fork flag. If the process forks a child while we
1515 are registered for events in the parent, then we will NOT recieve
1516 events from the child. Returns non-zero for success, zero for
1520 proc_unset_inherit_on_fork (procinfo
*pi
)
1522 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1526 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
1527 (signal etc.), the remaining LWPs will continue to run. Returns
1528 non-zero for success, zero for failure. */
1531 proc_set_async (procinfo
*pi
)
1533 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1536 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
1537 (signal etc.), then all other LWPs will stop as well. Returns
1538 non-zero for success, zero for failure. */
1541 proc_unset_async (procinfo
*pi
)
1543 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1545 #endif /* PR_ASYNC */
1547 /* Request the process/LWP to stop. Does not wait. Returns non-zero
1548 for success, zero for failure. */
1551 proc_stop_process (procinfo
*pi
)
1555 /* We might conceivably apply this operation to an LWP, and the
1556 LWP's ctl file descriptor might not be open. */
1558 if (pi
->ctl_fd
== 0 &&
1559 open_procinfo_files (pi
, FD_CTL
) == 0)
1564 procfs_ctl_t cmd
= PCSTOP
;
1566 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1567 #else /* ioctl method */
1568 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1569 /* Note: the call also reads the prstatus. */
1572 pi
->status_valid
= 1;
1573 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1576 proc_get_current_thread (pi
));
1584 /* Wait for the process or LWP to stop (block until it does). Returns
1585 non-zero for success, zero for failure. */
1588 proc_wait_for_stop (procinfo
*pi
)
1592 /* We should never have to apply this operation to any procinfo
1593 except the one for the main process. If that ever changes for
1594 any reason, then take out the following clause and replace it
1595 with one that makes sure the ctl_fd is open. */
1598 pi
= find_procinfo_or_die (pi
->pid
, 0);
1602 procfs_ctl_t cmd
= PCWSTOP
;
1604 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1605 /* We been runnin' and we stopped -- need to update status. */
1606 pi
->status_valid
= 0;
1608 #else /* ioctl method */
1609 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1610 /* Above call also refreshes the prstatus. */
1613 pi
->status_valid
= 1;
1614 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1617 proc_get_current_thread (pi
));
1624 /* Make the process or LWP runnable.
1626 Options (not all are implemented):
1628 - clear current fault
1629 - clear current signal
1630 - abort the current system call
1631 - stop as soon as finished with system call
1632 - (ioctl): set traced signal set
1633 - (ioctl): set held signal set
1634 - (ioctl): set traced fault set
1635 - (ioctl): set start pc (vaddr)
1637 Always clears the current fault. PI is the process or LWP to
1638 operate on. If STEP is true, set the process or LWP to trap after
1639 one instruction. If SIGNO is zero, clear the current signal if
1640 any; if non-zero, set the current signal to this one. Returns
1641 non-zero for success, zero for failure. */
1644 proc_run_process (procinfo
*pi
, int step
, int signo
)
1649 /* We will probably have to apply this operation to individual
1650 threads, so make sure the control file descriptor is open. */
1652 if (pi
->ctl_fd
== 0 &&
1653 open_procinfo_files (pi
, FD_CTL
) == 0)
1658 runflags
= PRCFAULT
; /* Always clear current fault. */
1663 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
1664 proc_set_current_signal (pi
, signo
);
1668 procfs_ctl_t cmd
[2];
1672 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1674 #else /* ioctl method */
1678 memset (&prrun
, 0, sizeof (prrun
));
1679 prrun
.pr_flags
= runflags
;
1680 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1687 /* Register to trace signals in the process or LWP. Returns non-zero
1688 for success, zero for failure. */
1691 proc_set_traced_signals (procinfo
*pi
, gdb_sigset_t
*sigset
)
1695 /* We should never have to apply this operation to any procinfo
1696 except the one for the main process. If that ever changes for
1697 any reason, then take out the following clause and replace it
1698 with one that makes sure the ctl_fd is open. */
1701 pi
= find_procinfo_or_die (pi
->pid
, 0);
1707 /* Use char array to avoid alignment issues. */
1708 char sigset
[sizeof (gdb_sigset_t
)];
1712 memcpy (&arg
.sigset
, sigset
, sizeof (gdb_sigset_t
));
1714 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1716 #else /* ioctl method */
1717 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1719 /* The above operation renders the procinfo's cached pstatus obsolete. */
1720 pi
->status_valid
= 0;
1723 warning (_("procfs: set_traced_signals failed"));
1727 /* Register to trace hardware faults in the process or LWP. Returns
1728 non-zero for success, zero for failure. */
1731 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1735 /* We should never have to apply this operation to any procinfo
1736 except the one for the main process. If that ever changes for
1737 any reason, then take out the following clause and replace it
1738 with one that makes sure the ctl_fd is open. */
1741 pi
= find_procinfo_or_die (pi
->pid
, 0);
1747 /* Use char array to avoid alignment issues. */
1748 char fltset
[sizeof (fltset_t
)];
1752 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1754 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1756 #else /* ioctl method */
1757 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1759 /* The above operation renders the procinfo's cached pstatus obsolete. */
1760 pi
->status_valid
= 0;
1765 /* Register to trace entry to system calls in the process or LWP.
1766 Returns non-zero for success, zero for failure. */
1769 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1773 /* We should never have to apply this operation to any procinfo
1774 except the one for the main process. If that ever changes for
1775 any reason, then take out the following clause and replace it
1776 with one that makes sure the ctl_fd is open. */
1779 pi
= find_procinfo_or_die (pi
->pid
, 0);
1783 struct gdb_proc_ctl_pcsentry
{
1785 /* Use char array to avoid alignment issues. */
1786 char sysset
[sizeof (sysset_t
)];
1788 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
)
1790 + sysset_t_size (pi
);
1792 argp
= xmalloc (argp_size
);
1794 argp
->cmd
= PCSENTRY
;
1795 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1797 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1800 #else /* ioctl method */
1801 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1803 /* The above operation renders the procinfo's cached pstatus
1805 pi
->status_valid
= 0;
1810 /* Register to trace exit from system calls in the process or LWP.
1811 Returns non-zero for success, zero for failure. */
1814 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1818 /* We should never have to apply this operation to any procinfo
1819 except the one for the main process. If that ever changes for
1820 any reason, then take out the following clause and replace it
1821 with one that makes sure the ctl_fd is open. */
1824 pi
= find_procinfo_or_die (pi
->pid
, 0);
1828 struct gdb_proc_ctl_pcsexit
{
1830 /* Use char array to avoid alignment issues. */
1831 char sysset
[sizeof (sysset_t
)];
1833 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
)
1835 + sysset_t_size (pi
);
1837 argp
= xmalloc (argp_size
);
1839 argp
->cmd
= PCSEXIT
;
1840 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1842 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1845 #else /* ioctl method */
1846 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1848 /* The above operation renders the procinfo's cached pstatus
1850 pi
->status_valid
= 0;
1855 /* Specify the set of blocked / held signals in the process or LWP.
1856 Returns non-zero for success, zero for failure. */
1859 proc_set_held_signals (procinfo
*pi
, gdb_sigset_t
*sighold
)
1863 /* We should never have to apply this operation to any procinfo
1864 except the one for the main process. If that ever changes for
1865 any reason, then take out the following clause and replace it
1866 with one that makes sure the ctl_fd is open. */
1869 pi
= find_procinfo_or_die (pi
->pid
, 0);
1875 /* Use char array to avoid alignment issues. */
1876 char hold
[sizeof (gdb_sigset_t
)];
1880 memcpy (&arg
.hold
, sighold
, sizeof (gdb_sigset_t
));
1881 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1884 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1886 /* The above operation renders the procinfo's cached pstatus
1888 pi
->status_valid
= 0;
1893 /* Returns the set of signals that are pending in the process or LWP.
1894 Will also copy the sigset if SAVE is non-zero. */
1897 proc_get_pending_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1899 gdb_sigset_t
*ret
= NULL
;
1901 /* We should never have to apply this operation to any procinfo
1902 except the one for the main process. If that ever changes for
1903 any reason, then take out the following clause and replace it
1904 with one that makes sure the ctl_fd is open. */
1907 pi
= find_procinfo_or_die (pi
->pid
, 0);
1909 if (!pi
->status_valid
)
1910 if (!proc_get_status (pi
))
1914 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
1916 ret
= &pi
->prstatus
.pr_sigpend
;
1919 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1924 /* Returns the set of signal actions. Will also copy the sigactionset
1925 if SAVE is non-zero. */
1928 proc_get_signal_actions (procinfo
*pi
, gdb_sigaction_t
*save
)
1930 gdb_sigaction_t
*ret
= NULL
;
1932 /* We should never have to apply this operation to any procinfo
1933 except the one for the main process. If that ever changes for
1934 any reason, then take out the following clause and replace it
1935 with one that makes sure the ctl_fd is open. */
1938 pi
= find_procinfo_or_die (pi
->pid
, 0);
1940 if (!pi
->status_valid
)
1941 if (!proc_get_status (pi
))
1945 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
1947 ret
= &pi
->prstatus
.pr_action
;
1950 memcpy (save
, ret
, sizeof (gdb_sigaction_t
));
1955 /* Returns the set of signals that are held / blocked. Will also copy
1956 the sigset if SAVE is non-zero. */
1959 proc_get_held_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1961 gdb_sigset_t
*ret
= NULL
;
1963 /* We should never have to apply this operation to any procinfo
1964 except the one for the main process. If that ever changes for
1965 any reason, then take out the following clause and replace it
1966 with one that makes sure the ctl_fd is open. */
1969 pi
= find_procinfo_or_die (pi
->pid
, 0);
1972 if (!pi
->status_valid
)
1973 if (!proc_get_status (pi
))
1977 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1979 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1980 #endif /* UNIXWARE */
1981 #else /* not NEW_PROC_API */
1983 static gdb_sigset_t sigheld
;
1985 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1988 #endif /* NEW_PROC_API */
1990 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1995 /* Returns the set of signals that are traced / debugged. Will also
1996 copy the sigset if SAVE is non-zero. */
1999 proc_get_traced_signals (procinfo
*pi
, gdb_sigset_t
*save
)
2001 gdb_sigset_t
*ret
= NULL
;
2003 /* We should never have to apply this operation to any procinfo
2004 except the one for the main process. If that ever changes for
2005 any reason, then take out the following clause and replace it
2006 with one that makes sure the ctl_fd is open. */
2009 pi
= find_procinfo_or_die (pi
->pid
, 0);
2012 if (!pi
->status_valid
)
2013 if (!proc_get_status (pi
))
2016 ret
= &pi
->prstatus
.pr_sigtrace
;
2019 static gdb_sigset_t sigtrace
;
2021 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
2026 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
2031 /* Add SIGNO to the set of signals that are traced. Returns non-zero
2032 for success, zero for failure. */
2035 proc_trace_signal (procinfo
*pi
, int signo
)
2039 /* We should never have to apply this operation to any procinfo
2040 except the one for the main process. If that ever changes for
2041 any reason, then take out the following clause and replace it
2042 with one that makes sure the ctl_fd is open. */
2045 pi
= find_procinfo_or_die (pi
->pid
, 0);
2049 if (proc_get_traced_signals (pi
, &temp
))
2051 gdb_praddset (&temp
, signo
);
2052 return proc_set_traced_signals (pi
, &temp
);
2056 return 0; /* failure */
2059 /* Remove SIGNO from the set of signals that are traced. Returns
2060 non-zero for success, zero for failure. */
2063 proc_ignore_signal (procinfo
*pi
, int signo
)
2067 /* We should never have to apply this operation to any procinfo
2068 except the one for the main process. If that ever changes for
2069 any reason, then take out the following clause and replace it
2070 with one that makes sure the ctl_fd is open. */
2073 pi
= find_procinfo_or_die (pi
->pid
, 0);
2077 if (proc_get_traced_signals (pi
, &temp
))
2079 gdb_prdelset (&temp
, signo
);
2080 return proc_set_traced_signals (pi
, &temp
);
2084 return 0; /* failure */
2087 /* Returns the set of hardware faults that are traced /debugged. Will
2088 also copy the faultset if SAVE is non-zero. */
2091 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
2093 fltset_t
*ret
= NULL
;
2095 /* We should never have to apply this operation to any procinfo
2096 except the one for the main process. If that ever changes for
2097 any reason, then take out the following clause and replace it
2098 with one that makes sure the ctl_fd is open. */
2101 pi
= find_procinfo_or_die (pi
->pid
, 0);
2104 if (!pi
->status_valid
)
2105 if (!proc_get_status (pi
))
2108 ret
= &pi
->prstatus
.pr_flttrace
;
2111 static fltset_t flttrace
;
2113 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
2118 memcpy (save
, ret
, sizeof (fltset_t
));
2123 /* Returns the set of syscalls that are traced /debugged on entry.
2124 Will also copy the syscall set if SAVE is non-zero. */
2127 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
2129 sysset_t
*ret
= NULL
;
2131 /* We should never have to apply this operation to any procinfo
2132 except the one for the main process. If that ever changes for
2133 any reason, then take out the following clause and replace it
2134 with one that makes sure the ctl_fd is open. */
2137 pi
= find_procinfo_or_die (pi
->pid
, 0);
2140 if (!pi
->status_valid
)
2141 if (!proc_get_status (pi
))
2144 #ifndef DYNAMIC_SYSCALLS
2145 ret
= &pi
->prstatus
.pr_sysentry
;
2146 #else /* DYNAMIC_SYSCALLS */
2148 static sysset_t
*sysentry
;
2152 sysentry
= sysset_t_alloc (pi
);
2154 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2156 if (pi
->prstatus
.pr_sysentry_offset
== 0)
2158 gdb_premptysysset (sysentry
);
2164 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysentry_offset
,
2166 != (off_t
) pi
->prstatus
.pr_sysentry_offset
)
2168 size
= sysset_t_size (pi
);
2169 gdb_premptysysset (sysentry
);
2170 rsize
= read (pi
->status_fd
, sysentry
, size
);
2175 #endif /* DYNAMIC_SYSCALLS */
2176 #else /* !NEW_PROC_API */
2178 static sysset_t sysentry
;
2180 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
2183 #endif /* NEW_PROC_API */
2185 memcpy (save
, ret
, sysset_t_size (pi
));
2190 /* Returns the set of syscalls that are traced /debugged on exit.
2191 Will also copy the syscall set if SAVE is non-zero. */
2194 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
2196 sysset_t
* ret
= NULL
;
2198 /* We should never have to apply this operation to any procinfo
2199 except the one for the main process. If that ever changes for
2200 any reason, then take out the following clause and replace it
2201 with one that makes sure the ctl_fd is open. */
2204 pi
= find_procinfo_or_die (pi
->pid
, 0);
2207 if (!pi
->status_valid
)
2208 if (!proc_get_status (pi
))
2211 #ifndef DYNAMIC_SYSCALLS
2212 ret
= &pi
->prstatus
.pr_sysexit
;
2213 #else /* DYNAMIC_SYSCALLS */
2215 static sysset_t
*sysexit
;
2219 sysexit
= sysset_t_alloc (pi
);
2221 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2223 if (pi
->prstatus
.pr_sysexit_offset
== 0)
2225 gdb_premptysysset (sysexit
);
2231 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysexit_offset
,
2233 != (off_t
) pi
->prstatus
.pr_sysexit_offset
)
2235 size
= sysset_t_size (pi
);
2236 gdb_premptysysset (sysexit
);
2237 rsize
= read (pi
->status_fd
, sysexit
, size
);
2242 #endif /* DYNAMIC_SYSCALLS */
2245 static sysset_t sysexit
;
2247 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2252 memcpy (save
, ret
, sysset_t_size (pi
));
2257 /* The current fault (if any) is cleared; the associated signal will
2258 not be sent to the process or LWP when it resumes. Returns
2259 non-zero for success, zero for failure. */
2262 proc_clear_current_fault (procinfo
*pi
)
2266 /* We should never have to apply this operation to any procinfo
2267 except the one for the main process. If that ever changes for
2268 any reason, then take out the following clause and replace it
2269 with one that makes sure the ctl_fd is open. */
2272 pi
= find_procinfo_or_die (pi
->pid
, 0);
2276 procfs_ctl_t cmd
= PCCFAULT
;
2278 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2281 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2287 /* Set the "current signal" that will be delivered next to the
2288 process. NOTE: semantics are different from those of KILL. This
2289 signal will be delivered to the process or LWP immediately when it
2290 is resumed (even if the signal is held/blocked); it will NOT
2291 immediately cause another event of interest, and will NOT first
2292 trap back to the debugger. Returns non-zero for success, zero for
2296 proc_set_current_signal (procinfo
*pi
, int signo
)
2301 /* Use char array to avoid alignment issues. */
2302 char sinfo
[sizeof (gdb_siginfo_t
)];
2304 gdb_siginfo_t mysinfo
;
2306 struct target_waitstatus wait_status
;
2308 /* We should never have to apply this operation to any procinfo
2309 except the one for the main process. If that ever changes for
2310 any reason, then take out the following clause and replace it
2311 with one that makes sure the ctl_fd is open. */
2314 pi
= find_procinfo_or_die (pi
->pid
, 0);
2316 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2317 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2318 receives a PIOCSSIG with a signal identical to the current
2319 signal, it messes up the current signal. Work around the kernel
2322 signo
== proc_cursig (pi
))
2323 return 1; /* I assume this is a success? */
2326 /* The pointer is just a type alias. */
2327 get_last_target_status (&wait_ptid
, &wait_status
);
2328 if (ptid_equal (wait_ptid
, inferior_ptid
)
2329 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
2330 && wait_status
.value
.sig
== target_signal_from_host (signo
)
2331 && proc_get_status (pi
)
2333 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
2335 && pi
->prstatus
.pr_info
.si_signo
== signo
2338 /* Use the siginfo associated with the signal being
2341 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (gdb_siginfo_t
));
2343 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_info
, sizeof (gdb_siginfo_t
));
2347 mysinfo
.si_signo
= signo
;
2348 mysinfo
.si_code
= 0;
2349 mysinfo
.si_pid
= getpid (); /* ?why? */
2350 mysinfo
.si_uid
= getuid (); /* ?why? */
2351 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2356 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2358 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2364 /* The current signal (if any) is cleared, and is not sent to the
2365 process or LWP when it resumes. Returns non-zero for success, zero
2369 proc_clear_current_signal (procinfo
*pi
)
2373 /* We should never have to apply this operation to any procinfo
2374 except the one for the main process. If that ever changes for
2375 any reason, then take out the following clause and replace it
2376 with one that makes sure the ctl_fd is open. */
2379 pi
= find_procinfo_or_die (pi
->pid
, 0);
2385 /* Use char array to avoid alignment issues. */
2386 char sinfo
[sizeof (gdb_siginfo_t
)];
2388 gdb_siginfo_t mysinfo
;
2391 /* The pointer is just a type alias. */
2392 mysinfo
.si_signo
= 0;
2393 mysinfo
.si_code
= 0;
2394 mysinfo
.si_errno
= 0;
2395 mysinfo
.si_pid
= getpid (); /* ?why? */
2396 mysinfo
.si_uid
= getuid (); /* ?why? */
2397 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2399 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2402 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2408 /* Return the general-purpose registers for the process or LWP
2409 corresponding to PI. Upon failure, return NULL. */
2412 proc_get_gregs (procinfo
*pi
)
2414 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2415 if (!proc_get_status (pi
))
2418 /* OK, sorry about the ifdef's. There's three cases instead of two,
2419 because in this case Unixware and Solaris/RW differ. */
2422 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2423 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2425 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2428 return &pi
->prstatus
.pr_reg
;
2432 /* Return the general-purpose registers for the process or LWP
2433 corresponding to PI. Upon failure, return NULL. */
2436 proc_get_fpregs (procinfo
*pi
)
2439 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2440 if (!proc_get_status (pi
))
2443 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2444 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2446 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2449 #else /* not NEW_PROC_API */
2450 if (pi
->fpregs_valid
)
2451 return &pi
->fpregset
; /* Already got 'em. */
2454 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2463 tid_t pr_error_thread
;
2464 tfpregset_t thread_1
;
2467 thread_fpregs
.pr_count
= 1;
2468 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2471 && ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2473 pi
->fpregs_valid
= 1;
2474 return &pi
->fpregset
; /* Got 'em now! */
2476 else if (pi
->tid
!= 0
2477 && ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2479 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2480 sizeof (pi
->fpregset
));
2481 pi
->fpregs_valid
= 1;
2482 return &pi
->fpregset
; /* Got 'em now! */
2489 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2491 pi
->fpregs_valid
= 1;
2492 return &pi
->fpregset
; /* Got 'em now! */
2501 #endif /* NEW_PROC_API */
2504 /* Write the general-purpose registers back to the process or LWP
2505 corresponding to PI. Return non-zero for success, zero for
2509 proc_set_gregs (procinfo
*pi
)
2511 gdb_gregset_t
*gregs
;
2514 gregs
= proc_get_gregs (pi
);
2516 return 0; /* proc_get_regs has already warned. */
2518 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2527 /* Use char array to avoid alignment issues. */
2528 char gregs
[sizeof (gdb_gregset_t
)];
2532 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2533 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2535 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2539 /* Policy: writing the registers invalidates our cache. */
2540 pi
->gregs_valid
= 0;
2544 /* Write the floating-pointer registers back to the process or LWP
2545 corresponding to PI. Return non-zero for success, zero for
2549 proc_set_fpregs (procinfo
*pi
)
2551 gdb_fpregset_t
*fpregs
;
2554 fpregs
= proc_get_fpregs (pi
);
2556 return 0; /* proc_get_fpregs has already warned. */
2558 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2567 /* Use char array to avoid alignment issues. */
2568 char fpregs
[sizeof (gdb_fpregset_t
)];
2572 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2573 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2577 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2582 tid_t pr_error_thread
;
2583 tfpregset_t thread_1
;
2586 thread_fpregs
.pr_count
= 1;
2587 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2588 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2590 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2593 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2595 #endif /* NEW_PROC_API */
2598 /* Policy: writing the registers invalidates our cache. */
2599 pi
->fpregs_valid
= 0;
2603 /* Send a signal to the proc or lwp with the semantics of "kill()".
2604 Returns non-zero for success, zero for failure. */
2607 proc_kill (procinfo
*pi
, int signo
)
2611 /* We might conceivably apply this operation to an LWP, and the
2612 LWP's ctl file descriptor might not be open. */
2614 if (pi
->ctl_fd
== 0 &&
2615 open_procinfo_files (pi
, FD_CTL
) == 0)
2622 procfs_ctl_t cmd
[2];
2626 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2627 #else /* ioctl method */
2628 /* FIXME: do I need the Alpha OSF fixups present in
2629 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2630 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2637 /* Find the pid of the process that started this one. Returns the
2638 parent process pid, or zero. */
2641 proc_parent_pid (procinfo
*pi
)
2643 /* We should never have to apply this operation to any procinfo
2644 except the one for the main process. If that ever changes for
2645 any reason, then take out the following clause and replace it
2646 with one that makes sure the ctl_fd is open. */
2649 pi
= find_procinfo_or_die (pi
->pid
, 0);
2651 if (!pi
->status_valid
)
2652 if (!proc_get_status (pi
))
2655 return pi
->prstatus
.pr_ppid
;
2658 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
2659 (a.k.a void pointer)! */
2661 #if (defined (PCWATCH) || defined (PIOCSWATCH)) \
2662 && !(defined (PIOCOPENLWP) || defined (UNIXWARE))
2664 procfs_address_to_host_pointer (CORE_ADDR addr
)
2666 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
2669 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
2670 gdbarch_address_to_pointer (target_gdbarch
, ptr_type
,
2671 (gdb_byte
*) &ptr
, addr
);
2677 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
2679 #if !defined (PCWATCH) && !defined (PIOCSWATCH)
2680 /* If neither or these is defined, we can't support watchpoints.
2681 This just avoids possibly failing to compile the below on such
2685 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5. */
2686 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out. */
2691 char watch
[sizeof (prwatch_t
)];
2695 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
2696 convert a target address into something that can be stored in a
2697 native data structure. */
2698 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
2699 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
2701 pwatch
.pr_vaddr
= (caddr_t
) procfs_address_to_host_pointer (addr
);
2703 pwatch
.pr_size
= len
;
2704 pwatch
.pr_wflags
= wflags
;
2705 #if defined(NEW_PROC_API) && defined (PCWATCH)
2707 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
2708 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2710 #if defined (PIOCSWATCH)
2711 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, &pwatch
) >= 0);
2713 return 0; /* Fail */
2720 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
2722 #include <sys/sysi86.h>
2724 /* The KEY is actually the value of the lower 16 bits of the GS
2725 register for the LWP that we're interested in. Returns the
2726 matching ssh struct (LDT entry). */
2729 proc_get_LDT_entry (procinfo
*pi
, int key
)
2731 static struct ssd
*ldt_entry
= NULL
;
2733 char pathname
[MAX_PROC_NAME_SIZE
];
2734 struct cleanup
*old_chain
= NULL
;
2737 /* Allocate space for one LDT entry.
2738 This alloc must persist, because we return a pointer to it. */
2739 if (ldt_entry
== NULL
)
2740 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2742 /* Open the file descriptor for the LDT table. */
2743 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2744 if ((fd
= open_with_retry (pathname
, O_RDONLY
)) < 0)
2746 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2749 /* Make sure it gets closed again! */
2750 old_chain
= make_cleanup_close (fd
);
2752 /* Now 'read' thru the table, find a match and return it. */
2753 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2755 if (ldt_entry
->sel
== 0 &&
2756 ldt_entry
->bo
== 0 &&
2757 ldt_entry
->acc1
== 0 &&
2758 ldt_entry
->acc2
== 0)
2759 break; /* end of table */
2760 /* If key matches, return this entry. */
2761 if (ldt_entry
->sel
== key
)
2764 /* Loop ended, match not found. */
2768 static int nalloc
= 0;
2770 /* Get the number of LDT entries. */
2771 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2773 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2777 /* Allocate space for the number of LDT entries. */
2778 /* This alloc has to persist, 'cause we return a pointer to it. */
2781 ldt_entry
= (struct ssd
*)
2782 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2786 /* Read the whole table in one gulp. */
2787 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2789 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2793 /* Search the table and return the (first) entry matching 'key'. */
2794 for (i
= 0; i
< nldt
; i
++)
2795 if (ldt_entry
[i
].sel
== key
)
2796 return &ldt_entry
[i
];
2798 /* Loop ended, match not found. */
2803 /* Returns the pointer to the LDT entry of PTID. */
2806 procfs_find_LDT_entry (ptid_t ptid
)
2808 gdb_gregset_t
*gregs
;
2812 /* Find procinfo for the lwp. */
2813 if ((pi
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
))) == NULL
)
2815 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
2816 PIDGET (ptid
), TIDGET (ptid
));
2819 /* get its general registers. */
2820 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2822 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
2823 PIDGET (ptid
), TIDGET (ptid
));
2826 /* Now extract the GS register's lower 16 bits. */
2827 key
= (*gregs
)[GS
] & 0xffff;
2829 /* Find the matching entry and return it. */
2830 return proc_get_LDT_entry (pi
, key
);
2835 /* =============== END, non-thread part of /proc "MODULE" =============== */
2837 /* =================== Thread "MODULE" =================== */
2839 /* NOTE: you'll see more ifdefs and duplication of functions here,
2840 since there is a different way to do threads on every OS. */
2842 /* Returns the number of threads for the process. */
2844 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2847 proc_get_nthreads (procinfo
*pi
)
2851 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2852 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2858 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2859 /* Solaris and Unixware version */
2861 proc_get_nthreads (procinfo
*pi
)
2863 if (!pi
->status_valid
)
2864 if (!proc_get_status (pi
))
2867 /* NEW_PROC_API: only works for the process procinfo, because the
2868 LWP procinfos do not get prstatus filled in. */
2870 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
2871 pi
= find_procinfo_or_die (pi
->pid
, 0);
2873 return pi
->prstatus
.pr_nlwp
;
2877 /* Default version */
2879 proc_get_nthreads (procinfo
*pi
)
2888 Return the ID of the thread that had an event of interest.
2889 (ie. the one that hit a breakpoint or other traced event). All
2890 other things being equal, this should be the ID of a thread that is
2891 currently executing. */
2893 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2894 /* Solaris and Unixware version */
2896 proc_get_current_thread (procinfo
*pi
)
2898 /* Note: this should be applied to the root procinfo for the
2899 process, not to the procinfo for an LWP. If applied to the
2900 procinfo for an LWP, it will simply return that LWP's ID. In
2901 that case, find the parent process procinfo. */
2904 pi
= find_procinfo_or_die (pi
->pid
, 0);
2906 if (!pi
->status_valid
)
2907 if (!proc_get_status (pi
))
2911 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2913 return pi
->prstatus
.pr_who
;
2918 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2921 proc_get_current_thread (procinfo
*pi
)
2923 #if 0 /* FIXME: not ready for prime time? */
2924 return pi
->prstatus
.pr_tid
;
2931 /* Default version */
2933 proc_get_current_thread (procinfo
*pi
)
2941 /* Discover the IDs of all the threads within the process, and create
2942 a procinfo for each of them (chained to the parent). This
2943 unfortunately requires a different method on every OS. Returns
2944 non-zero for success, zero for failure. */
2947 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
2949 if (thread
&& parent
) /* sanity */
2951 thread
->status_valid
= 0;
2952 if (!proc_get_status (thread
))
2953 destroy_one_procinfo (&parent
->thread_list
, thread
);
2955 return 0; /* keep iterating */
2958 #if defined (PIOCLSTATUS)
2959 /* Solaris 2.5 (ioctl) version */
2961 proc_update_threads (procinfo
*pi
)
2963 gdb_prstatus_t
*prstatus
;
2964 struct cleanup
*old_chain
= NULL
;
2968 /* We should never have to apply this operation to any procinfo
2969 except the one for the main process. If that ever changes for
2970 any reason, then take out the following clause and replace it
2971 with one that makes sure the ctl_fd is open. */
2974 pi
= find_procinfo_or_die (pi
->pid
, 0);
2976 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2978 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2979 return 1; /* Process is not multi-threaded; nothing to do. */
2981 prstatus
= xmalloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1));
2983 old_chain
= make_cleanup (xfree
, prstatus
);
2984 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2985 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2987 /* Skip element zero, which represents the process as a whole. */
2988 for (i
= 1; i
< nlwp
+ 1; i
++)
2990 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
2991 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2993 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
2994 thread
->status_valid
= 1;
2996 pi
->threads_valid
= 1;
2997 do_cleanups (old_chain
);
3002 /* Unixware and Solaris 6 (and later) version. */
3004 do_closedir_cleanup (void *dir
)
3010 proc_update_threads (procinfo
*pi
)
3012 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3013 struct dirent
*direntry
;
3014 struct cleanup
*old_chain
= NULL
;
3019 /* We should never have to apply this operation to any procinfo
3020 except the one for the main process. If that ever changes for
3021 any reason, then take out the following clause and replace it
3022 with one that makes sure the ctl_fd is open. */
3025 pi
= find_procinfo_or_die (pi
->pid
, 0);
3027 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3031 Note: this brute-force method is the only way I know of to
3032 accomplish this task on Unixware. This method will also work on
3033 Solaris 2.6 and 2.7. There is a much simpler and more elegant
3034 way to do this on Solaris, but the margins of this manuscript are
3035 too small to write it here... ;-) */
3037 strcpy (pathname
, pi
->pathname
);
3038 strcat (pathname
, "/lwp");
3039 if ((dirp
= opendir (pathname
)) == NULL
)
3040 proc_error (pi
, "update_threads, opendir", __LINE__
);
3042 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
3043 while ((direntry
= readdir (dirp
)) != NULL
)
3044 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3046 lwpid
= atoi (&direntry
->d_name
[0]);
3047 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3048 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3050 pi
->threads_valid
= 1;
3051 do_cleanups (old_chain
);
3058 proc_update_threads (procinfo
*pi
)
3063 /* We should never have to apply this operation to any procinfo
3064 except the one for the main process. If that ever changes for
3065 any reason, then take out the following clause and replace it
3066 with one that makes sure the ctl_fd is open. */
3069 pi
= find_procinfo_or_die (pi
->pid
, 0);
3071 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3073 nthreads
= proc_get_nthreads (pi
);
3075 return 0; /* Nothing to do for 1 or fewer threads. */
3077 threads
= xmalloc (nthreads
* sizeof (tid_t
));
3079 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3080 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3082 for (i
= 0; i
< nthreads
; i
++)
3084 if (!find_procinfo (pi
->pid
, threads
[i
]))
3085 if (!create_procinfo (pi
->pid
, threads
[i
]))
3086 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3088 pi
->threads_valid
= 1;
3092 /* Default version */
3094 proc_update_threads (procinfo
*pi
)
3098 #endif /* OSF PIOCTLIST */
3099 #endif /* NEW_PROC_API */
3100 #endif /* SOL 2.5 PIOCLSTATUS */
3102 /* Given a pointer to a function, call that function once for each lwp
3103 in the procinfo list, until the function returns non-zero, in which
3104 event return the value returned by the function.
3106 Note: this function does NOT call update_threads. If you want to
3107 discover new threads first, you must call that function explicitly.
3108 This function just makes a quick pass over the currently-known
3111 PI is the parent process procinfo. FUNC is the per-thread
3112 function. PTR is an opaque parameter for function. Returns the
3113 first non-zero return value from the callee, or zero. */
3116 proc_iterate_over_threads (procinfo
*pi
,
3117 int (*func
) (procinfo
*, procinfo
*, void *),
3120 procinfo
*thread
, *next
;
3123 /* We should never have to apply this operation to any procinfo
3124 except the one for the main process. If that ever changes for
3125 any reason, then take out the following clause and replace it
3126 with one that makes sure the ctl_fd is open. */
3129 pi
= find_procinfo_or_die (pi
->pid
, 0);
3131 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3133 next
= thread
->next
; /* In case thread is destroyed. */
3134 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3141 /* =================== END, Thread "MODULE" =================== */
3143 /* =================== END, /proc "MODULE" =================== */
3145 /* =================== GDB "MODULE" =================== */
3147 /* Here are all of the gdb target vector functions and their
3150 static ptid_t
do_attach (ptid_t ptid
);
3151 static void do_detach (int signo
);
3152 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
3153 int entry_or_exit
, int mode
, int from_tty
);
3155 /* On mips-irix, we need to insert a breakpoint at __dbx_link during
3156 the startup phase. The following two variables are used to record
3157 the address of the breakpoint, and the code that was replaced by
3159 static int dbx_link_bpt_addr
= 0;
3160 static void *dbx_link_bpt
;
3162 /* Sets up the inferior to be debugged. Registers to trace signals,
3163 hardware faults, and syscalls. Note: does not set RLC flag: caller
3164 may want to customize that. Returns zero for success (note!
3165 unlike most functions in this module); on failure, returns the LINE
3166 NUMBER where it failed! */
3169 procfs_debug_inferior (procinfo
*pi
)
3171 fltset_t traced_faults
;
3172 gdb_sigset_t traced_signals
;
3173 sysset_t
*traced_syscall_entries
;
3174 sysset_t
*traced_syscall_exits
;
3177 #ifdef PROCFS_DONT_TRACE_FAULTS
3178 /* On some systems (OSF), we don't trace hardware faults.
3179 Apparently it's enough that we catch them as signals.
3180 Wonder why we don't just do that in general? */
3181 premptyset (&traced_faults
); /* don't trace faults. */
3183 /* Register to trace hardware faults in the child. */
3184 prfillset (&traced_faults
); /* trace all faults... */
3185 gdb_prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3187 if (!proc_set_traced_faults (pi
, &traced_faults
))
3190 /* Initially, register to trace all signals in the child. */
3191 prfillset (&traced_signals
);
3192 if (!proc_set_traced_signals (pi
, &traced_signals
))
3196 /* Register to trace the 'exit' system call (on entry). */
3197 traced_syscall_entries
= sysset_t_alloc (pi
);
3198 gdb_premptysysset (traced_syscall_entries
);
3200 gdb_praddsysset (traced_syscall_entries
, SYS_exit
);
3203 gdb_praddsysset (traced_syscall_entries
, SYS_lwpexit
);/* And _lwp_exit... */
3206 gdb_praddsysset (traced_syscall_entries
, SYS_lwp_exit
);
3208 #ifdef DYNAMIC_SYSCALLS
3210 int callnum
= find_syscall (pi
, "_exit");
3213 gdb_praddsysset (traced_syscall_entries
, callnum
);
3217 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
3218 xfree (traced_syscall_entries
);
3222 #ifdef PRFS_STOPEXEC /* defined on OSF */
3223 /* OSF method for tracing exec syscalls. Quoting:
3224 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3225 exits from exec system calls because of the user level loader. */
3226 /* FIXME: make nice and maybe move into an access function. */
3230 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3233 prfs_flags
|= PRFS_STOPEXEC
;
3235 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3238 #else /* not PRFS_STOPEXEC */
3239 /* Everyone else's (except OSF) method for tracing exec syscalls. */
3241 Not all systems with /proc have all the exec* syscalls with the same
3242 names. On the SGI, for example, there is no SYS_exec, but there
3243 *is* a SYS_execv. So, we try to account for that. */
3245 traced_syscall_exits
= sysset_t_alloc (pi
);
3246 gdb_premptysysset (traced_syscall_exits
);
3248 gdb_praddsysset (traced_syscall_exits
, SYS_exec
);
3251 gdb_praddsysset (traced_syscall_exits
, SYS_execve
);
3254 gdb_praddsysset (traced_syscall_exits
, SYS_execv
);
3257 #ifdef SYS_lwpcreate
3258 gdb_praddsysset (traced_syscall_exits
, SYS_lwpcreate
);
3259 gdb_praddsysset (traced_syscall_exits
, SYS_lwpexit
);
3262 #ifdef SYS_lwp_create /* FIXME: once only, please. */
3263 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_create
);
3264 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_exit
);
3267 #ifdef DYNAMIC_SYSCALLS
3269 int callnum
= find_syscall (pi
, "execve");
3272 gdb_praddsysset (traced_syscall_exits
, callnum
);
3273 callnum
= find_syscall (pi
, "ra_execve");
3275 gdb_praddsysset (traced_syscall_exits
, callnum
);
3279 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
3280 xfree (traced_syscall_exits
);
3284 #endif /* PRFS_STOPEXEC */
3289 procfs_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3294 pid
= parse_pid_to_attach (args
);
3296 if (pid
== getpid ())
3297 error (_("Attaching GDB to itself is not a good idea..."));
3301 exec_file
= get_exec_file (0);
3304 printf_filtered (_("Attaching to program `%s', %s\n"),
3305 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
3307 printf_filtered (_("Attaching to %s\n"),
3308 target_pid_to_str (pid_to_ptid (pid
)));
3312 inferior_ptid
= do_attach (pid_to_ptid (pid
));
3317 procfs_detach (struct target_ops
*ops
, char *args
, int from_tty
)
3320 int pid
= PIDGET (inferior_ptid
);
3329 exec_file
= get_exec_file (0);
3330 if (exec_file
== NULL
)
3333 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
3334 target_pid_to_str (pid_to_ptid (pid
)));
3335 gdb_flush (gdb_stdout
);
3340 inferior_ptid
= null_ptid
;
3341 detach_inferior (pid
);
3342 unpush_target (ops
);
3346 do_attach (ptid_t ptid
)
3349 struct inferior
*inf
;
3353 if ((pi
= create_procinfo (PIDGET (ptid
), 0)) == NULL
)
3354 perror (_("procfs: out of memory in 'attach'"));
3356 if (!open_procinfo_files (pi
, FD_CTL
))
3358 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3359 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3361 dead_procinfo (pi
, errmsg
, NOKILL
);
3364 /* Stop the process (if it isn't already stopped). */
3365 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3367 pi
->was_stopped
= 1;
3368 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3372 pi
->was_stopped
= 0;
3373 /* Set the process to run again when we close it. */
3374 if (!proc_set_run_on_last_close (pi
))
3375 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3377 /* Now stop the process. */
3378 if (!proc_stop_process (pi
))
3379 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3380 pi
->ignore_next_sigstop
= 1;
3382 /* Save some of the /proc state to be restored if we detach. */
3383 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3384 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3385 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3386 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3387 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
3388 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3390 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
3391 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3393 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3394 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3396 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3397 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3399 inf
= current_inferior ();
3400 inferior_appeared (inf
, pi
->pid
);
3401 /* Let GDB know that the inferior was attached. */
3402 inf
->attach_flag
= 1;
3404 /* Create a procinfo for the current lwp. */
3405 lwpid
= proc_get_current_thread (pi
);
3406 create_procinfo (pi
->pid
, lwpid
);
3408 /* Add it to gdb's thread list. */
3409 ptid
= MERGEPID (pi
->pid
, lwpid
);
3416 do_detach (int signo
)
3420 /* Find procinfo for the main process. */
3421 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0); /* FIXME: threads */
3423 if (!proc_set_current_signal (pi
, signo
))
3424 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3426 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3427 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3429 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3430 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3432 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
3433 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3435 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
3436 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3438 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3439 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3441 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3442 if (signo
|| !(pi
->was_stopped
) ||
3443 query (_("Was stopped when attached, make it runnable again? ")))
3445 /* Clear any pending signal. */
3446 if (!proc_clear_current_fault (pi
))
3447 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3449 if (signo
== 0 && !proc_clear_current_signal (pi
))
3450 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
3452 if (!proc_set_run_on_last_close (pi
))
3453 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3456 destroy_procinfo (pi
);
3459 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
3462 ??? Is the following note still relevant? We can't get individual
3463 registers with the PT_GETREGS ptrace(2) request either, yet we
3464 don't bother with caching at all in that case.
3466 NOTE: Since the /proc interface cannot give us individual
3467 registers, we pay no attention to REGNUM, and just fetch them all.
3468 This results in the possibility that we will do unnecessarily many
3469 fetches, since we may be called repeatedly for individual
3470 registers. So we cache the results, and mark the cache invalid
3471 when the process is resumed. */
3474 procfs_fetch_registers (struct target_ops
*ops
,
3475 struct regcache
*regcache
, int regnum
)
3477 gdb_gregset_t
*gregs
;
3479 int pid
= PIDGET (inferior_ptid
);
3480 int tid
= TIDGET (inferior_ptid
);
3481 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3483 pi
= find_procinfo_or_die (pid
, tid
);
3486 error (_("procfs: fetch_registers failed to find procinfo for %s"),
3487 target_pid_to_str (inferior_ptid
));
3489 gregs
= proc_get_gregs (pi
);
3491 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3493 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
3495 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3497 gdb_fpregset_t
*fpregs
;
3499 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3500 || regnum
== gdbarch_pc_regnum (gdbarch
)
3501 || regnum
== gdbarch_sp_regnum (gdbarch
))
3502 return; /* Not a floating point register. */
3504 fpregs
= proc_get_fpregs (pi
);
3506 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3508 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
3512 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
3513 this for all registers.
3515 NOTE: Since the /proc interface will not read individual registers,
3516 we will cache these requests until the process is resumed, and only
3517 then write them back to the inferior process.
3519 FIXME: is that a really bad idea? Have to think about cases where
3520 writing one register might affect the value of others, etc. */
3523 procfs_store_registers (struct target_ops
*ops
,
3524 struct regcache
*regcache
, int regnum
)
3526 gdb_gregset_t
*gregs
;
3528 int pid
= PIDGET (inferior_ptid
);
3529 int tid
= TIDGET (inferior_ptid
);
3530 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3532 pi
= find_procinfo_or_die (pid
, tid
);
3535 error (_("procfs: store_registers: failed to find procinfo for %s"),
3536 target_pid_to_str (inferior_ptid
));
3538 gregs
= proc_get_gregs (pi
);
3540 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3542 fill_gregset (regcache
, gregs
, regnum
);
3543 if (!proc_set_gregs (pi
))
3544 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3546 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3548 gdb_fpregset_t
*fpregs
;
3550 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3551 || regnum
== gdbarch_pc_regnum (gdbarch
)
3552 || regnum
== gdbarch_sp_regnum (gdbarch
))
3553 return; /* Not a floating point register. */
3555 fpregs
= proc_get_fpregs (pi
);
3557 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3559 fill_fpregset (regcache
, fpregs
, regnum
);
3560 if (!proc_set_fpregs (pi
))
3561 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3566 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
3569 if (scall
== SYS_lwp_exit
)
3573 if (scall
== SYS_lwpexit
)
3580 syscall_is_exit (procinfo
*pi
, int scall
)
3583 if (scall
== SYS_exit
)
3586 #ifdef DYNAMIC_SYSCALLS
3587 if (find_syscall (pi
, "_exit") == scall
)
3594 syscall_is_exec (procinfo
*pi
, int scall
)
3597 if (scall
== SYS_exec
)
3601 if (scall
== SYS_execv
)
3605 if (scall
== SYS_execve
)
3608 #ifdef DYNAMIC_SYSCALLS
3609 if (find_syscall (pi
, "_execve"))
3611 if (find_syscall (pi
, "ra_execve"))
3618 syscall_is_lwp_create (procinfo
*pi
, int scall
)
3620 #ifdef SYS_lwp_create
3621 if (scall
== SYS_lwp_create
)
3624 #ifdef SYS_lwpcreate
3625 if (scall
== SYS_lwpcreate
)
3631 /* Remove the breakpoint that we inserted in __dbx_link().
3632 Does nothing if the breakpoint hasn't been inserted or has already
3636 remove_dbx_link_breakpoint (void)
3638 if (dbx_link_bpt_addr
== 0)
3641 if (deprecated_remove_raw_breakpoint (target_gdbarch
, dbx_link_bpt
) != 0)
3642 warning (_("Unable to remove __dbx_link breakpoint."));
3644 dbx_link_bpt_addr
= 0;
3645 dbx_link_bpt
= NULL
;
3649 /* Return the address of the __dbx_link() function in the file
3650 refernced by ABFD by scanning its symbol table. Return 0 if
3651 the symbol was not found. */
3654 dbx_link_addr (bfd
*abfd
)
3656 long storage_needed
;
3657 asymbol
**symbol_table
;
3658 long number_of_symbols
;
3661 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
3662 if (storage_needed
<= 0)
3665 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
3666 make_cleanup (xfree
, symbol_table
);
3668 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
3670 for (i
= 0; i
< number_of_symbols
; i
++)
3672 asymbol
*sym
= symbol_table
[i
];
3674 if ((sym
->flags
& BSF_GLOBAL
)
3675 && sym
->name
!= NULL
&& strcmp (sym
->name
, "__dbx_link") == 0)
3676 return (sym
->value
+ sym
->section
->vma
);
3679 /* Symbol not found, return NULL. */
3683 /* Search the symbol table of the file referenced by FD for a symbol
3684 named __dbx_link(). If found, then insert a breakpoint at this location,
3685 and return nonzero. Return zero otherwise. */
3688 insert_dbx_link_bpt_in_file (int fd
, CORE_ADDR ignored
)
3691 long storage_needed
;
3694 abfd
= bfd_fdopenr ("unamed", 0, fd
);
3697 warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
3701 if (!bfd_check_format (abfd
, bfd_object
))
3703 /* Not the correct format, so we can not possibly find the dbx_link
3709 sym_addr
= dbx_link_addr (abfd
);
3712 /* Insert the breakpoint. */
3713 dbx_link_bpt_addr
= sym_addr
;
3714 dbx_link_bpt
= deprecated_insert_raw_breakpoint (target_gdbarch
, NULL
,
3716 if (dbx_link_bpt
== NULL
)
3718 warning (_("Failed to insert dbx_link breakpoint."));
3730 /* Calls the supplied callback function once for each mapped address
3731 space in the process. The callback function receives an open file
3732 descriptor for the file corresponding to that mapped address space
3733 (if there is one), and the base address of the mapped space. Quit
3734 when the callback function returns a nonzero value, or at teh end
3735 of the mappings. Returns the first non-zero return value of the
3736 callback function, or zero. */
3739 solib_mappings_callback (struct prmap
*map
, int (*func
) (int, CORE_ADDR
),
3742 procinfo
*pi
= data
;
3746 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
3748 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
3749 return -1; /* sanity */
3751 if (map
->pr_mapname
[0] == 0)
3753 fd
= -1; /* no map file */
3757 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
3758 /* Note: caller's responsibility to close this fd! */
3759 fd
= open_with_retry (name
, O_RDONLY
);
3760 /* Note: we don't test the above call for failure;
3761 we just pass the FD on as given. Sometimes there is
3762 no file, so the open may return failure, but that's
3766 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
->pr_vaddr
);
3767 /* Note: we don't test the above call for failure;
3768 we just pass the FD on as given. Sometimes there is
3769 no file, so the ioctl may return failure, but that's
3772 return (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
);
3775 /* If the given memory region MAP contains a symbol named __dbx_link,
3776 insert a breakpoint at this location and return nonzero. Return
3780 insert_dbx_link_bpt_in_region (struct prmap
*map
,
3781 find_memory_region_ftype child_func
,
3784 procinfo
*pi
= (procinfo
*) data
;
3786 /* We know the symbol we're looking for is in a text region, so
3787 only look for it if the region is a text one. */
3788 if (map
->pr_mflags
& MA_EXEC
)
3789 return solib_mappings_callback (map
, insert_dbx_link_bpt_in_file
, pi
);
3794 /* Search all memory regions for a symbol named __dbx_link. If found,
3795 insert a breakpoint at its location, and return nonzero. Return zero
3799 insert_dbx_link_breakpoint (procinfo
*pi
)
3801 return iterate_over_mappings (pi
, NULL
, pi
, insert_dbx_link_bpt_in_region
);
3805 /* Retrieve the next stop event from the child process. If child has
3806 not stopped yet, wait for it to stop. Translate /proc eventcodes
3807 (or possibly wait eventcodes) into gdb internal event codes.
3808 Returns the id of process (and possibly thread) that incurred the
3809 event. Event codes are returned through a pointer parameter. */
3812 procfs_wait (struct target_ops
*ops
,
3813 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
3815 /* First cut: loosely based on original version 2.1. */
3819 ptid_t retval
, temp_ptid
;
3820 int why
, what
, flags
;
3827 retval
= pid_to_ptid (-1);
3829 /* Find procinfo for main process. */
3830 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
3833 /* We must assume that the status is stale now... */
3834 pi
->status_valid
= 0;
3835 pi
->gregs_valid
= 0;
3836 pi
->fpregs_valid
= 0;
3838 #if 0 /* just try this out... */
3839 flags
= proc_flags (pi
);
3840 why
= proc_why (pi
);
3841 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3842 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3844 /* If child is not stopped, wait for it to stop. */
3845 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3846 !proc_wait_for_stop (pi
))
3848 /* wait_for_stop failed: has the child terminated? */
3849 if (errno
== ENOENT
)
3853 /* /proc file not found; presumably child has terminated. */
3854 wait_retval
= wait (&wstat
); /* "wait" for the child's exit. */
3856 if (wait_retval
!= PIDGET (inferior_ptid
)) /* wrong child? */
3857 error (_("procfs: couldn't stop "
3858 "process %d: wait returned %d."),
3859 PIDGET (inferior_ptid
), wait_retval
);
3860 /* FIXME: might I not just use waitpid?
3861 Or try find_procinfo to see if I know about this child? */
3862 retval
= pid_to_ptid (wait_retval
);
3864 else if (errno
== EINTR
)
3868 /* Unknown error from wait_for_stop. */
3869 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3874 /* This long block is reached if either:
3875 a) the child was already stopped, or
3876 b) we successfully waited for the child with wait_for_stop.
3877 This block will analyze the /proc status, and translate it
3878 into a waitstatus for GDB.
3880 If we actually had to call wait because the /proc file
3881 is gone (child terminated), then we skip this block,
3882 because we already have a waitstatus. */
3884 flags
= proc_flags (pi
);
3885 why
= proc_why (pi
);
3886 what
= proc_what (pi
);
3888 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3891 /* If it's running async (for single_thread control),
3892 set it back to normal again. */
3893 if (flags
& PR_ASYNC
)
3894 if (!proc_unset_async (pi
))
3895 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3899 proc_prettyprint_why (why
, what
, 1);
3901 /* The 'pid' we will return to GDB is composed of
3902 the process ID plus the lwp ID. */
3903 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3907 wstat
= (what
<< 8) | 0177;
3910 if (syscall_is_lwp_exit (pi
, what
))
3912 if (print_thread_events
)
3913 printf_unfiltered (_("[%s exited]\n"),
3914 target_pid_to_str (retval
));
3915 delete_thread (retval
);
3916 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3919 else if (syscall_is_exit (pi
, what
))
3921 struct inferior
*inf
;
3923 /* Handle SYS_exit call only. */
3924 /* Stopped at entry to SYS_exit.
3925 Make it runnable, resume it, then use
3926 the wait system call to get its exit code.
3927 Proc_run_process always clears the current
3929 Then return its exit status. */
3930 pi
->status_valid
= 0;
3932 /* FIXME: what we should do is return
3933 TARGET_WAITKIND_SPURIOUS. */
3934 if (!proc_run_process (pi
, 0, 0))
3935 proc_error (pi
, "target_wait, run_process", __LINE__
);
3937 inf
= find_inferior_pid (pi
->pid
);
3938 if (inf
->attach_flag
)
3940 /* Don't call wait: simulate waiting for exit,
3941 return a "success" exit code. Bogus: what if
3942 it returns something else? */
3944 retval
= inferior_ptid
; /* ? ? ? */
3948 int temp
= wait (&wstat
);
3950 /* FIXME: shouldn't I make sure I get the right
3951 event from the right process? If (for
3952 instance) I have killed an earlier inferior
3953 process but failed to clean up after it
3954 somehow, I could get its termination event
3957 /* If wait returns -1, that's what we return
3960 retval
= pid_to_ptid (temp
);
3965 printf_filtered (_("procfs: trapped on entry to "));
3966 proc_prettyprint_syscall (proc_what (pi
), 0);
3967 printf_filtered ("\n");
3970 long i
, nsysargs
, *sysargs
;
3972 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3973 (sysargs
= proc_sysargs (pi
)) != NULL
)
3975 printf_filtered (_("%ld syscall arguments:\n"),
3977 for (i
= 0; i
< nsysargs
; i
++)
3978 printf_filtered ("#%ld: 0x%08lx\n",
3986 /* How to exit gracefully, returning "unknown
3988 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3989 return inferior_ptid
;
3993 /* How to keep going without returning to wfi: */
3994 target_resume (ptid
, 0, TARGET_SIGNAL_0
);
4000 if (syscall_is_exec (pi
, what
))
4002 /* Hopefully this is our own "fork-child" execing
4003 the real child. Hoax this event into a trap, and
4004 GDB will see the child about to execute its start
4006 wstat
= (SIGTRAP
<< 8) | 0177;
4009 else if (what
== SYS_syssgi
)
4011 /* see if we can break on dbx_link(). If yes, then
4012 we no longer need the SYS_syssgi notifications. */
4013 if (insert_dbx_link_breakpoint (pi
))
4014 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
,
4017 /* This is an internal event and should be transparent
4018 to wfi, so resume the execution and wait again. See
4019 comment in procfs_init_inferior() for more details. */
4020 target_resume (ptid
, 0, TARGET_SIGNAL_0
);
4024 else if (syscall_is_lwp_create (pi
, what
))
4026 /* This syscall is somewhat like fork/exec. We
4027 will get the event twice: once for the parent
4028 LWP, and once for the child. We should already
4029 know about the parent LWP, but the child will
4030 be new to us. So, whenever we get this event,
4031 if it represents a new thread, simply add the
4032 thread to the list. */
4034 /* If not in procinfo list, add it. */
4035 temp_tid
= proc_get_current_thread (pi
);
4036 if (!find_procinfo (pi
->pid
, temp_tid
))
4037 create_procinfo (pi
->pid
, temp_tid
);
4039 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
4040 /* If not in GDB's thread list, add it. */
4041 if (!in_thread_list (temp_ptid
))
4042 add_thread (temp_ptid
);
4044 /* Return to WFI, but tell it to immediately resume. */
4045 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4046 return inferior_ptid
;
4048 else if (syscall_is_lwp_exit (pi
, what
))
4050 if (print_thread_events
)
4051 printf_unfiltered (_("[%s exited]\n"),
4052 target_pid_to_str (retval
));
4053 delete_thread (retval
);
4054 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4059 /* FIXME: Do we need to handle SYS_sproc,
4060 SYS_fork, or SYS_vfork here? The old procfs
4061 seemed to use this event to handle threads on
4062 older (non-LWP) systems, where I'm assuming
4063 that threads were actually separate processes.
4064 Irix, maybe? Anyway, low priority for now. */
4068 printf_filtered (_("procfs: trapped on exit from "));
4069 proc_prettyprint_syscall (proc_what (pi
), 0);
4070 printf_filtered ("\n");
4073 long i
, nsysargs
, *sysargs
;
4075 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
4076 (sysargs
= proc_sysargs (pi
)) != NULL
)
4078 printf_filtered (_("%ld syscall arguments:\n"),
4080 for (i
= 0; i
< nsysargs
; i
++)
4081 printf_filtered ("#%ld: 0x%08lx\n",
4086 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4087 return inferior_ptid
;
4092 wstat
= (SIGSTOP
<< 8) | 0177;
4097 printf_filtered (_("Retry #%d:\n"), retry
);
4098 pi
->status_valid
= 0;
4103 /* If not in procinfo list, add it. */
4104 temp_tid
= proc_get_current_thread (pi
);
4105 if (!find_procinfo (pi
->pid
, temp_tid
))
4106 create_procinfo (pi
->pid
, temp_tid
);
4108 /* If not in GDB's thread list, add it. */
4109 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
4110 if (!in_thread_list (temp_ptid
))
4111 add_thread (temp_ptid
);
4113 status
->kind
= TARGET_WAITKIND_STOPPED
;
4114 status
->value
.sig
= 0;
4119 wstat
= (what
<< 8) | 0177;
4125 wstat
= (SIGTRAP
<< 8) | 0177;
4130 wstat
= (SIGTRAP
<< 8) | 0177;
4133 /* FIXME: use si_signo where possible. */
4135 #if (FLTILL != FLTPRIV) /* Avoid "duplicate case" error. */
4138 wstat
= (SIGILL
<< 8) | 0177;
4141 #if (FLTTRACE != FLTBPT) /* Avoid "duplicate case" error. */
4144 /* If we hit our __dbx_link() internal breakpoint,
4145 then remove it. See comments in procfs_init_inferior()
4146 for more details. */
4147 if (dbx_link_bpt_addr
!= 0
4148 && dbx_link_bpt_addr
4149 == regcache_read_pc (get_current_regcache ()))
4150 remove_dbx_link_breakpoint ();
4152 wstat
= (SIGTRAP
<< 8) | 0177;
4156 #if (FLTBOUNDS != FLTSTACK) /* Avoid "duplicate case" error. */
4159 wstat
= (SIGSEGV
<< 8) | 0177;
4163 #if (FLTFPE != FLTIOVF) /* Avoid "duplicate case" error. */
4166 wstat
= (SIGFPE
<< 8) | 0177;
4168 case FLTPAGE
: /* Recoverable page fault */
4169 default: /* FIXME: use si_signo if possible for
4171 retval
= pid_to_ptid (-1);
4172 printf_filtered ("procfs:%d -- ", __LINE__
);
4173 printf_filtered (_("child stopped for unknown reason:\n"));
4174 proc_prettyprint_why (why
, what
, 1);
4175 error (_("... giving up..."));
4178 break; /* case PR_FAULTED: */
4179 default: /* switch (why) unmatched */
4180 printf_filtered ("procfs:%d -- ", __LINE__
);
4181 printf_filtered (_("child stopped for unknown reason:\n"));
4182 proc_prettyprint_why (why
, what
, 1);
4183 error (_("... giving up..."));
4186 /* Got this far without error: If retval isn't in the
4187 threads database, add it. */
4188 if (PIDGET (retval
) > 0 &&
4189 !ptid_equal (retval
, inferior_ptid
) &&
4190 !in_thread_list (retval
))
4192 /* We have a new thread. We need to add it both to
4193 GDB's list and to our own. If we don't create a
4194 procinfo, resume may be unhappy later. */
4195 add_thread (retval
);
4196 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
4197 create_procinfo (PIDGET (retval
), TIDGET (retval
));
4200 else /* Flags do not indicate STOPPED. */
4202 /* surely this can't happen... */
4203 printf_filtered ("procfs:%d -- process not stopped.\n",
4205 proc_prettyprint_flags (flags
, 1);
4206 error (_("procfs: ...giving up..."));
4211 store_waitstatus (status
, wstat
);
4217 /* Perform a partial transfer to/from the specified object. For
4218 memory transfers, fall back to the old memory xfer functions. */
4221 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4222 const char *annex
, gdb_byte
*readbuf
,
4223 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4227 case TARGET_OBJECT_MEMORY
:
4229 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
4230 len
, 0/*read*/, NULL
, ops
);
4232 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
4233 len
, 1/*write*/, NULL
, ops
);
4237 case TARGET_OBJECT_AUXV
:
4238 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
4243 if (ops
->beneath
!= NULL
)
4244 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
4245 readbuf
, writebuf
, offset
, len
);
4251 /* Transfer LEN bytes between GDB address MYADDR and target address
4252 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
4253 otherwise transfer them from the target. TARGET is unused.
4255 The return value is 0 if an error occurred or no bytes were
4256 transferred. Otherwise, it will be a positive value which
4257 indicates the number of bytes transferred between gdb and the
4258 target. (Note that the interface also makes provisions for
4259 negative values, but this capability isn't implemented here.) */
4262 procfs_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int dowrite
,
4263 struct mem_attrib
*attrib
, struct target_ops
*target
)
4268 /* Find procinfo for main process. */
4269 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4270 if (pi
->as_fd
== 0 &&
4271 open_procinfo_files (pi
, FD_AS
) == 0)
4273 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4277 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4282 PROCFS_NOTE ("write memory:\n");
4284 PROCFS_NOTE ("write memory:\n");
4286 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4290 PROCFS_NOTE ("read memory:\n");
4291 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4301 /* Called by target_resume before making child runnable. Mark cached
4302 registers and status's invalid. If there are "dirty" caches that
4303 need to be written back to the child process, do that.
4305 File descriptors are also cached. As they are a limited resource,
4306 we cannot hold onto them indefinitely. However, as they are
4307 expensive to open, we don't want to throw them away
4308 indescriminately either. As a compromise, we will keep the file
4309 descriptors for the parent process, but discard any file
4310 descriptors we may have accumulated for the threads.
4312 As this function is called by iterate_over_threads, it always
4313 returns zero (so that iterate_over_threads will keep
4317 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
4319 /* About to run the child; invalidate caches and do any other
4323 if (pi
->gregs_dirty
)
4324 if (parent
== NULL
||
4325 proc_get_current_thread (parent
) != pi
->tid
)
4326 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4327 proc_warn (pi
, "target_resume, set_gregs",
4329 if (gdbarch_fp0_regnum (target_gdbarch
) >= 0)
4330 if (pi
->fpregs_dirty
)
4331 if (parent
== NULL
||
4332 proc_get_current_thread (parent
) != pi
->tid
)
4333 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4334 proc_warn (pi
, "target_resume, set_fpregs",
4340 /* The presence of a parent indicates that this is an LWP.
4341 Close any file descriptors that it might have open.
4342 We don't do this to the master (parent) procinfo. */
4344 close_procinfo_files (pi
);
4346 pi
->gregs_valid
= 0;
4347 pi
->fpregs_valid
= 0;
4349 pi
->gregs_dirty
= 0;
4350 pi
->fpregs_dirty
= 0;
4352 pi
->status_valid
= 0;
4353 pi
->threads_valid
= 0;
4359 /* A callback function for iterate_over_threads. Find the
4360 asynchronous signal thread, and make it runnable. See if that
4361 helps matters any. */
4364 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
4367 if (proc_flags (pi
) & PR_ASLWP
)
4369 if (!proc_run_process (pi
, 0, -1))
4370 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4378 /* Make the child process runnable. Normally we will then call
4379 procfs_wait and wait for it to stop again (unless gdb is async).
4381 If STEP is true, then arrange for the child to stop again after
4382 executing a single instruction. If SIGNO is zero, then cancel any
4383 pending signal; if non-zero, then arrange for the indicated signal
4384 to be delivered to the child when it runs. If PID is -1, then
4385 allow any child thread to run; if non-zero, then allow only the
4386 indicated thread to run. (not implemented yet). */
4389 procfs_resume (struct target_ops
*ops
,
4390 ptid_t ptid
, int step
, enum target_signal signo
)
4392 procinfo
*pi
, *thread
;
4396 prrun.prflags |= PRSVADDR;
4397 prrun.pr_vaddr = $PC; set resume address
4398 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4399 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4400 prrun.prflags |= PRCFAULT; clear current fault.
4402 PRSTRACE and PRSFAULT can be done by other means
4403 (proc_trace_signals, proc_trace_faults)
4404 PRSVADDR is unnecessary.
4405 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4406 This basically leaves PRSTEP and PRCSIG.
4407 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4408 So basically PR_STEP is the sole argument that must be passed
4409 to proc_run_process (for use in the prrun struct by ioctl). */
4411 /* Find procinfo for main process. */
4412 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4414 /* First cut: ignore pid argument. */
4417 /* Convert signal to host numbering. */
4419 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4422 native_signo
= target_signal_to_host (signo
);
4424 pi
->ignore_next_sigstop
= 0;
4426 /* Running the process voids all cached registers and status. */
4427 /* Void the threads' caches first. */
4428 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4429 /* Void the process procinfo's caches. */
4430 invalidate_cache (NULL
, pi
, NULL
);
4432 if (PIDGET (ptid
) != -1)
4434 /* Resume a specific thread, presumably suppressing the
4436 thread
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
));
4439 if (thread
->tid
!= 0)
4441 /* We're to resume a specific thread, and not the
4442 others. Set the child process's PR_ASYNC flag. */
4444 if (!proc_set_async (pi
))
4445 proc_error (pi
, "target_resume, set_async", __LINE__
);
4448 proc_iterate_over_threads (pi
,
4449 make_signal_thread_runnable
,
4452 pi
= thread
; /* Substitute the thread's procinfo
4458 if (!proc_run_process (pi
, step
, native_signo
))
4461 warning (_("resume: target already running. "
4462 "Pretend to resume, and hope for the best!"));
4464 proc_error (pi
, "target_resume", __LINE__
);
4468 /* Set up to trace signals in the child process. */
4471 procfs_pass_signals (int numsigs
, unsigned char *pass_signals
)
4473 gdb_sigset_t signals
;
4474 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4477 prfillset (&signals
);
4479 for (signo
= 0; signo
< NSIG
; signo
++)
4481 int target_signo
= target_signal_from_host (signo
);
4482 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
4483 gdb_prdelset (&signals
, signo
);
4486 if (!proc_set_traced_signals (pi
, &signals
))
4487 proc_error (pi
, "pass_signals", __LINE__
);
4490 /* Print status information about the child process. */
4493 procfs_files_info (struct target_ops
*ignore
)
4495 struct inferior
*inf
= current_inferior ();
4497 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
4498 inf
->attach_flag
? "attached": "child",
4499 target_pid_to_str (inferior_ptid
));
4502 /* Stop the child process asynchronously, as when the gdb user types
4503 control-c or presses a "stop" button. Works by sending
4504 kill(SIGINT) to the child's process group. */
4507 procfs_stop (ptid_t ptid
)
4509 kill (-inferior_process_group (), SIGINT
);
4512 /* Make it die. Wait for it to die. Clean up after it. Note: this
4513 should only be applied to the real process, not to an LWP, because
4514 of the check for parent-process. If we need this to work for an
4515 LWP, it needs some more logic. */
4518 unconditionally_kill_inferior (procinfo
*pi
)
4522 parent_pid
= proc_parent_pid (pi
);
4523 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4524 /* FIXME: use access functions. */
4525 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4526 before the PIOCKILL, otherwise it might generate a corrupted core
4527 file for the inferior. */
4528 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4530 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4533 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4534 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4535 to kill the inferior, otherwise it might remain stopped with a
4537 We do not check the result of the PIOCSSIG, the inferior might have
4540 gdb_siginfo_t newsiginfo
;
4542 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4543 newsiginfo
.si_signo
= SIGKILL
;
4544 newsiginfo
.si_code
= 0;
4545 newsiginfo
.si_errno
= 0;
4546 newsiginfo
.si_pid
= getpid ();
4547 newsiginfo
.si_uid
= getuid ();
4548 /* FIXME: use proc_set_current_signal. */
4549 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4551 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4552 if (!proc_kill (pi
, SIGKILL
))
4553 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4554 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4555 destroy_procinfo (pi
);
4557 /* If pi is GDB's child, wait for it to die. */
4558 if (parent_pid
== getpid ())
4559 /* FIXME: should we use waitpid to make sure we get the right event?
4560 Should we check the returned event? */
4565 ret
= waitpid (pi
->pid
, &status
, 0);
4572 /* We're done debugging it, and we want it to go away. Then we want
4573 GDB to forget all about it. */
4576 procfs_kill_inferior (struct target_ops
*ops
)
4578 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
4580 /* Find procinfo for main process. */
4581 procinfo
*pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4584 unconditionally_kill_inferior (pi
);
4585 target_mourn_inferior ();
4589 /* Forget we ever debugged this thing! */
4592 procfs_mourn_inferior (struct target_ops
*ops
)
4596 if (!ptid_equal (inferior_ptid
, null_ptid
))
4598 /* Find procinfo for main process. */
4599 pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4601 destroy_procinfo (pi
);
4603 unpush_target (ops
);
4605 if (dbx_link_bpt
!= NULL
)
4607 deprecated_remove_raw_breakpoint (target_gdbarch
, dbx_link_bpt
);
4608 dbx_link_bpt_addr
= 0;
4609 dbx_link_bpt
= NULL
;
4612 generic_mourn_inferior ();
4615 /* When GDB forks to create a runnable inferior process, this function
4616 is called on the parent side of the fork. It's job is to do
4617 whatever is necessary to make the child ready to be debugged, and
4618 then wait for the child to synchronize. */
4621 procfs_init_inferior (struct target_ops
*ops
, int pid
)
4624 gdb_sigset_t signals
;
4628 /* This routine called on the parent side (GDB side)
4629 after GDB forks the inferior. */
4632 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4633 perror (_("procfs: out of memory in 'init_inferior'"));
4635 if (!open_procinfo_files (pi
, FD_CTL
))
4636 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4640 open_procinfo_files // done
4643 procfs_notice_signals
4650 /* If not stopped yet, wait for it to stop. */
4651 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4652 !(proc_wait_for_stop (pi
)))
4653 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4655 /* Save some of the /proc state to be restored if we detach. */
4656 /* FIXME: Why? In case another debugger was debugging it?
4657 We're it's parent, for Ghu's sake! */
4658 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4659 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4660 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4661 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4662 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4663 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4664 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
4665 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4666 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
4667 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4669 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4670 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4672 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4673 and possibly even turning ON kill-on-last-close at this point. But
4674 I can't make that change without careful testing which I don't have
4675 time to do right now... */
4676 /* Turn on run-on-last-close flag so that the child
4677 will die if GDB goes away for some reason. */
4678 if (!proc_set_run_on_last_close (pi
))
4679 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4681 /* We now have have access to the lwpid of the main thread/lwp. */
4682 lwpid
= proc_get_current_thread (pi
);
4684 /* Create a procinfo for the main lwp. */
4685 create_procinfo (pid
, lwpid
);
4687 /* We already have a main thread registered in the thread table at
4688 this point, but it didn't have any lwp info yet. Notify the core
4689 about it. This changes inferior_ptid as well. */
4690 thread_change_ptid (pid_to_ptid (pid
),
4691 MERGEPID (pid
, lwpid
));
4693 /* Typically two, one trap to exec the shell, one to exec the
4694 program being debugged. Defined by "inferior.h". */
4695 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4698 /* On mips-irix, we need to stop the inferior early enough during
4699 the startup phase in order to be able to load the shared library
4700 symbols and insert the breakpoints that are located in these shared
4701 libraries. Stopping at the program entry point is not good enough
4702 because the -init code is executed before the execution reaches
4705 So what we need to do is to insert a breakpoint in the runtime
4706 loader (rld), more precisely in __dbx_link(). This procedure is
4707 called by rld once all shared libraries have been mapped, but before
4708 the -init code is executed. Unfortuantely, this is not straightforward,
4709 as rld is not part of the executable we are running, and thus we need
4710 the inferior to run until rld itself has been mapped in memory.
4712 For this, we trace all syssgi() syscall exit events. Each time
4713 we detect such an event, we iterate over each text memory maps,
4714 get its associated fd, and scan the symbol table for __dbx_link().
4715 When found, we know that rld has been mapped, and that we can insert
4716 the breakpoint at the symbol address. Once the dbx_link() breakpoint
4717 has been inserted, the syssgi() notifications are no longer necessary,
4718 so they should be canceled. */
4719 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
, FLAG_SET
, 0);
4723 /* When GDB forks to create a new process, this function is called on
4724 the child side of the fork before GDB exec's the user program. Its
4725 job is to make the child minimally debuggable, so that the parent
4726 GDB process can connect to the child and take over. This function
4727 should do only the minimum to make that possible, and to
4728 synchronize with the parent process. The parent process should
4729 take care of the details. */
4732 procfs_set_exec_trap (void)
4734 /* This routine called on the child side (inferior side)
4735 after GDB forks the inferior. It must use only local variables,
4736 because it may be sharing data space with its parent. */
4741 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4742 perror_with_name (_("procfs: create_procinfo failed in child."));
4744 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4746 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4747 gdb_flush (gdb_stderr
);
4748 /* No need to call "dead_procinfo", because we're going to
4753 #ifdef PRFS_STOPEXEC /* defined on OSF */
4754 /* OSF method for tracing exec syscalls. Quoting:
4755 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4756 exits from exec system calls because of the user level loader. */
4757 /* FIXME: make nice and maybe move into an access function. */
4761 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4763 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4764 gdb_flush (gdb_stderr
);
4767 prfs_flags
|= PRFS_STOPEXEC
;
4769 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4771 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4772 gdb_flush (gdb_stderr
);
4776 #else /* not PRFS_STOPEXEC */
4777 /* Everyone else's (except OSF) method for tracing exec syscalls. */
4779 Not all systems with /proc have all the exec* syscalls with the same
4780 names. On the SGI, for example, there is no SYS_exec, but there
4781 *is* a SYS_execv. So, we try to account for that. */
4783 exitset
= sysset_t_alloc (pi
);
4784 gdb_premptysysset (exitset
);
4786 gdb_praddsysset (exitset
, SYS_exec
);
4789 gdb_praddsysset (exitset
, SYS_execve
);
4792 gdb_praddsysset (exitset
, SYS_execv
);
4794 #ifdef DYNAMIC_SYSCALLS
4796 int callnum
= find_syscall (pi
, "execve");
4799 gdb_praddsysset (exitset
, callnum
);
4801 callnum
= find_syscall (pi
, "ra_execve");
4803 gdb_praddsysset (exitset
, callnum
);
4805 #endif /* DYNAMIC_SYSCALLS */
4807 if (!proc_set_traced_sysexit (pi
, exitset
))
4809 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4810 gdb_flush (gdb_stderr
);
4813 #endif /* PRFS_STOPEXEC */
4815 /* FIXME: should this be done in the parent instead? */
4816 /* Turn off inherit on fork flag so that all grand-children
4817 of gdb start with tracing flags cleared. */
4818 if (!proc_unset_inherit_on_fork (pi
))
4819 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4821 /* Turn off run on last close flag, so that the child process
4822 cannot run away just because we close our handle on it.
4823 We want it to wait for the parent to attach. */
4824 if (!proc_unset_run_on_last_close (pi
))
4825 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4827 /* FIXME: No need to destroy the procinfo --
4828 we have our own address space, and we're about to do an exec! */
4829 /*destroy_procinfo (pi);*/
4832 /* This function is called BEFORE gdb forks the inferior process. Its
4833 only real responsibility is to set things up for the fork, and tell
4834 GDB which two functions to call after the fork (one for the parent,
4835 and one for the child).
4837 This function does a complicated search for a unix shell program,
4838 which it then uses to parse arguments and environment variables to
4839 be sent to the child. I wonder whether this code could not be
4840 abstracted out and shared with other unix targets such as
4844 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
4845 char *allargs
, char **env
, int from_tty
)
4847 char *shell_file
= getenv ("SHELL");
4851 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4854 /* We will be looking down the PATH to find shell_file. If we
4855 just do this the normal way (via execlp, which operates by
4856 attempting an exec for each element of the PATH until it
4857 finds one which succeeds), then there will be an exec for
4858 each failed attempt, each of which will cause a PR_SYSEXIT
4859 stop, and we won't know how to distinguish the PR_SYSEXIT's
4860 for these failed execs with the ones for successful execs
4861 (whether the exec has succeeded is stored at that time in the
4862 carry bit or some such architecture-specific and
4863 non-ABI-specified place).
4865 So I can't think of anything better than to search the PATH
4866 now. This has several disadvantages: (1) There is a race
4867 condition; if we find a file now and it is deleted before we
4868 exec it, we lose, even if the deletion leaves a valid file
4869 further down in the PATH, (2) there is no way to know exactly
4870 what an executable (in the sense of "capable of being
4871 exec'd") file is. Using access() loses because it may lose
4872 if the caller is the superuser; failing to use it loses if
4873 there are ACLs or some such. */
4877 /* FIXME-maybe: might want "set path" command so user can change what
4878 path is used from within GDB. */
4879 char *path
= getenv ("PATH");
4881 struct stat statbuf
;
4884 path
= "/bin:/usr/bin";
4886 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4887 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4889 p1
= strchr (p
, ':');
4894 strncpy (tryname
, p
, len
);
4895 tryname
[len
] = '\0';
4896 strcat (tryname
, "/");
4897 strcat (tryname
, shell_file
);
4898 if (access (tryname
, X_OK
) < 0)
4900 if (stat (tryname
, &statbuf
) < 0)
4902 if (!S_ISREG (statbuf
.st_mode
))
4903 /* We certainly need to reject directories. I'm not quite
4904 as sure about FIFOs, sockets, etc., but I kind of doubt
4905 that people want to exec() these things. */
4910 /* Not found. This must be an error rather than merely passing
4911 the file to execlp(), because execlp() would try all the
4912 exec()s, causing GDB to get confused. */
4913 error (_("procfs:%d -- Can't find shell %s in PATH"),
4914 __LINE__
, shell_file
);
4916 shell_file
= tryname
;
4919 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4920 NULL
, NULL
, shell_file
, NULL
);
4922 procfs_init_inferior (ops
, pid
);
4925 /* An observer for the "inferior_created" event. */
4928 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
4931 /* Make sure to cancel the syssgi() syscall-exit notifications.
4932 They should normally have been removed by now, but they may still
4933 be activated if the inferior doesn't use shared libraries, or if
4934 we didn't locate __dbx_link, or if we never stopped in __dbx_link.
4935 See procfs_init_inferior() for more details.
4937 Since these notifications are only ever enabled when we spawned
4938 the inferior ourselves, there is nothing to do when the inferior
4939 was created by attaching to an already running process, or when
4940 debugging a core file. */
4941 if (current_inferior ()->attach_flag
|| !target_can_run (¤t_target
))
4944 proc_trace_syscalls_1 (find_procinfo_or_die (PIDGET (inferior_ptid
), 0),
4945 SYS_syssgi
, PR_SYSEXIT
, FLAG_RESET
, 0);
4949 /* Callback for find_new_threads. Calls "add_thread". */
4952 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
4954 ptid_t gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4956 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
4957 add_thread (gdb_threadid
);
4962 /* Query all the threads that the target knows about, and give them
4963 back to GDB to add to its list. */
4966 procfs_find_new_threads (struct target_ops
*ops
)
4970 /* Find procinfo for main process. */
4971 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4972 proc_update_threads (pi
);
4973 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4976 /* Return true if the thread is still 'alive'. This guy doesn't
4977 really seem to be doing his job. Got to investigate how to tell
4978 when a thread is really gone. */
4981 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4986 proc
= PIDGET (ptid
);
4987 thread
= TIDGET (ptid
);
4988 /* If I don't know it, it ain't alive! */
4989 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4992 /* If I can't get its status, it ain't alive!
4993 What's more, I need to forget about it! */
4994 if (!proc_get_status (pi
))
4996 destroy_procinfo (pi
);
4999 /* I couldn't have got its status if it weren't alive, so it's
5004 /* Convert PTID to a string. Returns the string in a static
5008 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
5010 static char buf
[80];
5012 if (TIDGET (ptid
) == 0)
5013 sprintf (buf
, "process %d", PIDGET (ptid
));
5015 sprintf (buf
, "LWP %ld", TIDGET (ptid
));
5020 /* Insert a watchpoint. */
5023 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
5031 pi
= find_procinfo_or_die (PIDGET (ptid
) == -1 ?
5032 PIDGET (inferior_ptid
) : PIDGET (ptid
), 0);
5034 /* Translate from GDB's flags to /proc's. */
5035 if (len
> 0) /* len == 0 means delete watchpoint. */
5037 switch (rwflag
) { /* FIXME: need an enum! */
5038 case hw_write
: /* default watchpoint (write) */
5039 pflags
= WRITE_WATCHFLAG
;
5041 case hw_read
: /* read watchpoint */
5042 pflags
= READ_WATCHFLAG
;
5044 case hw_access
: /* access watchpoint */
5045 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
5047 case hw_execute
: /* execution HW breakpoint */
5048 pflags
= EXEC_WATCHFLAG
;
5050 default: /* Something weird. Return error. */
5053 if (after
) /* Stop after r/w access is completed. */
5054 pflags
|= AFTER_WATCHFLAG
;
5057 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
5059 if (errno
== E2BIG
) /* Typical error for no resources. */
5060 return -1; /* fail */
5061 /* GDB may try to remove the same watchpoint twice.
5062 If a remove request returns no match, don't error. */
5063 if (errno
== ESRCH
&& len
== 0)
5064 return 0; /* ignore */
5065 proc_error (pi
, "set_watchpoint", __LINE__
);
5068 #endif /* UNIXWARE */
5072 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
5073 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
5074 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
5077 Note: procfs_can_use_hw_breakpoint() is not yet used by all
5078 procfs.c targets due to the fact that some of them still define
5079 target_can_use_hardware_watchpoint. */
5082 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
5084 /* Due to the way that proc_set_watchpoint() is implemented, host
5085 and target pointers must be of the same size. If they are not,
5086 we can't use hardware watchpoints. This limitation is due to the
5087 fact that proc_set_watchpoint() calls
5088 procfs_address_to_host_pointer(); a close inspection of
5089 procfs_address_to_host_pointer will reveal that an internal error
5090 will be generated when the host and target pointer sizes are
5092 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
5094 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
5097 /* Other tests here??? */
5102 /* Returns non-zero if process is stopped on a hardware watchpoint
5103 fault, else returns zero. */
5106 procfs_stopped_by_watchpoint (void)
5110 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5112 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
5114 if (proc_why (pi
) == PR_FAULTED
)
5117 if (proc_what (pi
) == FLTWATCH
)
5121 if (proc_what (pi
) == FLTKWATCH
)
5129 /* Returns 1 if the OS knows the position of the triggered watchpoint,
5130 and sets *ADDR to that address. Returns 0 if OS cannot report that
5131 address. This function is only called if
5132 procfs_stopped_by_watchpoint returned 1, thus no further checks are
5133 done. The function also assumes that ADDR is not NULL. */
5136 procfs_stopped_data_address (struct target_ops
*targ
, CORE_ADDR
*addr
)
5140 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5141 return proc_watchpoint_address (pi
, addr
);
5145 procfs_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
5146 struct expression
*cond
)
5148 if (!target_have_steppable_watchpoint
5149 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch
))
5151 /* When a hardware watchpoint fires off the PC will be left at
5152 the instruction following the one which caused the
5153 watchpoint. It will *NOT* be necessary for GDB to step over
5155 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
5159 /* When a hardware watchpoint fires off the PC will be left at
5160 the instruction which caused the watchpoint. It will be
5161 necessary for GDB to step over the watchpoint. */
5162 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
5167 procfs_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
5168 struct expression
*cond
)
5170 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
5174 procfs_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
5176 /* The man page for proc(4) on Solaris 2.6 and up says that the
5177 system can support "thousands" of hardware watchpoints, but gives
5178 no method for finding out how many; It doesn't say anything about
5179 the allowed size for the watched area either. So we just tell
5185 procfs_use_watchpoints (struct target_ops
*t
)
5187 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
5188 t
->to_insert_watchpoint
= procfs_insert_watchpoint
;
5189 t
->to_remove_watchpoint
= procfs_remove_watchpoint
;
5190 t
->to_region_ok_for_hw_watchpoint
= procfs_region_ok_for_hw_watchpoint
;
5191 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
5192 t
->to_stopped_data_address
= procfs_stopped_data_address
;
5195 /* Memory Mappings Functions: */
5197 /* Call a callback function once for each mapping, passing it the
5198 mapping, an optional secondary callback function, and some optional
5199 opaque data. Quit and return the first non-zero value returned
5202 PI is the procinfo struct for the process to be mapped. FUNC is
5203 the callback function to be called by this iterator. DATA is the
5204 optional opaque data to be passed to the callback function.
5205 CHILD_FUNC is the optional secondary function pointer to be passed
5206 to the child function. Returns the first non-zero return value
5207 from the callback function, or zero. */
5210 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
5212 int (*func
) (struct prmap
*map
,
5213 find_memory_region_ftype child_func
,
5216 char pathname
[MAX_PROC_NAME_SIZE
];
5217 struct prmap
*prmaps
;
5218 struct prmap
*prmap
;
5222 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
5227 /* Get the number of mappings, allocate space,
5228 and read the mappings into prmaps. */
5231 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
5232 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
5233 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
5235 /* Make sure it gets closed again. */
5236 make_cleanup_close (map_fd
);
5238 /* Use stat to determine the file size, and compute
5239 the number of prmap_t objects it contains. */
5240 if (fstat (map_fd
, &sbuf
) != 0)
5241 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
5243 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
5244 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5245 if (read (map_fd
, (char *) prmaps
, nmap
* sizeof (*prmaps
))
5246 != (nmap
* sizeof (*prmaps
)))
5247 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
5249 /* Use ioctl command PIOCNMAP to get number of mappings. */
5250 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmap
) != 0)
5251 proc_error (pi
, "iterate_over_mappings (PIOCNMAP)", __LINE__
);
5253 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5254 if (ioctl (pi
->ctl_fd
, PIOCMAP
, prmaps
) != 0)
5255 proc_error (pi
, "iterate_over_mappings (PIOCMAP)", __LINE__
);
5258 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
5259 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
5261 do_cleanups (cleanups
);
5265 do_cleanups (cleanups
);
5269 /* Implements the to_find_memory_regions method. Calls an external
5270 function for each memory region.
5271 Returns the integer value returned by the callback. */
5274 find_memory_regions_callback (struct prmap
*map
,
5275 find_memory_region_ftype func
, void *data
)
5277 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
5279 (map
->pr_mflags
& MA_READ
) != 0,
5280 (map
->pr_mflags
& MA_WRITE
) != 0,
5281 (map
->pr_mflags
& MA_EXEC
) != 0,
5285 /* External interface. Calls a callback function once for each
5286 mapped memory region in the child process, passing as arguments:
5288 CORE_ADDR virtual_address,
5290 int read, TRUE if region is readable by the child
5291 int write, TRUE if region is writable by the child
5292 int execute TRUE if region is executable by the child.
5294 Stops iterating and returns the first non-zero value returned by
5298 proc_find_memory_regions (find_memory_region_ftype func
, void *data
)
5300 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5302 return iterate_over_mappings (pi
, func
, data
,
5303 find_memory_regions_callback
);
5306 /* Returns an ascii representation of a memory mapping's flags. */
5309 mappingflags (long flags
)
5311 static char asciiflags
[8];
5313 strcpy (asciiflags
, "-------");
5314 #if defined (MA_PHYS)
5315 if (flags
& MA_PHYS
)
5316 asciiflags
[0] = 'd';
5318 if (flags
& MA_STACK
)
5319 asciiflags
[1] = 's';
5320 if (flags
& MA_BREAK
)
5321 asciiflags
[2] = 'b';
5322 if (flags
& MA_SHARED
)
5323 asciiflags
[3] = 's';
5324 if (flags
& MA_READ
)
5325 asciiflags
[4] = 'r';
5326 if (flags
& MA_WRITE
)
5327 asciiflags
[5] = 'w';
5328 if (flags
& MA_EXEC
)
5329 asciiflags
[6] = 'x';
5330 return (asciiflags
);
5333 /* Callback function, does the actual work for 'info proc
5337 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
5340 unsigned int pr_off
;
5342 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
5343 pr_off
= (unsigned int) map
->pr_offset
;
5345 pr_off
= map
->pr_off
;
5348 if (gdbarch_addr_bit (target_gdbarch
) == 32)
5349 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
5350 (unsigned long) map
->pr_vaddr
,
5351 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5352 (unsigned long) map
->pr_size
,
5354 mappingflags (map
->pr_mflags
));
5356 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
5357 (unsigned long) map
->pr_vaddr
,
5358 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5359 (unsigned long) map
->pr_size
,
5361 mappingflags (map
->pr_mflags
));
5366 /* Implement the "info proc mappings" subcommand. */
5369 info_proc_mappings (procinfo
*pi
, int summary
)
5372 return; /* No output for summary mode. */
5374 printf_filtered (_("Mapped address spaces:\n\n"));
5375 if (gdbarch_ptr_bit (target_gdbarch
) == 32)
5376 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
5383 printf_filtered (" %18s %18s %10s %10s %7s\n",
5390 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
5391 printf_filtered ("\n");
5394 /* Implement the "info proc" command. */
5397 procfs_info_proc (struct target_ops
*ops
, char *args
,
5398 enum info_proc_what what
)
5400 struct cleanup
*old_chain
;
5401 procinfo
*process
= NULL
;
5402 procinfo
*thread
= NULL
;
5420 error (_("Not supported on this target."));
5423 old_chain
= make_cleanup (null_cleanup
, 0);
5426 argv
= gdb_buildargv (args
);
5427 make_cleanup_freeargv (argv
);
5429 while (argv
!= NULL
&& *argv
!= NULL
)
5431 if (isdigit (argv
[0][0]))
5433 pid
= strtoul (argv
[0], &tmp
, 10);
5435 tid
= strtoul (++tmp
, NULL
, 10);
5437 else if (argv
[0][0] == '/')
5439 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5444 pid
= PIDGET (inferior_ptid
);
5446 error (_("No current process: you must name one."));
5449 /* Have pid, will travel.
5450 First see if it's a process we're already debugging. */
5451 process
= find_procinfo (pid
, 0);
5452 if (process
== NULL
)
5454 /* No. So open a procinfo for it, but
5455 remember to close it again when finished. */
5456 process
= create_procinfo (pid
, 0);
5457 make_cleanup (do_destroy_procinfo_cleanup
, process
);
5458 if (!open_procinfo_files (process
, FD_CTL
))
5459 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5463 thread
= create_procinfo (pid
, tid
);
5467 printf_filtered (_("process %d flags:\n"), process
->pid
);
5468 proc_prettyprint_flags (proc_flags (process
), 1);
5469 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5470 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5471 if (proc_get_nthreads (process
) > 1)
5472 printf_filtered ("Process has %d threads.\n",
5473 proc_get_nthreads (process
));
5477 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
5478 proc_prettyprint_flags (proc_flags (thread
), 1);
5479 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5480 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5485 info_proc_mappings (process
, 0);
5488 do_cleanups (old_chain
);
5491 /* Modify the status of the system call identified by SYSCALLNUM in
5492 the set of syscalls that are currently traced/debugged.
5494 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
5495 will be updated. Otherwise, the exit syscalls set will be updated.
5497 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
5498 will be disabled. */
5501 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
5502 int mode
, int from_tty
)
5506 if (entry_or_exit
== PR_SYSENTRY
)
5507 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5509 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5512 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5514 if (mode
== FLAG_SET
)
5515 gdb_praddsysset (sysset
, syscallnum
);
5517 gdb_prdelsysset (sysset
, syscallnum
);
5519 if (entry_or_exit
== PR_SYSENTRY
)
5521 if (!proc_set_traced_sysentry (pi
, sysset
))
5522 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5526 if (!proc_set_traced_sysexit (pi
, sysset
))
5527 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5532 proc_trace_syscalls (char *args
, int from_tty
, int entry_or_exit
, int mode
)
5536 if (PIDGET (inferior_ptid
) <= 0)
5537 error (_("you must be debugging a process to use this command."));
5539 if (args
== NULL
|| args
[0] == 0)
5540 error_no_arg (_("system call to trace"));
5542 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5543 if (isdigit (args
[0]))
5545 const int syscallnum
= atoi (args
);
5547 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
5552 proc_trace_sysentry_cmd (char *args
, int from_tty
)
5554 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5558 proc_trace_sysexit_cmd (char *args
, int from_tty
)
5560 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5564 proc_untrace_sysentry_cmd (char *args
, int from_tty
)
5566 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5570 proc_untrace_sysexit_cmd (char *args
, int from_tty
)
5572 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5577 _initialize_procfs (void)
5579 observer_attach_inferior_created (procfs_inferior_created
);
5581 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5582 _("Give a trace of entries into the syscall."));
5583 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5584 _("Give a trace of exits from the syscall."));
5585 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5586 _("Cancel a trace of entries into the syscall."));
5587 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5588 _("Cancel a trace of exits from the syscall."));
5591 /* =================== END, GDB "MODULE" =================== */
5595 /* miscellaneous stubs: */
5597 /* The following satisfy a few random symbols mostly created by the
5598 solaris threads implementation, which I will chase down later. */
5600 /* Return a pid for which we guarantee we will be able to find a
5604 procfs_first_available (void)
5606 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
5609 /* =================== GCORE .NOTE "MODULE" =================== */
5610 #if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT)
5611 /* gcore only implemented on solaris and unixware (so far) */
5614 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
5615 char *note_data
, int *note_size
,
5616 enum target_signal stop_signal
)
5618 struct regcache
*regcache
= get_thread_regcache (ptid
);
5619 gdb_gregset_t gregs
;
5620 gdb_fpregset_t fpregs
;
5621 unsigned long merged_pid
;
5622 struct cleanup
*old_chain
;
5624 merged_pid
= TIDGET (ptid
) << 16 | PIDGET (ptid
);
5626 /* This part is the old method for fetching registers.
5627 It should be replaced by the newer one using regsets
5628 once it is implemented in this platform:
5629 gdbarch_regset_from_core_section() and regset->collect_regset(). */
5631 old_chain
= save_inferior_ptid ();
5632 inferior_ptid
= ptid
;
5633 target_fetch_registers (regcache
, -1);
5635 fill_gregset (regcache
, &gregs
, -1);
5636 #if defined (NEW_PROC_API)
5637 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
5644 note_data
= (char *) elfcore_write_prstatus (obfd
,
5651 fill_fpregset (regcache
, &fpregs
, -1);
5652 note_data
= (char *) elfcore_write_prfpreg (obfd
,
5658 do_cleanups (old_chain
);
5663 struct procfs_corefile_thread_data
{
5667 enum target_signal stop_signal
;
5671 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
5673 struct procfs_corefile_thread_data
*args
= data
;
5677 ptid_t ptid
= MERGEPID (pi
->pid
, thread
->tid
);
5679 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
5688 find_signalled_thread (struct thread_info
*info
, void *data
)
5690 if (info
->suspend
.stop_signal
!= TARGET_SIGNAL_0
5691 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
5697 static enum target_signal
5698 find_stop_signal (void)
5700 struct thread_info
*info
=
5701 iterate_over_threads (find_signalled_thread
, NULL
);
5704 return info
->suspend
.stop_signal
;
5706 return TARGET_SIGNAL_0
;
5710 procfs_make_note_section (bfd
*obfd
, int *note_size
)
5712 struct cleanup
*old_chain
;
5713 gdb_gregset_t gregs
;
5714 gdb_fpregset_t fpregs
;
5715 char fname
[16] = {'\0'};
5716 char psargs
[80] = {'\0'};
5717 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5718 char *note_data
= NULL
;
5720 struct procfs_corefile_thread_data thread_args
;
5723 enum target_signal stop_signal
;
5725 if (get_exec_file (0))
5727 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
5728 strncpy (psargs
, get_exec_file (0),
5731 inf_args
= get_inferior_args ();
5732 if (inf_args
&& *inf_args
&&
5733 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
5735 strncat (psargs
, " ",
5736 sizeof (psargs
) - strlen (psargs
));
5737 strncat (psargs
, inf_args
,
5738 sizeof (psargs
) - strlen (psargs
));
5742 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
5748 stop_signal
= find_stop_signal ();
5751 fill_gregset (get_current_regcache (), &gregs
, -1);
5752 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
5753 PIDGET (inferior_ptid
),
5754 stop_signal
, &gregs
);
5757 thread_args
.obfd
= obfd
;
5758 thread_args
.note_data
= note_data
;
5759 thread_args
.note_size
= note_size
;
5760 thread_args
.stop_signal
= stop_signal
;
5761 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
5764 /* There should be always at least one thread. */
5765 gdb_assert (thread_args
.note_data
!= note_data
);
5766 note_data
= thread_args
.note_data
;
5768 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
5772 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
5773 "CORE", NT_AUXV
, auxv
, auxv_len
);
5777 make_cleanup (xfree
, note_data
);
5780 #else /* !(Solaris or Unixware) */
5782 procfs_make_note_section (bfd
*obfd
, int *note_size
)
5784 error (_("gcore not implemented for this host."));
5785 return NULL
; /* lint */
5787 #endif /* Solaris or Unixware */
5788 /* =================== END GCORE .NOTE "MODULE" =================== */