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 siginfo_t 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_nsysarg (procinfo
* pi
);
1027 long *proc_sysargs (procinfo
* pi
);
1028 int proc_syscall (procinfo
* pi
);
1029 long proc_cursig (struct procinfo
* pi
);
1030 int proc_set_run_on_last_close (procinfo
* pi
);
1031 int proc_unset_run_on_last_close (procinfo
* pi
);
1032 int proc_set_kill_on_last_close (procinfo
* pi
);
1033 int proc_unset_kill_on_last_close (procinfo
* pi
);
1034 int proc_set_inherit_on_fork (procinfo
* pi
);
1035 int proc_unset_inherit_on_fork (procinfo
* pi
);
1036 int proc_set_async (procinfo
* pi
);
1037 int proc_unset_async (procinfo
* pi
);
1038 int proc_stop_process (procinfo
* pi
);
1039 int proc_trace_signal (procinfo
* pi
, int signo
);
1040 int proc_ignore_signal (procinfo
* pi
, int signo
);
1041 int proc_clear_current_fault (procinfo
* pi
);
1042 int proc_set_current_signal (procinfo
* pi
, int signo
);
1043 int proc_clear_current_signal (procinfo
* pi
);
1044 int proc_set_gregs (procinfo
* pi
);
1045 int proc_set_fpregs (procinfo
* pi
);
1046 int proc_wait_for_stop (procinfo
* pi
);
1047 int proc_run_process (procinfo
* pi
, int step
, int signo
);
1048 int proc_kill (procinfo
* pi
, int signo
);
1049 int proc_parent_pid (procinfo
* pi
);
1050 int proc_get_nthreads (procinfo
* pi
);
1051 int proc_get_current_thread (procinfo
* pi
);
1052 int proc_set_held_signals (procinfo
* pi
, gdb_sigset_t
* sighold
);
1053 int proc_set_traced_sysexit (procinfo
* pi
, sysset_t
* sysset
);
1054 int proc_set_traced_sysentry (procinfo
* pi
, sysset_t
* sysset
);
1055 int proc_set_traced_faults (procinfo
* pi
, fltset_t
* fltset
);
1056 int proc_set_traced_signals (procinfo
* pi
, gdb_sigset_t
* sigset
);
1058 int proc_update_threads (procinfo
* pi
);
1059 int proc_iterate_over_threads (procinfo
* pi
,
1060 int (*func
) (procinfo
*, procinfo
*, void *),
1063 gdb_gregset_t
*proc_get_gregs (procinfo
* pi
);
1064 gdb_fpregset_t
*proc_get_fpregs (procinfo
* pi
);
1065 sysset_t
*proc_get_traced_sysexit (procinfo
* pi
, sysset_t
* save
);
1066 sysset_t
*proc_get_traced_sysentry (procinfo
* pi
, sysset_t
* save
);
1067 fltset_t
*proc_get_traced_faults (procinfo
* pi
, fltset_t
* save
);
1068 gdb_sigset_t
*proc_get_traced_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1069 gdb_sigset_t
*proc_get_held_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1070 gdb_sigset_t
*proc_get_pending_signals (procinfo
* pi
, gdb_sigset_t
* save
);
1071 gdb_sigaction_t
*proc_get_signal_actions (procinfo
* pi
,
1072 gdb_sigaction_t
*save
);
1074 void proc_warn (procinfo
* pi
, char *func
, int line
);
1075 void proc_error (procinfo
* pi
, char *func
, int line
);
1078 proc_warn (procinfo
*pi
, char *func
, int line
)
1080 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1081 print_sys_errmsg (errmsg
, errno
);
1085 proc_error (procinfo
*pi
, char *func
, int line
)
1087 sprintf (errmsg
, "procfs: %s line %d, %s", func
, line
, pi
->pathname
);
1088 perror_with_name (errmsg
);
1091 /* Updates the status struct in the procinfo. There is a 'valid'
1092 flag, to let other functions know when this function needs to be
1093 called (so the status is only read when it is needed). The status
1094 file descriptor is also only opened when it is needed. Returns
1095 non-zero for success, zero for failure. */
1098 proc_get_status (procinfo
*pi
)
1100 /* Status file descriptor is opened "lazily". */
1101 if (pi
->status_fd
== 0 &&
1102 open_procinfo_files (pi
, FD_STATUS
) == 0)
1104 pi
->status_valid
= 0;
1109 if (lseek (pi
->status_fd
, 0, SEEK_SET
) < 0)
1110 pi
->status_valid
= 0; /* fail */
1113 /* Sigh... I have to read a different data structure,
1114 depending on whether this is a main process or an LWP. */
1116 pi
->status_valid
= (read (pi
->status_fd
,
1117 (char *) &pi
->prstatus
.pr_lwp
,
1118 sizeof (lwpstatus_t
))
1119 == sizeof (lwpstatus_t
));
1122 pi
->status_valid
= (read (pi
->status_fd
,
1123 (char *) &pi
->prstatus
,
1124 sizeof (gdb_prstatus_t
))
1125 == sizeof (gdb_prstatus_t
));
1126 #if 0 /*def UNIXWARE*/
1127 if (pi
->status_valid
&&
1128 (pi
->prstatus
.pr_lwp
.pr_flags
& PR_ISTOP
) &&
1129 pi
->prstatus
.pr_lwp
.pr_why
== PR_REQUESTED
)
1130 /* Unixware peculiarity -- read the damn thing again! */
1131 pi
->status_valid
= (read (pi
->status_fd
,
1132 (char *) &pi
->prstatus
,
1133 sizeof (gdb_prstatus_t
))
1134 == sizeof (gdb_prstatus_t
));
1135 #endif /* UNIXWARE */
1138 #else /* ioctl method */
1139 #ifdef PIOCTSTATUS /* osf */
1140 if (pi
->tid
== 0) /* main process */
1142 /* Just read the danged status. Now isn't that simple? */
1144 (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1151 tid_t pr_error_thread
;
1152 struct prstatus status
;
1155 thread_status
.pr_count
= 1;
1156 thread_status
.status
.pr_tid
= pi
->tid
;
1157 win
= (ioctl (pi
->status_fd
, PIOCTSTATUS
, &thread_status
) >= 0);
1160 memcpy (&pi
->prstatus
, &thread_status
.status
,
1161 sizeof (pi
->prstatus
));
1162 pi
->status_valid
= 1;
1166 /* Just read the danged status. Now isn't that simple? */
1167 pi
->status_valid
= (ioctl (pi
->status_fd
, PIOCSTATUS
, &pi
->prstatus
) >= 0);
1171 if (pi
->status_valid
)
1173 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1176 proc_get_current_thread (pi
));
1179 /* The status struct includes general regs, so mark them valid too. */
1180 pi
->gregs_valid
= pi
->status_valid
;
1182 /* In the read/write multiple-fd model, the status struct includes
1183 the fp regs too, so mark them valid too. */
1184 pi
->fpregs_valid
= pi
->status_valid
;
1186 return pi
->status_valid
; /* True if success, false if failure. */
1189 /* Returns the process flags (pr_flags field). */
1192 proc_flags (procinfo
*pi
)
1194 if (!pi
->status_valid
)
1195 if (!proc_get_status (pi
))
1196 return 0; /* FIXME: not a good failure value (but what is?) */
1200 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
1201 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
1202 The two sets of flags don't overlap. */
1203 return pi
->prstatus
.pr_flags
| pi
->prstatus
.pr_lwp
.pr_flags
;
1205 return pi
->prstatus
.pr_lwp
.pr_flags
;
1208 return pi
->prstatus
.pr_flags
;
1212 /* Returns the pr_why field (why the process stopped). */
1215 proc_why (procinfo
*pi
)
1217 if (!pi
->status_valid
)
1218 if (!proc_get_status (pi
))
1219 return 0; /* FIXME: not a good failure value (but what is?) */
1222 return pi
->prstatus
.pr_lwp
.pr_why
;
1224 return pi
->prstatus
.pr_why
;
1228 /* Returns the pr_what field (details of why the process stopped). */
1231 proc_what (procinfo
*pi
)
1233 if (!pi
->status_valid
)
1234 if (!proc_get_status (pi
))
1235 return 0; /* FIXME: not a good failure value (but what is?) */
1238 return pi
->prstatus
.pr_lwp
.pr_what
;
1240 return pi
->prstatus
.pr_what
;
1244 /* This function is only called when PI is stopped by a watchpoint.
1245 Assuming the OS supports it, write to *ADDR the data address which
1246 triggered it and return 1. Return 0 if it is not possible to know
1250 proc_watchpoint_address (procinfo
*pi
, CORE_ADDR
*addr
)
1252 if (!pi
->status_valid
)
1253 if (!proc_get_status (pi
))
1257 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch
,
1258 builtin_type (target_gdbarch
)->builtin_data_ptr
,
1259 (gdb_byte
*) &pi
->prstatus
.pr_lwp
.pr_info
.si_addr
);
1261 *addr
= (CORE_ADDR
) gdbarch_pointer_to_address (target_gdbarch
,
1262 builtin_type (target_gdbarch
)->builtin_data_ptr
,
1263 (gdb_byte
*) &pi
->prstatus
.pr_info
.si_addr
);
1268 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1270 /* Returns the pr_nsysarg field (number of args to the current
1274 proc_nsysarg (procinfo
*pi
)
1276 if (!pi
->status_valid
)
1277 if (!proc_get_status (pi
))
1281 return pi
->prstatus
.pr_lwp
.pr_nsysarg
;
1283 return pi
->prstatus
.pr_nsysarg
;
1287 /* Returns the pr_sysarg field (pointer to the arguments of current
1291 proc_sysargs (procinfo
*pi
)
1293 if (!pi
->status_valid
)
1294 if (!proc_get_status (pi
))
1298 return (long *) &pi
->prstatus
.pr_lwp
.pr_sysarg
;
1300 return (long *) &pi
->prstatus
.pr_sysarg
;
1304 /* Returns the pr_syscall field (id of current syscall if we are in
1308 proc_syscall (procinfo
*pi
)
1310 if (!pi
->status_valid
)
1311 if (!proc_get_status (pi
))
1315 return pi
->prstatus
.pr_lwp
.pr_syscall
;
1317 return pi
->prstatus
.pr_syscall
;
1320 #endif /* PIOCSSPCACT */
1322 /* Returns the pr_cursig field (current signal). */
1325 proc_cursig (struct procinfo
*pi
)
1327 if (!pi
->status_valid
)
1328 if (!proc_get_status (pi
))
1329 return 0; /* FIXME: not a good failure value (but what is?) */
1332 return pi
->prstatus
.pr_lwp
.pr_cursig
;
1334 return pi
->prstatus
.pr_cursig
;
1338 /* === I appologize for the messiness of this function.
1339 === This is an area where the different versions of
1340 === /proc are more inconsistent than usual.
1342 Set or reset any of the following process flags:
1343 PR_FORK -- forked child will inherit trace flags
1344 PR_RLC -- traced process runs when last /proc file closed.
1345 PR_KLC -- traced process is killed when last /proc file closed.
1346 PR_ASYNC -- LWP's get to run/stop independently.
1348 There are three methods for doing this function:
1349 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1351 2) Middle: PIOCSET/PIOCRESET
1353 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1356 Note: Irix does not define PR_ASYNC.
1357 Note: OSF does not define PR_KLC.
1358 Note: OSF is the only one that can ONLY use the oldest method.
1362 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1363 mode -- 1 for set, 0 for reset.
1365 Returns non-zero for success, zero for failure. */
1367 enum { FLAG_RESET
, FLAG_SET
};
1370 proc_modify_flag (procinfo
*pi
, long flag
, long mode
)
1372 long win
= 0; /* default to fail */
1374 /* These operations affect the process as a whole, and applying them
1375 to an individual LWP has the same meaning as applying them to the
1376 main process. Therefore, if we're ever called with a pointer to
1377 an LWP's procinfo, let's substitute the process's procinfo and
1378 avoid opening the LWP's file descriptor unnecessarily. */
1381 pi
= find_procinfo_or_die (pi
->pid
, 0);
1383 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii. */
1384 /* First normalize the PCUNSET/PCRESET command opcode
1385 (which for no obvious reason has a different definition
1386 from one operating system to the next...) */
1388 #define GDBRESET PCUNSET
1391 #define GDBRESET PCRESET
1395 procfs_ctl_t arg
[2];
1397 if (mode
== FLAG_SET
) /* Set the flag (RLC, FORK, or ASYNC). */
1399 else /* Reset the flag. */
1403 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1406 #ifdef PIOCSET /* Irix/Sol5 method */
1407 if (mode
== FLAG_SET
) /* Set the flag (hopefully RLC, FORK, or ASYNC). */
1409 win
= (ioctl (pi
->ctl_fd
, PIOCSET
, &flag
) >= 0);
1411 else /* Reset the flag. */
1413 win
= (ioctl (pi
->ctl_fd
, PIOCRESET
, &flag
) >= 0);
1417 #ifdef PIOCSRLC /* Oldest method: OSF */
1420 if (mode
== FLAG_SET
) /* Set run-on-last-close */
1422 win
= (ioctl (pi
->ctl_fd
, PIOCSRLC
, NULL
) >= 0);
1424 else /* Clear run-on-last-close */
1426 win
= (ioctl (pi
->ctl_fd
, PIOCRRLC
, NULL
) >= 0);
1430 if (mode
== FLAG_SET
) /* Set inherit-on-fork */
1432 win
= (ioctl (pi
->ctl_fd
, PIOCSFORK
, NULL
) >= 0);
1434 else /* Clear inherit-on-fork */
1436 win
= (ioctl (pi
->ctl_fd
, PIOCRFORK
, NULL
) >= 0);
1440 win
= 0; /* Fail -- unknown flag (can't do PR_ASYNC). */
1447 /* The above operation renders the procinfo's cached pstatus
1449 pi
->status_valid
= 0;
1452 warning (_("procfs: modify_flag failed to turn %s %s"),
1453 flag
== PR_FORK
? "PR_FORK" :
1454 flag
== PR_RLC
? "PR_RLC" :
1456 flag
== PR_ASYNC
? "PR_ASYNC" :
1459 flag
== PR_KLC
? "PR_KLC" :
1462 mode
== FLAG_RESET
? "off" : "on");
1467 /* Set the run_on_last_close flag. Process with all threads will
1468 become runnable when debugger closes all /proc fds. Returns
1469 non-zero for success, zero for failure. */
1472 proc_set_run_on_last_close (procinfo
*pi
)
1474 return proc_modify_flag (pi
, PR_RLC
, FLAG_SET
);
1477 /* Reset the run_on_last_close flag. The process will NOT become
1478 runnable when debugger closes its file handles. Returns non-zero
1479 for success, zero for failure. */
1482 proc_unset_run_on_last_close (procinfo
*pi
)
1484 return proc_modify_flag (pi
, PR_RLC
, FLAG_RESET
);
1488 /* Set the kill_on_last_close flag. Process with all threads will be
1489 killed when debugger closes all /proc fds (or debugger exits or
1490 dies). Returns non-zero for success, zero for failure. */
1493 proc_set_kill_on_last_close (procinfo
*pi
)
1495 return proc_modify_flag (pi
, PR_KLC
, FLAG_SET
);
1498 /* Reset the kill_on_last_close flag. Process will NOT be killed when
1499 debugger closes its file handles (or exits or dies). Returns
1500 non-zero for success, zero for failure. */
1503 proc_unset_kill_on_last_close (procinfo
*pi
)
1505 return proc_modify_flag (pi
, PR_KLC
, FLAG_RESET
);
1509 /* Set inherit_on_fork flag. If the process forks a child while we
1510 are registered for events in the parent, then we will also recieve
1511 events from the child. Returns non-zero for success, zero for
1515 proc_set_inherit_on_fork (procinfo
*pi
)
1517 return proc_modify_flag (pi
, PR_FORK
, FLAG_SET
);
1520 /* Reset inherit_on_fork flag. If the process forks a child while we
1521 are registered for events in the parent, then we will NOT recieve
1522 events from the child. Returns non-zero for success, zero for
1526 proc_unset_inherit_on_fork (procinfo
*pi
)
1528 return proc_modify_flag (pi
, PR_FORK
, FLAG_RESET
);
1532 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
1533 (signal etc.), the remaining LWPs will continue to run. Returns
1534 non-zero for success, zero for failure. */
1537 proc_set_async (procinfo
*pi
)
1539 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_SET
);
1542 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
1543 (signal etc.), then all other LWPs will stop as well. Returns
1544 non-zero for success, zero for failure. */
1547 proc_unset_async (procinfo
*pi
)
1549 return proc_modify_flag (pi
, PR_ASYNC
, FLAG_RESET
);
1551 #endif /* PR_ASYNC */
1553 /* Request the process/LWP to stop. Does not wait. Returns non-zero
1554 for success, zero for failure. */
1557 proc_stop_process (procinfo
*pi
)
1561 /* We might conceivably apply this operation to an LWP, and the
1562 LWP's ctl file descriptor might not be open. */
1564 if (pi
->ctl_fd
== 0 &&
1565 open_procinfo_files (pi
, FD_CTL
) == 0)
1570 procfs_ctl_t cmd
= PCSTOP
;
1572 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1573 #else /* ioctl method */
1574 win
= (ioctl (pi
->ctl_fd
, PIOCSTOP
, &pi
->prstatus
) >= 0);
1575 /* Note: the call also reads the prstatus. */
1578 pi
->status_valid
= 1;
1579 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1582 proc_get_current_thread (pi
));
1590 /* Wait for the process or LWP to stop (block until it does). Returns
1591 non-zero for success, zero for failure. */
1594 proc_wait_for_stop (procinfo
*pi
)
1598 /* We should never have to apply this operation to any procinfo
1599 except the one for the main process. If that ever changes for
1600 any reason, then take out the following clause and replace it
1601 with one that makes sure the ctl_fd is open. */
1604 pi
= find_procinfo_or_die (pi
->pid
, 0);
1608 procfs_ctl_t cmd
= PCWSTOP
;
1610 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1611 /* We been runnin' and we stopped -- need to update status. */
1612 pi
->status_valid
= 0;
1614 #else /* ioctl method */
1615 win
= (ioctl (pi
->ctl_fd
, PIOCWSTOP
, &pi
->prstatus
) >= 0);
1616 /* Above call also refreshes the prstatus. */
1619 pi
->status_valid
= 1;
1620 PROC_PRETTYFPRINT_STATUS (proc_flags (pi
),
1623 proc_get_current_thread (pi
));
1630 /* Make the process or LWP runnable.
1632 Options (not all are implemented):
1634 - clear current fault
1635 - clear current signal
1636 - abort the current system call
1637 - stop as soon as finished with system call
1638 - (ioctl): set traced signal set
1639 - (ioctl): set held signal set
1640 - (ioctl): set traced fault set
1641 - (ioctl): set start pc (vaddr)
1643 Always clears the current fault. PI is the process or LWP to
1644 operate on. If STEP is true, set the process or LWP to trap after
1645 one instruction. If SIGNO is zero, clear the current signal if
1646 any; if non-zero, set the current signal to this one. Returns
1647 non-zero for success, zero for failure. */
1650 proc_run_process (procinfo
*pi
, int step
, int signo
)
1655 /* We will probably have to apply this operation to individual
1656 threads, so make sure the control file descriptor is open. */
1658 if (pi
->ctl_fd
== 0 &&
1659 open_procinfo_files (pi
, FD_CTL
) == 0)
1664 runflags
= PRCFAULT
; /* Always clear current fault. */
1669 else if (signo
!= -1) /* -1 means do nothing W.R.T. signals. */
1670 proc_set_current_signal (pi
, signo
);
1674 procfs_ctl_t cmd
[2];
1678 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
1680 #else /* ioctl method */
1684 memset (&prrun
, 0, sizeof (prrun
));
1685 prrun
.pr_flags
= runflags
;
1686 win
= (ioctl (pi
->ctl_fd
, PIOCRUN
, &prrun
) >= 0);
1693 /* Register to trace signals in the process or LWP. Returns non-zero
1694 for success, zero for failure. */
1697 proc_set_traced_signals (procinfo
*pi
, gdb_sigset_t
*sigset
)
1701 /* We should never have to apply this operation to any procinfo
1702 except the one for the main process. If that ever changes for
1703 any reason, then take out the following clause and replace it
1704 with one that makes sure the ctl_fd is open. */
1707 pi
= find_procinfo_or_die (pi
->pid
, 0);
1713 /* Use char array to avoid alignment issues. */
1714 char sigset
[sizeof (gdb_sigset_t
)];
1718 memcpy (&arg
.sigset
, sigset
, sizeof (gdb_sigset_t
));
1720 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1722 #else /* ioctl method */
1723 win
= (ioctl (pi
->ctl_fd
, PIOCSTRACE
, sigset
) >= 0);
1725 /* The above operation renders the procinfo's cached pstatus obsolete. */
1726 pi
->status_valid
= 0;
1729 warning (_("procfs: set_traced_signals failed"));
1733 /* Register to trace hardware faults in the process or LWP. Returns
1734 non-zero for success, zero for failure. */
1737 proc_set_traced_faults (procinfo
*pi
, fltset_t
*fltset
)
1741 /* We should never have to apply this operation to any procinfo
1742 except the one for the main process. If that ever changes for
1743 any reason, then take out the following clause and replace it
1744 with one that makes sure the ctl_fd is open. */
1747 pi
= find_procinfo_or_die (pi
->pid
, 0);
1753 /* Use char array to avoid alignment issues. */
1754 char fltset
[sizeof (fltset_t
)];
1758 memcpy (&arg
.fltset
, fltset
, sizeof (fltset_t
));
1760 win
= (write (pi
->ctl_fd
, (char *) &arg
, sizeof (arg
)) == sizeof (arg
));
1762 #else /* ioctl method */
1763 win
= (ioctl (pi
->ctl_fd
, PIOCSFAULT
, fltset
) >= 0);
1765 /* The above operation renders the procinfo's cached pstatus obsolete. */
1766 pi
->status_valid
= 0;
1771 /* Register to trace entry to system calls in the process or LWP.
1772 Returns non-zero for success, zero for failure. */
1775 proc_set_traced_sysentry (procinfo
*pi
, sysset_t
*sysset
)
1779 /* We should never have to apply this operation to any procinfo
1780 except the one for the main process. If that ever changes for
1781 any reason, then take out the following clause and replace it
1782 with one that makes sure the ctl_fd is open. */
1785 pi
= find_procinfo_or_die (pi
->pid
, 0);
1789 struct gdb_proc_ctl_pcsentry
{
1791 /* Use char array to avoid alignment issues. */
1792 char sysset
[sizeof (sysset_t
)];
1794 int argp_size
= sizeof (struct gdb_proc_ctl_pcsentry
)
1796 + sysset_t_size (pi
);
1798 argp
= xmalloc (argp_size
);
1800 argp
->cmd
= PCSENTRY
;
1801 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1803 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1806 #else /* ioctl method */
1807 win
= (ioctl (pi
->ctl_fd
, PIOCSENTRY
, sysset
) >= 0);
1809 /* The above operation renders the procinfo's cached pstatus
1811 pi
->status_valid
= 0;
1816 /* Register to trace exit from system calls in the process or LWP.
1817 Returns non-zero for success, zero for failure. */
1820 proc_set_traced_sysexit (procinfo
*pi
, sysset_t
*sysset
)
1824 /* We should never have to apply this operation to any procinfo
1825 except the one for the main process. If that ever changes for
1826 any reason, then take out the following clause and replace it
1827 with one that makes sure the ctl_fd is open. */
1830 pi
= find_procinfo_or_die (pi
->pid
, 0);
1834 struct gdb_proc_ctl_pcsexit
{
1836 /* Use char array to avoid alignment issues. */
1837 char sysset
[sizeof (sysset_t
)];
1839 int argp_size
= sizeof (struct gdb_proc_ctl_pcsexit
)
1841 + sysset_t_size (pi
);
1843 argp
= xmalloc (argp_size
);
1845 argp
->cmd
= PCSEXIT
;
1846 memcpy (&argp
->sysset
, sysset
, sysset_t_size (pi
));
1848 win
= (write (pi
->ctl_fd
, (char *) argp
, argp_size
) == argp_size
);
1851 #else /* ioctl method */
1852 win
= (ioctl (pi
->ctl_fd
, PIOCSEXIT
, sysset
) >= 0);
1854 /* The above operation renders the procinfo's cached pstatus
1856 pi
->status_valid
= 0;
1861 /* Specify the set of blocked / held signals in the process or LWP.
1862 Returns non-zero for success, zero for failure. */
1865 proc_set_held_signals (procinfo
*pi
, gdb_sigset_t
*sighold
)
1869 /* We should never have to apply this operation to any procinfo
1870 except the one for the main process. If that ever changes for
1871 any reason, then take out the following clause and replace it
1872 with one that makes sure the ctl_fd is open. */
1875 pi
= find_procinfo_or_die (pi
->pid
, 0);
1881 /* Use char array to avoid alignment issues. */
1882 char hold
[sizeof (gdb_sigset_t
)];
1886 memcpy (&arg
.hold
, sighold
, sizeof (gdb_sigset_t
));
1887 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
1890 win
= (ioctl (pi
->ctl_fd
, PIOCSHOLD
, sighold
) >= 0);
1892 /* The above operation renders the procinfo's cached pstatus
1894 pi
->status_valid
= 0;
1899 /* Returns the set of signals that are pending in the process or LWP.
1900 Will also copy the sigset if SAVE is non-zero. */
1903 proc_get_pending_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1905 gdb_sigset_t
*ret
= NULL
;
1907 /* We should never have to apply this operation to any procinfo
1908 except the one for the main process. If that ever changes for
1909 any reason, then take out the following clause and replace it
1910 with one that makes sure the ctl_fd is open. */
1913 pi
= find_procinfo_or_die (pi
->pid
, 0);
1915 if (!pi
->status_valid
)
1916 if (!proc_get_status (pi
))
1920 ret
= &pi
->prstatus
.pr_lwp
.pr_lwppend
;
1922 ret
= &pi
->prstatus
.pr_sigpend
;
1925 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
1930 /* Returns the set of signal actions. Will also copy the sigactionset
1931 if SAVE is non-zero. */
1934 proc_get_signal_actions (procinfo
*pi
, gdb_sigaction_t
*save
)
1936 gdb_sigaction_t
*ret
= NULL
;
1938 /* We should never have to apply this operation to any procinfo
1939 except the one for the main process. If that ever changes for
1940 any reason, then take out the following clause and replace it
1941 with one that makes sure the ctl_fd is open. */
1944 pi
= find_procinfo_or_die (pi
->pid
, 0);
1946 if (!pi
->status_valid
)
1947 if (!proc_get_status (pi
))
1951 ret
= &pi
->prstatus
.pr_lwp
.pr_action
;
1953 ret
= &pi
->prstatus
.pr_action
;
1956 memcpy (save
, ret
, sizeof (gdb_sigaction_t
));
1961 /* Returns the set of signals that are held / blocked. Will also copy
1962 the sigset if SAVE is non-zero. */
1965 proc_get_held_signals (procinfo
*pi
, gdb_sigset_t
*save
)
1967 gdb_sigset_t
*ret
= NULL
;
1969 /* We should never have to apply this operation to any procinfo
1970 except the one for the main process. If that ever changes for
1971 any reason, then take out the following clause and replace it
1972 with one that makes sure the ctl_fd is open. */
1975 pi
= find_procinfo_or_die (pi
->pid
, 0);
1978 if (!pi
->status_valid
)
1979 if (!proc_get_status (pi
))
1983 ret
= &pi
->prstatus
.pr_lwp
.pr_context
.uc_sigmask
;
1985 ret
= &pi
->prstatus
.pr_lwp
.pr_lwphold
;
1986 #endif /* UNIXWARE */
1987 #else /* not NEW_PROC_API */
1989 static gdb_sigset_t sigheld
;
1991 if (ioctl (pi
->ctl_fd
, PIOCGHOLD
, &sigheld
) >= 0)
1994 #endif /* NEW_PROC_API */
1996 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
2001 /* Returns the set of signals that are traced / debugged. Will also
2002 copy the sigset if SAVE is non-zero. */
2005 proc_get_traced_signals (procinfo
*pi
, gdb_sigset_t
*save
)
2007 gdb_sigset_t
*ret
= NULL
;
2009 /* We should never have to apply this operation to any procinfo
2010 except the one for the main process. If that ever changes for
2011 any reason, then take out the following clause and replace it
2012 with one that makes sure the ctl_fd is open. */
2015 pi
= find_procinfo_or_die (pi
->pid
, 0);
2018 if (!pi
->status_valid
)
2019 if (!proc_get_status (pi
))
2022 ret
= &pi
->prstatus
.pr_sigtrace
;
2025 static gdb_sigset_t sigtrace
;
2027 if (ioctl (pi
->ctl_fd
, PIOCGTRACE
, &sigtrace
) >= 0)
2032 memcpy (save
, ret
, sizeof (gdb_sigset_t
));
2037 /* Add SIGNO to the set of signals that are traced. Returns non-zero
2038 for success, zero for failure. */
2041 proc_trace_signal (procinfo
*pi
, int signo
)
2045 /* We should never have to apply this operation to any procinfo
2046 except the one for the main process. If that ever changes for
2047 any reason, then take out the following clause and replace it
2048 with one that makes sure the ctl_fd is open. */
2051 pi
= find_procinfo_or_die (pi
->pid
, 0);
2055 if (proc_get_traced_signals (pi
, &temp
))
2057 gdb_praddset (&temp
, signo
);
2058 return proc_set_traced_signals (pi
, &temp
);
2062 return 0; /* failure */
2065 /* Remove SIGNO from the set of signals that are traced. Returns
2066 non-zero for success, zero for failure. */
2069 proc_ignore_signal (procinfo
*pi
, int signo
)
2073 /* We should never have to apply this operation to any procinfo
2074 except the one for the main process. If that ever changes for
2075 any reason, then take out the following clause and replace it
2076 with one that makes sure the ctl_fd is open. */
2079 pi
= find_procinfo_or_die (pi
->pid
, 0);
2083 if (proc_get_traced_signals (pi
, &temp
))
2085 gdb_prdelset (&temp
, signo
);
2086 return proc_set_traced_signals (pi
, &temp
);
2090 return 0; /* failure */
2093 /* Returns the set of hardware faults that are traced /debugged. Will
2094 also copy the faultset if SAVE is non-zero. */
2097 proc_get_traced_faults (procinfo
*pi
, fltset_t
*save
)
2099 fltset_t
*ret
= NULL
;
2101 /* We should never have to apply this operation to any procinfo
2102 except the one for the main process. If that ever changes for
2103 any reason, then take out the following clause and replace it
2104 with one that makes sure the ctl_fd is open. */
2107 pi
= find_procinfo_or_die (pi
->pid
, 0);
2110 if (!pi
->status_valid
)
2111 if (!proc_get_status (pi
))
2114 ret
= &pi
->prstatus
.pr_flttrace
;
2117 static fltset_t flttrace
;
2119 if (ioctl (pi
->ctl_fd
, PIOCGFAULT
, &flttrace
) >= 0)
2124 memcpy (save
, ret
, sizeof (fltset_t
));
2129 /* Returns the set of syscalls that are traced /debugged on entry.
2130 Will also copy the syscall set if SAVE is non-zero. */
2133 proc_get_traced_sysentry (procinfo
*pi
, sysset_t
*save
)
2135 sysset_t
*ret
= NULL
;
2137 /* We should never have to apply this operation to any procinfo
2138 except the one for the main process. If that ever changes for
2139 any reason, then take out the following clause and replace it
2140 with one that makes sure the ctl_fd is open. */
2143 pi
= find_procinfo_or_die (pi
->pid
, 0);
2146 if (!pi
->status_valid
)
2147 if (!proc_get_status (pi
))
2150 #ifndef DYNAMIC_SYSCALLS
2151 ret
= &pi
->prstatus
.pr_sysentry
;
2152 #else /* DYNAMIC_SYSCALLS */
2154 static sysset_t
*sysentry
;
2158 sysentry
= sysset_t_alloc (pi
);
2160 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2162 if (pi
->prstatus
.pr_sysentry_offset
== 0)
2164 gdb_premptysysset (sysentry
);
2170 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysentry_offset
,
2172 != (off_t
) pi
->prstatus
.pr_sysentry_offset
)
2174 size
= sysset_t_size (pi
);
2175 gdb_premptysysset (sysentry
);
2176 rsize
= read (pi
->status_fd
, sysentry
, size
);
2181 #endif /* DYNAMIC_SYSCALLS */
2182 #else /* !NEW_PROC_API */
2184 static sysset_t sysentry
;
2186 if (ioctl (pi
->ctl_fd
, PIOCGENTRY
, &sysentry
) >= 0)
2189 #endif /* NEW_PROC_API */
2191 memcpy (save
, ret
, sysset_t_size (pi
));
2196 /* Returns the set of syscalls that are traced /debugged on exit.
2197 Will also copy the syscall set if SAVE is non-zero. */
2200 proc_get_traced_sysexit (procinfo
*pi
, sysset_t
*save
)
2202 sysset_t
* ret
= NULL
;
2204 /* We should never have to apply this operation to any procinfo
2205 except the one for the main process. If that ever changes for
2206 any reason, then take out the following clause and replace it
2207 with one that makes sure the ctl_fd is open. */
2210 pi
= find_procinfo_or_die (pi
->pid
, 0);
2213 if (!pi
->status_valid
)
2214 if (!proc_get_status (pi
))
2217 #ifndef DYNAMIC_SYSCALLS
2218 ret
= &pi
->prstatus
.pr_sysexit
;
2219 #else /* DYNAMIC_SYSCALLS */
2221 static sysset_t
*sysexit
;
2225 sysexit
= sysset_t_alloc (pi
);
2227 if (pi
->status_fd
== 0 && open_procinfo_files (pi
, FD_STATUS
) == 0)
2229 if (pi
->prstatus
.pr_sysexit_offset
== 0)
2231 gdb_premptysysset (sysexit
);
2237 if (lseek (pi
->status_fd
, (off_t
) pi
->prstatus
.pr_sysexit_offset
,
2239 != (off_t
) pi
->prstatus
.pr_sysexit_offset
)
2241 size
= sysset_t_size (pi
);
2242 gdb_premptysysset (sysexit
);
2243 rsize
= read (pi
->status_fd
, sysexit
, size
);
2248 #endif /* DYNAMIC_SYSCALLS */
2251 static sysset_t sysexit
;
2253 if (ioctl (pi
->ctl_fd
, PIOCGEXIT
, &sysexit
) >= 0)
2258 memcpy (save
, ret
, sysset_t_size (pi
));
2263 /* The current fault (if any) is cleared; the associated signal will
2264 not be sent to the process or LWP when it resumes. Returns
2265 non-zero for success, zero for failure. */
2268 proc_clear_current_fault (procinfo
*pi
)
2272 /* We should never have to apply this operation to any procinfo
2273 except the one for the main process. If that ever changes for
2274 any reason, then take out the following clause and replace it
2275 with one that makes sure the ctl_fd is open. */
2278 pi
= find_procinfo_or_die (pi
->pid
, 0);
2282 procfs_ctl_t cmd
= PCCFAULT
;
2284 win
= (write (pi
->ctl_fd
, (void *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2287 win
= (ioctl (pi
->ctl_fd
, PIOCCFAULT
, 0) >= 0);
2293 /* Set the "current signal" that will be delivered next to the
2294 process. NOTE: semantics are different from those of KILL. This
2295 signal will be delivered to the process or LWP immediately when it
2296 is resumed (even if the signal is held/blocked); it will NOT
2297 immediately cause another event of interest, and will NOT first
2298 trap back to the debugger. Returns non-zero for success, zero for
2302 proc_set_current_signal (procinfo
*pi
, int signo
)
2307 /* Use char array to avoid alignment issues. */
2308 char sinfo
[sizeof (gdb_siginfo_t
)];
2310 gdb_siginfo_t mysinfo
;
2312 struct target_waitstatus wait_status
;
2314 /* We should never have to apply this operation to any procinfo
2315 except the one for the main process. If that ever changes for
2316 any reason, then take out the following clause and replace it
2317 with one that makes sure the ctl_fd is open. */
2320 pi
= find_procinfo_or_die (pi
->pid
, 0);
2322 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2323 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2324 receives a PIOCSSIG with a signal identical to the current
2325 signal, it messes up the current signal. Work around the kernel
2328 signo
== proc_cursig (pi
))
2329 return 1; /* I assume this is a success? */
2332 /* The pointer is just a type alias. */
2333 get_last_target_status (&wait_ptid
, &wait_status
);
2334 if (ptid_equal (wait_ptid
, inferior_ptid
)
2335 && wait_status
.kind
== TARGET_WAITKIND_STOPPED
2336 && wait_status
.value
.sig
== target_signal_from_host (signo
)
2337 && proc_get_status (pi
)
2339 && pi
->prstatus
.pr_lwp
.pr_info
.si_signo
== signo
2341 && pi
->prstatus
.pr_info
.si_signo
== signo
2344 /* Use the siginfo associated with the signal being
2347 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_lwp
.pr_info
, sizeof (gdb_siginfo_t
));
2349 memcpy (arg
.sinfo
, &pi
->prstatus
.pr_info
, sizeof (gdb_siginfo_t
));
2353 mysinfo
.si_signo
= signo
;
2354 mysinfo
.si_code
= 0;
2355 mysinfo
.si_pid
= getpid (); /* ?why? */
2356 mysinfo
.si_uid
= getuid (); /* ?why? */
2357 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2362 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2364 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, (void *) &arg
.sinfo
) >= 0);
2370 /* The current signal (if any) is cleared, and is not sent to the
2371 process or LWP when it resumes. Returns non-zero for success, zero
2375 proc_clear_current_signal (procinfo
*pi
)
2379 /* We should never have to apply this operation to any procinfo
2380 except the one for the main process. If that ever changes for
2381 any reason, then take out the following clause and replace it
2382 with one that makes sure the ctl_fd is open. */
2385 pi
= find_procinfo_or_die (pi
->pid
, 0);
2391 /* Use char array to avoid alignment issues. */
2392 char sinfo
[sizeof (gdb_siginfo_t
)];
2394 gdb_siginfo_t mysinfo
;
2397 /* The pointer is just a type alias. */
2398 mysinfo
.si_signo
= 0;
2399 mysinfo
.si_code
= 0;
2400 mysinfo
.si_errno
= 0;
2401 mysinfo
.si_pid
= getpid (); /* ?why? */
2402 mysinfo
.si_uid
= getuid (); /* ?why? */
2403 memcpy (arg
.sinfo
, &mysinfo
, sizeof (gdb_siginfo_t
));
2405 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2408 win
= (ioctl (pi
->ctl_fd
, PIOCSSIG
, 0) >= 0);
2414 /* Return the general-purpose registers for the process or LWP
2415 corresponding to PI. Upon failure, return NULL. */
2418 proc_get_gregs (procinfo
*pi
)
2420 if (!pi
->status_valid
|| !pi
->gregs_valid
)
2421 if (!proc_get_status (pi
))
2424 /* OK, sorry about the ifdef's. There's three cases instead of two,
2425 because in this case Unixware and Solaris/RW differ. */
2428 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2429 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.gregs
;
2431 return &pi
->prstatus
.pr_lwp
.pr_reg
;
2434 return &pi
->prstatus
.pr_reg
;
2438 /* Return the general-purpose registers for the process or LWP
2439 corresponding to PI. Upon failure, return NULL. */
2442 proc_get_fpregs (procinfo
*pi
)
2445 if (!pi
->status_valid
|| !pi
->fpregs_valid
)
2446 if (!proc_get_status (pi
))
2449 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2450 return &pi
->prstatus
.pr_lwp
.pr_context
.uc_mcontext
.fpregs
;
2452 return &pi
->prstatus
.pr_lwp
.pr_fpreg
;
2455 #else /* not NEW_PROC_API */
2456 if (pi
->fpregs_valid
)
2457 return &pi
->fpregset
; /* Already got 'em. */
2460 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2469 tid_t pr_error_thread
;
2470 tfpregset_t thread_1
;
2473 thread_fpregs
.pr_count
= 1;
2474 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2477 && ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2479 pi
->fpregs_valid
= 1;
2480 return &pi
->fpregset
; /* Got 'em now! */
2482 else if (pi
->tid
!= 0
2483 && ioctl (pi
->ctl_fd
, PIOCTGFPREG
, &thread_fpregs
) >= 0)
2485 memcpy (&pi
->fpregset
, &thread_fpregs
.thread_1
.pr_fpregs
,
2486 sizeof (pi
->fpregset
));
2487 pi
->fpregs_valid
= 1;
2488 return &pi
->fpregset
; /* Got 'em now! */
2495 if (ioctl (pi
->ctl_fd
, PIOCGFPREG
, &pi
->fpregset
) >= 0)
2497 pi
->fpregs_valid
= 1;
2498 return &pi
->fpregset
; /* Got 'em now! */
2507 #endif /* NEW_PROC_API */
2510 /* Write the general-purpose registers back to the process or LWP
2511 corresponding to PI. Return non-zero for success, zero for
2515 proc_set_gregs (procinfo
*pi
)
2517 gdb_gregset_t
*gregs
;
2520 gregs
= proc_get_gregs (pi
);
2522 return 0; /* proc_get_regs has already warned. */
2524 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2533 /* Use char array to avoid alignment issues. */
2534 char gregs
[sizeof (gdb_gregset_t
)];
2538 memcpy (&arg
.gregs
, gregs
, sizeof (arg
.gregs
));
2539 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2541 win
= (ioctl (pi
->ctl_fd
, PIOCSREG
, gregs
) >= 0);
2545 /* Policy: writing the registers invalidates our cache. */
2546 pi
->gregs_valid
= 0;
2550 /* Write the floating-pointer registers back to the process or LWP
2551 corresponding to PI. Return non-zero for success, zero for
2555 proc_set_fpregs (procinfo
*pi
)
2557 gdb_fpregset_t
*fpregs
;
2560 fpregs
= proc_get_fpregs (pi
);
2562 return 0; /* proc_get_fpregs has already warned. */
2564 if (pi
->ctl_fd
== 0 && open_procinfo_files (pi
, FD_CTL
) == 0)
2573 /* Use char array to avoid alignment issues. */
2574 char fpregs
[sizeof (gdb_fpregset_t
)];
2578 memcpy (&arg
.fpregs
, fpregs
, sizeof (arg
.fpregs
));
2579 win
= (write (pi
->ctl_fd
, (void *) &arg
, sizeof (arg
)) == sizeof (arg
));
2583 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2588 tid_t pr_error_thread
;
2589 tfpregset_t thread_1
;
2592 thread_fpregs
.pr_count
= 1;
2593 thread_fpregs
.thread_1
.tid
= pi
->tid
;
2594 memcpy (&thread_fpregs
.thread_1
.pr_fpregs
, fpregs
,
2596 win
= (ioctl (pi
->ctl_fd
, PIOCTSFPREG
, &thread_fpregs
) >= 0);
2599 win
= (ioctl (pi
->ctl_fd
, PIOCSFPREG
, fpregs
) >= 0);
2601 #endif /* NEW_PROC_API */
2604 /* Policy: writing the registers invalidates our cache. */
2605 pi
->fpregs_valid
= 0;
2609 /* Send a signal to the proc or lwp with the semantics of "kill()".
2610 Returns non-zero for success, zero for failure. */
2613 proc_kill (procinfo
*pi
, int signo
)
2617 /* We might conceivably apply this operation to an LWP, and the
2618 LWP's ctl file descriptor might not be open. */
2620 if (pi
->ctl_fd
== 0 &&
2621 open_procinfo_files (pi
, FD_CTL
) == 0)
2628 procfs_ctl_t cmd
[2];
2632 win
= (write (pi
->ctl_fd
, (char *) &cmd
, sizeof (cmd
)) == sizeof (cmd
));
2633 #else /* ioctl method */
2634 /* FIXME: do I need the Alpha OSF fixups present in
2635 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2636 win
= (ioctl (pi
->ctl_fd
, PIOCKILL
, &signo
) >= 0);
2643 /* Find the pid of the process that started this one. Returns the
2644 parent process pid, or zero. */
2647 proc_parent_pid (procinfo
*pi
)
2649 /* We should never have to apply this operation to any procinfo
2650 except the one for the main process. If that ever changes for
2651 any reason, then take out the following clause and replace it
2652 with one that makes sure the ctl_fd is open. */
2655 pi
= find_procinfo_or_die (pi
->pid
, 0);
2657 if (!pi
->status_valid
)
2658 if (!proc_get_status (pi
))
2661 return pi
->prstatus
.pr_ppid
;
2664 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
2665 (a.k.a void pointer)! */
2667 #if (defined (PCWATCH) || defined (PIOCSWATCH)) \
2668 && !(defined (PIOCOPENLWP) || defined (UNIXWARE))
2670 procfs_address_to_host_pointer (CORE_ADDR addr
)
2672 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
2675 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (ptr_type
));
2676 gdbarch_address_to_pointer (target_gdbarch
, ptr_type
,
2677 (gdb_byte
*) &ptr
, addr
);
2683 proc_set_watchpoint (procinfo
*pi
, CORE_ADDR addr
, int len
, int wflags
)
2685 #if !defined (PCWATCH) && !defined (PIOCSWATCH)
2686 /* If neither or these is defined, we can't support watchpoints.
2687 This just avoids possibly failing to compile the below on such
2691 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5. */
2692 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out. */
2697 char watch
[sizeof (prwatch_t
)];
2701 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
2702 convert a target address into something that can be stored in a
2703 native data structure. */
2704 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
2705 pwatch
.pr_vaddr
= (uintptr_t) procfs_address_to_host_pointer (addr
);
2707 pwatch
.pr_vaddr
= (caddr_t
) procfs_address_to_host_pointer (addr
);
2709 pwatch
.pr_size
= len
;
2710 pwatch
.pr_wflags
= wflags
;
2711 #if defined(NEW_PROC_API) && defined (PCWATCH)
2713 memcpy (arg
.watch
, &pwatch
, sizeof (prwatch_t
));
2714 return (write (pi
->ctl_fd
, &arg
, sizeof (arg
)) == sizeof (arg
));
2716 #if defined (PIOCSWATCH)
2717 return (ioctl (pi
->ctl_fd
, PIOCSWATCH
, &pwatch
) >= 0);
2719 return 0; /* Fail */
2726 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
2728 #include <sys/sysi86.h>
2730 /* The KEY is actually the value of the lower 16 bits of the GS
2731 register for the LWP that we're interested in. Returns the
2732 matching ssh struct (LDT entry). */
2735 proc_get_LDT_entry (procinfo
*pi
, int key
)
2737 static struct ssd
*ldt_entry
= NULL
;
2739 char pathname
[MAX_PROC_NAME_SIZE
];
2740 struct cleanup
*old_chain
= NULL
;
2743 /* Allocate space for one LDT entry.
2744 This alloc must persist, because we return a pointer to it. */
2745 if (ldt_entry
== NULL
)
2746 ldt_entry
= (struct ssd
*) xmalloc (sizeof (struct ssd
));
2748 /* Open the file descriptor for the LDT table. */
2749 sprintf (pathname
, "/proc/%d/ldt", pi
->pid
);
2750 if ((fd
= open_with_retry (pathname
, O_RDONLY
)) < 0)
2752 proc_warn (pi
, "proc_get_LDT_entry (open)", __LINE__
);
2755 /* Make sure it gets closed again! */
2756 old_chain
= make_cleanup_close (fd
);
2758 /* Now 'read' thru the table, find a match and return it. */
2759 while (read (fd
, ldt_entry
, sizeof (struct ssd
)) == sizeof (struct ssd
))
2761 if (ldt_entry
->sel
== 0 &&
2762 ldt_entry
->bo
== 0 &&
2763 ldt_entry
->acc1
== 0 &&
2764 ldt_entry
->acc2
== 0)
2765 break; /* end of table */
2766 /* If key matches, return this entry. */
2767 if (ldt_entry
->sel
== key
)
2770 /* Loop ended, match not found. */
2774 static int nalloc
= 0;
2776 /* Get the number of LDT entries. */
2777 if (ioctl (pi
->ctl_fd
, PIOCNLDT
, &nldt
) < 0)
2779 proc_warn (pi
, "proc_get_LDT_entry (PIOCNLDT)", __LINE__
);
2783 /* Allocate space for the number of LDT entries. */
2784 /* This alloc has to persist, 'cause we return a pointer to it. */
2787 ldt_entry
= (struct ssd
*)
2788 xrealloc (ldt_entry
, (nldt
+ 1) * sizeof (struct ssd
));
2792 /* Read the whole table in one gulp. */
2793 if (ioctl (pi
->ctl_fd
, PIOCLDT
, ldt_entry
) < 0)
2795 proc_warn (pi
, "proc_get_LDT_entry (PIOCLDT)", __LINE__
);
2799 /* Search the table and return the (first) entry matching 'key'. */
2800 for (i
= 0; i
< nldt
; i
++)
2801 if (ldt_entry
[i
].sel
== key
)
2802 return &ldt_entry
[i
];
2804 /* Loop ended, match not found. */
2809 /* Returns the pointer to the LDT entry of PTID. */
2812 procfs_find_LDT_entry (ptid_t ptid
)
2814 gdb_gregset_t
*gregs
;
2818 /* Find procinfo for the lwp. */
2819 if ((pi
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
))) == NULL
)
2821 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
2822 PIDGET (ptid
), TIDGET (ptid
));
2825 /* get its general registers. */
2826 if ((gregs
= proc_get_gregs (pi
)) == NULL
)
2828 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
2829 PIDGET (ptid
), TIDGET (ptid
));
2832 /* Now extract the GS register's lower 16 bits. */
2833 key
= (*gregs
)[GS
] & 0xffff;
2835 /* Find the matching entry and return it. */
2836 return proc_get_LDT_entry (pi
, key
);
2841 /* =============== END, non-thread part of /proc "MODULE" =============== */
2843 /* =================== Thread "MODULE" =================== */
2845 /* NOTE: you'll see more ifdefs and duplication of functions here,
2846 since there is a different way to do threads on every OS. */
2848 /* Returns the number of threads for the process. */
2850 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2853 proc_get_nthreads (procinfo
*pi
)
2857 if (ioctl (pi
->ctl_fd
, PIOCNTHR
, &nthreads
) < 0)
2858 proc_warn (pi
, "procfs: PIOCNTHR failed", __LINE__
);
2864 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2865 /* Solaris and Unixware version */
2867 proc_get_nthreads (procinfo
*pi
)
2869 if (!pi
->status_valid
)
2870 if (!proc_get_status (pi
))
2873 /* NEW_PROC_API: only works for the process procinfo, because the
2874 LWP procinfos do not get prstatus filled in. */
2876 if (pi
->tid
!= 0) /* Find the parent process procinfo. */
2877 pi
= find_procinfo_or_die (pi
->pid
, 0);
2879 return pi
->prstatus
.pr_nlwp
;
2883 /* Default version */
2885 proc_get_nthreads (procinfo
*pi
)
2894 Return the ID of the thread that had an event of interest.
2895 (ie. the one that hit a breakpoint or other traced event). All
2896 other things being equal, this should be the ID of a thread that is
2897 currently executing. */
2899 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2900 /* Solaris and Unixware version */
2902 proc_get_current_thread (procinfo
*pi
)
2904 /* Note: this should be applied to the root procinfo for the
2905 process, not to the procinfo for an LWP. If applied to the
2906 procinfo for an LWP, it will simply return that LWP's ID. In
2907 that case, find the parent process procinfo. */
2910 pi
= find_procinfo_or_die (pi
->pid
, 0);
2912 if (!pi
->status_valid
)
2913 if (!proc_get_status (pi
))
2917 return pi
->prstatus
.pr_lwp
.pr_lwpid
;
2919 return pi
->prstatus
.pr_who
;
2924 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2927 proc_get_current_thread (procinfo
*pi
)
2929 #if 0 /* FIXME: not ready for prime time? */
2930 return pi
->prstatus
.pr_tid
;
2937 /* Default version */
2939 proc_get_current_thread (procinfo
*pi
)
2947 /* Discover the IDs of all the threads within the process, and create
2948 a procinfo for each of them (chained to the parent). This
2949 unfortunately requires a different method on every OS. Returns
2950 non-zero for success, zero for failure. */
2953 proc_delete_dead_threads (procinfo
*parent
, procinfo
*thread
, void *ignore
)
2955 if (thread
&& parent
) /* sanity */
2957 thread
->status_valid
= 0;
2958 if (!proc_get_status (thread
))
2959 destroy_one_procinfo (&parent
->thread_list
, thread
);
2961 return 0; /* keep iterating */
2964 #if defined (PIOCLSTATUS)
2965 /* Solaris 2.5 (ioctl) version */
2967 proc_update_threads (procinfo
*pi
)
2969 gdb_prstatus_t
*prstatus
;
2970 struct cleanup
*old_chain
= NULL
;
2974 /* We should never have to apply this operation to any procinfo
2975 except the one for the main process. If that ever changes for
2976 any reason, then take out the following clause and replace it
2977 with one that makes sure the ctl_fd is open. */
2980 pi
= find_procinfo_or_die (pi
->pid
, 0);
2982 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
2984 if ((nlwp
= proc_get_nthreads (pi
)) <= 1)
2985 return 1; /* Process is not multi-threaded; nothing to do. */
2987 prstatus
= xmalloc (sizeof (gdb_prstatus_t
) * (nlwp
+ 1));
2989 old_chain
= make_cleanup (xfree
, prstatus
);
2990 if (ioctl (pi
->ctl_fd
, PIOCLSTATUS
, prstatus
) < 0)
2991 proc_error (pi
, "update_threads (PIOCLSTATUS)", __LINE__
);
2993 /* Skip element zero, which represents the process as a whole. */
2994 for (i
= 1; i
< nlwp
+ 1; i
++)
2996 if ((thread
= create_procinfo (pi
->pid
, prstatus
[i
].pr_who
)) == NULL
)
2997 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
2999 memcpy (&thread
->prstatus
, &prstatus
[i
], sizeof (*prstatus
));
3000 thread
->status_valid
= 1;
3002 pi
->threads_valid
= 1;
3003 do_cleanups (old_chain
);
3008 /* Unixware and Solaris 6 (and later) version. */
3010 do_closedir_cleanup (void *dir
)
3016 proc_update_threads (procinfo
*pi
)
3018 char pathname
[MAX_PROC_NAME_SIZE
+ 16];
3019 struct dirent
*direntry
;
3020 struct cleanup
*old_chain
= NULL
;
3025 /* We should never have to apply this operation to any procinfo
3026 except the one for the main process. If that ever changes for
3027 any reason, then take out the following clause and replace it
3028 with one that makes sure the ctl_fd is open. */
3031 pi
= find_procinfo_or_die (pi
->pid
, 0);
3033 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3037 Note: this brute-force method is the only way I know of to
3038 accomplish this task on Unixware. This method will also work on
3039 Solaris 2.6 and 2.7. There is a much simpler and more elegant
3040 way to do this on Solaris, but the margins of this manuscript are
3041 too small to write it here... ;-) */
3043 strcpy (pathname
, pi
->pathname
);
3044 strcat (pathname
, "/lwp");
3045 if ((dirp
= opendir (pathname
)) == NULL
)
3046 proc_error (pi
, "update_threads, opendir", __LINE__
);
3048 old_chain
= make_cleanup (do_closedir_cleanup
, dirp
);
3049 while ((direntry
= readdir (dirp
)) != NULL
)
3050 if (direntry
->d_name
[0] != '.') /* skip '.' and '..' */
3052 lwpid
= atoi (&direntry
->d_name
[0]);
3053 if ((thread
= create_procinfo (pi
->pid
, lwpid
)) == NULL
)
3054 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3056 pi
->threads_valid
= 1;
3057 do_cleanups (old_chain
);
3064 proc_update_threads (procinfo
*pi
)
3069 /* We should never have to apply this operation to any procinfo
3070 except the one for the main process. If that ever changes for
3071 any reason, then take out the following clause and replace it
3072 with one that makes sure the ctl_fd is open. */
3075 pi
= find_procinfo_or_die (pi
->pid
, 0);
3077 proc_iterate_over_threads (pi
, proc_delete_dead_threads
, NULL
);
3079 nthreads
= proc_get_nthreads (pi
);
3081 return 0; /* Nothing to do for 1 or fewer threads. */
3083 threads
= xmalloc (nthreads
* sizeof (tid_t
));
3085 if (ioctl (pi
->ctl_fd
, PIOCTLIST
, threads
) < 0)
3086 proc_error (pi
, "procfs: update_threads (PIOCTLIST)", __LINE__
);
3088 for (i
= 0; i
< nthreads
; i
++)
3090 if (!find_procinfo (pi
->pid
, threads
[i
]))
3091 if (!create_procinfo (pi
->pid
, threads
[i
]))
3092 proc_error (pi
, "update_threads, create_procinfo", __LINE__
);
3094 pi
->threads_valid
= 1;
3098 /* Default version */
3100 proc_update_threads (procinfo
*pi
)
3104 #endif /* OSF PIOCTLIST */
3105 #endif /* NEW_PROC_API */
3106 #endif /* SOL 2.5 PIOCLSTATUS */
3108 /* Given a pointer to a function, call that function once for each lwp
3109 in the procinfo list, until the function returns non-zero, in which
3110 event return the value returned by the function.
3112 Note: this function does NOT call update_threads. If you want to
3113 discover new threads first, you must call that function explicitly.
3114 This function just makes a quick pass over the currently-known
3117 PI is the parent process procinfo. FUNC is the per-thread
3118 function. PTR is an opaque parameter for function. Returns the
3119 first non-zero return value from the callee, or zero. */
3122 proc_iterate_over_threads (procinfo
*pi
,
3123 int (*func
) (procinfo
*, procinfo
*, void *),
3126 procinfo
*thread
, *next
;
3129 /* We should never have to apply this operation to any procinfo
3130 except the one for the main process. If that ever changes for
3131 any reason, then take out the following clause and replace it
3132 with one that makes sure the ctl_fd is open. */
3135 pi
= find_procinfo_or_die (pi
->pid
, 0);
3137 for (thread
= pi
->thread_list
; thread
!= NULL
; thread
= next
)
3139 next
= thread
->next
; /* In case thread is destroyed. */
3140 if ((retval
= (*func
) (pi
, thread
, ptr
)) != 0)
3147 /* =================== END, Thread "MODULE" =================== */
3149 /* =================== END, /proc "MODULE" =================== */
3151 /* =================== GDB "MODULE" =================== */
3153 /* Here are all of the gdb target vector functions and their
3156 static ptid_t
do_attach (ptid_t ptid
);
3157 static void do_detach (int signo
);
3158 static void proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
,
3159 int entry_or_exit
, int mode
, int from_tty
);
3161 /* On mips-irix, we need to insert a breakpoint at __dbx_link during
3162 the startup phase. The following two variables are used to record
3163 the address of the breakpoint, and the code that was replaced by
3165 static int dbx_link_bpt_addr
= 0;
3166 static void *dbx_link_bpt
;
3168 /* Sets up the inferior to be debugged. Registers to trace signals,
3169 hardware faults, and syscalls. Note: does not set RLC flag: caller
3170 may want to customize that. Returns zero for success (note!
3171 unlike most functions in this module); on failure, returns the LINE
3172 NUMBER where it failed! */
3175 procfs_debug_inferior (procinfo
*pi
)
3177 fltset_t traced_faults
;
3178 gdb_sigset_t traced_signals
;
3179 sysset_t
*traced_syscall_entries
;
3180 sysset_t
*traced_syscall_exits
;
3183 #ifdef PROCFS_DONT_TRACE_FAULTS
3184 /* On some systems (OSF), we don't trace hardware faults.
3185 Apparently it's enough that we catch them as signals.
3186 Wonder why we don't just do that in general? */
3187 premptyset (&traced_faults
); /* don't trace faults. */
3189 /* Register to trace hardware faults in the child. */
3190 prfillset (&traced_faults
); /* trace all faults... */
3191 gdb_prdelset (&traced_faults
, FLTPAGE
); /* except page fault. */
3193 if (!proc_set_traced_faults (pi
, &traced_faults
))
3196 /* Initially, register to trace all signals in the child. */
3197 prfillset (&traced_signals
);
3198 if (!proc_set_traced_signals (pi
, &traced_signals
))
3202 /* Register to trace the 'exit' system call (on entry). */
3203 traced_syscall_entries
= sysset_t_alloc (pi
);
3204 gdb_premptysysset (traced_syscall_entries
);
3206 gdb_praddsysset (traced_syscall_entries
, SYS_exit
);
3209 gdb_praddsysset (traced_syscall_entries
, SYS_lwpexit
);/* And _lwp_exit... */
3212 gdb_praddsysset (traced_syscall_entries
, SYS_lwp_exit
);
3214 #ifdef DYNAMIC_SYSCALLS
3216 int callnum
= find_syscall (pi
, "_exit");
3219 gdb_praddsysset (traced_syscall_entries
, callnum
);
3223 status
= proc_set_traced_sysentry (pi
, traced_syscall_entries
);
3224 xfree (traced_syscall_entries
);
3228 #ifdef PRFS_STOPEXEC /* defined on OSF */
3229 /* OSF method for tracing exec syscalls. Quoting:
3230 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3231 exits from exec system calls because of the user level loader. */
3232 /* FIXME: make nice and maybe move into an access function. */
3236 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
3239 prfs_flags
|= PRFS_STOPEXEC
;
3241 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
3244 #else /* not PRFS_STOPEXEC */
3245 /* Everyone else's (except OSF) method for tracing exec syscalls. */
3247 Not all systems with /proc have all the exec* syscalls with the same
3248 names. On the SGI, for example, there is no SYS_exec, but there
3249 *is* a SYS_execv. So, we try to account for that. */
3251 traced_syscall_exits
= sysset_t_alloc (pi
);
3252 gdb_premptysysset (traced_syscall_exits
);
3254 gdb_praddsysset (traced_syscall_exits
, SYS_exec
);
3257 gdb_praddsysset (traced_syscall_exits
, SYS_execve
);
3260 gdb_praddsysset (traced_syscall_exits
, SYS_execv
);
3263 #ifdef SYS_lwpcreate
3264 gdb_praddsysset (traced_syscall_exits
, SYS_lwpcreate
);
3265 gdb_praddsysset (traced_syscall_exits
, SYS_lwpexit
);
3268 #ifdef SYS_lwp_create /* FIXME: once only, please. */
3269 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_create
);
3270 gdb_praddsysset (traced_syscall_exits
, SYS_lwp_exit
);
3273 #ifdef DYNAMIC_SYSCALLS
3275 int callnum
= find_syscall (pi
, "execve");
3278 gdb_praddsysset (traced_syscall_exits
, callnum
);
3279 callnum
= find_syscall (pi
, "ra_execve");
3281 gdb_praddsysset (traced_syscall_exits
, callnum
);
3285 status
= proc_set_traced_sysexit (pi
, traced_syscall_exits
);
3286 xfree (traced_syscall_exits
);
3290 #endif /* PRFS_STOPEXEC */
3295 procfs_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3300 pid
= parse_pid_to_attach (args
);
3302 if (pid
== getpid ())
3303 error (_("Attaching GDB to itself is not a good idea..."));
3307 exec_file
= get_exec_file (0);
3310 printf_filtered (_("Attaching to program `%s', %s\n"),
3311 exec_file
, target_pid_to_str (pid_to_ptid (pid
)));
3313 printf_filtered (_("Attaching to %s\n"),
3314 target_pid_to_str (pid_to_ptid (pid
)));
3318 inferior_ptid
= do_attach (pid_to_ptid (pid
));
3323 procfs_detach (struct target_ops
*ops
, char *args
, int from_tty
)
3326 int pid
= PIDGET (inferior_ptid
);
3335 exec_file
= get_exec_file (0);
3336 if (exec_file
== NULL
)
3339 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file
,
3340 target_pid_to_str (pid_to_ptid (pid
)));
3341 gdb_flush (gdb_stdout
);
3346 inferior_ptid
= null_ptid
;
3347 detach_inferior (pid
);
3348 unpush_target (ops
);
3352 do_attach (ptid_t ptid
)
3355 struct inferior
*inf
;
3359 if ((pi
= create_procinfo (PIDGET (ptid
), 0)) == NULL
)
3360 perror (_("procfs: out of memory in 'attach'"));
3362 if (!open_procinfo_files (pi
, FD_CTL
))
3364 fprintf_filtered (gdb_stderr
, "procfs:%d -- ", __LINE__
);
3365 sprintf (errmsg
, "do_attach: couldn't open /proc file for process %d",
3367 dead_procinfo (pi
, errmsg
, NOKILL
);
3370 /* Stop the process (if it isn't already stopped). */
3371 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
3373 pi
->was_stopped
= 1;
3374 proc_prettyprint_why (proc_why (pi
), proc_what (pi
), 1);
3378 pi
->was_stopped
= 0;
3379 /* Set the process to run again when we close it. */
3380 if (!proc_set_run_on_last_close (pi
))
3381 dead_procinfo (pi
, "do_attach: couldn't set RLC.", NOKILL
);
3383 /* Now stop the process. */
3384 if (!proc_stop_process (pi
))
3385 dead_procinfo (pi
, "do_attach: couldn't stop the process.", NOKILL
);
3386 pi
->ignore_next_sigstop
= 1;
3388 /* Save some of the /proc state to be restored if we detach. */
3389 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
3390 dead_procinfo (pi
, "do_attach: couldn't save traced faults.", NOKILL
);
3391 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
3392 dead_procinfo (pi
, "do_attach: couldn't save traced signals.", NOKILL
);
3393 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
3394 dead_procinfo (pi
, "do_attach: couldn't save traced syscall entries.",
3396 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
3397 dead_procinfo (pi
, "do_attach: couldn't save traced syscall exits.",
3399 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
3400 dead_procinfo (pi
, "do_attach: couldn't save held signals.", NOKILL
);
3402 if ((fail
= procfs_debug_inferior (pi
)) != 0)
3403 dead_procinfo (pi
, "do_attach: failed in procfs_debug_inferior", NOKILL
);
3405 inf
= current_inferior ();
3406 inferior_appeared (inf
, pi
->pid
);
3407 /* Let GDB know that the inferior was attached. */
3408 inf
->attach_flag
= 1;
3410 /* Create a procinfo for the current lwp. */
3411 lwpid
= proc_get_current_thread (pi
);
3412 create_procinfo (pi
->pid
, lwpid
);
3414 /* Add it to gdb's thread list. */
3415 ptid
= MERGEPID (pi
->pid
, lwpid
);
3422 do_detach (int signo
)
3426 /* Find procinfo for the main process. */
3427 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0); /* FIXME: threads */
3429 if (!proc_set_current_signal (pi
, signo
))
3430 proc_warn (pi
, "do_detach, set_current_signal", __LINE__
);
3432 if (!proc_set_traced_signals (pi
, &pi
->saved_sigset
))
3433 proc_warn (pi
, "do_detach, set_traced_signal", __LINE__
);
3435 if (!proc_set_traced_faults (pi
, &pi
->saved_fltset
))
3436 proc_warn (pi
, "do_detach, set_traced_faults", __LINE__
);
3438 if (!proc_set_traced_sysentry (pi
, pi
->saved_entryset
))
3439 proc_warn (pi
, "do_detach, set_traced_sysentry", __LINE__
);
3441 if (!proc_set_traced_sysexit (pi
, pi
->saved_exitset
))
3442 proc_warn (pi
, "do_detach, set_traced_sysexit", __LINE__
);
3444 if (!proc_set_held_signals (pi
, &pi
->saved_sighold
))
3445 proc_warn (pi
, "do_detach, set_held_signals", __LINE__
);
3447 if (signo
|| (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)))
3448 if (signo
|| !(pi
->was_stopped
) ||
3449 query (_("Was stopped when attached, make it runnable again? ")))
3451 /* Clear any pending signal. */
3452 if (!proc_clear_current_fault (pi
))
3453 proc_warn (pi
, "do_detach, clear_current_fault", __LINE__
);
3455 if (signo
== 0 && !proc_clear_current_signal (pi
))
3456 proc_warn (pi
, "do_detach, clear_current_signal", __LINE__
);
3458 if (!proc_set_run_on_last_close (pi
))
3459 proc_warn (pi
, "do_detach, set_rlc", __LINE__
);
3462 destroy_procinfo (pi
);
3465 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
3468 ??? Is the following note still relevant? We can't get individual
3469 registers with the PT_GETREGS ptrace(2) request either, yet we
3470 don't bother with caching at all in that case.
3472 NOTE: Since the /proc interface cannot give us individual
3473 registers, we pay no attention to REGNUM, and just fetch them all.
3474 This results in the possibility that we will do unnecessarily many
3475 fetches, since we may be called repeatedly for individual
3476 registers. So we cache the results, and mark the cache invalid
3477 when the process is resumed. */
3480 procfs_fetch_registers (struct target_ops
*ops
,
3481 struct regcache
*regcache
, int regnum
)
3483 gdb_gregset_t
*gregs
;
3485 int pid
= PIDGET (inferior_ptid
);
3486 int tid
= TIDGET (inferior_ptid
);
3487 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3489 pi
= find_procinfo_or_die (pid
, tid
);
3492 error (_("procfs: fetch_registers failed to find procinfo for %s"),
3493 target_pid_to_str (inferior_ptid
));
3495 gregs
= proc_get_gregs (pi
);
3497 proc_error (pi
, "fetch_registers, get_gregs", __LINE__
);
3499 supply_gregset (regcache
, (const gdb_gregset_t
*) gregs
);
3501 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3503 gdb_fpregset_t
*fpregs
;
3505 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3506 || regnum
== gdbarch_pc_regnum (gdbarch
)
3507 || regnum
== gdbarch_sp_regnum (gdbarch
))
3508 return; /* Not a floating point register. */
3510 fpregs
= proc_get_fpregs (pi
);
3512 proc_error (pi
, "fetch_registers, get_fpregs", __LINE__
);
3514 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregs
);
3518 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
3519 this for all registers.
3521 NOTE: Since the /proc interface will not read individual registers,
3522 we will cache these requests until the process is resumed, and only
3523 then write them back to the inferior process.
3525 FIXME: is that a really bad idea? Have to think about cases where
3526 writing one register might affect the value of others, etc. */
3529 procfs_store_registers (struct target_ops
*ops
,
3530 struct regcache
*regcache
, int regnum
)
3532 gdb_gregset_t
*gregs
;
3534 int pid
= PIDGET (inferior_ptid
);
3535 int tid
= TIDGET (inferior_ptid
);
3536 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3538 pi
= find_procinfo_or_die (pid
, tid
);
3541 error (_("procfs: store_registers: failed to find procinfo for %s"),
3542 target_pid_to_str (inferior_ptid
));
3544 gregs
= proc_get_gregs (pi
);
3546 proc_error (pi
, "store_registers, get_gregs", __LINE__
);
3548 fill_gregset (regcache
, gregs
, regnum
);
3549 if (!proc_set_gregs (pi
))
3550 proc_error (pi
, "store_registers, set_gregs", __LINE__
);
3552 if (gdbarch_fp0_regnum (gdbarch
) >= 0) /* Do we have an FPU? */
3554 gdb_fpregset_t
*fpregs
;
3556 if ((regnum
>= 0 && regnum
< gdbarch_fp0_regnum (gdbarch
))
3557 || regnum
== gdbarch_pc_regnum (gdbarch
)
3558 || regnum
== gdbarch_sp_regnum (gdbarch
))
3559 return; /* Not a floating point register. */
3561 fpregs
= proc_get_fpregs (pi
);
3563 proc_error (pi
, "store_registers, get_fpregs", __LINE__
);
3565 fill_fpregset (regcache
, fpregs
, regnum
);
3566 if (!proc_set_fpregs (pi
))
3567 proc_error (pi
, "store_registers, set_fpregs", __LINE__
);
3572 syscall_is_lwp_exit (procinfo
*pi
, int scall
)
3575 if (scall
== SYS_lwp_exit
)
3579 if (scall
== SYS_lwpexit
)
3586 syscall_is_exit (procinfo
*pi
, int scall
)
3589 if (scall
== SYS_exit
)
3592 #ifdef DYNAMIC_SYSCALLS
3593 if (find_syscall (pi
, "_exit") == scall
)
3600 syscall_is_exec (procinfo
*pi
, int scall
)
3603 if (scall
== SYS_exec
)
3607 if (scall
== SYS_execv
)
3611 if (scall
== SYS_execve
)
3614 #ifdef DYNAMIC_SYSCALLS
3615 if (find_syscall (pi
, "_execve"))
3617 if (find_syscall (pi
, "ra_execve"))
3624 syscall_is_lwp_create (procinfo
*pi
, int scall
)
3626 #ifdef SYS_lwp_create
3627 if (scall
== SYS_lwp_create
)
3630 #ifdef SYS_lwpcreate
3631 if (scall
== SYS_lwpcreate
)
3637 /* Remove the breakpoint that we inserted in __dbx_link().
3638 Does nothing if the breakpoint hasn't been inserted or has already
3642 remove_dbx_link_breakpoint (void)
3644 if (dbx_link_bpt_addr
== 0)
3647 if (deprecated_remove_raw_breakpoint (target_gdbarch
, dbx_link_bpt
) != 0)
3648 warning (_("Unable to remove __dbx_link breakpoint."));
3650 dbx_link_bpt_addr
= 0;
3651 dbx_link_bpt
= NULL
;
3655 /* Return the address of the __dbx_link() function in the file
3656 refernced by ABFD by scanning its symbol table. Return 0 if
3657 the symbol was not found. */
3660 dbx_link_addr (bfd
*abfd
)
3662 long storage_needed
;
3663 asymbol
**symbol_table
;
3664 long number_of_symbols
;
3667 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
3668 if (storage_needed
<= 0)
3671 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
3672 make_cleanup (xfree
, symbol_table
);
3674 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
3676 for (i
= 0; i
< number_of_symbols
; i
++)
3678 asymbol
*sym
= symbol_table
[i
];
3680 if ((sym
->flags
& BSF_GLOBAL
)
3681 && sym
->name
!= NULL
&& strcmp (sym
->name
, "__dbx_link") == 0)
3682 return (sym
->value
+ sym
->section
->vma
);
3685 /* Symbol not found, return NULL. */
3689 /* Search the symbol table of the file referenced by FD for a symbol
3690 named __dbx_link(). If found, then insert a breakpoint at this location,
3691 and return nonzero. Return zero otherwise. */
3694 insert_dbx_link_bpt_in_file (int fd
, CORE_ADDR ignored
)
3697 long storage_needed
;
3700 abfd
= bfd_fdopenr ("unamed", 0, fd
);
3703 warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
3707 if (!bfd_check_format (abfd
, bfd_object
))
3709 /* Not the correct format, so we can not possibly find the dbx_link
3715 sym_addr
= dbx_link_addr (abfd
);
3718 /* Insert the breakpoint. */
3719 dbx_link_bpt_addr
= sym_addr
;
3720 dbx_link_bpt
= deprecated_insert_raw_breakpoint (target_gdbarch
, NULL
,
3722 if (dbx_link_bpt
== NULL
)
3724 warning (_("Failed to insert dbx_link breakpoint."));
3736 /* Calls the supplied callback function once for each mapped address
3737 space in the process. The callback function receives an open file
3738 descriptor for the file corresponding to that mapped address space
3739 (if there is one), and the base address of the mapped space. Quit
3740 when the callback function returns a nonzero value, or at teh end
3741 of the mappings. Returns the first non-zero return value of the
3742 callback function, or zero. */
3745 solib_mappings_callback (struct prmap
*map
, int (*func
) (int, CORE_ADDR
),
3748 procinfo
*pi
= data
;
3752 char name
[MAX_PROC_NAME_SIZE
+ sizeof (map
->pr_mapname
)];
3754 if (map
->pr_vaddr
== 0 && map
->pr_size
== 0)
3755 return -1; /* sanity */
3757 if (map
->pr_mapname
[0] == 0)
3759 fd
= -1; /* no map file */
3763 sprintf (name
, "/proc/%d/object/%s", pi
->pid
, map
->pr_mapname
);
3764 /* Note: caller's responsibility to close this fd! */
3765 fd
= open_with_retry (name
, O_RDONLY
);
3766 /* Note: we don't test the above call for failure;
3767 we just pass the FD on as given. Sometimes there is
3768 no file, so the open may return failure, but that's
3772 fd
= ioctl (pi
->ctl_fd
, PIOCOPENM
, &map
->pr_vaddr
);
3773 /* Note: we don't test the above call for failure;
3774 we just pass the FD on as given. Sometimes there is
3775 no file, so the ioctl may return failure, but that's
3778 return (*func
) (fd
, (CORE_ADDR
) map
->pr_vaddr
);
3781 /* If the given memory region MAP contains a symbol named __dbx_link,
3782 insert a breakpoint at this location and return nonzero. Return
3786 insert_dbx_link_bpt_in_region (struct prmap
*map
,
3787 find_memory_region_ftype child_func
,
3790 procinfo
*pi
= (procinfo
*) data
;
3792 /* We know the symbol we're looking for is in a text region, so
3793 only look for it if the region is a text one. */
3794 if (map
->pr_mflags
& MA_EXEC
)
3795 return solib_mappings_callback (map
, insert_dbx_link_bpt_in_file
, pi
);
3800 /* Search all memory regions for a symbol named __dbx_link. If found,
3801 insert a breakpoint at its location, and return nonzero. Return zero
3805 insert_dbx_link_breakpoint (procinfo
*pi
)
3807 return iterate_over_mappings (pi
, NULL
, pi
, insert_dbx_link_bpt_in_region
);
3811 /* Retrieve the next stop event from the child process. If child has
3812 not stopped yet, wait for it to stop. Translate /proc eventcodes
3813 (or possibly wait eventcodes) into gdb internal event codes.
3814 Returns the id of process (and possibly thread) that incurred the
3815 event. Event codes are returned through a pointer parameter. */
3818 procfs_wait (struct target_ops
*ops
,
3819 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
3821 /* First cut: loosely based on original version 2.1. */
3825 ptid_t retval
, temp_ptid
;
3826 int why
, what
, flags
;
3833 retval
= pid_to_ptid (-1);
3835 /* Find procinfo for main process. */
3836 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
3839 /* We must assume that the status is stale now... */
3840 pi
->status_valid
= 0;
3841 pi
->gregs_valid
= 0;
3842 pi
->fpregs_valid
= 0;
3844 #if 0 /* just try this out... */
3845 flags
= proc_flags (pi
);
3846 why
= proc_why (pi
);
3847 if ((flags
& PR_STOPPED
) && (why
== PR_REQUESTED
))
3848 pi
->status_valid
= 0; /* re-read again, IMMEDIATELY... */
3850 /* If child is not stopped, wait for it to stop. */
3851 if (!(proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
)) &&
3852 !proc_wait_for_stop (pi
))
3854 /* wait_for_stop failed: has the child terminated? */
3855 if (errno
== ENOENT
)
3859 /* /proc file not found; presumably child has terminated. */
3860 wait_retval
= wait (&wstat
); /* "wait" for the child's exit. */
3862 if (wait_retval
!= PIDGET (inferior_ptid
)) /* wrong child? */
3863 error (_("procfs: couldn't stop "
3864 "process %d: wait returned %d."),
3865 PIDGET (inferior_ptid
), wait_retval
);
3866 /* FIXME: might I not just use waitpid?
3867 Or try find_procinfo to see if I know about this child? */
3868 retval
= pid_to_ptid (wait_retval
);
3870 else if (errno
== EINTR
)
3874 /* Unknown error from wait_for_stop. */
3875 proc_error (pi
, "target_wait (wait_for_stop)", __LINE__
);
3880 /* This long block is reached if either:
3881 a) the child was already stopped, or
3882 b) we successfully waited for the child with wait_for_stop.
3883 This block will analyze the /proc status, and translate it
3884 into a waitstatus for GDB.
3886 If we actually had to call wait because the /proc file
3887 is gone (child terminated), then we skip this block,
3888 because we already have a waitstatus. */
3890 flags
= proc_flags (pi
);
3891 why
= proc_why (pi
);
3892 what
= proc_what (pi
);
3894 if (flags
& (PR_STOPPED
| PR_ISTOP
))
3897 /* If it's running async (for single_thread control),
3898 set it back to normal again. */
3899 if (flags
& PR_ASYNC
)
3900 if (!proc_unset_async (pi
))
3901 proc_error (pi
, "target_wait, unset_async", __LINE__
);
3905 proc_prettyprint_why (why
, what
, 1);
3907 /* The 'pid' we will return to GDB is composed of
3908 the process ID plus the lwp ID. */
3909 retval
= MERGEPID (pi
->pid
, proc_get_current_thread (pi
));
3913 wstat
= (what
<< 8) | 0177;
3916 if (syscall_is_lwp_exit (pi
, what
))
3918 if (print_thread_events
)
3919 printf_unfiltered (_("[%s exited]\n"),
3920 target_pid_to_str (retval
));
3921 delete_thread (retval
);
3922 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3925 else if (syscall_is_exit (pi
, what
))
3927 struct inferior
*inf
;
3929 /* Handle SYS_exit call only. */
3930 /* Stopped at entry to SYS_exit.
3931 Make it runnable, resume it, then use
3932 the wait system call to get its exit code.
3933 Proc_run_process always clears the current
3935 Then return its exit status. */
3936 pi
->status_valid
= 0;
3938 /* FIXME: what we should do is return
3939 TARGET_WAITKIND_SPURIOUS. */
3940 if (!proc_run_process (pi
, 0, 0))
3941 proc_error (pi
, "target_wait, run_process", __LINE__
);
3943 inf
= find_inferior_pid (pi
->pid
);
3944 if (inf
->attach_flag
)
3946 /* Don't call wait: simulate waiting for exit,
3947 return a "success" exit code. Bogus: what if
3948 it returns something else? */
3950 retval
= inferior_ptid
; /* ? ? ? */
3954 int temp
= wait (&wstat
);
3956 /* FIXME: shouldn't I make sure I get the right
3957 event from the right process? If (for
3958 instance) I have killed an earlier inferior
3959 process but failed to clean up after it
3960 somehow, I could get its termination event
3963 /* If wait returns -1, that's what we return
3966 retval
= pid_to_ptid (temp
);
3971 printf_filtered (_("procfs: trapped on entry to "));
3972 proc_prettyprint_syscall (proc_what (pi
), 0);
3973 printf_filtered ("\n");
3976 long i
, nsysargs
, *sysargs
;
3978 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
3979 (sysargs
= proc_sysargs (pi
)) != NULL
)
3981 printf_filtered (_("%ld syscall arguments:\n"),
3983 for (i
= 0; i
< nsysargs
; i
++)
3984 printf_filtered ("#%ld: 0x%08lx\n",
3992 /* How to exit gracefully, returning "unknown
3994 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
3995 return inferior_ptid
;
3999 /* How to keep going without returning to wfi: */
4000 target_resume (ptid
, 0, TARGET_SIGNAL_0
);
4006 if (syscall_is_exec (pi
, what
))
4008 /* Hopefully this is our own "fork-child" execing
4009 the real child. Hoax this event into a trap, and
4010 GDB will see the child about to execute its start
4012 wstat
= (SIGTRAP
<< 8) | 0177;
4015 else if (what
== SYS_syssgi
)
4017 /* see if we can break on dbx_link(). If yes, then
4018 we no longer need the SYS_syssgi notifications. */
4019 if (insert_dbx_link_breakpoint (pi
))
4020 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
,
4023 /* This is an internal event and should be transparent
4024 to wfi, so resume the execution and wait again. See
4025 comment in procfs_init_inferior() for more details. */
4026 target_resume (ptid
, 0, TARGET_SIGNAL_0
);
4030 else if (syscall_is_lwp_create (pi
, what
))
4032 /* This syscall is somewhat like fork/exec. We
4033 will get the event twice: once for the parent
4034 LWP, and once for the child. We should already
4035 know about the parent LWP, but the child will
4036 be new to us. So, whenever we get this event,
4037 if it represents a new thread, simply add the
4038 thread to the list. */
4040 /* If not in procinfo list, add it. */
4041 temp_tid
= proc_get_current_thread (pi
);
4042 if (!find_procinfo (pi
->pid
, temp_tid
))
4043 create_procinfo (pi
->pid
, temp_tid
);
4045 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
4046 /* If not in GDB's thread list, add it. */
4047 if (!in_thread_list (temp_ptid
))
4048 add_thread (temp_ptid
);
4050 /* Return to WFI, but tell it to immediately resume. */
4051 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4052 return inferior_ptid
;
4054 else if (syscall_is_lwp_exit (pi
, what
))
4056 if (print_thread_events
)
4057 printf_unfiltered (_("[%s exited]\n"),
4058 target_pid_to_str (retval
));
4059 delete_thread (retval
);
4060 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4065 /* FIXME: Do we need to handle SYS_sproc,
4066 SYS_fork, or SYS_vfork here? The old procfs
4067 seemed to use this event to handle threads on
4068 older (non-LWP) systems, where I'm assuming
4069 that threads were actually separate processes.
4070 Irix, maybe? Anyway, low priority for now. */
4074 printf_filtered (_("procfs: trapped on exit from "));
4075 proc_prettyprint_syscall (proc_what (pi
), 0);
4076 printf_filtered ("\n");
4079 long i
, nsysargs
, *sysargs
;
4081 if ((nsysargs
= proc_nsysarg (pi
)) > 0 &&
4082 (sysargs
= proc_sysargs (pi
)) != NULL
)
4084 printf_filtered (_("%ld syscall arguments:\n"),
4086 for (i
= 0; i
< nsysargs
; i
++)
4087 printf_filtered ("#%ld: 0x%08lx\n",
4092 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
4093 return inferior_ptid
;
4098 wstat
= (SIGSTOP
<< 8) | 0177;
4103 printf_filtered (_("Retry #%d:\n"), retry
);
4104 pi
->status_valid
= 0;
4109 /* If not in procinfo list, add it. */
4110 temp_tid
= proc_get_current_thread (pi
);
4111 if (!find_procinfo (pi
->pid
, temp_tid
))
4112 create_procinfo (pi
->pid
, temp_tid
);
4114 /* If not in GDB's thread list, add it. */
4115 temp_ptid
= MERGEPID (pi
->pid
, temp_tid
);
4116 if (!in_thread_list (temp_ptid
))
4117 add_thread (temp_ptid
);
4119 status
->kind
= TARGET_WAITKIND_STOPPED
;
4120 status
->value
.sig
= 0;
4125 wstat
= (what
<< 8) | 0177;
4131 wstat
= (SIGTRAP
<< 8) | 0177;
4136 wstat
= (SIGTRAP
<< 8) | 0177;
4139 /* FIXME: use si_signo where possible. */
4141 #if (FLTILL != FLTPRIV) /* Avoid "duplicate case" error. */
4144 wstat
= (SIGILL
<< 8) | 0177;
4147 #if (FLTTRACE != FLTBPT) /* Avoid "duplicate case" error. */
4150 /* If we hit our __dbx_link() internal breakpoint,
4151 then remove it. See comments in procfs_init_inferior()
4152 for more details. */
4153 if (dbx_link_bpt_addr
!= 0
4154 && dbx_link_bpt_addr
4155 == regcache_read_pc (get_current_regcache ()))
4156 remove_dbx_link_breakpoint ();
4158 wstat
= (SIGTRAP
<< 8) | 0177;
4162 #if (FLTBOUNDS != FLTSTACK) /* Avoid "duplicate case" error. */
4165 wstat
= (SIGSEGV
<< 8) | 0177;
4169 #if (FLTFPE != FLTIOVF) /* Avoid "duplicate case" error. */
4172 wstat
= (SIGFPE
<< 8) | 0177;
4174 case FLTPAGE
: /* Recoverable page fault */
4175 default: /* FIXME: use si_signo if possible for
4177 retval
= pid_to_ptid (-1);
4178 printf_filtered ("procfs:%d -- ", __LINE__
);
4179 printf_filtered (_("child stopped for unknown reason:\n"));
4180 proc_prettyprint_why (why
, what
, 1);
4181 error (_("... giving up..."));
4184 break; /* case PR_FAULTED: */
4185 default: /* switch (why) unmatched */
4186 printf_filtered ("procfs:%d -- ", __LINE__
);
4187 printf_filtered (_("child stopped for unknown reason:\n"));
4188 proc_prettyprint_why (why
, what
, 1);
4189 error (_("... giving up..."));
4192 /* Got this far without error: If retval isn't in the
4193 threads database, add it. */
4194 if (PIDGET (retval
) > 0 &&
4195 !ptid_equal (retval
, inferior_ptid
) &&
4196 !in_thread_list (retval
))
4198 /* We have a new thread. We need to add it both to
4199 GDB's list and to our own. If we don't create a
4200 procinfo, resume may be unhappy later. */
4201 add_thread (retval
);
4202 if (find_procinfo (PIDGET (retval
), TIDGET (retval
)) == NULL
)
4203 create_procinfo (PIDGET (retval
), TIDGET (retval
));
4206 else /* Flags do not indicate STOPPED. */
4208 /* surely this can't happen... */
4209 printf_filtered ("procfs:%d -- process not stopped.\n",
4211 proc_prettyprint_flags (flags
, 1);
4212 error (_("procfs: ...giving up..."));
4217 store_waitstatus (status
, wstat
);
4223 /* Perform a partial transfer to/from the specified object. For
4224 memory transfers, fall back to the old memory xfer functions. */
4227 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4228 const char *annex
, gdb_byte
*readbuf
,
4229 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4233 case TARGET_OBJECT_MEMORY
:
4235 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
4236 len
, 0/*read*/, NULL
, ops
);
4238 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
4239 len
, 1/*write*/, NULL
, ops
);
4243 case TARGET_OBJECT_AUXV
:
4244 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
4249 if (ops
->beneath
!= NULL
)
4250 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
4251 readbuf
, writebuf
, offset
, len
);
4257 /* Transfer LEN bytes between GDB address MYADDR and target address
4258 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
4259 otherwise transfer them from the target. TARGET is unused.
4261 The return value is 0 if an error occurred or no bytes were
4262 transferred. Otherwise, it will be a positive value which
4263 indicates the number of bytes transferred between gdb and the
4264 target. (Note that the interface also makes provisions for
4265 negative values, but this capability isn't implemented here.) */
4268 procfs_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int dowrite
,
4269 struct mem_attrib
*attrib
, struct target_ops
*target
)
4274 /* Find procinfo for main process. */
4275 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4276 if (pi
->as_fd
== 0 &&
4277 open_procinfo_files (pi
, FD_AS
) == 0)
4279 proc_warn (pi
, "xfer_memory, open_proc_files", __LINE__
);
4283 if (lseek (pi
->as_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
4288 PROCFS_NOTE ("write memory:\n");
4290 PROCFS_NOTE ("write memory:\n");
4292 nbytes
= write (pi
->as_fd
, myaddr
, len
);
4296 PROCFS_NOTE ("read memory:\n");
4297 nbytes
= read (pi
->as_fd
, myaddr
, len
);
4307 /* Called by target_resume before making child runnable. Mark cached
4308 registers and status's invalid. If there are "dirty" caches that
4309 need to be written back to the child process, do that.
4311 File descriptors are also cached. As they are a limited resource,
4312 we cannot hold onto them indefinitely. However, as they are
4313 expensive to open, we don't want to throw them away
4314 indescriminately either. As a compromise, we will keep the file
4315 descriptors for the parent process, but discard any file
4316 descriptors we may have accumulated for the threads.
4318 As this function is called by iterate_over_threads, it always
4319 returns zero (so that iterate_over_threads will keep
4323 invalidate_cache (procinfo
*parent
, procinfo
*pi
, void *ptr
)
4325 /* About to run the child; invalidate caches and do any other
4329 if (pi
->gregs_dirty
)
4330 if (parent
== NULL
||
4331 proc_get_current_thread (parent
) != pi
->tid
)
4332 if (!proc_set_gregs (pi
)) /* flush gregs cache */
4333 proc_warn (pi
, "target_resume, set_gregs",
4335 if (gdbarch_fp0_regnum (target_gdbarch
) >= 0)
4336 if (pi
->fpregs_dirty
)
4337 if (parent
== NULL
||
4338 proc_get_current_thread (parent
) != pi
->tid
)
4339 if (!proc_set_fpregs (pi
)) /* flush fpregs cache */
4340 proc_warn (pi
, "target_resume, set_fpregs",
4346 /* The presence of a parent indicates that this is an LWP.
4347 Close any file descriptors that it might have open.
4348 We don't do this to the master (parent) procinfo. */
4350 close_procinfo_files (pi
);
4352 pi
->gregs_valid
= 0;
4353 pi
->fpregs_valid
= 0;
4355 pi
->gregs_dirty
= 0;
4356 pi
->fpregs_dirty
= 0;
4358 pi
->status_valid
= 0;
4359 pi
->threads_valid
= 0;
4365 /* A callback function for iterate_over_threads. Find the
4366 asynchronous signal thread, and make it runnable. See if that
4367 helps matters any. */
4370 make_signal_thread_runnable (procinfo
*process
, procinfo
*pi
, void *ptr
)
4373 if (proc_flags (pi
) & PR_ASLWP
)
4375 if (!proc_run_process (pi
, 0, -1))
4376 proc_error (pi
, "make_signal_thread_runnable", __LINE__
);
4384 /* Make the child process runnable. Normally we will then call
4385 procfs_wait and wait for it to stop again (unless gdb is async).
4387 If STEP is true, then arrange for the child to stop again after
4388 executing a single instruction. If SIGNO is zero, then cancel any
4389 pending signal; if non-zero, then arrange for the indicated signal
4390 to be delivered to the child when it runs. If PID is -1, then
4391 allow any child thread to run; if non-zero, then allow only the
4392 indicated thread to run. (not implemented yet). */
4395 procfs_resume (struct target_ops
*ops
,
4396 ptid_t ptid
, int step
, enum target_signal signo
)
4398 procinfo
*pi
, *thread
;
4402 prrun.prflags |= PRSVADDR;
4403 prrun.pr_vaddr = $PC; set resume address
4404 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4405 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4406 prrun.prflags |= PRCFAULT; clear current fault.
4408 PRSTRACE and PRSFAULT can be done by other means
4409 (proc_trace_signals, proc_trace_faults)
4410 PRSVADDR is unnecessary.
4411 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4412 This basically leaves PRSTEP and PRCSIG.
4413 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4414 So basically PR_STEP is the sole argument that must be passed
4415 to proc_run_process (for use in the prrun struct by ioctl). */
4417 /* Find procinfo for main process. */
4418 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4420 /* First cut: ignore pid argument. */
4423 /* Convert signal to host numbering. */
4425 (signo
== TARGET_SIGNAL_STOP
&& pi
->ignore_next_sigstop
))
4428 native_signo
= target_signal_to_host (signo
);
4430 pi
->ignore_next_sigstop
= 0;
4432 /* Running the process voids all cached registers and status. */
4433 /* Void the threads' caches first. */
4434 proc_iterate_over_threads (pi
, invalidate_cache
, NULL
);
4435 /* Void the process procinfo's caches. */
4436 invalidate_cache (NULL
, pi
, NULL
);
4438 if (PIDGET (ptid
) != -1)
4440 /* Resume a specific thread, presumably suppressing the
4442 thread
= find_procinfo (PIDGET (ptid
), TIDGET (ptid
));
4445 if (thread
->tid
!= 0)
4447 /* We're to resume a specific thread, and not the
4448 others. Set the child process's PR_ASYNC flag. */
4450 if (!proc_set_async (pi
))
4451 proc_error (pi
, "target_resume, set_async", __LINE__
);
4454 proc_iterate_over_threads (pi
,
4455 make_signal_thread_runnable
,
4458 pi
= thread
; /* Substitute the thread's procinfo
4464 if (!proc_run_process (pi
, step
, native_signo
))
4467 warning (_("resume: target already running. "
4468 "Pretend to resume, and hope for the best!"));
4470 proc_error (pi
, "target_resume", __LINE__
);
4474 /* Set up to trace signals in the child process. */
4477 procfs_pass_signals (int numsigs
, unsigned char *pass_signals
)
4479 gdb_sigset_t signals
;
4480 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4483 prfillset (&signals
);
4485 for (signo
= 0; signo
< NSIG
; signo
++)
4487 int target_signo
= target_signal_from_host (signo
);
4488 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
4489 gdb_prdelset (&signals
, signo
);
4492 if (!proc_set_traced_signals (pi
, &signals
))
4493 proc_error (pi
, "pass_signals", __LINE__
);
4496 /* Print status information about the child process. */
4499 procfs_files_info (struct target_ops
*ignore
)
4501 struct inferior
*inf
= current_inferior ();
4503 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
4504 inf
->attach_flag
? "attached": "child",
4505 target_pid_to_str (inferior_ptid
));
4508 /* Stop the child process asynchronously, as when the gdb user types
4509 control-c or presses a "stop" button. Works by sending
4510 kill(SIGINT) to the child's process group. */
4513 procfs_stop (ptid_t ptid
)
4515 kill (-inferior_process_group (), SIGINT
);
4518 /* Make it die. Wait for it to die. Clean up after it. Note: this
4519 should only be applied to the real process, not to an LWP, because
4520 of the check for parent-process. If we need this to work for an
4521 LWP, it needs some more logic. */
4524 unconditionally_kill_inferior (procinfo
*pi
)
4528 parent_pid
= proc_parent_pid (pi
);
4529 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4530 /* FIXME: use access functions. */
4531 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4532 before the PIOCKILL, otherwise it might generate a corrupted core
4533 file for the inferior. */
4534 if (ioctl (pi
->ctl_fd
, PIOCSSIG
, NULL
) < 0)
4536 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4539 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4540 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4541 to kill the inferior, otherwise it might remain stopped with a
4543 We do not check the result of the PIOCSSIG, the inferior might have
4546 gdb_siginfo_t newsiginfo
;
4548 memset ((char *) &newsiginfo
, 0, sizeof (newsiginfo
));
4549 newsiginfo
.si_signo
= SIGKILL
;
4550 newsiginfo
.si_code
= 0;
4551 newsiginfo
.si_errno
= 0;
4552 newsiginfo
.si_pid
= getpid ();
4553 newsiginfo
.si_uid
= getuid ();
4554 /* FIXME: use proc_set_current_signal. */
4555 ioctl (pi
->ctl_fd
, PIOCSSIG
, &newsiginfo
);
4557 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4558 if (!proc_kill (pi
, SIGKILL
))
4559 proc_error (pi
, "unconditionally_kill, proc_kill", __LINE__
);
4560 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4561 destroy_procinfo (pi
);
4563 /* If pi is GDB's child, wait for it to die. */
4564 if (parent_pid
== getpid ())
4565 /* FIXME: should we use waitpid to make sure we get the right event?
4566 Should we check the returned event? */
4571 ret
= waitpid (pi
->pid
, &status
, 0);
4578 /* We're done debugging it, and we want it to go away. Then we want
4579 GDB to forget all about it. */
4582 procfs_kill_inferior (struct target_ops
*ops
)
4584 if (!ptid_equal (inferior_ptid
, null_ptid
)) /* ? */
4586 /* Find procinfo for main process. */
4587 procinfo
*pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4590 unconditionally_kill_inferior (pi
);
4591 target_mourn_inferior ();
4595 /* Forget we ever debugged this thing! */
4598 procfs_mourn_inferior (struct target_ops
*ops
)
4602 if (!ptid_equal (inferior_ptid
, null_ptid
))
4604 /* Find procinfo for main process. */
4605 pi
= find_procinfo (PIDGET (inferior_ptid
), 0);
4607 destroy_procinfo (pi
);
4609 unpush_target (ops
);
4611 if (dbx_link_bpt
!= NULL
)
4613 deprecated_remove_raw_breakpoint (target_gdbarch
, dbx_link_bpt
);
4614 dbx_link_bpt_addr
= 0;
4615 dbx_link_bpt
= NULL
;
4618 generic_mourn_inferior ();
4621 /* When GDB forks to create a runnable inferior process, this function
4622 is called on the parent side of the fork. It's job is to do
4623 whatever is necessary to make the child ready to be debugged, and
4624 then wait for the child to synchronize. */
4627 procfs_init_inferior (struct target_ops
*ops
, int pid
)
4630 gdb_sigset_t signals
;
4634 /* This routine called on the parent side (GDB side)
4635 after GDB forks the inferior. */
4638 if ((pi
= create_procinfo (pid
, 0)) == NULL
)
4639 perror (_("procfs: out of memory in 'init_inferior'"));
4641 if (!open_procinfo_files (pi
, FD_CTL
))
4642 proc_error (pi
, "init_inferior, open_proc_files", __LINE__
);
4646 open_procinfo_files // done
4649 procfs_notice_signals
4656 /* If not stopped yet, wait for it to stop. */
4657 if (!(proc_flags (pi
) & PR_STOPPED
) &&
4658 !(proc_wait_for_stop (pi
)))
4659 dead_procinfo (pi
, "init_inferior: wait_for_stop failed", KILL
);
4661 /* Save some of the /proc state to be restored if we detach. */
4662 /* FIXME: Why? In case another debugger was debugging it?
4663 We're it's parent, for Ghu's sake! */
4664 if (!proc_get_traced_signals (pi
, &pi
->saved_sigset
))
4665 proc_error (pi
, "init_inferior, get_traced_signals", __LINE__
);
4666 if (!proc_get_held_signals (pi
, &pi
->saved_sighold
))
4667 proc_error (pi
, "init_inferior, get_held_signals", __LINE__
);
4668 if (!proc_get_traced_faults (pi
, &pi
->saved_fltset
))
4669 proc_error (pi
, "init_inferior, get_traced_faults", __LINE__
);
4670 if (!proc_get_traced_sysentry (pi
, pi
->saved_entryset
))
4671 proc_error (pi
, "init_inferior, get_traced_sysentry", __LINE__
);
4672 if (!proc_get_traced_sysexit (pi
, pi
->saved_exitset
))
4673 proc_error (pi
, "init_inferior, get_traced_sysexit", __LINE__
);
4675 if ((fail
= procfs_debug_inferior (pi
)) != 0)
4676 proc_error (pi
, "init_inferior (procfs_debug_inferior)", fail
);
4678 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4679 and possibly even turning ON kill-on-last-close at this point. But
4680 I can't make that change without careful testing which I don't have
4681 time to do right now... */
4682 /* Turn on run-on-last-close flag so that the child
4683 will die if GDB goes away for some reason. */
4684 if (!proc_set_run_on_last_close (pi
))
4685 proc_error (pi
, "init_inferior, set_RLC", __LINE__
);
4687 /* We now have have access to the lwpid of the main thread/lwp. */
4688 lwpid
= proc_get_current_thread (pi
);
4690 /* Create a procinfo for the main lwp. */
4691 create_procinfo (pid
, lwpid
);
4693 /* We already have a main thread registered in the thread table at
4694 this point, but it didn't have any lwp info yet. Notify the core
4695 about it. This changes inferior_ptid as well. */
4696 thread_change_ptid (pid_to_ptid (pid
),
4697 MERGEPID (pid
, lwpid
));
4699 /* Typically two, one trap to exec the shell, one to exec the
4700 program being debugged. Defined by "inferior.h". */
4701 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
4704 /* On mips-irix, we need to stop the inferior early enough during
4705 the startup phase in order to be able to load the shared library
4706 symbols and insert the breakpoints that are located in these shared
4707 libraries. Stopping at the program entry point is not good enough
4708 because the -init code is executed before the execution reaches
4711 So what we need to do is to insert a breakpoint in the runtime
4712 loader (rld), more precisely in __dbx_link(). This procedure is
4713 called by rld once all shared libraries have been mapped, but before
4714 the -init code is executed. Unfortuantely, this is not straightforward,
4715 as rld is not part of the executable we are running, and thus we need
4716 the inferior to run until rld itself has been mapped in memory.
4718 For this, we trace all syssgi() syscall exit events. Each time
4719 we detect such an event, we iterate over each text memory maps,
4720 get its associated fd, and scan the symbol table for __dbx_link().
4721 When found, we know that rld has been mapped, and that we can insert
4722 the breakpoint at the symbol address. Once the dbx_link() breakpoint
4723 has been inserted, the syssgi() notifications are no longer necessary,
4724 so they should be canceled. */
4725 proc_trace_syscalls_1 (pi
, SYS_syssgi
, PR_SYSEXIT
, FLAG_SET
, 0);
4729 /* When GDB forks to create a new process, this function is called on
4730 the child side of the fork before GDB exec's the user program. Its
4731 job is to make the child minimally debuggable, so that the parent
4732 GDB process can connect to the child and take over. This function
4733 should do only the minimum to make that possible, and to
4734 synchronize with the parent process. The parent process should
4735 take care of the details. */
4738 procfs_set_exec_trap (void)
4740 /* This routine called on the child side (inferior side)
4741 after GDB forks the inferior. It must use only local variables,
4742 because it may be sharing data space with its parent. */
4747 if ((pi
= create_procinfo (getpid (), 0)) == NULL
)
4748 perror_with_name (_("procfs: create_procinfo failed in child."));
4750 if (open_procinfo_files (pi
, FD_CTL
) == 0)
4752 proc_warn (pi
, "set_exec_trap, open_proc_files", __LINE__
);
4753 gdb_flush (gdb_stderr
);
4754 /* No need to call "dead_procinfo", because we're going to
4759 #ifdef PRFS_STOPEXEC /* defined on OSF */
4760 /* OSF method for tracing exec syscalls. Quoting:
4761 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4762 exits from exec system calls because of the user level loader. */
4763 /* FIXME: make nice and maybe move into an access function. */
4767 if (ioctl (pi
->ctl_fd
, PIOCGSPCACT
, &prfs_flags
) < 0)
4769 proc_warn (pi
, "set_exec_trap (PIOCGSPCACT)", __LINE__
);
4770 gdb_flush (gdb_stderr
);
4773 prfs_flags
|= PRFS_STOPEXEC
;
4775 if (ioctl (pi
->ctl_fd
, PIOCSSPCACT
, &prfs_flags
) < 0)
4777 proc_warn (pi
, "set_exec_trap (PIOCSSPCACT)", __LINE__
);
4778 gdb_flush (gdb_stderr
);
4782 #else /* not PRFS_STOPEXEC */
4783 /* Everyone else's (except OSF) method for tracing exec syscalls. */
4785 Not all systems with /proc have all the exec* syscalls with the same
4786 names. On the SGI, for example, there is no SYS_exec, but there
4787 *is* a SYS_execv. So, we try to account for that. */
4789 exitset
= sysset_t_alloc (pi
);
4790 gdb_premptysysset (exitset
);
4792 gdb_praddsysset (exitset
, SYS_exec
);
4795 gdb_praddsysset (exitset
, SYS_execve
);
4798 gdb_praddsysset (exitset
, SYS_execv
);
4800 #ifdef DYNAMIC_SYSCALLS
4802 int callnum
= find_syscall (pi
, "execve");
4805 gdb_praddsysset (exitset
, callnum
);
4807 callnum
= find_syscall (pi
, "ra_execve");
4809 gdb_praddsysset (exitset
, callnum
);
4811 #endif /* DYNAMIC_SYSCALLS */
4813 if (!proc_set_traced_sysexit (pi
, exitset
))
4815 proc_warn (pi
, "set_exec_trap, set_traced_sysexit", __LINE__
);
4816 gdb_flush (gdb_stderr
);
4819 #endif /* PRFS_STOPEXEC */
4821 /* FIXME: should this be done in the parent instead? */
4822 /* Turn off inherit on fork flag so that all grand-children
4823 of gdb start with tracing flags cleared. */
4824 if (!proc_unset_inherit_on_fork (pi
))
4825 proc_warn (pi
, "set_exec_trap, unset_inherit", __LINE__
);
4827 /* Turn off run on last close flag, so that the child process
4828 cannot run away just because we close our handle on it.
4829 We want it to wait for the parent to attach. */
4830 if (!proc_unset_run_on_last_close (pi
))
4831 proc_warn (pi
, "set_exec_trap, unset_RLC", __LINE__
);
4833 /* FIXME: No need to destroy the procinfo --
4834 we have our own address space, and we're about to do an exec! */
4835 /*destroy_procinfo (pi);*/
4838 /* This function is called BEFORE gdb forks the inferior process. Its
4839 only real responsibility is to set things up for the fork, and tell
4840 GDB which two functions to call after the fork (one for the parent,
4841 and one for the child).
4843 This function does a complicated search for a unix shell program,
4844 which it then uses to parse arguments and environment variables to
4845 be sent to the child. I wonder whether this code could not be
4846 abstracted out and shared with other unix targets such as
4850 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
4851 char *allargs
, char **env
, int from_tty
)
4853 char *shell_file
= getenv ("SHELL");
4857 if (shell_file
!= NULL
&& strchr (shell_file
, '/') == NULL
)
4860 /* We will be looking down the PATH to find shell_file. If we
4861 just do this the normal way (via execlp, which operates by
4862 attempting an exec for each element of the PATH until it
4863 finds one which succeeds), then there will be an exec for
4864 each failed attempt, each of which will cause a PR_SYSEXIT
4865 stop, and we won't know how to distinguish the PR_SYSEXIT's
4866 for these failed execs with the ones for successful execs
4867 (whether the exec has succeeded is stored at that time in the
4868 carry bit or some such architecture-specific and
4869 non-ABI-specified place).
4871 So I can't think of anything better than to search the PATH
4872 now. This has several disadvantages: (1) There is a race
4873 condition; if we find a file now and it is deleted before we
4874 exec it, we lose, even if the deletion leaves a valid file
4875 further down in the PATH, (2) there is no way to know exactly
4876 what an executable (in the sense of "capable of being
4877 exec'd") file is. Using access() loses because it may lose
4878 if the caller is the superuser; failing to use it loses if
4879 there are ACLs or some such. */
4883 /* FIXME-maybe: might want "set path" command so user can change what
4884 path is used from within GDB. */
4885 char *path
= getenv ("PATH");
4887 struct stat statbuf
;
4890 path
= "/bin:/usr/bin";
4892 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
4893 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
4895 p1
= strchr (p
, ':');
4900 strncpy (tryname
, p
, len
);
4901 tryname
[len
] = '\0';
4902 strcat (tryname
, "/");
4903 strcat (tryname
, shell_file
);
4904 if (access (tryname
, X_OK
) < 0)
4906 if (stat (tryname
, &statbuf
) < 0)
4908 if (!S_ISREG (statbuf
.st_mode
))
4909 /* We certainly need to reject directories. I'm not quite
4910 as sure about FIFOs, sockets, etc., but I kind of doubt
4911 that people want to exec() these things. */
4916 /* Not found. This must be an error rather than merely passing
4917 the file to execlp(), because execlp() would try all the
4918 exec()s, causing GDB to get confused. */
4919 error (_("procfs:%d -- Can't find shell %s in PATH"),
4920 __LINE__
, shell_file
);
4922 shell_file
= tryname
;
4925 pid
= fork_inferior (exec_file
, allargs
, env
, procfs_set_exec_trap
,
4926 NULL
, NULL
, shell_file
, NULL
);
4928 procfs_init_inferior (ops
, pid
);
4931 /* An observer for the "inferior_created" event. */
4934 procfs_inferior_created (struct target_ops
*ops
, int from_tty
)
4937 /* Make sure to cancel the syssgi() syscall-exit notifications.
4938 They should normally have been removed by now, but they may still
4939 be activated if the inferior doesn't use shared libraries, or if
4940 we didn't locate __dbx_link, or if we never stopped in __dbx_link.
4941 See procfs_init_inferior() for more details.
4943 Since these notifications are only ever enabled when we spawned
4944 the inferior ourselves, there is nothing to do when the inferior
4945 was created by attaching to an already running process, or when
4946 debugging a core file. */
4947 if (current_inferior ()->attach_flag
|| !target_can_run (¤t_target
))
4950 proc_trace_syscalls_1 (find_procinfo_or_die (PIDGET (inferior_ptid
), 0),
4951 SYS_syssgi
, PR_SYSEXIT
, FLAG_RESET
, 0);
4955 /* Callback for find_new_threads. Calls "add_thread". */
4958 procfs_notice_thread (procinfo
*pi
, procinfo
*thread
, void *ptr
)
4960 ptid_t gdb_threadid
= MERGEPID (pi
->pid
, thread
->tid
);
4962 if (!in_thread_list (gdb_threadid
) || is_exited (gdb_threadid
))
4963 add_thread (gdb_threadid
);
4968 /* Query all the threads that the target knows about, and give them
4969 back to GDB to add to its list. */
4972 procfs_find_new_threads (struct target_ops
*ops
)
4976 /* Find procinfo for main process. */
4977 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
4978 proc_update_threads (pi
);
4979 proc_iterate_over_threads (pi
, procfs_notice_thread
, NULL
);
4982 /* Return true if the thread is still 'alive'. This guy doesn't
4983 really seem to be doing his job. Got to investigate how to tell
4984 when a thread is really gone. */
4987 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4992 proc
= PIDGET (ptid
);
4993 thread
= TIDGET (ptid
);
4994 /* If I don't know it, it ain't alive! */
4995 if ((pi
= find_procinfo (proc
, thread
)) == NULL
)
4998 /* If I can't get its status, it ain't alive!
4999 What's more, I need to forget about it! */
5000 if (!proc_get_status (pi
))
5002 destroy_procinfo (pi
);
5005 /* I couldn't have got its status if it weren't alive, so it's
5010 /* Convert PTID to a string. Returns the string in a static
5014 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
5016 static char buf
[80];
5018 if (TIDGET (ptid
) == 0)
5019 sprintf (buf
, "process %d", PIDGET (ptid
));
5021 sprintf (buf
, "LWP %ld", TIDGET (ptid
));
5026 /* Insert a watchpoint. */
5029 procfs_set_watchpoint (ptid_t ptid
, CORE_ADDR addr
, int len
, int rwflag
,
5037 pi
= find_procinfo_or_die (PIDGET (ptid
) == -1 ?
5038 PIDGET (inferior_ptid
) : PIDGET (ptid
), 0);
5040 /* Translate from GDB's flags to /proc's. */
5041 if (len
> 0) /* len == 0 means delete watchpoint. */
5043 switch (rwflag
) { /* FIXME: need an enum! */
5044 case hw_write
: /* default watchpoint (write) */
5045 pflags
= WRITE_WATCHFLAG
;
5047 case hw_read
: /* read watchpoint */
5048 pflags
= READ_WATCHFLAG
;
5050 case hw_access
: /* access watchpoint */
5051 pflags
= READ_WATCHFLAG
| WRITE_WATCHFLAG
;
5053 case hw_execute
: /* execution HW breakpoint */
5054 pflags
= EXEC_WATCHFLAG
;
5056 default: /* Something weird. Return error. */
5059 if (after
) /* Stop after r/w access is completed. */
5060 pflags
|= AFTER_WATCHFLAG
;
5063 if (!proc_set_watchpoint (pi
, addr
, len
, pflags
))
5065 if (errno
== E2BIG
) /* Typical error for no resources. */
5066 return -1; /* fail */
5067 /* GDB may try to remove the same watchpoint twice.
5068 If a remove request returns no match, don't error. */
5069 if (errno
== ESRCH
&& len
== 0)
5070 return 0; /* ignore */
5071 proc_error (pi
, "set_watchpoint", __LINE__
);
5074 #endif /* UNIXWARE */
5078 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
5079 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
5080 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
5083 Note: procfs_can_use_hw_breakpoint() is not yet used by all
5084 procfs.c targets due to the fact that some of them still define
5085 target_can_use_hardware_watchpoint. */
5088 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
5090 /* Due to the way that proc_set_watchpoint() is implemented, host
5091 and target pointers must be of the same size. If they are not,
5092 we can't use hardware watchpoints. This limitation is due to the
5093 fact that proc_set_watchpoint() calls
5094 procfs_address_to_host_pointer(); a close inspection of
5095 procfs_address_to_host_pointer will reveal that an internal error
5096 will be generated when the host and target pointer sizes are
5098 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
5100 if (sizeof (void *) != TYPE_LENGTH (ptr_type
))
5103 /* Other tests here??? */
5108 /* Returns non-zero if process is stopped on a hardware watchpoint
5109 fault, else returns zero. */
5112 procfs_stopped_by_watchpoint (void)
5116 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5118 if (proc_flags (pi
) & (PR_STOPPED
| PR_ISTOP
))
5120 if (proc_why (pi
) == PR_FAULTED
)
5123 if (proc_what (pi
) == FLTWATCH
)
5127 if (proc_what (pi
) == FLTKWATCH
)
5135 /* Returns 1 if the OS knows the position of the triggered watchpoint,
5136 and sets *ADDR to that address. Returns 0 if OS cannot report that
5137 address. This function is only called if
5138 procfs_stopped_by_watchpoint returned 1, thus no further checks are
5139 done. The function also assumes that ADDR is not NULL. */
5142 procfs_stopped_data_address (struct target_ops
*targ
, CORE_ADDR
*addr
)
5146 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5147 return proc_watchpoint_address (pi
, addr
);
5151 procfs_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
5152 struct expression
*cond
)
5154 if (!target_have_steppable_watchpoint
5155 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch
))
5157 /* When a hardware watchpoint fires off the PC will be left at
5158 the instruction following the one which caused the
5159 watchpoint. It will *NOT* be necessary for GDB to step over
5161 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 1);
5165 /* When a hardware watchpoint fires off the PC will be left at
5166 the instruction which caused the watchpoint. It will be
5167 necessary for GDB to step over the watchpoint. */
5168 return procfs_set_watchpoint (inferior_ptid
, addr
, len
, type
, 0);
5173 procfs_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
5174 struct expression
*cond
)
5176 return procfs_set_watchpoint (inferior_ptid
, addr
, 0, 0, 0);
5180 procfs_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
5182 /* The man page for proc(4) on Solaris 2.6 and up says that the
5183 system can support "thousands" of hardware watchpoints, but gives
5184 no method for finding out how many; It doesn't say anything about
5185 the allowed size for the watched area either. So we just tell
5191 procfs_use_watchpoints (struct target_ops
*t
)
5193 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
5194 t
->to_insert_watchpoint
= procfs_insert_watchpoint
;
5195 t
->to_remove_watchpoint
= procfs_remove_watchpoint
;
5196 t
->to_region_ok_for_hw_watchpoint
= procfs_region_ok_for_hw_watchpoint
;
5197 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
5198 t
->to_stopped_data_address
= procfs_stopped_data_address
;
5201 /* Memory Mappings Functions: */
5203 /* Call a callback function once for each mapping, passing it the
5204 mapping, an optional secondary callback function, and some optional
5205 opaque data. Quit and return the first non-zero value returned
5208 PI is the procinfo struct for the process to be mapped. FUNC is
5209 the callback function to be called by this iterator. DATA is the
5210 optional opaque data to be passed to the callback function.
5211 CHILD_FUNC is the optional secondary function pointer to be passed
5212 to the child function. Returns the first non-zero return value
5213 from the callback function, or zero. */
5216 iterate_over_mappings (procinfo
*pi
, find_memory_region_ftype child_func
,
5218 int (*func
) (struct prmap
*map
,
5219 find_memory_region_ftype child_func
,
5222 char pathname
[MAX_PROC_NAME_SIZE
];
5223 struct prmap
*prmaps
;
5224 struct prmap
*prmap
;
5228 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
5233 /* Get the number of mappings, allocate space,
5234 and read the mappings into prmaps. */
5237 sprintf (pathname
, "/proc/%d/map", pi
->pid
);
5238 if ((map_fd
= open (pathname
, O_RDONLY
)) < 0)
5239 proc_error (pi
, "iterate_over_mappings (open)", __LINE__
);
5241 /* Make sure it gets closed again. */
5242 make_cleanup_close (map_fd
);
5244 /* Use stat to determine the file size, and compute
5245 the number of prmap_t objects it contains. */
5246 if (fstat (map_fd
, &sbuf
) != 0)
5247 proc_error (pi
, "iterate_over_mappings (fstat)", __LINE__
);
5249 nmap
= sbuf
.st_size
/ sizeof (prmap_t
);
5250 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5251 if (read (map_fd
, (char *) prmaps
, nmap
* sizeof (*prmaps
))
5252 != (nmap
* sizeof (*prmaps
)))
5253 proc_error (pi
, "iterate_over_mappings (read)", __LINE__
);
5255 /* Use ioctl command PIOCNMAP to get number of mappings. */
5256 if (ioctl (pi
->ctl_fd
, PIOCNMAP
, &nmap
) != 0)
5257 proc_error (pi
, "iterate_over_mappings (PIOCNMAP)", __LINE__
);
5259 prmaps
= (struct prmap
*) alloca ((nmap
+ 1) * sizeof (*prmaps
));
5260 if (ioctl (pi
->ctl_fd
, PIOCMAP
, prmaps
) != 0)
5261 proc_error (pi
, "iterate_over_mappings (PIOCMAP)", __LINE__
);
5264 for (prmap
= prmaps
; nmap
> 0; prmap
++, nmap
--)
5265 if ((funcstat
= (*func
) (prmap
, child_func
, data
)) != 0)
5267 do_cleanups (cleanups
);
5271 do_cleanups (cleanups
);
5275 /* Implements the to_find_memory_regions method. Calls an external
5276 function for each memory region.
5277 Returns the integer value returned by the callback. */
5280 find_memory_regions_callback (struct prmap
*map
,
5281 find_memory_region_ftype func
, void *data
)
5283 return (*func
) ((CORE_ADDR
) map
->pr_vaddr
,
5285 (map
->pr_mflags
& MA_READ
) != 0,
5286 (map
->pr_mflags
& MA_WRITE
) != 0,
5287 (map
->pr_mflags
& MA_EXEC
) != 0,
5291 /* External interface. Calls a callback function once for each
5292 mapped memory region in the child process, passing as arguments:
5294 CORE_ADDR virtual_address,
5296 int read, TRUE if region is readable by the child
5297 int write, TRUE if region is writable by the child
5298 int execute TRUE if region is executable by the child.
5300 Stops iterating and returns the first non-zero value returned by
5304 proc_find_memory_regions (find_memory_region_ftype func
, void *data
)
5306 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5308 return iterate_over_mappings (pi
, func
, data
,
5309 find_memory_regions_callback
);
5312 /* Returns an ascii representation of a memory mapping's flags. */
5315 mappingflags (long flags
)
5317 static char asciiflags
[8];
5319 strcpy (asciiflags
, "-------");
5320 #if defined (MA_PHYS)
5321 if (flags
& MA_PHYS
)
5322 asciiflags
[0] = 'd';
5324 if (flags
& MA_STACK
)
5325 asciiflags
[1] = 's';
5326 if (flags
& MA_BREAK
)
5327 asciiflags
[2] = 'b';
5328 if (flags
& MA_SHARED
)
5329 asciiflags
[3] = 's';
5330 if (flags
& MA_READ
)
5331 asciiflags
[4] = 'r';
5332 if (flags
& MA_WRITE
)
5333 asciiflags
[5] = 'w';
5334 if (flags
& MA_EXEC
)
5335 asciiflags
[6] = 'x';
5336 return (asciiflags
);
5339 /* Callback function, does the actual work for 'info proc
5343 info_mappings_callback (struct prmap
*map
, find_memory_region_ftype ignore
,
5346 unsigned int pr_off
;
5348 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
5349 pr_off
= (unsigned int) map
->pr_offset
;
5351 pr_off
= map
->pr_off
;
5354 if (gdbarch_addr_bit (target_gdbarch
) == 32)
5355 printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
5356 (unsigned long) map
->pr_vaddr
,
5357 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5358 (unsigned long) map
->pr_size
,
5360 mappingflags (map
->pr_mflags
));
5362 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
5363 (unsigned long) map
->pr_vaddr
,
5364 (unsigned long) map
->pr_vaddr
+ map
->pr_size
- 1,
5365 (unsigned long) map
->pr_size
,
5367 mappingflags (map
->pr_mflags
));
5372 /* Implement the "info proc mappings" subcommand. */
5375 info_proc_mappings (procinfo
*pi
, int summary
)
5378 return; /* No output for summary mode. */
5380 printf_filtered (_("Mapped address spaces:\n\n"));
5381 if (gdbarch_ptr_bit (target_gdbarch
) == 32)
5382 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
5389 printf_filtered (" %18s %18s %10s %10s %7s\n",
5396 iterate_over_mappings (pi
, NULL
, NULL
, info_mappings_callback
);
5397 printf_filtered ("\n");
5400 /* Implement the "info proc" command. */
5403 procfs_info_proc (struct target_ops
*ops
, char *args
,
5404 enum info_proc_what what
)
5406 struct cleanup
*old_chain
;
5407 procinfo
*process
= NULL
;
5408 procinfo
*thread
= NULL
;
5426 error (_("Not supported on this target."));
5429 old_chain
= make_cleanup (null_cleanup
, 0);
5432 argv
= gdb_buildargv (args
);
5433 make_cleanup_freeargv (argv
);
5435 while (argv
!= NULL
&& *argv
!= NULL
)
5437 if (isdigit (argv
[0][0]))
5439 pid
= strtoul (argv
[0], &tmp
, 10);
5441 tid
= strtoul (++tmp
, NULL
, 10);
5443 else if (argv
[0][0] == '/')
5445 tid
= strtoul (argv
[0] + 1, NULL
, 10);
5450 pid
= PIDGET (inferior_ptid
);
5452 error (_("No current process: you must name one."));
5455 /* Have pid, will travel.
5456 First see if it's a process we're already debugging. */
5457 process
= find_procinfo (pid
, 0);
5458 if (process
== NULL
)
5460 /* No. So open a procinfo for it, but
5461 remember to close it again when finished. */
5462 process
= create_procinfo (pid
, 0);
5463 make_cleanup (do_destroy_procinfo_cleanup
, process
);
5464 if (!open_procinfo_files (process
, FD_CTL
))
5465 proc_error (process
, "info proc, open_procinfo_files", __LINE__
);
5469 thread
= create_procinfo (pid
, tid
);
5473 printf_filtered (_("process %d flags:\n"), process
->pid
);
5474 proc_prettyprint_flags (proc_flags (process
), 1);
5475 if (proc_flags (process
) & (PR_STOPPED
| PR_ISTOP
))
5476 proc_prettyprint_why (proc_why (process
), proc_what (process
), 1);
5477 if (proc_get_nthreads (process
) > 1)
5478 printf_filtered ("Process has %d threads.\n",
5479 proc_get_nthreads (process
));
5483 printf_filtered (_("thread %d flags:\n"), thread
->tid
);
5484 proc_prettyprint_flags (proc_flags (thread
), 1);
5485 if (proc_flags (thread
) & (PR_STOPPED
| PR_ISTOP
))
5486 proc_prettyprint_why (proc_why (thread
), proc_what (thread
), 1);
5491 info_proc_mappings (process
, 0);
5494 do_cleanups (old_chain
);
5497 /* Modify the status of the system call identified by SYSCALLNUM in
5498 the set of syscalls that are currently traced/debugged.
5500 If ENTRY_OR_EXIT is set to PR_SYSENTRY, then the entry syscalls set
5501 will be updated. Otherwise, the exit syscalls set will be updated.
5503 If MODE is FLAG_SET, then traces will be enabled. Otherwise, they
5504 will be disabled. */
5507 proc_trace_syscalls_1 (procinfo
*pi
, int syscallnum
, int entry_or_exit
,
5508 int mode
, int from_tty
)
5512 if (entry_or_exit
== PR_SYSENTRY
)
5513 sysset
= proc_get_traced_sysentry (pi
, NULL
);
5515 sysset
= proc_get_traced_sysexit (pi
, NULL
);
5518 proc_error (pi
, "proc-trace, get_traced_sysset", __LINE__
);
5520 if (mode
== FLAG_SET
)
5521 gdb_praddsysset (sysset
, syscallnum
);
5523 gdb_prdelsysset (sysset
, syscallnum
);
5525 if (entry_or_exit
== PR_SYSENTRY
)
5527 if (!proc_set_traced_sysentry (pi
, sysset
))
5528 proc_error (pi
, "proc-trace, set_traced_sysentry", __LINE__
);
5532 if (!proc_set_traced_sysexit (pi
, sysset
))
5533 proc_error (pi
, "proc-trace, set_traced_sysexit", __LINE__
);
5538 proc_trace_syscalls (char *args
, int from_tty
, int entry_or_exit
, int mode
)
5542 if (PIDGET (inferior_ptid
) <= 0)
5543 error (_("you must be debugging a process to use this command."));
5545 if (args
== NULL
|| args
[0] == 0)
5546 error_no_arg (_("system call to trace"));
5548 pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5549 if (isdigit (args
[0]))
5551 const int syscallnum
= atoi (args
);
5553 proc_trace_syscalls_1 (pi
, syscallnum
, entry_or_exit
, mode
, from_tty
);
5558 proc_trace_sysentry_cmd (char *args
, int from_tty
)
5560 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_SET
);
5564 proc_trace_sysexit_cmd (char *args
, int from_tty
)
5566 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_SET
);
5570 proc_untrace_sysentry_cmd (char *args
, int from_tty
)
5572 proc_trace_syscalls (args
, from_tty
, PR_SYSENTRY
, FLAG_RESET
);
5576 proc_untrace_sysexit_cmd (char *args
, int from_tty
)
5578 proc_trace_syscalls (args
, from_tty
, PR_SYSEXIT
, FLAG_RESET
);
5582 /* Provide a prototype to silence -Wmissing-prototypes. */
5583 extern void _initialize_procfs (void);
5586 _initialize_procfs (void)
5588 observer_attach_inferior_created (procfs_inferior_created
);
5590 add_com ("proc-trace-entry", no_class
, proc_trace_sysentry_cmd
,
5591 _("Give a trace of entries into the syscall."));
5592 add_com ("proc-trace-exit", no_class
, proc_trace_sysexit_cmd
,
5593 _("Give a trace of exits from the syscall."));
5594 add_com ("proc-untrace-entry", no_class
, proc_untrace_sysentry_cmd
,
5595 _("Cancel a trace of entries into the syscall."));
5596 add_com ("proc-untrace-exit", no_class
, proc_untrace_sysexit_cmd
,
5597 _("Cancel a trace of exits from the syscall."));
5600 /* =================== END, GDB "MODULE" =================== */
5604 /* miscellaneous stubs: */
5606 /* The following satisfy a few random symbols mostly created by the
5607 solaris threads implementation, which I will chase down later. */
5609 /* Return a pid for which we guarantee we will be able to find a
5613 procfs_first_available (void)
5615 return pid_to_ptid (procinfo_list
? procinfo_list
->pid
: -1);
5618 /* =================== GCORE .NOTE "MODULE" =================== */
5619 #if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT)
5620 /* gcore only implemented on solaris and unixware (so far) */
5623 procfs_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
5624 char *note_data
, int *note_size
,
5625 enum target_signal stop_signal
)
5627 struct regcache
*regcache
= get_thread_regcache (ptid
);
5628 gdb_gregset_t gregs
;
5629 gdb_fpregset_t fpregs
;
5630 unsigned long merged_pid
;
5631 struct cleanup
*old_chain
;
5633 merged_pid
= TIDGET (ptid
) << 16 | PIDGET (ptid
);
5635 /* This part is the old method for fetching registers.
5636 It should be replaced by the newer one using regsets
5637 once it is implemented in this platform:
5638 gdbarch_regset_from_core_section() and regset->collect_regset(). */
5640 old_chain
= save_inferior_ptid ();
5641 inferior_ptid
= ptid
;
5642 target_fetch_registers (regcache
, -1);
5644 fill_gregset (regcache
, &gregs
, -1);
5645 #if defined (NEW_PROC_API)
5646 note_data
= (char *) elfcore_write_lwpstatus (obfd
,
5653 note_data
= (char *) elfcore_write_prstatus (obfd
,
5660 fill_fpregset (regcache
, &fpregs
, -1);
5661 note_data
= (char *) elfcore_write_prfpreg (obfd
,
5667 do_cleanups (old_chain
);
5672 struct procfs_corefile_thread_data
{
5676 enum target_signal stop_signal
;
5680 procfs_corefile_thread_callback (procinfo
*pi
, procinfo
*thread
, void *data
)
5682 struct procfs_corefile_thread_data
*args
= data
;
5686 ptid_t ptid
= MERGEPID (pi
->pid
, thread
->tid
);
5688 args
->note_data
= procfs_do_thread_registers (args
->obfd
, ptid
,
5697 find_signalled_thread (struct thread_info
*info
, void *data
)
5699 if (info
->suspend
.stop_signal
!= TARGET_SIGNAL_0
5700 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
5706 static enum target_signal
5707 find_stop_signal (void)
5709 struct thread_info
*info
=
5710 iterate_over_threads (find_signalled_thread
, NULL
);
5713 return info
->suspend
.stop_signal
;
5715 return TARGET_SIGNAL_0
;
5719 procfs_make_note_section (bfd
*obfd
, int *note_size
)
5721 struct cleanup
*old_chain
;
5722 gdb_gregset_t gregs
;
5723 gdb_fpregset_t fpregs
;
5724 char fname
[16] = {'\0'};
5725 char psargs
[80] = {'\0'};
5726 procinfo
*pi
= find_procinfo_or_die (PIDGET (inferior_ptid
), 0);
5727 char *note_data
= NULL
;
5729 struct procfs_corefile_thread_data thread_args
;
5732 enum target_signal stop_signal
;
5734 if (get_exec_file (0))
5736 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
5737 fname
[sizeof (fname
) - 1] = 0;
5738 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
5739 psargs
[sizeof (psargs
) - 1] = 0;
5741 inf_args
= get_inferior_args ();
5742 if (inf_args
&& *inf_args
&&
5743 strlen (inf_args
) < ((int) sizeof (psargs
) - (int) strlen (psargs
)))
5745 strncat (psargs
, " ",
5746 sizeof (psargs
) - strlen (psargs
));
5747 strncat (psargs
, inf_args
,
5748 sizeof (psargs
) - strlen (psargs
));
5752 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
5758 stop_signal
= find_stop_signal ();
5761 fill_gregset (get_current_regcache (), &gregs
, -1);
5762 note_data
= elfcore_write_pstatus (obfd
, note_data
, note_size
,
5763 PIDGET (inferior_ptid
),
5764 stop_signal
, &gregs
);
5767 thread_args
.obfd
= obfd
;
5768 thread_args
.note_data
= note_data
;
5769 thread_args
.note_size
= note_size
;
5770 thread_args
.stop_signal
= stop_signal
;
5771 proc_iterate_over_threads (pi
, procfs_corefile_thread_callback
,
5774 /* There should be always at least one thread. */
5775 gdb_assert (thread_args
.note_data
!= note_data
);
5776 note_data
= thread_args
.note_data
;
5778 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
5782 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
5783 "CORE", NT_AUXV
, auxv
, auxv_len
);
5787 make_cleanup (xfree
, note_data
);
5790 #else /* !(Solaris or Unixware) */
5792 procfs_make_note_section (bfd
*obfd
, int *note_size
)
5794 error (_("gcore not implemented for this host."));
5795 return NULL
; /* lint */
5797 #endif /* Solaris or Unixware */
5798 /* =================== END GCORE .NOTE "MODULE" =================== */