1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 Written by Michael Snyder at Cygnus Solutions.
7 Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "elf-bfd.h" /* for elfcore_write_* */
30 #include "gdbthread.h"
32 #include "inf-child.h"
34 #if defined (NEW_PROC_API)
35 #define _STRUCTURED_PROC 1 /* Should be done by configure script. */
38 #include <sys/procfs.h>
39 #ifdef HAVE_SYS_FAULT_H
40 #include <sys/fault.h>
42 #ifdef HAVE_SYS_SYSCALL_H
43 #include <sys/syscall.h>
45 #include <sys/errno.h>
49 #include "gdb_string.h"
50 #include "gdb_assert.h"
56 /* This module provides the interface between GDB and the
57 /proc file system, which is used on many versions of Unix
58 as a means for debuggers to control other processes.
60 Examples of the systems that use this interface are:
68 /proc works by imitating a file system: you open a simulated file
69 that represents the process you wish to interact with, and perform
70 operations on that "file" in order to examine or change the state
73 The most important thing to know about /proc and this module is
74 that there are two very different interfaces to /proc:
76 One that uses the ioctl system call, and another that uses read
77 and write system calls.
79 This module has to support both /proc interfaces. This means that
80 there are two different ways of doing every basic operation.
82 In order to keep most of the code simple and clean, I have defined
83 an interface "layer" which hides all these system calls. An ifdef
84 (NEW_PROC_API) determines which interface we are using, and most or
85 all occurrances of this ifdef should be confined to this interface
88 /* Determine which /proc API we are using: The ioctl API defines
89 PIOCSTATUS, while the read/write (multiple fd) API never does. */
92 #include <sys/types.h>
93 #include "gdb_dirent.h" /* opendir/readdir, for listing the LWP's */
96 #include <fcntl.h> /* for O_RDONLY */
97 #include <unistd.h> /* for "X_OK" */
98 #include "gdb_stat.h" /* for struct stat */
100 /* Note: procfs-utils.h must be included after the above system header
101 files, because it redefines various system calls using macros.
102 This may be incompatible with the prototype declarations. */
104 #include "proc-utils.h"
106 /* Prototypes for supply_gregset etc. */
109 /* =================== TARGET_OPS "MODULE" =================== */
111 /* This module defines the GDB target vector and its methods. */
113 static void procfs_attach (struct target_ops *, char *, int);
114 static void procfs_detach (struct target_ops *, char *, int);
115 static void procfs_resume (struct target_ops *,
116 ptid_t, int, enum target_signal);
117 static void procfs_stop (ptid_t);
118 static void procfs_files_info (struct target_ops *);
119 static void procfs_fetch_registers (struct target_ops *,
120 struct regcache *, int);
121 static void procfs_store_registers (struct target_ops *,
122 struct regcache *, int);
123 static void procfs_notice_signals (ptid_t);
124 static void procfs_kill_inferior (struct target_ops *ops);
125 static void procfs_mourn_inferior (struct target_ops *ops);
126 static void procfs_create_inferior (struct target_ops *, char *,
127 char *, char **, int);
128 static ptid_t procfs_wait (struct target_ops *,
129 ptid_t, struct target_waitstatus *, int);
130 static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
131 struct mem_attrib *attrib,
132 struct target_ops *);
133 static LONGEST procfs_xfer_partial (struct target_ops *ops,
134 enum target_object object,
137 const gdb_byte *writebuf,
138 ULONGEST offset, LONGEST len);
140 static int procfs_thread_alive (struct target_ops *ops, ptid_t);
142 void procfs_find_new_threads (struct target_ops *ops);
143 char *procfs_pid_to_str (struct target_ops *, ptid_t);
145 static int proc_find_memory_regions (int (*) (CORE_ADDR,
151 static char * procfs_make_note_section (bfd *, int *);
153 static int procfs_can_use_hw_breakpoint (int, int, int);
155 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
156 /* When GDB is built as 64-bit application on Solaris, the auxv data
157 is presented in 64-bit format. We need to provide a custom parser
160 procfs_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
161 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
163 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
164 gdb_byte *ptr = *readptr;
169 if (endptr - ptr < 8 * 2)
172 *typep = extract_unsigned_integer (ptr, 4, byte_order);
174 /* The size of data is always 64-bit. If the application is 32-bit,
175 it will be zero extended, as expected. */
176 *valp = extract_unsigned_integer (ptr, 8, byte_order);
187 struct target_ops *t = inf_child_target ();
189 t->to_shortname = "procfs";
190 t->to_longname = "Unix /proc child process";
192 "Unix /proc child process (started by the \"run\" command).";
193 t->to_create_inferior = procfs_create_inferior;
194 t->to_kill = procfs_kill_inferior;
195 t->to_mourn_inferior = procfs_mourn_inferior;
196 t->to_attach = procfs_attach;
197 t->to_detach = procfs_detach;
198 t->to_wait = procfs_wait;
199 t->to_resume = procfs_resume;
200 t->to_fetch_registers = procfs_fetch_registers;
201 t->to_store_registers = procfs_store_registers;
202 t->to_xfer_partial = procfs_xfer_partial;
203 t->deprecated_xfer_memory = procfs_xfer_memory;
204 t->to_notice_signals = procfs_notice_signals;
205 t->to_files_info = procfs_files_info;
206 t->to_stop = procfs_stop;
208 t->to_find_new_threads = procfs_find_new_threads;
209 t->to_thread_alive = procfs_thread_alive;
210 t->to_pid_to_str = procfs_pid_to_str;
212 t->to_has_thread_control = tc_schedlock;
213 t->to_find_memory_regions = proc_find_memory_regions;
214 t->to_make_corefile_notes = procfs_make_note_section;
216 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
217 t->to_auxv_parse = procfs_auxv_parse;
220 t->to_magic = OPS_MAGIC;
225 /* =================== END, TARGET_OPS "MODULE" =================== */
227 /* World Unification:
229 Put any typedefs, defines etc. here that are required for the
230 unification of code that handles different versions of /proc. */
232 #ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
234 enum { READ_WATCHFLAG = WA_READ,
235 WRITE_WATCHFLAG = WA_WRITE,
236 EXEC_WATCHFLAG = WA_EXEC,
237 AFTER_WATCHFLAG = WA_TRAPAFTER
240 #else /* Irix method for watchpoints */
241 enum { READ_WATCHFLAG = MA_READ,
242 WRITE_WATCHFLAG = MA_WRITE,
243 EXEC_WATCHFLAG = MA_EXEC,
244 AFTER_WATCHFLAG = 0 /* trapafter not implemented */
249 #ifdef HAVE_PR_SIGSET_T
250 typedef pr_sigset_t gdb_sigset_t;
252 typedef sigset_t gdb_sigset_t;
256 #ifdef HAVE_PR_SIGACTION64_T
257 typedef pr_sigaction64_t gdb_sigaction_t;
259 typedef struct sigaction gdb_sigaction_t;
263 #ifdef HAVE_PR_SIGINFO64_T
264 typedef pr_siginfo64_t gdb_siginfo_t;
266 typedef struct siginfo gdb_siginfo_t;
269 /* On mips-irix, praddset and prdelset are defined in such a way that
270 they return a value, which causes GCC to emit a -Wunused error
271 because the returned value is not used. Prevent this warning
272 by casting the return value to void. On sparc-solaris, this issue
273 does not exist because the definition of these macros already include
274 that cast to void. */
275 #define gdb_praddset(sp, flag) ((void) praddset (sp, flag))
276 #define gdb_prdelset(sp, flag) ((void) prdelset (sp, flag))
278 /* gdb_premptysysset */
280 #define gdb_premptysysset premptysysset
282 #define gdb_premptysysset premptyset
287 #define gdb_praddsysset praddsysset
289 #define gdb_praddsysset gdb_praddset
294 #define gdb_prdelsysset prdelsysset
296 #define gdb_prdelsysset gdb_prdelset
299 /* prissyssetmember */
300 #ifdef prissyssetmember
301 #define gdb_pr_issyssetmember prissyssetmember
303 #define gdb_pr_issyssetmember prismember
306 /* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't
307 as intuitively descriptive as it could be, so we'll define
308 DYNAMIC_SYSCALLS to mean the same thing. Anyway, at the time of
309 this writing, this feature is only found on AIX5 systems and
310 basically means that the set of syscalls is not fixed. I.e,
311 there's no nice table that one can #include to get all of the
312 syscall numbers. Instead, they're stored in /proc/PID/sysent
313 for each process. We are at least guaranteed that they won't
314 change over the lifetime of the process. But each process could
315 (in theory) have different syscall numbers. */
316 #ifdef HAVE_PRSYSENT_T
317 #define DYNAMIC_SYSCALLS
322 /* =================== STRUCT PROCINFO "MODULE" =================== */
324 /* FIXME: this comment will soon be out of date W.R.T. threads. */
326 /* The procinfo struct is a wrapper to hold all the state information
327 concerning a /proc process. There should be exactly one procinfo
328 for each process, and since GDB currently can debug only one
329 process at a time, that means there should be only one procinfo.
330 All of the LWP's of a process can be accessed indirectly thru the
331 single process procinfo.
333 However, against the day when GDB may debug more than one process,
334 this data structure is kept in a list (which for now will hold no
335 more than one member), and many functions will have a pointer to a
336 procinfo as an argument.
338 There will be a separate procinfo structure for use by the (not yet
339 implemented) "info proc" command, so that we can print useful
340 information about any random process without interfering with the
341 inferior's procinfo information. */
344 /* format strings for /proc paths */
345 # ifndef CTL_PROC_NAME_FMT
346 # define MAIN_PROC_NAME_FMT "/proc/%d"
347 # define CTL_PROC_NAME_FMT "/proc/%d/ctl"
348 # define AS_PROC_NAME_FMT "/proc/%d/as"
349 # define MAP_PROC_NAME_FMT "/proc/%d/map"
350 # define STATUS_PROC_NAME_FMT "/proc/%d/status"
351 # define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
353 /* the name of the proc status struct depends on the implementation */
354 typedef pstatus_t gdb_prstatus_t;
355 typedef lwpstatus_t gdb_lwpstatus_t;
356 #else /* ! NEW_PROC_API */
357 /* format strings for /proc paths */
358 # ifndef CTL_PROC_NAME_FMT
359 # define MAIN_PROC_NAME_FMT "/proc/%05d"
360 # define CTL_PROC_NAME_FMT "/proc/%05d"
361 # define AS_PROC_NAME_FMT "/proc/%05d"
362 # define MAP_PROC_NAME_FMT "/proc/%05d"
363 # define STATUS_PROC_NAME_FMT "/proc/%05d"
364 # define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
366 /* The name of the proc status struct depends on the implementation. */
367 typedef prstatus_t gdb_prstatus_t;
368 typedef prstatus_t gdb_lwpstatus_t;
369 #endif /* NEW_PROC_API */
371 typedef struct procinfo {
372 struct procinfo *next;
373 int pid; /* Process ID */
374 int tid; /* Thread/LWP id */
378 int ignore_next_sigstop;
380 /* The following four fd fields may be identical, or may contain
381 several different fd's, depending on the version of /proc
382 (old ioctl or new read/write). */
384 int ctl_fd; /* File descriptor for /proc control file */
386 /* The next three file descriptors are actually only needed in the
387 read/write, multiple-file-descriptor implemenation
388 (NEW_PROC_API). However, to avoid a bunch of #ifdefs in the
389 code, we will use them uniformly by (in the case of the ioctl
390 single-file-descriptor implementation) filling them with copies
391 of the control fd. */
392 int status_fd; /* File descriptor for /proc status file */
393 int as_fd; /* File descriptor for /proc as file */
395 char pathname[MAX_PROC_NAME_SIZE]; /* Pathname to /proc entry */
397 fltset_t saved_fltset; /* Saved traced hardware fault set */
398 gdb_sigset_t saved_sigset; /* Saved traced signal set */
399 gdb_sigset_t saved_sighold; /* Saved held signal set */
400 sysset_t *saved_exitset; /* Saved traced system call exit set */
401 sysset_t *saved_entryset; /* Saved traced system call entry set */
403 gdb_prstatus_t prstatus; /* Current process status info */
406 gdb_fpregset_t fpregset; /* Current floating point registers */
409 #ifdef DYNAMIC_SYSCALLS
410 int num_syscalls; /* Total number of syscalls */
411 char **syscall_names; /* Syscall number to name map */
414 struct procinfo *thread_list;
416 int status_valid : 1;
418 int fpregs_valid : 1;
419 int threads_valid: 1;
422 static char errmsg[128]; /* shared error msg buffer */
424 /* Function prototypes for procinfo module: */
426 static procinfo *find_procinfo_or_die (int pid, int tid);
427 static procinfo *find_procinfo (int pid, int tid);
428 static procinfo *create_procinfo (int pid, int tid);
429 static void destroy_procinfo (procinfo * p);
430 static void do_destroy_procinfo_cleanup (void *);
431 static void dead_procinfo (procinfo * p, char *msg, int killp);
432 static int open_procinfo_files (procinfo * p, int which);
433 static void close_procinfo_files (procinfo * p);
434 static int sysset_t_size (procinfo *p);
435 static sysset_t *sysset_t_alloc (procinfo * pi);
436 #ifdef DYNAMIC_SYSCALLS
437 static void load_syscalls (procinfo *pi);
438 static void free_syscalls (procinfo *pi);
439 static int find_syscall (procinfo *pi, char *name);
440 #endif /* DYNAMIC_SYSCALLS */
442 static int iterate_over_mappings
443 (procinfo *pi, find_memory_region_ftype child_func, void *data,
444 int (*func) (struct prmap *map, find_memory_region_ftype child_func,
447 /* The head of the procinfo list: */
448 static procinfo * procinfo_list;
450 /* Search the procinfo list. Return a pointer to procinfo, or NULL if
454 find_procinfo (int pid, int tid)
458 for (pi = procinfo_list; pi; pi = pi->next)
465 /* Don't check threads_valid. If we're updating the
466 thread_list, we want to find whatever threads are already
467 here. This means that in general it is the caller's
468 responsibility to check threads_valid and update before
469 calling find_procinfo, if the caller wants to find a new
472 for (pi = pi->thread_list; pi; pi = pi->next)
480 /* Calls find_procinfo, but errors on failure. */
483 find_procinfo_or_die (int pid, int tid)
485 procinfo *pi = find_procinfo (pid, tid);
490 error (_("procfs: couldn't find pid %d "
491 "(kernel thread %d) in procinfo list."),
494 error (_("procfs: couldn't find pid %d in procinfo list."), pid);
499 /* Wrapper for `open'. The appropriate open call is attempted; if
500 unsuccessful, it will be retried as many times as needed for the
501 EAGAIN and EINTR conditions.
503 For other conditions, retry the open a limited number of times. In
504 addition, a short sleep is imposed prior to retrying the open. The
505 reason for this sleep is to give the kernel a chance to catch up
506 and create the file in question in the event that GDB "wins" the
507 race to open a file before the kernel has created it. */
510 open_with_retry (const char *pathname, int flags)
512 int retries_remaining, status;
514 retries_remaining = 2;
518 status = open (pathname, flags);
520 if (status >= 0 || retries_remaining == 0)
522 else if (errno != EINTR && errno != EAGAIN)
532 /* Open the file descriptor for the process or LWP. If NEW_PROC_API
533 is defined, we only open the control file descriptor; the others
534 are opened lazily as needed. Otherwise (if not NEW_PROC_API),
535 there is only one real file descriptor, but we keep multiple copies
536 of it so that the code that uses them does not have to be #ifdef'd.
537 Returns the file descriptor, or zero for failure. */
539 enum { FD_CTL, FD_STATUS, FD_AS };
542 open_procinfo_files (procinfo *pi, int which)
545 char tmp[MAX_PROC_NAME_SIZE];
549 /* This function is getting ALMOST long enough to break up into
550 several. Here is some rationale:
552 NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
553 There are several file descriptors that may need to be open
554 for any given process or LWP. The ones we're intereted in are:
555 - control (ctl) write-only change the state
556 - status (status) read-only query the state
557 - address space (as) read/write access memory
558 - map (map) read-only virtual addr map
559 Most of these are opened lazily as they are needed.
560 The pathnames for the 'files' for an LWP look slightly
561 different from those of a first-class process:
562 Pathnames for a process (<proc-id>):
564 /proc/<proc-id>/status
567 Pathnames for an LWP (lwp-id):
568 /proc/<proc-id>/lwp/<lwp-id>/lwpctl
569 /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
570 An LWP has no map or address space file descriptor, since
571 the memory map and address space are shared by all LWPs.
573 Everyone else (Solaris 2.5, Irix, OSF)
574 There is only one file descriptor for each process or LWP.
575 For convenience, we copy the same file descriptor into all
576 three fields of the procinfo struct (ctl_fd, status_fd, and
577 as_fd, see NEW_PROC_API above) so that code that uses them
578 doesn't need any #ifdef's.
583 Each LWP has an independent file descriptor, but these
584 are not obtained via the 'open' system call like the rest:
585 instead, they're obtained thru an ioctl call (PIOCOPENLWP)
586 to the file descriptor of the parent process.
589 These do not even have their own independent file descriptor.
590 All operations are carried out on the file descriptor of the
591 parent process. Therefore we just call open again for each
592 thread, getting a new handle for the same 'file'. */
595 /* In this case, there are several different file descriptors that
596 we might be asked to open. The control file descriptor will be
597 opened early, but the others will be opened lazily as they are
600 strcpy (tmp, pi->pathname);
601 switch (which) { /* Which file descriptor to open? */
604 strcat (tmp, "/lwpctl");
606 strcat (tmp, "/ctl");
607 fd = open_with_retry (tmp, O_WRONLY);
614 return 0; /* There is no 'as' file descriptor for an lwp. */
616 fd = open_with_retry (tmp, O_RDWR);
623 strcat (tmp, "/lwpstatus");
625 strcat (tmp, "/status");
626 fd = open_with_retry (tmp, O_RDONLY);
632 return 0; /* unknown file descriptor */
634 #else /* not NEW_PROC_API */
635 /* In this case, there is only one file descriptor for each procinfo
636 (ie. each process or LWP). In fact, only the file descriptor for
637 the process can actually be opened by an 'open' system call. The
638 ones for the LWPs have to be obtained thru an IOCTL call on the
639 process's file descriptor.
641 For convenience, we copy each procinfo's single file descriptor
642 into all of the fields occupied by the several file descriptors
643 of the NEW_PROC_API implementation. That way, the code that uses
644 them can be written without ifdefs. */
647 #ifdef PIOCTSTATUS /* OSF */
648 /* Only one FD; just open it. */
649 if ((fd = open_with_retry (pi->pathname, O_RDWR)) == 0)
651 #else /* Sol 2.5, Irix, other? */
652 if (pi->tid == 0) /* Master procinfo for the process */
654 fd = open_with_retry (pi->pathname, O_RDWR);
658 else /* LWP thread procinfo */
660 #ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
664 /* Find the procinfo for the entire process. */
665 if ((process = find_procinfo (pi->pid, 0)) == NULL)
668 /* Now obtain the file descriptor for the LWP. */
669 if ((fd = ioctl (process->ctl_fd, PIOCOPENLWP, &lwpid)) <= 0)
671 #else /* Irix, other? */
672 return 0; /* Don't know how to open threads. */
673 #endif /* Sol 2.5 PIOCOPENLWP */
675 #endif /* OSF PIOCTSTATUS */
676 pi->ctl_fd = pi->as_fd = pi->status_fd = fd;
677 #endif /* NEW_PROC_API */
679 return 1; /* success */
682 /* Allocate a data structure and link it into the procinfo list.
683 First tries to find a pre-existing one (FIXME: why?). Returns the
684 pointer to new procinfo struct. */
687 create_procinfo (int pid, int tid)
689 procinfo *pi, *parent = NULL;
691 if ((pi = find_procinfo (pid, tid)))
692 return pi; /* Already exists, nothing to do. */
694 /* Find parent before doing malloc, to save having to cleanup. */
696 parent = find_procinfo_or_die (pid, 0); /* FIXME: should I
698 doesn't exist yet? */
700 pi = (procinfo *) xmalloc (sizeof (procinfo));
701 memset (pi, 0, sizeof (procinfo));
705 #ifdef DYNAMIC_SYSCALLS
709 pi->saved_entryset = sysset_t_alloc (pi);
710 pi->saved_exitset = sysset_t_alloc (pi);
712 /* Chain into list. */
715 sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
716 pi->next = procinfo_list;
722 sprintf (pi->pathname, "/proc/%05d/lwp/%d", pid, tid);
724 sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
726 pi->next = parent->thread_list;
727 parent->thread_list = pi;
732 /* Close all file descriptors associated with the procinfo. */
735 close_procinfo_files (procinfo *pi)
742 if (pi->status_fd > 0)
743 close (pi->status_fd);
745 pi->ctl_fd = pi->as_fd = pi->status_fd = 0;
748 /* Destructor function. Close, unlink and deallocate the object. */
751 destroy_one_procinfo (procinfo **list, procinfo *pi)
755 /* Step one: unlink the procinfo from its list. */
759 for (ptr = *list; ptr; ptr = ptr->next)
762 ptr->next = pi->next;
766 /* Step two: close any open file descriptors. */
767 close_procinfo_files (pi);
769 /* Step three: free the memory. */
770 #ifdef DYNAMIC_SYSCALLS
773 xfree (pi->saved_entryset);
774 xfree (pi->saved_exitset);
779 destroy_procinfo (procinfo *pi)
783 if (pi->tid != 0) /* Destroy a thread procinfo. */
785 tmp = find_procinfo (pi->pid, 0); /* Find the parent process. */
786 destroy_one_procinfo (&tmp->thread_list, pi);
788 else /* Destroy a process procinfo and all its threads. */
790 /* First destroy the children, if any; */
791 while (pi->thread_list != NULL)
792 destroy_one_procinfo (&pi->thread_list, pi->thread_list);
793 /* Then destroy the parent. Genocide!!! */
794 destroy_one_procinfo (&procinfo_list, pi);
799 do_destroy_procinfo_cleanup (void *pi)
801 destroy_procinfo (pi);
804 enum { NOKILL, KILL };
806 /* To be called on a non_recoverable error for a procinfo. Prints
807 error messages, optionally sends a SIGKILL to the process, then
808 destroys the data structure. */
811 dead_procinfo (procinfo *pi, char *msg, int kill_p)
817 print_sys_errmsg (pi->pathname, errno);
821 sprintf (procfile, "process %d", pi->pid);
822 print_sys_errmsg (procfile, errno);
825 kill (pi->pid, SIGKILL);
827 destroy_procinfo (pi);
831 /* Returns the (complete) size of a sysset_t struct. Normally, this
832 is just sizeof (sysset_t), but in the case of Monterey/64, the
833 actual size of sysset_t isn't known until runtime. */
836 sysset_t_size (procinfo * pi)
838 #ifndef DYNAMIC_SYSCALLS
839 return sizeof (sysset_t);
841 return sizeof (sysset_t) - sizeof (uint64_t)
842 + sizeof (uint64_t) * ((pi->num_syscalls + (8 * sizeof (uint64_t) - 1))
843 / (8 * sizeof (uint64_t)));
847 /* Allocate and (partially) initialize a sysset_t struct. */
850 sysset_t_alloc (procinfo * pi)
853 int size = sysset_t_size (pi);
855 ret = xmalloc (size);
856 #ifdef DYNAMIC_SYSCALLS
857 ret->pr_size = ((pi->num_syscalls + (8 * sizeof (uint64_t) - 1))
858 / (8 * sizeof (uint64_t)));
863 #ifdef DYNAMIC_SYSCALLS
865 /* Extract syscall numbers and names from /proc/<pid>/sysent. Initialize
866 pi->num_syscalls with the number of syscalls and pi->syscall_names
867 with the names. (Certain numbers may be skipped in which case the
868 names for these numbers will be left as NULL.) */
870 #define MAX_SYSCALL_NAME_LENGTH 256
871 #define MAX_SYSCALLS 65536
874 load_syscalls (procinfo *pi)
876 char pathname[MAX_PROC_NAME_SIZE];
879 prsyscall_t *syscalls;
880 int i, size, maxcall;
882 pi->num_syscalls = 0;
883 pi->syscall_names = 0;
885 /* Open the file descriptor for the sysent file. */
886 sprintf (pathname, "/proc/%d/sysent", pi->pid);
887 sysent_fd = open_with_retry (pathname, O_RDONLY);
890 error (_("load_syscalls: Can't open /proc/%d/sysent"), pi->pid);
893 size = sizeof header - sizeof (prsyscall_t);
894 if (read (sysent_fd, &header, size) != size)
896 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi->pid);
899 if (header.pr_nsyscalls == 0)
901 error (_("load_syscalls: /proc/%d/sysent contains no syscalls!"),
905 size = header.pr_nsyscalls * sizeof (prsyscall_t);
906 syscalls = xmalloc (size);
908 if (read (sysent_fd, syscalls, size) != size)
911 error (_("load_syscalls: Error reading /proc/%d/sysent"), pi->pid);
914 /* Find maximum syscall number. This may not be the same as
915 pr_nsyscalls since that value refers to the number of entries
916 in the table. (Also, the docs indicate that some system
917 call numbers may be skipped.) */
919 maxcall = syscalls[0].pr_number;
921 for (i = 1; i < header.pr_nsyscalls; i++)
922 if (syscalls[i].pr_number > maxcall
923 && syscalls[i].pr_nameoff > 0
924 && syscalls[i].pr_number < MAX_SYSCALLS)
925 maxcall = syscalls[i].pr_number;
927 pi->num_syscalls = maxcall+1;
928 pi->syscall_names = xmalloc (pi->num_syscalls * sizeof (char *));
930 for (i = 0; i < pi->num_syscalls; i++)
931 pi->syscall_names[i] = NULL;
933 /* Read the syscall names in. */
934 for (i = 0; i < header.pr_nsyscalls; i++)
936 char namebuf[MAX_SYSCALL_NAME_LENGTH];
940 if (syscalls[i].pr_number >= MAX_SYSCALLS
941 || syscalls[i].pr_number < 0
942 || syscalls[i].pr_nameoff <= 0
943 || (lseek (sysent_fd, (off_t) syscalls[i].pr_nameoff, SEEK_SET)
944 != (off_t) syscalls[i].pr_nameoff))
947 nread = read (sysent_fd, namebuf, sizeof namebuf);
951 callnum = syscalls[i].pr_number;
953 if (pi->syscall_names[callnum] != NULL)
955 /* FIXME: Generate warning. */
959 namebuf[nread-1] = '\0';
960 size = strlen (namebuf) + 1;
961 pi->syscall_names[callnum] = xmalloc (size);
962 strncpy (pi->syscall_names[callnum], namebuf, size-1);
963 pi->syscall_names[callnum][size-1] = '\0';
970 /* Free the space allocated for the syscall names from the procinfo
974 free_syscalls (procinfo *pi)
976 if (pi->syscall_names)
980 for (i = 0; i < pi->num_syscalls; i++)
981 if (pi->syscall_names[i] != NULL)
982 xfree (pi->syscall_names[i]);
984 xfree (pi->syscall_names);
985 pi->syscall_names = 0;
989 /* Given a name, look up (and return) the corresponding syscall number.
990 If no match is found, return -1. */
993 find_syscall (procinfo *pi, char *name)
997 for (i = 0; i < pi->num_syscalls; i++)
999 if (pi->syscall_names[i] && strcmp (name, pi->syscall_names[i]) == 0)
1006 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
1008 /* =================== /proc "MODULE" =================== */
1010 /* This "module" is the interface layer between the /proc system API
1011 and the gdb target vector functions. This layer consists of access
1012 functions that encapsulate each of the basic operations that we
1013 need to use from the /proc API.
1015 The main motivation for this layer is to hide the fact that there
1016 are two very different implementations of the /proc API. Rather
1017 than have a bunch of #ifdefs all thru the gdb target vector
1018 functions, we do our best to hide them all in here. */
1020 int proc_get_status (procinfo * pi);
1021 long proc_flags (procinfo * pi);
1022 int proc_why (procinfo * pi);
1023 int proc_what (procinfo * pi);
1024 int proc_set_run_on_last_close (procinfo * pi);
1025 int proc_unset_run_on_last_close (procinfo * pi);
1026 int proc_set_inherit_on_fork (procinfo * pi);
1027 int proc_unset_inherit_on_fork (procinfo * pi);
1028 int proc_set_async (procinfo * pi);
1029 int proc_unset_async (procinfo * pi);
1030 int proc_stop_process (procinfo * pi);
1031 int proc_trace_signal (procinfo * pi, int signo);
1032 int proc_ignore_signal (procinfo * pi, int signo);
1033 int proc_clear_current_fault (procinfo * pi);
1034 int proc_set_current_signal (procinfo * pi, int signo);
1035 int proc_clear_current_signal (procinfo * pi);
1036 int proc_set_gregs (procinfo * pi);
1037 int proc_set_fpregs (procinfo * pi);
1038 int proc_wait_for_stop (procinfo * pi);
1039 int proc_run_process (procinfo * pi, int step, int signo);
1040 int proc_kill (procinfo * pi, int signo);
1041 int proc_parent_pid (procinfo * pi);
1042 int proc_get_nthreads (procinfo * pi);
1043 int proc_get_current_thread (procinfo * pi);
1044 int proc_set_held_signals (procinfo * pi, gdb_sigset_t * sighold);
1045 int proc_set_traced_sysexit (procinfo * pi, sysset_t * sysset);
1046 int proc_set_traced_sysentry (procinfo * pi, sysset_t * sysset);
1047 int proc_set_traced_faults (procinfo * pi, fltset_t * fltset);
1048 int proc_set_traced_signals (procinfo * pi, gdb_sigset_t * sigset);
1050 int proc_update_threads (procinfo * pi);
1051 int proc_iterate_over_threads (procinfo * pi,
1052 int (*func) (procinfo *, procinfo *, void *),
1055 gdb_gregset_t *proc_get_gregs (procinfo * pi);
1056 gdb_fpregset_t *proc_get_fpregs (procinfo * pi);
1057 sysset_t *proc_get_traced_sysexit (procinfo * pi, sysset_t * save);
1058 sysset_t *proc_get_traced_sysentry (procinfo * pi, sysset_t * save);
1059 fltset_t *proc_get_traced_faults (procinfo * pi, fltset_t * save);
1060 gdb_sigset_t *proc_get_traced_signals (procinfo * pi, gdb_sigset_t * save);
1061 gdb_sigset_t *proc_get_held_signals (procinfo * pi, gdb_sigset_t * save);
1062 gdb_sigset_t *proc_get_pending_signals (procinfo * pi, gdb_sigset_t * save);
1063 gdb_sigaction_t *proc_get_signal_actions (procinfo * pi,
1064 gdb_sigaction_t *save);
1066 void proc_warn (procinfo * pi, char *func, int line);
1067 void proc_error (procinfo * pi, char *func, int line);
1070 proc_warn (procinfo *pi, char *func, int line)
1072 sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
1073 print_sys_errmsg (errmsg, errno);
1077 proc_error (procinfo *pi, char *func, int line)
1079 sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
1080 perror_with_name (errmsg);
1083 /* Updates the status struct in the procinfo. There is a 'valid'
1084 flag, to let other functions know when this function needs to be
1085 called (so the status is only read when it is needed). The status
1086 file descriptor is also only opened when it is needed. Returns
1087 non-zero for success, zero for failure. */
1090 proc_get_status (procinfo *pi)
1092 /* Status file descriptor is opened "lazily". */
1093 if (pi->status_fd == 0 &&
1094 open_procinfo_files (pi, FD_STATUS) == 0)
1096 pi->status_valid = 0;
1101 if (lseek (pi->status_fd, 0, SEEK_SET) < 0)
1102 pi->status_valid = 0; /* fail */
1105 /* Sigh... I have to read a different data structure,
1106 depending on whether this is a main process or an LWP. */
1108 pi->status_valid = (read (pi->status_fd,
1109 (char *) &pi->prstatus.pr_lwp,
1110 sizeof (lwpstatus_t))
1111 == sizeof (lwpstatus_t));
1114 pi->status_valid = (read (pi->status_fd,
1115 (char *) &pi->prstatus,
1116 sizeof (gdb_prstatus_t))
1117 == sizeof (gdb_prstatus_t));
1118 #if 0 /*def UNIXWARE*/
1119 if (pi->status_valid &&
1120 (pi->prstatus.pr_lwp.pr_flags & PR_ISTOP) &&
1121 pi->prstatus.pr_lwp.pr_why == PR_REQUESTED)
1122 /* Unixware peculiarity -- read the damn thing again! */
1123 pi->status_valid = (read (pi->status_fd,
1124 (char *) &pi->prstatus,
1125 sizeof (gdb_prstatus_t))
1126 == sizeof (gdb_prstatus_t));
1127 #endif /* UNIXWARE */
1130 #else /* ioctl method */
1131 #ifdef PIOCTSTATUS /* osf */
1132 if (pi->tid == 0) /* main process */
1134 /* Just read the danged status. Now isn't that simple? */
1136 (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
1143 tid_t pr_error_thread;
1144 struct prstatus status;
1147 thread_status.pr_count = 1;
1148 thread_status.status.pr_tid = pi->tid;
1149 win = (ioctl (pi->status_fd, PIOCTSTATUS, &thread_status) >= 0);
1152 memcpy (&pi->prstatus, &thread_status.status,
1153 sizeof (pi->prstatus));
1154 pi->status_valid = 1;
1158 /* Just read the danged status. Now isn't that simple? */
1159 pi->status_valid = (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
1163 if (pi->status_valid)
1165 PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
1168 proc_get_current_thread (pi));
1171 /* The status struct includes general regs, so mark them valid too. */
1172 pi->gregs_valid = pi->status_valid;
1174 /* In the read/write multiple-fd model, the status struct includes
1175 the fp regs too, so mark them valid too. */
1176 pi->fpregs_valid = pi->status_valid;
1178 return pi->status_valid; /* True if success, false if failure. */
1181 /* Returns the process flags (pr_flags field). */
1184 proc_flags (procinfo *pi)
1186 if (!pi->status_valid)
1187 if (!proc_get_status (pi))
1188 return 0; /* FIXME: not a good failure value (but what is?) */
1192 /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
1193 pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
1194 The two sets of flags don't overlap. */
1195 return pi->prstatus.pr_flags | pi->prstatus.pr_lwp.pr_flags;
1197 return pi->prstatus.pr_lwp.pr_flags;
1200 return pi->prstatus.pr_flags;
1204 /* Returns the pr_why field (why the process stopped). */
1207 proc_why (procinfo *pi)
1209 if (!pi->status_valid)
1210 if (!proc_get_status (pi))
1211 return 0; /* FIXME: not a good failure value (but what is?) */
1214 return pi->prstatus.pr_lwp.pr_why;
1216 return pi->prstatus.pr_why;
1220 /* Returns the pr_what field (details of why the process stopped). */
1223 proc_what (procinfo *pi)
1225 if (!pi->status_valid)
1226 if (!proc_get_status (pi))
1227 return 0; /* FIXME: not a good failure value (but what is?) */
1230 return pi->prstatus.pr_lwp.pr_what;
1232 return pi->prstatus.pr_what;
1236 /* This function is only called when PI is stopped by a watchpoint.
1237 Assuming the OS supports it, write to *ADDR the data address which
1238 triggered it and return 1. Return 0 if it is not possible to know
1242 proc_watchpoint_address (procinfo *pi, CORE_ADDR *addr)
1244 if (!pi->status_valid)
1245 if (!proc_get_status (pi))
1249 *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch,
1250 builtin_type (target_gdbarch)->builtin_data_ptr,
1251 (gdb_byte *) &pi->prstatus.pr_lwp.pr_info.si_addr);
1253 *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch,
1254 builtin_type (target_gdbarch)->builtin_data_ptr,
1255 (gdb_byte *) &pi->prstatus.pr_info.si_addr);
1260 #ifndef PIOCSSPCACT /* The following is not supported on OSF. */
1262 /* Returns the pr_nsysarg field (number of args to the current
1266 proc_nsysarg (procinfo *pi)
1268 if (!pi->status_valid)
1269 if (!proc_get_status (pi))
1273 return pi->prstatus.pr_lwp.pr_nsysarg;
1275 return pi->prstatus.pr_nsysarg;
1279 /* Returns the pr_sysarg field (pointer to the arguments of current
1283 proc_sysargs (procinfo *pi)
1285 if (!pi->status_valid)
1286 if (!proc_get_status (pi))
1290 return (long *) &pi->prstatus.pr_lwp.pr_sysarg;
1292 return (long *) &pi->prstatus.pr_sysarg;
1296 /* Returns the pr_syscall field (id of current syscall if we are in
1300 proc_syscall (procinfo *pi)
1302 if (!pi->status_valid)
1303 if (!proc_get_status (pi))
1307 return pi->prstatus.pr_lwp.pr_syscall;
1309 return pi->prstatus.pr_syscall;
1312 #endif /* PIOCSSPCACT */
1314 /* Returns the pr_cursig field (current signal). */
1317 proc_cursig (struct procinfo *pi)
1319 if (!pi->status_valid)
1320 if (!proc_get_status (pi))
1321 return 0; /* FIXME: not a good failure value (but what is?) */
1324 return pi->prstatus.pr_lwp.pr_cursig;
1326 return pi->prstatus.pr_cursig;
1330 /* === I appologize for the messiness of this function.
1331 === This is an area where the different versions of
1332 === /proc are more inconsistent than usual.
1334 Set or reset any of the following process flags:
1335 PR_FORK -- forked child will inherit trace flags
1336 PR_RLC -- traced process runs when last /proc file closed.
1337 PR_KLC -- traced process is killed when last /proc file closed.
1338 PR_ASYNC -- LWP's get to run/stop independently.
1340 There are three methods for doing this function:
1341 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
1343 2) Middle: PIOCSET/PIOCRESET
1345 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
1348 Note: Irix does not define PR_ASYNC.
1349 Note: OSF does not define PR_KLC.
1350 Note: OSF is the only one that can ONLY use the oldest method.
1354 flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
1355 mode -- 1 for set, 0 for reset.
1357 Returns non-zero for success, zero for failure. */
1359 enum { FLAG_RESET, FLAG_SET };
1362 proc_modify_flag (procinfo *pi, long flag, long mode)
1364 long win = 0; /* default to fail */
1366 /* These operations affect the process as a whole, and applying them
1367 to an individual LWP has the same meaning as applying them to the
1368 main process. Therefore, if we're ever called with a pointer to
1369 an LWP's procinfo, let's substitute the process's procinfo and
1370 avoid opening the LWP's file descriptor unnecessarily. */
1373 pi = find_procinfo_or_die (pi->pid, 0);
1375 #ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii. */
1376 /* First normalize the PCUNSET/PCRESET command opcode
1377 (which for no obvious reason has a different definition
1378 from one operating system to the next...) */
1380 #define GDBRESET PCUNSET
1383 #define GDBRESET PCRESET
1387 procfs_ctl_t arg[2];
1389 if (mode == FLAG_SET) /* Set the flag (RLC, FORK, or ASYNC). */
1391 else /* Reset the flag. */
1395 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
1398 #ifdef PIOCSET /* Irix/Sol5 method */
1399 if (mode == FLAG_SET) /* Set the flag (hopefully RLC, FORK, or ASYNC). */
1401 win = (ioctl (pi->ctl_fd, PIOCSET, &flag) >= 0);
1403 else /* Reset the flag. */
1405 win = (ioctl (pi->ctl_fd, PIOCRESET, &flag) >= 0);
1409 #ifdef PIOCSRLC /* Oldest method: OSF */
1412 if (mode == FLAG_SET) /* Set run-on-last-close */
1414 win = (ioctl (pi->ctl_fd, PIOCSRLC, NULL) >= 0);
1416 else /* Clear run-on-last-close */
1418 win = (ioctl (pi->ctl_fd, PIOCRRLC, NULL) >= 0);
1422 if (mode == FLAG_SET) /* Set inherit-on-fork */
1424 win = (ioctl (pi->ctl_fd, PIOCSFORK, NULL) >= 0);
1426 else /* Clear inherit-on-fork */
1428 win = (ioctl (pi->ctl_fd, PIOCRFORK, NULL) >= 0);
1432 win = 0; /* Fail -- unknown flag (can't do PR_ASYNC). */
1439 /* The above operation renders the procinfo's cached pstatus
1441 pi->status_valid = 0;
1444 warning (_("procfs: modify_flag failed to turn %s %s"),
1445 flag == PR_FORK ? "PR_FORK" :
1446 flag == PR_RLC ? "PR_RLC" :
1448 flag == PR_ASYNC ? "PR_ASYNC" :
1451 flag == PR_KLC ? "PR_KLC" :
1454 mode == FLAG_RESET ? "off" : "on");
1459 /* Set the run_on_last_close flag. Process with all threads will
1460 become runnable when debugger closes all /proc fds. Returns
1461 non-zero for success, zero for failure. */
1464 proc_set_run_on_last_close (procinfo *pi)
1466 return proc_modify_flag (pi, PR_RLC, FLAG_SET);
1469 /* Reset the run_on_last_close flag. The process will NOT become
1470 runnable when debugger closes its file handles. Returns non-zero
1471 for success, zero for failure. */
1474 proc_unset_run_on_last_close (procinfo *pi)
1476 return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
1480 /* Set the kill_on_last_close flag. Process with all threads will be
1481 killed when debugger closes all /proc fds (or debugger exits or
1482 dies). Returns non-zero for success, zero for failure. */
1485 proc_set_kill_on_last_close (procinfo *pi)
1487 return proc_modify_flag (pi, PR_KLC, FLAG_SET);
1490 /* Reset the kill_on_last_close flag. Process will NOT be killed when
1491 debugger closes its file handles (or exits or dies). Returns
1492 non-zero for success, zero for failure. */
1495 proc_unset_kill_on_last_close (procinfo *pi)
1497 return proc_modify_flag (pi, PR_KLC, FLAG_RESET);
1501 /* Set inherit_on_fork flag. If the process forks a child while we
1502 are registered for events in the parent, then we will also recieve
1503 events from the child. Returns non-zero for success, zero for
1507 proc_set_inherit_on_fork (procinfo *pi)
1509 return proc_modify_flag (pi, PR_FORK, FLAG_SET);
1512 /* Reset inherit_on_fork flag. If the process forks a child while we
1513 are registered for events in the parent, then we will NOT recieve
1514 events from the child. Returns non-zero for success, zero for
1518 proc_unset_inherit_on_fork (procinfo *pi)
1520 return proc_modify_flag (pi, PR_FORK, FLAG_RESET);
1524 /* Set PR_ASYNC flag. If one LWP stops because of a debug event
1525 (signal etc.), the remaining LWPs will continue to run. Returns
1526 non-zero for success, zero for failure. */
1529 proc_set_async (procinfo *pi)
1531 return proc_modify_flag (pi, PR_ASYNC, FLAG_SET);
1534 /* Reset PR_ASYNC flag. If one LWP stops because of a debug event
1535 (signal etc.), then all other LWPs will stop as well. Returns
1536 non-zero for success, zero for failure. */
1539 proc_unset_async (procinfo *pi)
1541 return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET);
1543 #endif /* PR_ASYNC */
1545 /* Request the process/LWP to stop. Does not wait. Returns non-zero
1546 for success, zero for failure. */
1549 proc_stop_process (procinfo *pi)
1553 /* We might conceivably apply this operation to an LWP, and the
1554 LWP's ctl file descriptor might not be open. */
1556 if (pi->ctl_fd == 0 &&
1557 open_procinfo_files (pi, FD_CTL) == 0)
1562 procfs_ctl_t cmd = PCSTOP;
1564 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1565 #else /* ioctl method */
1566 win = (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) >= 0);
1567 /* Note: the call also reads the prstatus. */
1570 pi->status_valid = 1;
1571 PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
1574 proc_get_current_thread (pi));
1582 /* Wait for the process or LWP to stop (block until it does). Returns
1583 non-zero for success, zero for failure. */
1586 proc_wait_for_stop (procinfo *pi)
1590 /* We should never have to apply this operation to any procinfo
1591 except the one for the main process. If that ever changes for
1592 any reason, then take out the following clause and replace it
1593 with one that makes sure the ctl_fd is open. */
1596 pi = find_procinfo_or_die (pi->pid, 0);
1600 procfs_ctl_t cmd = PCWSTOP;
1602 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1603 /* We been runnin' and we stopped -- need to update status. */
1604 pi->status_valid = 0;
1606 #else /* ioctl method */
1607 win = (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) >= 0);
1608 /* Above call also refreshes the prstatus. */
1611 pi->status_valid = 1;
1612 PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
1615 proc_get_current_thread (pi));
1622 /* Make the process or LWP runnable.
1624 Options (not all are implemented):
1626 - clear current fault
1627 - clear current signal
1628 - abort the current system call
1629 - stop as soon as finished with system call
1630 - (ioctl): set traced signal set
1631 - (ioctl): set held signal set
1632 - (ioctl): set traced fault set
1633 - (ioctl): set start pc (vaddr)
1635 Always clears the current fault. PI is the process or LWP to
1636 operate on. If STEP is true, set the process or LWP to trap after
1637 one instruction. If SIGNO is zero, clear the current signal if
1638 any; if non-zero, set the current signal to this one. Returns
1639 non-zero for success, zero for failure. */
1642 proc_run_process (procinfo *pi, int step, int signo)
1647 /* We will probably have to apply this operation to individual
1648 threads, so make sure the control file descriptor is open. */
1650 if (pi->ctl_fd == 0 &&
1651 open_procinfo_files (pi, FD_CTL) == 0)
1656 runflags = PRCFAULT; /* Always clear current fault. */
1661 else if (signo != -1) /* -1 means do nothing W.R.T. signals. */
1662 proc_set_current_signal (pi, signo);
1666 procfs_ctl_t cmd[2];
1670 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
1672 #else /* ioctl method */
1676 memset (&prrun, 0, sizeof (prrun));
1677 prrun.pr_flags = runflags;
1678 win = (ioctl (pi->ctl_fd, PIOCRUN, &prrun) >= 0);
1685 /* Register to trace signals in the process or LWP. Returns non-zero
1686 for success, zero for failure. */
1689 proc_set_traced_signals (procinfo *pi, gdb_sigset_t *sigset)
1693 /* We should never have to apply this operation to any procinfo
1694 except the one for the main process. If that ever changes for
1695 any reason, then take out the following clause and replace it
1696 with one that makes sure the ctl_fd is open. */
1699 pi = find_procinfo_or_die (pi->pid, 0);
1705 /* Use char array to avoid alignment issues. */
1706 char sigset[sizeof (gdb_sigset_t)];
1710 memcpy (&arg.sigset, sigset, sizeof (gdb_sigset_t));
1712 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
1714 #else /* ioctl method */
1715 win = (ioctl (pi->ctl_fd, PIOCSTRACE, sigset) >= 0);
1717 /* The above operation renders the procinfo's cached pstatus obsolete. */
1718 pi->status_valid = 0;
1721 warning (_("procfs: set_traced_signals failed"));
1725 /* Register to trace hardware faults in the process or LWP. Returns
1726 non-zero for success, zero for failure. */
1729 proc_set_traced_faults (procinfo *pi, fltset_t *fltset)
1733 /* We should never have to apply this operation to any procinfo
1734 except the one for the main process. If that ever changes for
1735 any reason, then take out the following clause and replace it
1736 with one that makes sure the ctl_fd is open. */
1739 pi = find_procinfo_or_die (pi->pid, 0);
1745 /* Use char array to avoid alignment issues. */
1746 char fltset[sizeof (fltset_t)];
1750 memcpy (&arg.fltset, fltset, sizeof (fltset_t));
1752 win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
1754 #else /* ioctl method */
1755 win = (ioctl (pi->ctl_fd, PIOCSFAULT, fltset) >= 0);
1757 /* The above operation renders the procinfo's cached pstatus obsolete. */
1758 pi->status_valid = 0;
1763 /* Register to trace entry to system calls in the process or LWP.
1764 Returns non-zero for success, zero for failure. */
1767 proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset)
1771 /* We should never have to apply this operation to any procinfo
1772 except the one for the main process. If that ever changes for
1773 any reason, then take out the following clause and replace it
1774 with one that makes sure the ctl_fd is open. */
1777 pi = find_procinfo_or_die (pi->pid, 0);
1781 struct gdb_proc_ctl_pcsentry {
1783 /* Use char array to avoid alignment issues. */
1784 char sysset[sizeof (sysset_t)];
1786 int argp_size = sizeof (struct gdb_proc_ctl_pcsentry)
1788 + sysset_t_size (pi);
1790 argp = xmalloc (argp_size);
1792 argp->cmd = PCSENTRY;
1793 memcpy (&argp->sysset, sysset, sysset_t_size (pi));
1795 win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size);
1798 #else /* ioctl method */
1799 win = (ioctl (pi->ctl_fd, PIOCSENTRY, sysset) >= 0);
1801 /* The above operation renders the procinfo's cached pstatus
1803 pi->status_valid = 0;
1808 /* Register to trace exit from system calls in the process or LWP.
1809 Returns non-zero for success, zero for failure. */
1812 proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset)
1816 /* We should never have to apply this operation to any procinfo
1817 except the one for the main process. If that ever changes for
1818 any reason, then take out the following clause and replace it
1819 with one that makes sure the ctl_fd is open. */
1822 pi = find_procinfo_or_die (pi->pid, 0);
1826 struct gdb_proc_ctl_pcsexit {
1828 /* Use char array to avoid alignment issues. */
1829 char sysset[sizeof (sysset_t)];
1831 int argp_size = sizeof (struct gdb_proc_ctl_pcsexit)
1833 + sysset_t_size (pi);
1835 argp = xmalloc (argp_size);
1837 argp->cmd = PCSEXIT;
1838 memcpy (&argp->sysset, sysset, sysset_t_size (pi));
1840 win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size);
1843 #else /* ioctl method */
1844 win = (ioctl (pi->ctl_fd, PIOCSEXIT, sysset) >= 0);
1846 /* The above operation renders the procinfo's cached pstatus
1848 pi->status_valid = 0;
1853 /* Specify the set of blocked / held signals in the process or LWP.
1854 Returns non-zero for success, zero for failure. */
1857 proc_set_held_signals (procinfo *pi, gdb_sigset_t *sighold)
1861 /* We should never have to apply this operation to any procinfo
1862 except the one for the main process. If that ever changes for
1863 any reason, then take out the following clause and replace it
1864 with one that makes sure the ctl_fd is open. */
1867 pi = find_procinfo_or_die (pi->pid, 0);
1873 /* Use char array to avoid alignment issues. */
1874 char hold[sizeof (gdb_sigset_t)];
1878 memcpy (&arg.hold, sighold, sizeof (gdb_sigset_t));
1879 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
1882 win = (ioctl (pi->ctl_fd, PIOCSHOLD, sighold) >= 0);
1884 /* The above operation renders the procinfo's cached pstatus
1886 pi->status_valid = 0;
1891 /* Returns the set of signals that are pending in the process or LWP.
1892 Will also copy the sigset if SAVE is non-zero. */
1895 proc_get_pending_signals (procinfo *pi, gdb_sigset_t *save)
1897 gdb_sigset_t *ret = NULL;
1899 /* We should never have to apply this operation to any procinfo
1900 except the one for the main process. If that ever changes for
1901 any reason, then take out the following clause and replace it
1902 with one that makes sure the ctl_fd is open. */
1905 pi = find_procinfo_or_die (pi->pid, 0);
1907 if (!pi->status_valid)
1908 if (!proc_get_status (pi))
1912 ret = &pi->prstatus.pr_lwp.pr_lwppend;
1914 ret = &pi->prstatus.pr_sigpend;
1917 memcpy (save, ret, sizeof (gdb_sigset_t));
1922 /* Returns the set of signal actions. Will also copy the sigactionset
1923 if SAVE is non-zero. */
1926 proc_get_signal_actions (procinfo *pi, gdb_sigaction_t *save)
1928 gdb_sigaction_t *ret = NULL;
1930 /* We should never have to apply this operation to any procinfo
1931 except the one for the main process. If that ever changes for
1932 any reason, then take out the following clause and replace it
1933 with one that makes sure the ctl_fd is open. */
1936 pi = find_procinfo_or_die (pi->pid, 0);
1938 if (!pi->status_valid)
1939 if (!proc_get_status (pi))
1943 ret = &pi->prstatus.pr_lwp.pr_action;
1945 ret = &pi->prstatus.pr_action;
1948 memcpy (save, ret, sizeof (gdb_sigaction_t));
1953 /* Returns the set of signals that are held / blocked. Will also copy
1954 the sigset if SAVE is non-zero. */
1957 proc_get_held_signals (procinfo *pi, gdb_sigset_t *save)
1959 gdb_sigset_t *ret = NULL;
1961 /* We should never have to apply this operation to any procinfo
1962 except the one for the main process. If that ever changes for
1963 any reason, then take out the following clause and replace it
1964 with one that makes sure the ctl_fd is open. */
1967 pi = find_procinfo_or_die (pi->pid, 0);
1970 if (!pi->status_valid)
1971 if (!proc_get_status (pi))
1975 ret = &pi->prstatus.pr_lwp.pr_context.uc_sigmask;
1977 ret = &pi->prstatus.pr_lwp.pr_lwphold;
1978 #endif /* UNIXWARE */
1979 #else /* not NEW_PROC_API */
1981 static gdb_sigset_t sigheld;
1983 if (ioctl (pi->ctl_fd, PIOCGHOLD, &sigheld) >= 0)
1986 #endif /* NEW_PROC_API */
1988 memcpy (save, ret, sizeof (gdb_sigset_t));
1993 /* Returns the set of signals that are traced / debugged. Will also
1994 copy the sigset if SAVE is non-zero. */
1997 proc_get_traced_signals (procinfo *pi, gdb_sigset_t *save)
1999 gdb_sigset_t *ret = NULL;
2001 /* We should never have to apply this operation to any procinfo
2002 except the one for the main process. If that ever changes for
2003 any reason, then take out the following clause and replace it
2004 with one that makes sure the ctl_fd is open. */
2007 pi = find_procinfo_or_die (pi->pid, 0);
2010 if (!pi->status_valid)
2011 if (!proc_get_status (pi))
2014 ret = &pi->prstatus.pr_sigtrace;
2017 static gdb_sigset_t sigtrace;
2019 if (ioctl (pi->ctl_fd, PIOCGTRACE, &sigtrace) >= 0)
2024 memcpy (save, ret, sizeof (gdb_sigset_t));
2029 /* Add SIGNO to the set of signals that are traced. Returns non-zero
2030 for success, zero for failure. */
2033 proc_trace_signal (procinfo *pi, int signo)
2037 /* We should never have to apply this operation to any procinfo
2038 except the one for the main process. If that ever changes for
2039 any reason, then take out the following clause and replace it
2040 with one that makes sure the ctl_fd is open. */
2043 pi = find_procinfo_or_die (pi->pid, 0);
2047 if (proc_get_traced_signals (pi, &temp))
2049 gdb_praddset (&temp, signo);
2050 return proc_set_traced_signals (pi, &temp);
2054 return 0; /* failure */
2057 /* Remove SIGNO from the set of signals that are traced. Returns
2058 non-zero for success, zero for failure. */
2061 proc_ignore_signal (procinfo *pi, int signo)
2065 /* We should never have to apply this operation to any procinfo
2066 except the one for the main process. If that ever changes for
2067 any reason, then take out the following clause and replace it
2068 with one that makes sure the ctl_fd is open. */
2071 pi = find_procinfo_or_die (pi->pid, 0);
2075 if (proc_get_traced_signals (pi, &temp))
2077 gdb_prdelset (&temp, signo);
2078 return proc_set_traced_signals (pi, &temp);
2082 return 0; /* failure */
2085 /* Returns the set of hardware faults that are traced /debugged. Will
2086 also copy the faultset if SAVE is non-zero. */
2089 proc_get_traced_faults (procinfo *pi, fltset_t *save)
2091 fltset_t *ret = NULL;
2093 /* We should never have to apply this operation to any procinfo
2094 except the one for the main process. If that ever changes for
2095 any reason, then take out the following clause and replace it
2096 with one that makes sure the ctl_fd is open. */
2099 pi = find_procinfo_or_die (pi->pid, 0);
2102 if (!pi->status_valid)
2103 if (!proc_get_status (pi))
2106 ret = &pi->prstatus.pr_flttrace;
2109 static fltset_t flttrace;
2111 if (ioctl (pi->ctl_fd, PIOCGFAULT, &flttrace) >= 0)
2116 memcpy (save, ret, sizeof (fltset_t));
2121 /* Returns the set of syscalls that are traced /debugged on entry.
2122 Will also copy the syscall set if SAVE is non-zero. */
2125 proc_get_traced_sysentry (procinfo *pi, sysset_t *save)
2127 sysset_t *ret = NULL;
2129 /* We should never have to apply this operation to any procinfo
2130 except the one for the main process. If that ever changes for
2131 any reason, then take out the following clause and replace it
2132 with one that makes sure the ctl_fd is open. */
2135 pi = find_procinfo_or_die (pi->pid, 0);
2138 if (!pi->status_valid)
2139 if (!proc_get_status (pi))
2142 #ifndef DYNAMIC_SYSCALLS
2143 ret = &pi->prstatus.pr_sysentry;
2144 #else /* DYNAMIC_SYSCALLS */
2146 static sysset_t *sysentry;
2150 sysentry = sysset_t_alloc (pi);
2152 if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0)
2154 if (pi->prstatus.pr_sysentry_offset == 0)
2156 gdb_premptysysset (sysentry);
2162 if (lseek (pi->status_fd, (off_t) pi->prstatus.pr_sysentry_offset,
2164 != (off_t) pi->prstatus.pr_sysentry_offset)
2166 size = sysset_t_size (pi);
2167 gdb_premptysysset (sysentry);
2168 rsize = read (pi->status_fd, sysentry, size);
2173 #endif /* DYNAMIC_SYSCALLS */
2174 #else /* !NEW_PROC_API */
2176 static sysset_t sysentry;
2178 if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysentry) >= 0)
2181 #endif /* NEW_PROC_API */
2183 memcpy (save, ret, sysset_t_size (pi));
2188 /* Returns the set of syscalls that are traced /debugged on exit.
2189 Will also copy the syscall set if SAVE is non-zero. */
2192 proc_get_traced_sysexit (procinfo *pi, sysset_t *save)
2194 sysset_t * ret = NULL;
2196 /* We should never have to apply this operation to any procinfo
2197 except the one for the main process. If that ever changes for
2198 any reason, then take out the following clause and replace it
2199 with one that makes sure the ctl_fd is open. */
2202 pi = find_procinfo_or_die (pi->pid, 0);
2205 if (!pi->status_valid)
2206 if (!proc_get_status (pi))
2209 #ifndef DYNAMIC_SYSCALLS
2210 ret = &pi->prstatus.pr_sysexit;
2211 #else /* DYNAMIC_SYSCALLS */
2213 static sysset_t *sysexit;
2217 sysexit = sysset_t_alloc (pi);
2219 if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0)
2221 if (pi->prstatus.pr_sysexit_offset == 0)
2223 gdb_premptysysset (sysexit);
2229 if (lseek (pi->status_fd, (off_t) pi->prstatus.pr_sysexit_offset,
2231 != (off_t) pi->prstatus.pr_sysexit_offset)
2233 size = sysset_t_size (pi);
2234 gdb_premptysysset (sysexit);
2235 rsize = read (pi->status_fd, sysexit, size);
2240 #endif /* DYNAMIC_SYSCALLS */
2243 static sysset_t sysexit;
2245 if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysexit) >= 0)
2250 memcpy (save, ret, sysset_t_size (pi));
2255 /* The current fault (if any) is cleared; the associated signal will
2256 not be sent to the process or LWP when it resumes. Returns
2257 non-zero for success, zero for failure. */
2260 proc_clear_current_fault (procinfo *pi)
2264 /* We should never have to apply this operation to any procinfo
2265 except the one for the main process. If that ever changes for
2266 any reason, then take out the following clause and replace it
2267 with one that makes sure the ctl_fd is open. */
2270 pi = find_procinfo_or_die (pi->pid, 0);
2274 procfs_ctl_t cmd = PCCFAULT;
2276 win = (write (pi->ctl_fd, (void *) &cmd, sizeof (cmd)) == sizeof (cmd));
2279 win = (ioctl (pi->ctl_fd, PIOCCFAULT, 0) >= 0);
2285 /* Set the "current signal" that will be delivered next to the
2286 process. NOTE: semantics are different from those of KILL. This
2287 signal will be delivered to the process or LWP immediately when it
2288 is resumed (even if the signal is held/blocked); it will NOT
2289 immediately cause another event of interest, and will NOT first
2290 trap back to the debugger. Returns non-zero for success, zero for
2294 proc_set_current_signal (procinfo *pi, int signo)
2299 /* Use char array to avoid alignment issues. */
2300 char sinfo[sizeof (gdb_siginfo_t)];
2302 gdb_siginfo_t mysinfo;
2304 struct target_waitstatus wait_status;
2306 /* We should never have to apply this operation to any procinfo
2307 except the one for the main process. If that ever changes for
2308 any reason, then take out the following clause and replace it
2309 with one that makes sure the ctl_fd is open. */
2312 pi = find_procinfo_or_die (pi->pid, 0);
2314 #ifdef PROCFS_DONT_PIOCSSIG_CURSIG
2315 /* With Alpha OSF/1 procfs, the kernel gets really confused if it
2316 receives a PIOCSSIG with a signal identical to the current
2317 signal, it messes up the current signal. Work around the kernel
2320 signo == proc_cursig (pi))
2321 return 1; /* I assume this is a success? */
2324 /* The pointer is just a type alias. */
2325 get_last_target_status (&wait_ptid, &wait_status);
2326 if (ptid_equal (wait_ptid, inferior_ptid)
2327 && wait_status.kind == TARGET_WAITKIND_STOPPED
2328 && wait_status.value.sig == target_signal_from_host (signo)
2329 && proc_get_status (pi)
2331 && pi->prstatus.pr_lwp.pr_info.si_signo == signo
2333 && pi->prstatus.pr_info.si_signo == signo
2336 /* Use the siginfo associated with the signal being
2339 memcpy (arg.sinfo, &pi->prstatus.pr_lwp.pr_info, sizeof (gdb_siginfo_t));
2341 memcpy (arg.sinfo, &pi->prstatus.pr_info, sizeof (gdb_siginfo_t));
2345 mysinfo.si_signo = signo;
2346 mysinfo.si_code = 0;
2347 mysinfo.si_pid = getpid (); /* ?why? */
2348 mysinfo.si_uid = getuid (); /* ?why? */
2349 memcpy (arg.sinfo, &mysinfo, sizeof (gdb_siginfo_t));
2354 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2356 win = (ioctl (pi->ctl_fd, PIOCSSIG, (void *) &arg.sinfo) >= 0);
2362 /* The current signal (if any) is cleared, and is not sent to the
2363 process or LWP when it resumes. Returns non-zero for success, zero
2367 proc_clear_current_signal (procinfo *pi)
2371 /* We should never have to apply this operation to any procinfo
2372 except the one for the main process. If that ever changes for
2373 any reason, then take out the following clause and replace it
2374 with one that makes sure the ctl_fd is open. */
2377 pi = find_procinfo_or_die (pi->pid, 0);
2383 /* Use char array to avoid alignment issues. */
2384 char sinfo[sizeof (gdb_siginfo_t)];
2386 gdb_siginfo_t mysinfo;
2389 /* The pointer is just a type alias. */
2390 mysinfo.si_signo = 0;
2391 mysinfo.si_code = 0;
2392 mysinfo.si_errno = 0;
2393 mysinfo.si_pid = getpid (); /* ?why? */
2394 mysinfo.si_uid = getuid (); /* ?why? */
2395 memcpy (arg.sinfo, &mysinfo, sizeof (gdb_siginfo_t));
2397 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2400 win = (ioctl (pi->ctl_fd, PIOCSSIG, 0) >= 0);
2406 /* Return the general-purpose registers for the process or LWP
2407 corresponding to PI. Upon failure, return NULL. */
2410 proc_get_gregs (procinfo *pi)
2412 if (!pi->status_valid || !pi->gregs_valid)
2413 if (!proc_get_status (pi))
2416 /* OK, sorry about the ifdef's. There's three cases instead of two,
2417 because in this case Unixware and Solaris/RW differ. */
2420 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2421 return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs;
2423 return &pi->prstatus.pr_lwp.pr_reg;
2426 return &pi->prstatus.pr_reg;
2430 /* Return the general-purpose registers for the process or LWP
2431 corresponding to PI. Upon failure, return NULL. */
2434 proc_get_fpregs (procinfo *pi)
2437 if (!pi->status_valid || !pi->fpregs_valid)
2438 if (!proc_get_status (pi))
2441 # ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
2442 return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs;
2444 return &pi->prstatus.pr_lwp.pr_fpreg;
2447 #else /* not NEW_PROC_API */
2448 if (pi->fpregs_valid)
2449 return &pi->fpregset; /* Already got 'em. */
2452 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
2461 tid_t pr_error_thread;
2462 tfpregset_t thread_1;
2465 thread_fpregs.pr_count = 1;
2466 thread_fpregs.thread_1.tid = pi->tid;
2469 && ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
2471 pi->fpregs_valid = 1;
2472 return &pi->fpregset; /* Got 'em now! */
2474 else if (pi->tid != 0
2475 && ioctl (pi->ctl_fd, PIOCTGFPREG, &thread_fpregs) >= 0)
2477 memcpy (&pi->fpregset, &thread_fpregs.thread_1.pr_fpregs,
2478 sizeof (pi->fpregset));
2479 pi->fpregs_valid = 1;
2480 return &pi->fpregset; /* Got 'em now! */
2487 if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
2489 pi->fpregs_valid = 1;
2490 return &pi->fpregset; /* Got 'em now! */
2499 #endif /* NEW_PROC_API */
2502 /* Write the general-purpose registers back to the process or LWP
2503 corresponding to PI. Return non-zero for success, zero for
2507 proc_set_gregs (procinfo *pi)
2509 gdb_gregset_t *gregs;
2512 gregs = proc_get_gregs (pi);
2514 return 0; /* proc_get_regs has already warned. */
2516 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
2525 /* Use char array to avoid alignment issues. */
2526 char gregs[sizeof (gdb_gregset_t)];
2530 memcpy (&arg.gregs, gregs, sizeof (arg.gregs));
2531 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2533 win = (ioctl (pi->ctl_fd, PIOCSREG, gregs) >= 0);
2537 /* Policy: writing the registers invalidates our cache. */
2538 pi->gregs_valid = 0;
2542 /* Write the floating-pointer registers back to the process or LWP
2543 corresponding to PI. Return non-zero for success, zero for
2547 proc_set_fpregs (procinfo *pi)
2549 gdb_fpregset_t *fpregs;
2552 fpregs = proc_get_fpregs (pi);
2554 return 0; /* proc_get_fpregs has already warned. */
2556 if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
2565 /* Use char array to avoid alignment issues. */
2566 char fpregs[sizeof (gdb_fpregset_t)];
2570 memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs));
2571 win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
2575 win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
2580 tid_t pr_error_thread;
2581 tfpregset_t thread_1;
2584 thread_fpregs.pr_count = 1;
2585 thread_fpregs.thread_1.tid = pi->tid;
2586 memcpy (&thread_fpregs.thread_1.pr_fpregs, fpregs,
2588 win = (ioctl (pi->ctl_fd, PIOCTSFPREG, &thread_fpregs) >= 0);
2591 win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
2593 #endif /* NEW_PROC_API */
2596 /* Policy: writing the registers invalidates our cache. */
2597 pi->fpregs_valid = 0;
2601 /* Send a signal to the proc or lwp with the semantics of "kill()".
2602 Returns non-zero for success, zero for failure. */
2605 proc_kill (procinfo *pi, int signo)
2609 /* We might conceivably apply this operation to an LWP, and the
2610 LWP's ctl file descriptor might not be open. */
2612 if (pi->ctl_fd == 0 &&
2613 open_procinfo_files (pi, FD_CTL) == 0)
2620 procfs_ctl_t cmd[2];
2624 win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
2625 #else /* ioctl method */
2626 /* FIXME: do I need the Alpha OSF fixups present in
2627 procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
2628 win = (ioctl (pi->ctl_fd, PIOCKILL, &signo) >= 0);
2635 /* Find the pid of the process that started this one. Returns the
2636 parent process pid, or zero. */
2639 proc_parent_pid (procinfo *pi)
2641 /* We should never have to apply this operation to any procinfo
2642 except the one for the main process. If that ever changes for
2643 any reason, then take out the following clause and replace it
2644 with one that makes sure the ctl_fd is open. */
2647 pi = find_procinfo_or_die (pi->pid, 0);
2649 if (!pi->status_valid)
2650 if (!proc_get_status (pi))
2653 return pi->prstatus.pr_ppid;
2656 /* Convert a target address (a.k.a. CORE_ADDR) into a host address
2657 (a.k.a void pointer)! */
2659 #if (defined (PCWATCH) || defined (PIOCSWATCH)) \
2660 && !(defined (PIOCOPENLWP) || defined (UNIXWARE))
2662 procfs_address_to_host_pointer (CORE_ADDR addr)
2664 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
2667 gdb_assert (sizeof (ptr) == TYPE_LENGTH (ptr_type));
2668 gdbarch_address_to_pointer (target_gdbarch, ptr_type,
2669 (gdb_byte *) &ptr, addr);
2675 proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags)
2677 #if !defined (PCWATCH) && !defined (PIOCSWATCH)
2678 /* If neither or these is defined, we can't support watchpoints.
2679 This just avoids possibly failing to compile the below on such
2683 /* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5. */
2684 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out. */
2689 char watch[sizeof (prwatch_t)];
2693 /* NOTE: cagney/2003-02-01: Even more horrible hack. Need to
2694 convert a target address into something that can be stored in a
2695 native data structure. */
2696 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
2697 pwatch.pr_vaddr = (uintptr_t) procfs_address_to_host_pointer (addr);
2699 pwatch.pr_vaddr = (caddr_t) procfs_address_to_host_pointer (addr);
2701 pwatch.pr_size = len;
2702 pwatch.pr_wflags = wflags;
2703 #if defined(NEW_PROC_API) && defined (PCWATCH)
2705 memcpy (arg.watch, &pwatch, sizeof (prwatch_t));
2706 return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg));
2708 #if defined (PIOCSWATCH)
2709 return (ioctl (pi->ctl_fd, PIOCSWATCH, &pwatch) >= 0);
2711 return 0; /* Fail */
2718 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
2720 #include <sys/sysi86.h>
2722 /* The KEY is actually the value of the lower 16 bits of the GS
2723 register for the LWP that we're interested in. Returns the
2724 matching ssh struct (LDT entry). */
2727 proc_get_LDT_entry (procinfo *pi, int key)
2729 static struct ssd *ldt_entry = NULL;
2731 char pathname[MAX_PROC_NAME_SIZE];
2732 struct cleanup *old_chain = NULL;
2735 /* Allocate space for one LDT entry.
2736 This alloc must persist, because we return a pointer to it. */
2737 if (ldt_entry == NULL)
2738 ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd));
2740 /* Open the file descriptor for the LDT table. */
2741 sprintf (pathname, "/proc/%d/ldt", pi->pid);
2742 if ((fd = open_with_retry (pathname, O_RDONLY)) < 0)
2744 proc_warn (pi, "proc_get_LDT_entry (open)", __LINE__);
2747 /* Make sure it gets closed again! */
2748 old_chain = make_cleanup_close (fd);
2750 /* Now 'read' thru the table, find a match and return it. */
2751 while (read (fd, ldt_entry, sizeof (struct ssd)) == sizeof (struct ssd))
2753 if (ldt_entry->sel == 0 &&
2754 ldt_entry->bo == 0 &&
2755 ldt_entry->acc1 == 0 &&
2756 ldt_entry->acc2 == 0)
2757 break; /* end of table */
2758 /* If key matches, return this entry. */
2759 if (ldt_entry->sel == key)
2762 /* Loop ended, match not found. */
2766 static int nalloc = 0;
2768 /* Get the number of LDT entries. */
2769 if (ioctl (pi->ctl_fd, PIOCNLDT, &nldt) < 0)
2771 proc_warn (pi, "proc_get_LDT_entry (PIOCNLDT)", __LINE__);
2775 /* Allocate space for the number of LDT entries. */
2776 /* This alloc has to persist, 'cause we return a pointer to it. */
2779 ldt_entry = (struct ssd *)
2780 xrealloc (ldt_entry, (nldt + 1) * sizeof (struct ssd));
2784 /* Read the whole table in one gulp. */
2785 if (ioctl (pi->ctl_fd, PIOCLDT, ldt_entry) < 0)
2787 proc_warn (pi, "proc_get_LDT_entry (PIOCLDT)", __LINE__);
2791 /* Search the table and return the (first) entry matching 'key'. */
2792 for (i = 0; i < nldt; i++)
2793 if (ldt_entry[i].sel == key)
2794 return &ldt_entry[i];
2796 /* Loop ended, match not found. */
2801 /* Returns the pointer to the LDT entry of PTID. */
2804 procfs_find_LDT_entry (ptid_t ptid)
2806 gdb_gregset_t *gregs;
2810 /* Find procinfo for the lwp. */
2811 if ((pi = find_procinfo (PIDGET (ptid), TIDGET (ptid))) == NULL)
2813 warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
2814 PIDGET (ptid), TIDGET (ptid));
2817 /* get its general registers. */
2818 if ((gregs = proc_get_gregs (pi)) == NULL)
2820 warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
2821 PIDGET (ptid), TIDGET (ptid));
2824 /* Now extract the GS register's lower 16 bits. */
2825 key = (*gregs)[GS] & 0xffff;
2827 /* Find the matching entry and return it. */
2828 return proc_get_LDT_entry (pi, key);
2833 /* =============== END, non-thread part of /proc "MODULE" =============== */
2835 /* =================== Thread "MODULE" =================== */
2837 /* NOTE: you'll see more ifdefs and duplication of functions here,
2838 since there is a different way to do threads on every OS. */
2840 /* Returns the number of threads for the process. */
2842 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2845 proc_get_nthreads (procinfo *pi)
2849 if (ioctl (pi->ctl_fd, PIOCNTHR, &nthreads) < 0)
2850 proc_warn (pi, "procfs: PIOCNTHR failed", __LINE__);
2856 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2857 /* Solaris and Unixware version */
2859 proc_get_nthreads (procinfo *pi)
2861 if (!pi->status_valid)
2862 if (!proc_get_status (pi))
2865 /* NEW_PROC_API: only works for the process procinfo, because the
2866 LWP procinfos do not get prstatus filled in. */
2868 if (pi->tid != 0) /* Find the parent process procinfo. */
2869 pi = find_procinfo_or_die (pi->pid, 0);
2871 return pi->prstatus.pr_nlwp;
2875 /* Default version */
2877 proc_get_nthreads (procinfo *pi)
2886 Return the ID of the thread that had an event of interest.
2887 (ie. the one that hit a breakpoint or other traced event). All
2888 other things being equal, this should be the ID of a thread that is
2889 currently executing. */
2891 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
2892 /* Solaris and Unixware version */
2894 proc_get_current_thread (procinfo *pi)
2896 /* Note: this should be applied to the root procinfo for the
2897 process, not to the procinfo for an LWP. If applied to the
2898 procinfo for an LWP, it will simply return that LWP's ID. In
2899 that case, find the parent process procinfo. */
2902 pi = find_procinfo_or_die (pi->pid, 0);
2904 if (!pi->status_valid)
2905 if (!proc_get_status (pi))
2909 return pi->prstatus.pr_lwp.pr_lwpid;
2911 return pi->prstatus.pr_who;
2916 #if defined (PIOCNTHR) && defined (PIOCTLIST)
2919 proc_get_current_thread (procinfo *pi)
2921 #if 0 /* FIXME: not ready for prime time? */
2922 return pi->prstatus.pr_tid;
2929 /* Default version */
2931 proc_get_current_thread (procinfo *pi)
2939 /* Discover the IDs of all the threads within the process, and create
2940 a procinfo for each of them (chained to the parent). This
2941 unfortunately requires a different method on every OS. Returns
2942 non-zero for success, zero for failure. */
2945 proc_delete_dead_threads (procinfo *parent, procinfo *thread, void *ignore)
2947 if (thread && parent) /* sanity */
2949 thread->status_valid = 0;
2950 if (!proc_get_status (thread))
2951 destroy_one_procinfo (&parent->thread_list, thread);
2953 return 0; /* keep iterating */
2956 #if defined (PIOCLSTATUS)
2957 /* Solaris 2.5 (ioctl) version */
2959 proc_update_threads (procinfo *pi)
2961 gdb_prstatus_t *prstatus;
2962 struct cleanup *old_chain = NULL;
2966 /* We should never have to apply this operation to any procinfo
2967 except the one for the main process. If that ever changes for
2968 any reason, then take out the following clause and replace it
2969 with one that makes sure the ctl_fd is open. */
2972 pi = find_procinfo_or_die (pi->pid, 0);
2974 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
2976 if ((nlwp = proc_get_nthreads (pi)) <= 1)
2977 return 1; /* Process is not multi-threaded; nothing to do. */
2979 prstatus = xmalloc (sizeof (gdb_prstatus_t) * (nlwp + 1));
2981 old_chain = make_cleanup (xfree, prstatus);
2982 if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0)
2983 proc_error (pi, "update_threads (PIOCLSTATUS)", __LINE__);
2985 /* Skip element zero, which represents the process as a whole. */
2986 for (i = 1; i < nlwp + 1; i++)
2988 if ((thread = create_procinfo (pi->pid, prstatus[i].pr_who)) == NULL)
2989 proc_error (pi, "update_threads, create_procinfo", __LINE__);
2991 memcpy (&thread->prstatus, &prstatus[i], sizeof (*prstatus));
2992 thread->status_valid = 1;
2994 pi->threads_valid = 1;
2995 do_cleanups (old_chain);
3000 /* Unixware and Solaris 6 (and later) version. */
3002 do_closedir_cleanup (void *dir)
3008 proc_update_threads (procinfo *pi)
3010 char pathname[MAX_PROC_NAME_SIZE + 16];
3011 struct dirent *direntry;
3012 struct cleanup *old_chain = NULL;
3017 /* We should never have to apply this operation to any procinfo
3018 except the one for the main process. If that ever changes for
3019 any reason, then take out the following clause and replace it
3020 with one that makes sure the ctl_fd is open. */
3023 pi = find_procinfo_or_die (pi->pid, 0);
3025 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
3029 Note: this brute-force method is the only way I know of to
3030 accomplish this task on Unixware. This method will also work on
3031 Solaris 2.6 and 2.7. There is a much simpler and more elegant
3032 way to do this on Solaris, but the margins of this manuscript are
3033 too small to write it here... ;-) */
3035 strcpy (pathname, pi->pathname);
3036 strcat (pathname, "/lwp");
3037 if ((dirp = opendir (pathname)) == NULL)
3038 proc_error (pi, "update_threads, opendir", __LINE__);
3040 old_chain = make_cleanup (do_closedir_cleanup, dirp);
3041 while ((direntry = readdir (dirp)) != NULL)
3042 if (direntry->d_name[0] != '.') /* skip '.' and '..' */
3044 lwpid = atoi (&direntry->d_name[0]);
3045 if ((thread = create_procinfo (pi->pid, lwpid)) == NULL)
3046 proc_error (pi, "update_threads, create_procinfo", __LINE__);
3048 pi->threads_valid = 1;
3049 do_cleanups (old_chain);
3056 proc_update_threads (procinfo *pi)
3061 /* We should never have to apply this operation to any procinfo
3062 except the one for the main process. If that ever changes for
3063 any reason, then take out the following clause and replace it
3064 with one that makes sure the ctl_fd is open. */
3067 pi = find_procinfo_or_die (pi->pid, 0);
3069 proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
3071 nthreads = proc_get_nthreads (pi);
3073 return 0; /* Nothing to do for 1 or fewer threads. */
3075 threads = xmalloc (nthreads * sizeof (tid_t));
3077 if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0)
3078 proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__);
3080 for (i = 0; i < nthreads; i++)
3082 if (!find_procinfo (pi->pid, threads[i]))
3083 if (!create_procinfo (pi->pid, threads[i]))
3084 proc_error (pi, "update_threads, create_procinfo", __LINE__);
3086 pi->threads_valid = 1;
3090 /* Default version */
3092 proc_update_threads (procinfo *pi)
3096 #endif /* OSF PIOCTLIST */
3097 #endif /* NEW_PROC_API */
3098 #endif /* SOL 2.5 PIOCLSTATUS */
3100 /* Given a pointer to a function, call that function once for each lwp
3101 in the procinfo list, until the function returns non-zero, in which
3102 event return the value returned by the function.
3104 Note: this function does NOT call update_threads. If you want to
3105 discover new threads first, you must call that function explicitly.
3106 This function just makes a quick pass over the currently-known
3109 PI is the parent process procinfo. FUNC is the per-thread
3110 function. PTR is an opaque parameter for function. Returns the
3111 first non-zero return value from the callee, or zero. */
3114 proc_iterate_over_threads (procinfo *pi,
3115 int (*func) (procinfo *, procinfo *, void *),
3118 procinfo *thread, *next;
3121 /* We should never have to apply this operation to any procinfo
3122 except the one for the main process. If that ever changes for
3123 any reason, then take out the following clause and replace it
3124 with one that makes sure the ctl_fd is open. */
3127 pi = find_procinfo_or_die (pi->pid, 0);
3129 for (thread = pi->thread_list; thread != NULL; thread = next)
3131 next = thread->next; /* In case thread is destroyed. */
3132 if ((retval = (*func) (pi, thread, ptr)) != 0)
3139 /* =================== END, Thread "MODULE" =================== */
3141 /* =================== END, /proc "MODULE" =================== */
3143 /* =================== GDB "MODULE" =================== */
3145 /* Here are all of the gdb target vector functions and their
3148 static ptid_t do_attach (ptid_t ptid);
3149 static void do_detach (int signo);
3150 static int register_gdb_signals (procinfo *, gdb_sigset_t *);
3151 static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum,
3152 int entry_or_exit, int mode, int from_tty);
3154 /* On mips-irix, we need to insert a breakpoint at __dbx_link during
3155 the startup phase. The following two variables are used to record
3156 the address of the breakpoint, and the code that was replaced by
3158 static int dbx_link_bpt_addr = 0;
3159 static void *dbx_link_bpt;
3161 /* Sets up the inferior to be debugged. Registers to trace signals,
3162 hardware faults, and syscalls. Note: does not set RLC flag: caller
3163 may want to customize that. Returns zero for success (note!
3164 unlike most functions in this module); on failure, returns the LINE
3165 NUMBER where it failed! */
3168 procfs_debug_inferior (procinfo *pi)
3170 fltset_t traced_faults;
3171 gdb_sigset_t traced_signals;
3172 sysset_t *traced_syscall_entries;
3173 sysset_t *traced_syscall_exits;
3176 #ifdef PROCFS_DONT_TRACE_FAULTS
3177 /* On some systems (OSF), we don't trace hardware faults.
3178 Apparently it's enough that we catch them as signals.
3179 Wonder why we don't just do that in general? */
3180 premptyset (&traced_faults); /* don't trace faults. */
3182 /* Register to trace hardware faults in the child. */
3183 prfillset (&traced_faults); /* trace all faults... */
3184 gdb_prdelset (&traced_faults, FLTPAGE); /* except page fault. */
3186 if (!proc_set_traced_faults (pi, &traced_faults))
3189 /* Register to trace selected signals in the child. */
3190 premptyset (&traced_signals);
3191 if (!register_gdb_signals (pi, &traced_signals))
3195 /* Register to trace the 'exit' system call (on entry). */
3196 traced_syscall_entries = sysset_t_alloc (pi);
3197 gdb_premptysysset (traced_syscall_entries);
3199 gdb_praddsysset (traced_syscall_entries, SYS_exit);
3202 gdb_praddsysset (traced_syscall_entries, SYS_lwpexit);/* And _lwp_exit... */
3205 gdb_praddsysset (traced_syscall_entries, SYS_lwp_exit);
3207 #ifdef DYNAMIC_SYSCALLS
3209 int callnum = find_syscall (pi, "_exit");
3212 gdb_praddsysset (traced_syscall_entries, callnum);
3216 status = proc_set_traced_sysentry (pi, traced_syscall_entries);
3217 xfree (traced_syscall_entries);
3221 #ifdef PRFS_STOPEXEC /* defined on OSF */
3222 /* OSF method for tracing exec syscalls. Quoting:
3223 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
3224 exits from exec system calls because of the user level loader. */
3225 /* FIXME: make nice and maybe move into an access function. */
3229 if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
3232 prfs_flags |= PRFS_STOPEXEC;
3234 if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
3237 #else /* not PRFS_STOPEXEC */
3238 /* Everyone else's (except OSF) method for tracing exec syscalls. */
3240 Not all systems with /proc have all the exec* syscalls with the same
3241 names. On the SGI, for example, there is no SYS_exec, but there
3242 *is* a SYS_execv. So, we try to account for that. */
3244 traced_syscall_exits = sysset_t_alloc (pi);
3245 gdb_premptysysset (traced_syscall_exits);
3247 gdb_praddsysset (traced_syscall_exits, SYS_exec);
3250 gdb_praddsysset (traced_syscall_exits, SYS_execve);
3253 gdb_praddsysset (traced_syscall_exits, SYS_execv);
3256 #ifdef SYS_lwpcreate
3257 gdb_praddsysset (traced_syscall_exits, SYS_lwpcreate);
3258 gdb_praddsysset (traced_syscall_exits, SYS_lwpexit);
3261 #ifdef SYS_lwp_create /* FIXME: once only, please. */
3262 gdb_praddsysset (traced_syscall_exits, SYS_lwp_create);
3263 gdb_praddsysset (traced_syscall_exits, SYS_lwp_exit);
3266 #ifdef DYNAMIC_SYSCALLS
3268 int callnum = find_syscall (pi, "execve");
3271 gdb_praddsysset (traced_syscall_exits, callnum);
3272 callnum = find_syscall (pi, "ra_execve");
3274 gdb_praddsysset (traced_syscall_exits, callnum);
3278 status = proc_set_traced_sysexit (pi, traced_syscall_exits);
3279 xfree (traced_syscall_exits);
3283 #endif /* PRFS_STOPEXEC */
3288 procfs_attach (struct target_ops *ops, char *args, int from_tty)
3293 pid = parse_pid_to_attach (args);
3295 if (pid == getpid ())
3296 error (_("Attaching GDB to itself is not a good idea..."));
3300 exec_file = get_exec_file (0);
3303 printf_filtered (_("Attaching to program `%s', %s\n"),
3304 exec_file, target_pid_to_str (pid_to_ptid (pid)));
3306 printf_filtered (_("Attaching to %s\n"),
3307 target_pid_to_str (pid_to_ptid (pid)));
3311 inferior_ptid = do_attach (pid_to_ptid (pid));
3316 procfs_detach (struct target_ops *ops, char *args, int from_tty)
3319 int pid = PIDGET (inferior_ptid);
3328 exec_file = get_exec_file (0);
3329 if (exec_file == NULL)
3332 printf_filtered (_("Detaching from program: %s, %s\n"), exec_file,
3333 target_pid_to_str (pid_to_ptid (pid)));
3334 gdb_flush (gdb_stdout);
3339 inferior_ptid = null_ptid;
3340 detach_inferior (pid);
3341 unpush_target (ops);
3345 do_attach (ptid_t ptid)
3348 struct inferior *inf;
3352 if ((pi = create_procinfo (PIDGET (ptid), 0)) == NULL)
3353 perror (_("procfs: out of memory in 'attach'"));
3355 if (!open_procinfo_files (pi, FD_CTL))
3357 fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__);
3358 sprintf (errmsg, "do_attach: couldn't open /proc file for process %d",
3360 dead_procinfo (pi, errmsg, NOKILL);
3363 /* Stop the process (if it isn't already stopped). */
3364 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
3366 pi->was_stopped = 1;
3367 proc_prettyprint_why (proc_why (pi), proc_what (pi), 1);
3371 pi->was_stopped = 0;
3372 /* Set the process to run again when we close it. */
3373 if (!proc_set_run_on_last_close (pi))
3374 dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL);
3376 /* Now stop the process. */
3377 if (!proc_stop_process (pi))
3378 dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL);
3379 pi->ignore_next_sigstop = 1;
3381 /* Save some of the /proc state to be restored if we detach. */
3382 if (!proc_get_traced_faults (pi, &pi->saved_fltset))
3383 dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL);
3384 if (!proc_get_traced_signals (pi, &pi->saved_sigset))
3385 dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL);
3386 if (!proc_get_traced_sysentry (pi, pi->saved_entryset))
3387 dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.",
3389 if (!proc_get_traced_sysexit (pi, pi->saved_exitset))
3390 dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.",
3392 if (!proc_get_held_signals (pi, &pi->saved_sighold))
3393 dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL);
3395 if ((fail = procfs_debug_inferior (pi)) != 0)
3396 dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL);
3398 inf = current_inferior ();
3399 inferior_appeared (inf, pi->pid);
3400 /* Let GDB know that the inferior was attached. */
3401 inf->attach_flag = 1;
3403 /* Create a procinfo for the current lwp. */
3404 lwpid = proc_get_current_thread (pi);
3405 create_procinfo (pi->pid, lwpid);
3407 /* Add it to gdb's thread list. */
3408 ptid = MERGEPID (pi->pid, lwpid);
3415 do_detach (int signo)
3419 /* Find procinfo for the main process. */
3420 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0); /* FIXME: threads */
3422 if (!proc_set_current_signal (pi, signo))
3423 proc_warn (pi, "do_detach, set_current_signal", __LINE__);
3425 if (!proc_set_traced_signals (pi, &pi->saved_sigset))
3426 proc_warn (pi, "do_detach, set_traced_signal", __LINE__);
3428 if (!proc_set_traced_faults (pi, &pi->saved_fltset))
3429 proc_warn (pi, "do_detach, set_traced_faults", __LINE__);
3431 if (!proc_set_traced_sysentry (pi, pi->saved_entryset))
3432 proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__);
3434 if (!proc_set_traced_sysexit (pi, pi->saved_exitset))
3435 proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__);
3437 if (!proc_set_held_signals (pi, &pi->saved_sighold))
3438 proc_warn (pi, "do_detach, set_held_signals", __LINE__);
3440 if (signo || (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)))
3441 if (signo || !(pi->was_stopped) ||
3442 query (_("Was stopped when attached, make it runnable again? ")))
3444 /* Clear any pending signal. */
3445 if (!proc_clear_current_fault (pi))
3446 proc_warn (pi, "do_detach, clear_current_fault", __LINE__);
3448 if (signo == 0 && !proc_clear_current_signal (pi))
3449 proc_warn (pi, "do_detach, clear_current_signal", __LINE__);
3451 if (!proc_set_run_on_last_close (pi))
3452 proc_warn (pi, "do_detach, set_rlc", __LINE__);
3455 destroy_procinfo (pi);
3458 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
3461 ??? Is the following note still relevant? We can't get individual
3462 registers with the PT_GETREGS ptrace(2) request either, yet we
3463 don't bother with caching at all in that case.
3465 NOTE: Since the /proc interface cannot give us individual
3466 registers, we pay no attention to REGNUM, and just fetch them all.
3467 This results in the possibility that we will do unnecessarily many
3468 fetches, since we may be called repeatedly for individual
3469 registers. So we cache the results, and mark the cache invalid
3470 when the process is resumed. */
3473 procfs_fetch_registers (struct target_ops *ops,
3474 struct regcache *regcache, int regnum)
3476 gdb_gregset_t *gregs;
3478 int pid = PIDGET (inferior_ptid);
3479 int tid = TIDGET (inferior_ptid);
3480 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3482 pi = find_procinfo_or_die (pid, tid);
3485 error (_("procfs: fetch_registers failed to find procinfo for %s"),
3486 target_pid_to_str (inferior_ptid));
3488 gregs = proc_get_gregs (pi);
3490 proc_error (pi, "fetch_registers, get_gregs", __LINE__);
3492 supply_gregset (regcache, (const gdb_gregset_t *) gregs);
3494 if (gdbarch_fp0_regnum (gdbarch) >= 0) /* Do we have an FPU? */
3496 gdb_fpregset_t *fpregs;
3498 if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (gdbarch))
3499 || regnum == gdbarch_pc_regnum (gdbarch)
3500 || regnum == gdbarch_sp_regnum (gdbarch))
3501 return; /* Not a floating point register. */
3503 fpregs = proc_get_fpregs (pi);
3505 proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
3507 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregs);
3511 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
3512 this for all registers.
3514 NOTE: Since the /proc interface will not read individual registers,
3515 we will cache these requests until the process is resumed, and only
3516 then write them back to the inferior process.
3518 FIXME: is that a really bad idea? Have to think about cases where
3519 writing one register might affect the value of others, etc. */
3522 procfs_store_registers (struct target_ops *ops,
3523 struct regcache *regcache, int regnum)
3525 gdb_gregset_t *gregs;
3527 int pid = PIDGET (inferior_ptid);
3528 int tid = TIDGET (inferior_ptid);
3529 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3531 pi = find_procinfo_or_die (pid, tid);
3534 error (_("procfs: store_registers: failed to find procinfo for %s"),
3535 target_pid_to_str (inferior_ptid));
3537 gregs = proc_get_gregs (pi);
3539 proc_error (pi, "store_registers, get_gregs", __LINE__);
3541 fill_gregset (regcache, gregs, regnum);
3542 if (!proc_set_gregs (pi))
3543 proc_error (pi, "store_registers, set_gregs", __LINE__);
3545 if (gdbarch_fp0_regnum (gdbarch) >= 0) /* Do we have an FPU? */
3547 gdb_fpregset_t *fpregs;
3549 if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (gdbarch))
3550 || regnum == gdbarch_pc_regnum (gdbarch)
3551 || regnum == gdbarch_sp_regnum (gdbarch))
3552 return; /* Not a floating point register. */
3554 fpregs = proc_get_fpregs (pi);
3556 proc_error (pi, "store_registers, get_fpregs", __LINE__);
3558 fill_fpregset (regcache, fpregs, regnum);
3559 if (!proc_set_fpregs (pi))
3560 proc_error (pi, "store_registers, set_fpregs", __LINE__);
3565 syscall_is_lwp_exit (procinfo *pi, int scall)
3568 if (scall == SYS_lwp_exit)
3572 if (scall == SYS_lwpexit)
3579 syscall_is_exit (procinfo *pi, int scall)
3582 if (scall == SYS_exit)
3585 #ifdef DYNAMIC_SYSCALLS
3586 if (find_syscall (pi, "_exit") == scall)
3593 syscall_is_exec (procinfo *pi, int scall)
3596 if (scall == SYS_exec)
3600 if (scall == SYS_execv)
3604 if (scall == SYS_execve)
3607 #ifdef DYNAMIC_SYSCALLS
3608 if (find_syscall (pi, "_execve"))
3610 if (find_syscall (pi, "ra_execve"))
3617 syscall_is_lwp_create (procinfo *pi, int scall)
3619 #ifdef SYS_lwp_create
3620 if (scall == SYS_lwp_create)
3623 #ifdef SYS_lwpcreate
3624 if (scall == SYS_lwpcreate)
3630 /* Remove the breakpoint that we inserted in __dbx_link().
3631 Does nothing if the breakpoint hasn't been inserted or has already
3635 remove_dbx_link_breakpoint (void)
3637 if (dbx_link_bpt_addr == 0)
3640 if (deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt) != 0)
3641 warning (_("Unable to remove __dbx_link breakpoint."));
3643 dbx_link_bpt_addr = 0;
3644 dbx_link_bpt = NULL;
3648 /* Return the address of the __dbx_link() function in the file
3649 refernced by ABFD by scanning its symbol table. Return 0 if
3650 the symbol was not found. */
3653 dbx_link_addr (bfd *abfd)
3655 long storage_needed;
3656 asymbol **symbol_table;
3657 long number_of_symbols;
3660 storage_needed = bfd_get_symtab_upper_bound (abfd);
3661 if (storage_needed <= 0)
3664 symbol_table = (asymbol **) xmalloc (storage_needed);
3665 make_cleanup (xfree, symbol_table);
3667 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
3669 for (i = 0; i < number_of_symbols; i++)
3671 asymbol *sym = symbol_table[i];
3673 if ((sym->flags & BSF_GLOBAL)
3674 && sym->name != NULL && strcmp (sym->name, "__dbx_link") == 0)
3675 return (sym->value + sym->section->vma);
3678 /* Symbol not found, return NULL. */
3682 /* Search the symbol table of the file referenced by FD for a symbol
3683 named __dbx_link(). If found, then insert a breakpoint at this location,
3684 and return nonzero. Return zero otherwise. */
3687 insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored)
3690 long storage_needed;
3693 abfd = bfd_fdopenr ("unamed", 0, fd);
3696 warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
3700 if (!bfd_check_format (abfd, bfd_object))
3702 /* Not the correct format, so we can not possibly find the dbx_link
3708 sym_addr = dbx_link_addr (abfd);
3711 /* Insert the breakpoint. */
3712 dbx_link_bpt_addr = sym_addr;
3713 dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch, NULL,
3715 if (dbx_link_bpt == NULL)
3717 warning (_("Failed to insert dbx_link breakpoint."));
3729 /* Calls the supplied callback function once for each mapped address
3730 space in the process. The callback function receives an open file
3731 descriptor for the file corresponding to that mapped address space
3732 (if there is one), and the base address of the mapped space. Quit
3733 when the callback function returns a nonzero value, or at teh end
3734 of the mappings. Returns the first non-zero return value of the
3735 callback function, or zero. */
3738 solib_mappings_callback (struct prmap *map, int (*func) (int, CORE_ADDR),
3741 procinfo *pi = data;
3745 char name[MAX_PROC_NAME_SIZE + sizeof (map->pr_mapname)];
3747 if (map->pr_vaddr == 0 && map->pr_size == 0)
3748 return -1; /* sanity */
3750 if (map->pr_mapname[0] == 0)
3752 fd = -1; /* no map file */
3756 sprintf (name, "/proc/%d/object/%s", pi->pid, map->pr_mapname);
3757 /* Note: caller's responsibility to close this fd! */
3758 fd = open_with_retry (name, O_RDONLY);
3759 /* Note: we don't test the above call for failure;
3760 we just pass the FD on as given. Sometimes there is
3761 no file, so the open may return failure, but that's
3765 fd = ioctl (pi->ctl_fd, PIOCOPENM, &map->pr_vaddr);
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 ioctl may return failure, but that's
3771 return (*func) (fd, (CORE_ADDR) map->pr_vaddr);
3774 /* If the given memory region MAP contains a symbol named __dbx_link,
3775 insert a breakpoint at this location and return nonzero. Return
3779 insert_dbx_link_bpt_in_region (struct prmap *map,
3780 find_memory_region_ftype child_func,
3783 procinfo *pi = (procinfo *) data;
3785 /* We know the symbol we're looking for is in a text region, so
3786 only look for it if the region is a text one. */
3787 if (map->pr_mflags & MA_EXEC)
3788 return solib_mappings_callback (map, insert_dbx_link_bpt_in_file, pi);
3793 /* Search all memory regions for a symbol named __dbx_link. If found,
3794 insert a breakpoint at its location, and return nonzero. Return zero
3798 insert_dbx_link_breakpoint (procinfo *pi)
3800 return iterate_over_mappings (pi, NULL, pi, insert_dbx_link_bpt_in_region);
3804 /* Retrieve the next stop event from the child process. If child has
3805 not stopped yet, wait for it to stop. Translate /proc eventcodes
3806 (or possibly wait eventcodes) into gdb internal event codes.
3807 Returns the id of process (and possibly thread) that incurred the
3808 event. Event codes are returned through a pointer parameter. */
3811 procfs_wait (struct target_ops *ops,
3812 ptid_t ptid, struct target_waitstatus *status, int options)
3814 /* First cut: loosely based on original version 2.1. */
3818 ptid_t retval, temp_ptid;
3819 int why, what, flags;
3826 retval = pid_to_ptid (-1);
3828 /* Find procinfo for main process. */
3829 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
3832 /* We must assume that the status is stale now... */
3833 pi->status_valid = 0;
3834 pi->gregs_valid = 0;
3835 pi->fpregs_valid = 0;
3837 #if 0 /* just try this out... */
3838 flags = proc_flags (pi);
3839 why = proc_why (pi);
3840 if ((flags & PR_STOPPED) && (why == PR_REQUESTED))
3841 pi->status_valid = 0; /* re-read again, IMMEDIATELY... */
3843 /* If child is not stopped, wait for it to stop. */
3844 if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) &&
3845 !proc_wait_for_stop (pi))
3847 /* wait_for_stop failed: has the child terminated? */
3848 if (errno == ENOENT)
3852 /* /proc file not found; presumably child has terminated. */
3853 wait_retval = wait (&wstat); /* "wait" for the child's exit. */
3855 if (wait_retval != PIDGET (inferior_ptid)) /* wrong child? */
3856 error (_("procfs: couldn't stop "
3857 "process %d: wait returned %d."),
3858 PIDGET (inferior_ptid), wait_retval);
3859 /* FIXME: might I not just use waitpid?
3860 Or try find_procinfo to see if I know about this child? */
3861 retval = pid_to_ptid (wait_retval);
3863 else if (errno == EINTR)
3867 /* Unknown error from wait_for_stop. */
3868 proc_error (pi, "target_wait (wait_for_stop)", __LINE__);
3873 /* This long block is reached if either:
3874 a) the child was already stopped, or
3875 b) we successfully waited for the child with wait_for_stop.
3876 This block will analyze the /proc status, and translate it
3877 into a waitstatus for GDB.
3879 If we actually had to call wait because the /proc file
3880 is gone (child terminated), then we skip this block,
3881 because we already have a waitstatus. */
3883 flags = proc_flags (pi);
3884 why = proc_why (pi);
3885 what = proc_what (pi);
3887 if (flags & (PR_STOPPED | PR_ISTOP))
3890 /* If it's running async (for single_thread control),
3891 set it back to normal again. */
3892 if (flags & PR_ASYNC)
3893 if (!proc_unset_async (pi))
3894 proc_error (pi, "target_wait, unset_async", __LINE__);
3898 proc_prettyprint_why (why, what, 1);
3900 /* The 'pid' we will return to GDB is composed of
3901 the process ID plus the lwp ID. */
3902 retval = MERGEPID (pi->pid, proc_get_current_thread (pi));
3906 wstat = (what << 8) | 0177;
3909 if (syscall_is_lwp_exit (pi, what))
3911 if (print_thread_events)
3912 printf_unfiltered (_("[%s exited]\n"),
3913 target_pid_to_str (retval));
3914 delete_thread (retval);
3915 status->kind = TARGET_WAITKIND_SPURIOUS;
3918 else if (syscall_is_exit (pi, what))
3920 struct inferior *inf;
3922 /* Handle SYS_exit call only. */
3923 /* Stopped at entry to SYS_exit.
3924 Make it runnable, resume it, then use
3925 the wait system call to get its exit code.
3926 Proc_run_process always clears the current
3928 Then return its exit status. */
3929 pi->status_valid = 0;
3931 /* FIXME: what we should do is return
3932 TARGET_WAITKIND_SPURIOUS. */
3933 if (!proc_run_process (pi, 0, 0))
3934 proc_error (pi, "target_wait, run_process", __LINE__);
3936 inf = find_inferior_pid (pi->pid);
3937 if (inf->attach_flag)
3939 /* Don't call wait: simulate waiting for exit,
3940 return a "success" exit code. Bogus: what if
3941 it returns something else? */
3943 retval = inferior_ptid; /* ? ? ? */
3947 int temp = wait (&wstat);
3949 /* FIXME: shouldn't I make sure I get the right
3950 event from the right process? If (for
3951 instance) I have killed an earlier inferior
3952 process but failed to clean up after it
3953 somehow, I could get its termination event
3956 /* If wait returns -1, that's what we return
3959 retval = pid_to_ptid (temp);
3964 printf_filtered (_("procfs: trapped on entry to "));
3965 proc_prettyprint_syscall (proc_what (pi), 0);
3966 printf_filtered ("\n");
3969 long i, nsysargs, *sysargs;
3971 if ((nsysargs = proc_nsysarg (pi)) > 0 &&
3972 (sysargs = proc_sysargs (pi)) != NULL)
3974 printf_filtered (_("%ld syscall arguments:\n"),
3976 for (i = 0; i < nsysargs; i++)
3977 printf_filtered ("#%ld: 0x%08lx\n",
3985 /* How to exit gracefully, returning "unknown
3987 status->kind = TARGET_WAITKIND_SPURIOUS;
3988 return inferior_ptid;
3992 /* How to keep going without returning to wfi: */
3993 target_resume (ptid, 0, TARGET_SIGNAL_0);
3999 if (syscall_is_exec (pi, what))
4001 /* Hopefully this is our own "fork-child" execing
4002 the real child. Hoax this event into a trap, and
4003 GDB will see the child about to execute its start
4005 wstat = (SIGTRAP << 8) | 0177;
4008 else if (what == SYS_syssgi)
4010 /* see if we can break on dbx_link(). If yes, then
4011 we no longer need the SYS_syssgi notifications. */
4012 if (insert_dbx_link_breakpoint (pi))
4013 proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT,
4016 /* This is an internal event and should be transparent
4017 to wfi, so resume the execution and wait again. See
4018 comment in procfs_init_inferior() for more details. */
4019 target_resume (ptid, 0, TARGET_SIGNAL_0);
4023 else if (syscall_is_lwp_create (pi, what))
4025 /* This syscall is somewhat like fork/exec. We
4026 will get the event twice: once for the parent
4027 LWP, and once for the child. We should already
4028 know about the parent LWP, but the child will
4029 be new to us. So, whenever we get this event,
4030 if it represents a new thread, simply add the
4031 thread to the list. */
4033 /* If not in procinfo list, add it. */
4034 temp_tid = proc_get_current_thread (pi);
4035 if (!find_procinfo (pi->pid, temp_tid))
4036 create_procinfo (pi->pid, temp_tid);
4038 temp_ptid = MERGEPID (pi->pid, temp_tid);
4039 /* If not in GDB's thread list, add it. */
4040 if (!in_thread_list (temp_ptid))
4041 add_thread (temp_ptid);
4043 /* Return to WFI, but tell it to immediately resume. */
4044 status->kind = TARGET_WAITKIND_SPURIOUS;
4045 return inferior_ptid;
4047 else if (syscall_is_lwp_exit (pi, what))
4049 if (print_thread_events)
4050 printf_unfiltered (_("[%s exited]\n"),
4051 target_pid_to_str (retval));
4052 delete_thread (retval);
4053 status->kind = TARGET_WAITKIND_SPURIOUS;
4058 /* FIXME: Do we need to handle SYS_sproc,
4059 SYS_fork, or SYS_vfork here? The old procfs
4060 seemed to use this event to handle threads on
4061 older (non-LWP) systems, where I'm assuming
4062 that threads were actually separate processes.
4063 Irix, maybe? Anyway, low priority for now. */
4067 printf_filtered (_("procfs: trapped on exit from "));
4068 proc_prettyprint_syscall (proc_what (pi), 0);
4069 printf_filtered ("\n");
4072 long i, nsysargs, *sysargs;
4074 if ((nsysargs = proc_nsysarg (pi)) > 0 &&
4075 (sysargs = proc_sysargs (pi)) != NULL)
4077 printf_filtered (_("%ld syscall arguments:\n"),
4079 for (i = 0; i < nsysargs; i++)
4080 printf_filtered ("#%ld: 0x%08lx\n",
4085 status->kind = TARGET_WAITKIND_SPURIOUS;
4086 return inferior_ptid;
4091 wstat = (SIGSTOP << 8) | 0177;
4096 printf_filtered (_("Retry #%d:\n"), retry);
4097 pi->status_valid = 0;
4102 /* If not in procinfo list, add it. */
4103 temp_tid = proc_get_current_thread (pi);
4104 if (!find_procinfo (pi->pid, temp_tid))
4105 create_procinfo (pi->pid, temp_tid);
4107 /* If not in GDB's thread list, add it. */
4108 temp_ptid = MERGEPID (pi->pid, temp_tid);
4109 if (!in_thread_list (temp_ptid))
4110 add_thread (temp_ptid);
4112 status->kind = TARGET_WAITKIND_STOPPED;
4113 status->value.sig = 0;
4118 wstat = (what << 8) | 0177;
4124 wstat = (SIGTRAP << 8) | 0177;
4129 wstat = (SIGTRAP << 8) | 0177;
4132 /* FIXME: use si_signo where possible. */
4134 #if (FLTILL != FLTPRIV) /* Avoid "duplicate case" error. */
4137 wstat = (SIGILL << 8) | 0177;
4140 #if (FLTTRACE != FLTBPT) /* Avoid "duplicate case" error. */
4143 /* If we hit our __dbx_link() internal breakpoint,
4144 then remove it. See comments in procfs_init_inferior()
4145 for more details. */
4146 if (dbx_link_bpt_addr != 0
4147 && dbx_link_bpt_addr
4148 == regcache_read_pc (get_current_regcache ()))
4149 remove_dbx_link_breakpoint ();
4151 wstat = (SIGTRAP << 8) | 0177;
4155 #if (FLTBOUNDS != FLTSTACK) /* Avoid "duplicate case" error. */
4158 wstat = (SIGSEGV << 8) | 0177;
4162 #if (FLTFPE != FLTIOVF) /* Avoid "duplicate case" error. */
4165 wstat = (SIGFPE << 8) | 0177;
4167 case FLTPAGE: /* Recoverable page fault */
4168 default: /* FIXME: use si_signo if possible for
4170 retval = pid_to_ptid (-1);
4171 printf_filtered ("procfs:%d -- ", __LINE__);
4172 printf_filtered (_("child stopped for unknown reason:\n"));
4173 proc_prettyprint_why (why, what, 1);
4174 error (_("... giving up..."));
4177 break; /* case PR_FAULTED: */
4178 default: /* switch (why) unmatched */
4179 printf_filtered ("procfs:%d -- ", __LINE__);
4180 printf_filtered (_("child stopped for unknown reason:\n"));
4181 proc_prettyprint_why (why, what, 1);
4182 error (_("... giving up..."));
4185 /* Got this far without error: If retval isn't in the
4186 threads database, add it. */
4187 if (PIDGET (retval) > 0 &&
4188 !ptid_equal (retval, inferior_ptid) &&
4189 !in_thread_list (retval))
4191 /* We have a new thread. We need to add it both to
4192 GDB's list and to our own. If we don't create a
4193 procinfo, resume may be unhappy later. */
4194 add_thread (retval);
4195 if (find_procinfo (PIDGET (retval), TIDGET (retval)) == NULL)
4196 create_procinfo (PIDGET (retval), TIDGET (retval));
4199 else /* Flags do not indicate STOPPED. */
4201 /* surely this can't happen... */
4202 printf_filtered ("procfs:%d -- process not stopped.\n",
4204 proc_prettyprint_flags (flags, 1);
4205 error (_("procfs: ...giving up..."));
4210 store_waitstatus (status, wstat);
4216 /* Perform a partial transfer to/from the specified object. For
4217 memory transfers, fall back to the old memory xfer functions. */
4220 procfs_xfer_partial (struct target_ops *ops, enum target_object object,
4221 const char *annex, gdb_byte *readbuf,
4222 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4226 case TARGET_OBJECT_MEMORY:
4228 return (*ops->deprecated_xfer_memory) (offset, readbuf,
4229 len, 0/*read*/, NULL, ops);
4231 return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
4232 len, 1/*write*/, NULL, ops);
4236 case TARGET_OBJECT_AUXV:
4237 return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
4242 if (ops->beneath != NULL)
4243 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
4244 readbuf, writebuf, offset, len);
4250 /* Transfer LEN bytes between GDB address MYADDR and target address
4251 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
4252 otherwise transfer them from the target. TARGET is unused.
4254 The return value is 0 if an error occurred or no bytes were
4255 transferred. Otherwise, it will be a positive value which
4256 indicates the number of bytes transferred between gdb and the
4257 target. (Note that the interface also makes provisions for
4258 negative values, but this capability isn't implemented here.) */
4261 procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
4262 struct mem_attrib *attrib, struct target_ops *target)
4267 /* Find procinfo for main process. */
4268 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
4269 if (pi->as_fd == 0 &&
4270 open_procinfo_files (pi, FD_AS) == 0)
4272 proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);
4276 if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
4281 PROCFS_NOTE ("write memory:\n");
4283 PROCFS_NOTE ("write memory:\n");
4285 nbytes = write (pi->as_fd, myaddr, len);
4289 PROCFS_NOTE ("read memory:\n");
4290 nbytes = read (pi->as_fd, myaddr, len);
4300 /* Called by target_resume before making child runnable. Mark cached
4301 registers and status's invalid. If there are "dirty" caches that
4302 need to be written back to the child process, do that.
4304 File descriptors are also cached. As they are a limited resource,
4305 we cannot hold onto them indefinitely. However, as they are
4306 expensive to open, we don't want to throw them away
4307 indescriminately either. As a compromise, we will keep the file
4308 descriptors for the parent process, but discard any file
4309 descriptors we may have accumulated for the threads.
4311 As this function is called by iterate_over_threads, it always
4312 returns zero (so that iterate_over_threads will keep
4316 invalidate_cache (procinfo *parent, procinfo *pi, void *ptr)
4318 /* About to run the child; invalidate caches and do any other
4322 if (pi->gregs_dirty)
4323 if (parent == NULL ||
4324 proc_get_current_thread (parent) != pi->tid)
4325 if (!proc_set_gregs (pi)) /* flush gregs cache */
4326 proc_warn (pi, "target_resume, set_gregs",
4328 if (gdbarch_fp0_regnum (target_gdbarch) >= 0)
4329 if (pi->fpregs_dirty)
4330 if (parent == NULL ||
4331 proc_get_current_thread (parent) != pi->tid)
4332 if (!proc_set_fpregs (pi)) /* flush fpregs cache */
4333 proc_warn (pi, "target_resume, set_fpregs",
4339 /* The presence of a parent indicates that this is an LWP.
4340 Close any file descriptors that it might have open.
4341 We don't do this to the master (parent) procinfo. */
4343 close_procinfo_files (pi);
4345 pi->gregs_valid = 0;
4346 pi->fpregs_valid = 0;
4348 pi->gregs_dirty = 0;
4349 pi->fpregs_dirty = 0;
4351 pi->status_valid = 0;
4352 pi->threads_valid = 0;
4358 /* A callback function for iterate_over_threads. Find the
4359 asynchronous signal thread, and make it runnable. See if that
4360 helps matters any. */
4363 make_signal_thread_runnable (procinfo *process, procinfo *pi, void *ptr)
4366 if (proc_flags (pi) & PR_ASLWP)
4368 if (!proc_run_process (pi, 0, -1))
4369 proc_error (pi, "make_signal_thread_runnable", __LINE__);
4377 /* Make the child process runnable. Normally we will then call
4378 procfs_wait and wait for it to stop again (unless gdb is async).
4380 If STEP is true, then arrange for the child to stop again after
4381 executing a single instruction. If SIGNO is zero, then cancel any
4382 pending signal; if non-zero, then arrange for the indicated signal
4383 to be delivered to the child when it runs. If PID is -1, then
4384 allow any child thread to run; if non-zero, then allow only the
4385 indicated thread to run. (not implemented yet). */
4388 procfs_resume (struct target_ops *ops,
4389 ptid_t ptid, int step, enum target_signal signo)
4391 procinfo *pi, *thread;
4395 prrun.prflags |= PRSVADDR;
4396 prrun.pr_vaddr = $PC; set resume address
4397 prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
4398 prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
4399 prrun.prflags |= PRCFAULT; clear current fault.
4401 PRSTRACE and PRSFAULT can be done by other means
4402 (proc_trace_signals, proc_trace_faults)
4403 PRSVADDR is unnecessary.
4404 PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
4405 This basically leaves PRSTEP and PRCSIG.
4406 PRCSIG is like PIOCSSIG (proc_clear_current_signal).
4407 So basically PR_STEP is the sole argument that must be passed
4408 to proc_run_process (for use in the prrun struct by ioctl). */
4410 /* Find procinfo for main process. */
4411 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
4413 /* First cut: ignore pid argument. */
4416 /* Convert signal to host numbering. */
4418 (signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop))
4421 native_signo = target_signal_to_host (signo);
4423 pi->ignore_next_sigstop = 0;
4425 /* Running the process voids all cached registers and status. */
4426 /* Void the threads' caches first. */
4427 proc_iterate_over_threads (pi, invalidate_cache, NULL);
4428 /* Void the process procinfo's caches. */
4429 invalidate_cache (NULL, pi, NULL);
4431 if (PIDGET (ptid) != -1)
4433 /* Resume a specific thread, presumably suppressing the
4435 thread = find_procinfo (PIDGET (ptid), TIDGET (ptid));
4438 if (thread->tid != 0)
4440 /* We're to resume a specific thread, and not the
4441 others. Set the child process's PR_ASYNC flag. */
4443 if (!proc_set_async (pi))
4444 proc_error (pi, "target_resume, set_async", __LINE__);
4447 proc_iterate_over_threads (pi,
4448 make_signal_thread_runnable,
4451 pi = thread; /* Substitute the thread's procinfo
4457 if (!proc_run_process (pi, step, native_signo))
4460 warning (_("resume: target already running. "
4461 "Pretend to resume, and hope for the best!"));
4463 proc_error (pi, "target_resume", __LINE__);
4467 /* Traverse the list of signals that GDB knows about (see "handle"
4468 command), and arrange for the target to be stopped or not,
4469 according to these settings. Returns non-zero for success, zero
4473 register_gdb_signals (procinfo *pi, gdb_sigset_t *signals)
4477 for (signo = 0; signo < NSIG; signo ++)
4478 if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
4479 signal_print_state (target_signal_from_host (signo)) == 0 &&
4480 signal_pass_state (target_signal_from_host (signo)) == 1)
4481 gdb_prdelset (signals, signo);
4483 gdb_praddset (signals, signo);
4485 return proc_set_traced_signals (pi, signals);
4488 /* Set up to trace signals in the child process. */
4491 procfs_notice_signals (ptid_t ptid)
4493 gdb_sigset_t signals;
4494 procinfo *pi = find_procinfo_or_die (PIDGET (ptid), 0);
4496 if (proc_get_traced_signals (pi, &signals) &&
4497 register_gdb_signals (pi, &signals))
4500 proc_error (pi, "notice_signals", __LINE__);
4503 /* Print status information about the child process. */
4506 procfs_files_info (struct target_ops *ignore)
4508 struct inferior *inf = current_inferior ();
4510 printf_filtered (_("\tUsing the running image of %s %s via /proc.\n"),
4511 inf->attach_flag? "attached": "child",
4512 target_pid_to_str (inferior_ptid));
4515 /* Stop the child process asynchronously, as when the gdb user types
4516 control-c or presses a "stop" button. Works by sending
4517 kill(SIGINT) to the child's process group. */
4520 procfs_stop (ptid_t ptid)
4522 kill (-inferior_process_group (), SIGINT);
4525 /* Make it die. Wait for it to die. Clean up after it. Note: this
4526 should only be applied to the real process, not to an LWP, because
4527 of the check for parent-process. If we need this to work for an
4528 LWP, it needs some more logic. */
4531 unconditionally_kill_inferior (procinfo *pi)
4535 parent_pid = proc_parent_pid (pi);
4536 #ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
4537 /* FIXME: use access functions. */
4538 /* Alpha OSF/1-3.x procfs needs a clear of the current signal
4539 before the PIOCKILL, otherwise it might generate a corrupted core
4540 file for the inferior. */
4541 if (ioctl (pi->ctl_fd, PIOCSSIG, NULL) < 0)
4543 printf_filtered ("unconditionally_kill: SSIG failed!\n");
4546 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
4547 /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
4548 to kill the inferior, otherwise it might remain stopped with a
4550 We do not check the result of the PIOCSSIG, the inferior might have
4553 gdb_siginfo_t newsiginfo;
4555 memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
4556 newsiginfo.si_signo = SIGKILL;
4557 newsiginfo.si_code = 0;
4558 newsiginfo.si_errno = 0;
4559 newsiginfo.si_pid = getpid ();
4560 newsiginfo.si_uid = getuid ();
4561 /* FIXME: use proc_set_current_signal. */
4562 ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo);
4564 #else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4565 if (!proc_kill (pi, SIGKILL))
4566 proc_error (pi, "unconditionally_kill, proc_kill", __LINE__);
4567 #endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
4568 destroy_procinfo (pi);
4570 /* If pi is GDB's child, wait for it to die. */
4571 if (parent_pid == getpid ())
4572 /* FIXME: should we use waitpid to make sure we get the right event?
4573 Should we check the returned event? */
4578 ret = waitpid (pi->pid, &status, 0);
4585 /* We're done debugging it, and we want it to go away. Then we want
4586 GDB to forget all about it. */
4589 procfs_kill_inferior (struct target_ops *ops)
4591 if (!ptid_equal (inferior_ptid, null_ptid)) /* ? */
4593 /* Find procinfo for main process. */
4594 procinfo *pi = find_procinfo (PIDGET (inferior_ptid), 0);
4597 unconditionally_kill_inferior (pi);
4598 target_mourn_inferior ();
4602 /* Forget we ever debugged this thing! */
4605 procfs_mourn_inferior (struct target_ops *ops)
4609 if (!ptid_equal (inferior_ptid, null_ptid))
4611 /* Find procinfo for main process. */
4612 pi = find_procinfo (PIDGET (inferior_ptid), 0);
4614 destroy_procinfo (pi);
4616 unpush_target (ops);
4618 if (dbx_link_bpt != NULL)
4620 deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt);
4621 dbx_link_bpt_addr = 0;
4622 dbx_link_bpt = NULL;
4625 generic_mourn_inferior ();
4628 /* When GDB forks to create a runnable inferior process, this function
4629 is called on the parent side of the fork. It's job is to do
4630 whatever is necessary to make the child ready to be debugged, and
4631 then wait for the child to synchronize. */
4634 procfs_init_inferior (struct target_ops *ops, int pid)
4637 gdb_sigset_t signals;
4641 /* This routine called on the parent side (GDB side)
4642 after GDB forks the inferior. */
4645 if ((pi = create_procinfo (pid, 0)) == NULL)
4646 perror (_("procfs: out of memory in 'init_inferior'"));
4648 if (!open_procinfo_files (pi, FD_CTL))
4649 proc_error (pi, "init_inferior, open_proc_files", __LINE__);
4653 open_procinfo_files // done
4656 procfs_notice_signals
4663 /* If not stopped yet, wait for it to stop. */
4664 if (!(proc_flags (pi) & PR_STOPPED) &&
4665 !(proc_wait_for_stop (pi)))
4666 dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL);
4668 /* Save some of the /proc state to be restored if we detach. */
4669 /* FIXME: Why? In case another debugger was debugging it?
4670 We're it's parent, for Ghu's sake! */
4671 if (!proc_get_traced_signals (pi, &pi->saved_sigset))
4672 proc_error (pi, "init_inferior, get_traced_signals", __LINE__);
4673 if (!proc_get_held_signals (pi, &pi->saved_sighold))
4674 proc_error (pi, "init_inferior, get_held_signals", __LINE__);
4675 if (!proc_get_traced_faults (pi, &pi->saved_fltset))
4676 proc_error (pi, "init_inferior, get_traced_faults", __LINE__);
4677 if (!proc_get_traced_sysentry (pi, pi->saved_entryset))
4678 proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__);
4679 if (!proc_get_traced_sysexit (pi, pi->saved_exitset))
4680 proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__);
4682 /* Register to trace selected signals in the child. */
4683 prfillset (&signals);
4684 if (!register_gdb_signals (pi, &signals))
4685 proc_error (pi, "init_inferior, register_signals", __LINE__);
4687 if ((fail = procfs_debug_inferior (pi)) != 0)
4688 proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
4690 /* FIXME: logically, we should really be turning OFF run-on-last-close,
4691 and possibly even turning ON kill-on-last-close at this point. But
4692 I can't make that change without careful testing which I don't have
4693 time to do right now... */
4694 /* Turn on run-on-last-close flag so that the child
4695 will die if GDB goes away for some reason. */
4696 if (!proc_set_run_on_last_close (pi))
4697 proc_error (pi, "init_inferior, set_RLC", __LINE__);
4699 /* We now have have access to the lwpid of the main thread/lwp. */
4700 lwpid = proc_get_current_thread (pi);
4702 /* Create a procinfo for the main lwp. */
4703 create_procinfo (pid, lwpid);
4705 /* We already have a main thread registered in the thread table at
4706 this point, but it didn't have any lwp info yet. Notify the core
4707 about it. This changes inferior_ptid as well. */
4708 thread_change_ptid (pid_to_ptid (pid),
4709 MERGEPID (pid, lwpid));
4711 /* Typically two, one trap to exec the shell, one to exec the
4712 program being debugged. Defined by "inferior.h". */
4713 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
4716 /* On mips-irix, we need to stop the inferior early enough during
4717 the startup phase in order to be able to load the shared library
4718 symbols and insert the breakpoints that are located in these shared
4719 libraries. Stopping at the program entry point is not good enough
4720 because the -init code is executed before the execution reaches
4723 So what we need to do is to insert a breakpoint in the runtime
4724 loader (rld), more precisely in __dbx_link(). This procedure is
4725 called by rld once all shared libraries have been mapped, but before
4726 the -init code is executed. Unfortuantely, this is not straightforward,
4727 as rld is not part of the executable we are running, and thus we need
4728 the inferior to run until rld itself has been mapped in memory.
4730 For this, we trace all syssgi() syscall exit events. Each time
4731 we detect such an event, we iterate over each text memory maps,
4732 get its associated fd, and scan the symbol table for __dbx_link().
4733 When found, we know that rld has been mapped, and that we can insert
4734 the breakpoint at the symbol address. Once the dbx_link() breakpoint
4735 has been inserted, the syssgi() notifications are no longer necessary,
4736 so they should be canceled. */
4737 proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT, FLAG_SET, 0);
4741 /* When GDB forks to create a new process, this function is called on
4742 the child side of the fork before GDB exec's the user program. Its
4743 job is to make the child minimally debuggable, so that the parent
4744 GDB process can connect to the child and take over. This function
4745 should do only the minimum to make that possible, and to
4746 synchronize with the parent process. The parent process should
4747 take care of the details. */
4750 procfs_set_exec_trap (void)
4752 /* This routine called on the child side (inferior side)
4753 after GDB forks the inferior. It must use only local variables,
4754 because it may be sharing data space with its parent. */
4759 if ((pi = create_procinfo (getpid (), 0)) == NULL)
4760 perror_with_name (_("procfs: create_procinfo failed in child."));
4762 if (open_procinfo_files (pi, FD_CTL) == 0)
4764 proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__);
4765 gdb_flush (gdb_stderr);
4766 /* No need to call "dead_procinfo", because we're going to
4771 #ifdef PRFS_STOPEXEC /* defined on OSF */
4772 /* OSF method for tracing exec syscalls. Quoting:
4773 Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
4774 exits from exec system calls because of the user level loader. */
4775 /* FIXME: make nice and maybe move into an access function. */
4779 if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
4781 proc_warn (pi, "set_exec_trap (PIOCGSPCACT)", __LINE__);
4782 gdb_flush (gdb_stderr);
4785 prfs_flags |= PRFS_STOPEXEC;
4787 if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
4789 proc_warn (pi, "set_exec_trap (PIOCSSPCACT)", __LINE__);
4790 gdb_flush (gdb_stderr);
4794 #else /* not PRFS_STOPEXEC */
4795 /* Everyone else's (except OSF) method for tracing exec syscalls. */
4797 Not all systems with /proc have all the exec* syscalls with the same
4798 names. On the SGI, for example, there is no SYS_exec, but there
4799 *is* a SYS_execv. So, we try to account for that. */
4801 exitset = sysset_t_alloc (pi);
4802 gdb_premptysysset (exitset);
4804 gdb_praddsysset (exitset, SYS_exec);
4807 gdb_praddsysset (exitset, SYS_execve);
4810 gdb_praddsysset (exitset, SYS_execv);
4812 #ifdef DYNAMIC_SYSCALLS
4814 int callnum = find_syscall (pi, "execve");
4817 gdb_praddsysset (exitset, callnum);
4819 callnum = find_syscall (pi, "ra_execve");
4821 gdb_praddsysset (exitset, callnum);
4823 #endif /* DYNAMIC_SYSCALLS */
4825 if (!proc_set_traced_sysexit (pi, exitset))
4827 proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__);
4828 gdb_flush (gdb_stderr);
4831 #endif /* PRFS_STOPEXEC */
4833 /* FIXME: should this be done in the parent instead? */
4834 /* Turn off inherit on fork flag so that all grand-children
4835 of gdb start with tracing flags cleared. */
4836 if (!proc_unset_inherit_on_fork (pi))
4837 proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__);
4839 /* Turn off run on last close flag, so that the child process
4840 cannot run away just because we close our handle on it.
4841 We want it to wait for the parent to attach. */
4842 if (!proc_unset_run_on_last_close (pi))
4843 proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__);
4845 /* FIXME: No need to destroy the procinfo --
4846 we have our own address space, and we're about to do an exec! */
4847 /*destroy_procinfo (pi);*/
4850 /* This function is called BEFORE gdb forks the inferior process. Its
4851 only real responsibility is to set things up for the fork, and tell
4852 GDB which two functions to call after the fork (one for the parent,
4853 and one for the child).
4855 This function does a complicated search for a unix shell program,
4856 which it then uses to parse arguments and environment variables to
4857 be sent to the child. I wonder whether this code could not be
4858 abstracted out and shared with other unix targets such as
4862 procfs_create_inferior (struct target_ops *ops, char *exec_file,
4863 char *allargs, char **env, int from_tty)
4865 char *shell_file = getenv ("SHELL");
4869 if (shell_file != NULL && strchr (shell_file, '/') == NULL)
4872 /* We will be looking down the PATH to find shell_file. If we
4873 just do this the normal way (via execlp, which operates by
4874 attempting an exec for each element of the PATH until it
4875 finds one which succeeds), then there will be an exec for
4876 each failed attempt, each of which will cause a PR_SYSEXIT
4877 stop, and we won't know how to distinguish the PR_SYSEXIT's
4878 for these failed execs with the ones for successful execs
4879 (whether the exec has succeeded is stored at that time in the
4880 carry bit or some such architecture-specific and
4881 non-ABI-specified place).
4883 So I can't think of anything better than to search the PATH
4884 now. This has several disadvantages: (1) There is a race
4885 condition; if we find a file now and it is deleted before we
4886 exec it, we lose, even if the deletion leaves a valid file
4887 further down in the PATH, (2) there is no way to know exactly
4888 what an executable (in the sense of "capable of being
4889 exec'd") file is. Using access() loses because it may lose
4890 if the caller is the superuser; failing to use it loses if
4891 there are ACLs or some such. */
4895 /* FIXME-maybe: might want "set path" command so user can change what
4896 path is used from within GDB. */
4897 char *path = getenv ("PATH");
4899 struct stat statbuf;
4902 path = "/bin:/usr/bin";
4904 tryname = alloca (strlen (path) + strlen (shell_file) + 2);
4905 for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
4907 p1 = strchr (p, ':');
4912 strncpy (tryname, p, len);
4913 tryname[len] = '\0';
4914 strcat (tryname, "/");
4915 strcat (tryname, shell_file);
4916 if (access (tryname, X_OK) < 0)
4918 if (stat (tryname, &statbuf) < 0)
4920 if (!S_ISREG (statbuf.st_mode))
4921 /* We certainly need to reject directories. I'm not quite
4922 as sure about FIFOs, sockets, etc., but I kind of doubt
4923 that people want to exec() these things. */
4928 /* Not found. This must be an error rather than merely passing
4929 the file to execlp(), because execlp() would try all the
4930 exec()s, causing GDB to get confused. */
4931 error (_("procfs:%d -- Can't find shell %s in PATH"),
4932 __LINE__, shell_file);
4934 shell_file = tryname;
4937 pid = fork_inferior (exec_file, allargs, env, procfs_set_exec_trap,
4938 NULL, NULL, shell_file);
4940 procfs_init_inferior (ops, pid);
4943 /* An observer for the "inferior_created" event. */
4946 procfs_inferior_created (struct target_ops *ops, int from_tty)
4949 /* Make sure to cancel the syssgi() syscall-exit notifications.
4950 They should normally have been removed by now, but they may still
4951 be activated if the inferior doesn't use shared libraries, or if
4952 we didn't locate __dbx_link, or if we never stopped in __dbx_link.
4953 See procfs_init_inferior() for more details.
4955 Since these notifications are only ever enabled when we spawned
4956 the inferior ourselves, there is nothing to do when the inferior
4957 was created by attaching to an already running process, or when
4958 debugging a core file. */
4959 if (current_inferior ()->attach_flag || !target_can_run (¤t_target))
4962 proc_trace_syscalls_1 (find_procinfo_or_die (PIDGET (inferior_ptid), 0),
4963 SYS_syssgi, PR_SYSEXIT, FLAG_RESET, 0);
4967 /* Callback for find_new_threads. Calls "add_thread". */
4970 procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr)
4972 ptid_t gdb_threadid = MERGEPID (pi->pid, thread->tid);
4974 if (!in_thread_list (gdb_threadid) || is_exited (gdb_threadid))
4975 add_thread (gdb_threadid);
4980 /* Query all the threads that the target knows about, and give them
4981 back to GDB to add to its list. */
4984 procfs_find_new_threads (struct target_ops *ops)
4988 /* Find procinfo for main process. */
4989 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
4990 proc_update_threads (pi);
4991 proc_iterate_over_threads (pi, procfs_notice_thread, NULL);
4994 /* Return true if the thread is still 'alive'. This guy doesn't
4995 really seem to be doing his job. Got to investigate how to tell
4996 when a thread is really gone. */
4999 procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
5004 proc = PIDGET (ptid);
5005 thread = TIDGET (ptid);
5006 /* If I don't know it, it ain't alive! */
5007 if ((pi = find_procinfo (proc, thread)) == NULL)
5010 /* If I can't get its status, it ain't alive!
5011 What's more, I need to forget about it! */
5012 if (!proc_get_status (pi))
5014 destroy_procinfo (pi);
5017 /* I couldn't have got its status if it weren't alive, so it's
5022 /* Convert PTID to a string. Returns the string in a static
5026 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
5028 static char buf[80];
5030 if (TIDGET (ptid) == 0)
5031 sprintf (buf, "process %d", PIDGET (ptid));
5033 sprintf (buf, "LWP %ld", TIDGET (ptid));
5038 /* Insert a watchpoint. */
5041 procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag,
5049 pi = find_procinfo_or_die (PIDGET (ptid) == -1 ?
5050 PIDGET (inferior_ptid) : PIDGET (ptid), 0);
5052 /* Translate from GDB's flags to /proc's. */
5053 if (len > 0) /* len == 0 means delete watchpoint. */
5055 switch (rwflag) { /* FIXME: need an enum! */
5056 case hw_write: /* default watchpoint (write) */
5057 pflags = WRITE_WATCHFLAG;
5059 case hw_read: /* read watchpoint */
5060 pflags = READ_WATCHFLAG;
5062 case hw_access: /* access watchpoint */
5063 pflags = READ_WATCHFLAG | WRITE_WATCHFLAG;
5065 case hw_execute: /* execution HW breakpoint */
5066 pflags = EXEC_WATCHFLAG;
5068 default: /* Something weird. Return error. */
5071 if (after) /* Stop after r/w access is completed. */
5072 pflags |= AFTER_WATCHFLAG;
5075 if (!proc_set_watchpoint (pi, addr, len, pflags))
5077 if (errno == E2BIG) /* Typical error for no resources. */
5078 return -1; /* fail */
5079 /* GDB may try to remove the same watchpoint twice.
5080 If a remove request returns no match, don't error. */
5081 if (errno == ESRCH && len == 0)
5082 return 0; /* ignore */
5083 proc_error (pi, "set_watchpoint", __LINE__);
5086 #endif /* UNIXWARE */
5090 /* Return non-zero if we can set a hardware watchpoint of type TYPE. TYPE
5091 is one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint,
5092 or bp_hardware_watchpoint. CNT is the number of watchpoints used so
5095 Note: procfs_can_use_hw_breakpoint() is not yet used by all
5096 procfs.c targets due to the fact that some of them still define
5097 target_can_use_hardware_watchpoint. */
5100 procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
5102 /* Due to the way that proc_set_watchpoint() is implemented, host
5103 and target pointers must be of the same size. If they are not,
5104 we can't use hardware watchpoints. This limitation is due to the
5105 fact that proc_set_watchpoint() calls
5106 procfs_address_to_host_pointer(); a close inspection of
5107 procfs_address_to_host_pointer will reveal that an internal error
5108 will be generated when the host and target pointer sizes are
5110 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
5112 if (sizeof (void *) != TYPE_LENGTH (ptr_type))
5115 /* Other tests here??? */
5120 /* Returns non-zero if process is stopped on a hardware watchpoint
5121 fault, else returns zero. */
5124 procfs_stopped_by_watchpoint (void)
5128 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
5130 if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
5132 if (proc_why (pi) == PR_FAULTED)
5135 if (proc_what (pi) == FLTWATCH)
5139 if (proc_what (pi) == FLTKWATCH)
5147 /* Returns 1 if the OS knows the position of the triggered watchpoint,
5148 and sets *ADDR to that address. Returns 0 if OS cannot report that
5149 address. This function is only called if
5150 procfs_stopped_by_watchpoint returned 1, thus no further checks are
5151 done. The function also assumes that ADDR is not NULL. */
5154 procfs_stopped_data_address (struct target_ops *targ, CORE_ADDR *addr)
5158 pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
5159 return proc_watchpoint_address (pi, addr);
5163 procfs_insert_watchpoint (CORE_ADDR addr, int len, int type,
5164 struct expression *cond)
5166 if (!target_have_steppable_watchpoint
5167 && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch))
5169 /* When a hardware watchpoint fires off the PC will be left at
5170 the instruction following the one which caused the
5171 watchpoint. It will *NOT* be necessary for GDB to step over
5173 return procfs_set_watchpoint (inferior_ptid, addr, len, type, 1);
5177 /* When a hardware watchpoint fires off the PC will be left at
5178 the instruction which caused the watchpoint. It will be
5179 necessary for GDB to step over the watchpoint. */
5180 return procfs_set_watchpoint (inferior_ptid, addr, len, type, 0);
5185 procfs_remove_watchpoint (CORE_ADDR addr, int len, int type,
5186 struct expression *cond)
5188 return procfs_set_watchpoint (inferior_ptid, addr, 0, 0, 0);
5192 procfs_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
5194 /* The man page for proc(4) on Solaris 2.6 and up says that the
5195 system can support "thousands" of hardware watchpoints, but gives
5196 no method for finding out how many; It doesn't say anything about
5197 the allowed size for the watched area either. So we just tell
5203 procfs_use_watchpoints (struct target_ops *t)
5205 t->to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
5206 t->to_insert_watchpoint = procfs_insert_watchpoint;
5207 t->to_remove_watchpoint = procfs_remove_watchpoint;
5208 t->to_region_ok_for_hw_watchpoint = procfs_region_ok_for_hw_watchpoint;
5209 t->to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
5210 t->to_stopped_data_address = procfs_stopped_data_address;
5213 /* Memory Mappings Functions: */
5215 /* Call a callback function once for each mapping, passing it the
5216 mapping, an optional secondary callback function, and some optional
5217 opaque data. Quit and return the first non-zero value returned
5220 PI is the procinfo struct for the process to be mapped. FUNC is
5221 the callback function to be called by this iterator. DATA is the
5222 optional opaque data to be passed to the callback function.
5223 CHILD_FUNC is the optional secondary function pointer to be passed
5224 to the child function. Returns the first non-zero return value
5225 from the callback function, or zero. */
5228 iterate_over_mappings (procinfo *pi, find_memory_region_ftype child_func,
5230 int (*func) (struct prmap *map,
5231 find_memory_region_ftype child_func,
5234 char pathname[MAX_PROC_NAME_SIZE];
5235 struct prmap *prmaps;
5236 struct prmap *prmap;
5244 /* Get the number of mappings, allocate space,
5245 and read the mappings into prmaps. */
5248 sprintf (pathname, "/proc/%d/map", pi->pid);
5249 if ((map_fd = open (pathname, O_RDONLY)) < 0)
5250 proc_error (pi, "iterate_over_mappings (open)", __LINE__);
5252 /* Make sure it gets closed again. */
5253 make_cleanup_close (map_fd);
5255 /* Use stat to determine the file size, and compute
5256 the number of prmap_t objects it contains. */
5257 if (fstat (map_fd, &sbuf) != 0)
5258 proc_error (pi, "iterate_over_mappings (fstat)", __LINE__);
5260 nmap = sbuf.st_size / sizeof (prmap_t);
5261 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
5262 if (read (map_fd, (char *) prmaps, nmap * sizeof (*prmaps))
5263 != (nmap * sizeof (*prmaps)))
5264 proc_error (pi, "iterate_over_mappings (read)", __LINE__);
5266 /* Use ioctl command PIOCNMAP to get number of mappings. */
5267 if (ioctl (pi->ctl_fd, PIOCNMAP, &nmap) != 0)
5268 proc_error (pi, "iterate_over_mappings (PIOCNMAP)", __LINE__);
5270 prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
5271 if (ioctl (pi->ctl_fd, PIOCMAP, prmaps) != 0)
5272 proc_error (pi, "iterate_over_mappings (PIOCMAP)", __LINE__);
5275 for (prmap = prmaps; nmap > 0; prmap++, nmap--)
5276 if ((funcstat = (*func) (prmap, child_func, data)) != 0)
5282 /* Implements the to_find_memory_regions method. Calls an external
5283 function for each memory region.
5284 Returns the integer value returned by the callback. */
5287 find_memory_regions_callback (struct prmap *map,
5288 find_memory_region_ftype func, void *data)
5290 return (*func) ((CORE_ADDR) map->pr_vaddr,
5292 (map->pr_mflags & MA_READ) != 0,
5293 (map->pr_mflags & MA_WRITE) != 0,
5294 (map->pr_mflags & MA_EXEC) != 0,
5298 /* External interface. Calls a callback function once for each
5299 mapped memory region in the child process, passing as arguments:
5301 CORE_ADDR virtual_address,
5303 int read, TRUE if region is readable by the child
5304 int write, TRUE if region is writable by the child
5305 int execute TRUE if region is executable by the child.
5307 Stops iterating and returns the first non-zero value returned by
5311 proc_find_memory_regions (find_memory_region_ftype func, void *data)
5313 procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
5315 return iterate_over_mappings (pi, func, data,
5316 find_memory_regions_callback);
5319 /* Returns an ascii representation of a memory mapping's flags. */
5322 mappingflags (long flags)
5324 static char asciiflags[8];
5326 strcpy (asciiflags, "-------");
5327 #if defined (MA_PHYS)
5328 if (flags & MA_PHYS)
5329 asciiflags[0] = 'd';
5331 if (flags & MA_STACK)
5332 asciiflags[1] = 's';
5333 if (flags & MA_BREAK)
5334 asciiflags[2] = 'b';
5335 if (flags & MA_SHARED)
5336 asciiflags[3] = 's';
5337 if (flags & MA_READ)
5338 asciiflags[4] = 'r';
5339 if (flags & MA_WRITE)
5340 asciiflags[5] = 'w';
5341 if (flags & MA_EXEC)
5342 asciiflags[6] = 'x';
5343 return (asciiflags);
5346 /* Callback function, does the actual work for 'info proc
5350 info_mappings_callback (struct prmap *map, find_memory_region_ftype ignore,
5353 unsigned int pr_off;
5355 #ifdef PCAGENT /* Horrible hack: only defined on Solaris 2.6+ */
5356 pr_off = (unsigned int) map->pr_offset;
5358 pr_off = map->pr_off;
5361 if (gdbarch_addr_bit (target_gdbarch) == 32)
5362 printf_filtered ("\t%#10lx %#10lx %#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));
5369 printf_filtered (" %#18lx %#18lx %#10lx %#10x %7s\n",
5370 (unsigned long) map->pr_vaddr,
5371 (unsigned long) map->pr_vaddr + map->pr_size - 1,
5372 (unsigned long) map->pr_size,
5374 mappingflags (map->pr_mflags));
5379 /* Implement the "info proc mappings" subcommand. */
5382 info_proc_mappings (procinfo *pi, int summary)
5385 return; /* No output for summary mode. */
5387 printf_filtered (_("Mapped address spaces:\n\n"));
5388 if (gdbarch_ptr_bit (target_gdbarch) == 32)
5389 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
5396 printf_filtered (" %18s %18s %10s %10s %7s\n",
5403 iterate_over_mappings (pi, NULL, NULL, info_mappings_callback);
5404 printf_filtered ("\n");
5407 /* Implement the "info proc" command. */
5410 info_proc_cmd (char *args, int from_tty)
5412 struct cleanup *old_chain;
5413 procinfo *process = NULL;
5414 procinfo *thread = NULL;
5421 old_chain = make_cleanup (null_cleanup, 0);
5424 argv = gdb_buildargv (args);
5425 make_cleanup_freeargv (argv);
5427 while (argv != NULL && *argv != NULL)
5429 if (isdigit (argv[0][0]))
5431 pid = strtoul (argv[0], &tmp, 10);
5433 tid = strtoul (++tmp, NULL, 10);
5435 else if (argv[0][0] == '/')
5437 tid = strtoul (argv[0] + 1, NULL, 10);
5439 else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
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);
5583 _initialize_procfs (void)
5585 observer_attach_inferior_created (procfs_inferior_created);
5587 add_info ("proc", info_proc_cmd, _("\
5588 Show /proc process information about any running process.\n\
5589 Specify process id, or use the program being debugged by default.\n\
5590 Specify keyword 'mappings' for detailed info on memory mappings."));
5591 add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
5592 _("Give a trace of entries into the syscall."));
5593 add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd,
5594 _("Give a trace of exits from the syscall."));
5595 add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd,
5596 _("Cancel a trace of entries into the syscall."));
5597 add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd,
5598 _("Cancel a trace of exits from the syscall."));
5601 /* =================== END, GDB "MODULE" =================== */
5605 /* miscellaneous stubs: */
5607 /* The following satisfy a few random symbols mostly created by the
5608 solaris threads implementation, which I will chase down later. */
5610 /* Return a pid for which we guarantee we will be able to find a
5614 procfs_first_available (void)
5616 return pid_to_ptid (procinfo_list ? procinfo_list->pid : -1);
5619 /* =================== GCORE .NOTE "MODULE" =================== */
5620 #if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT)
5621 /* gcore only implemented on solaris and unixware (so far) */
5624 procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
5625 char *note_data, int *note_size,
5626 enum target_signal stop_signal)
5628 struct regcache *regcache = get_thread_regcache (ptid);
5629 gdb_gregset_t gregs;
5630 gdb_fpregset_t fpregs;
5631 unsigned long merged_pid;
5632 struct cleanup *old_chain;
5634 merged_pid = TIDGET (ptid) << 16 | PIDGET (ptid);
5636 /* This part is the old method for fetching registers.
5637 It should be replaced by the newer one using regsets
5638 once it is implemented in this platform:
5639 gdbarch_regset_from_core_section() and regset->collect_regset(). */
5641 old_chain = save_inferior_ptid ();
5642 inferior_ptid = ptid;
5643 target_fetch_registers (regcache, -1);
5645 fill_gregset (regcache, &gregs, -1);
5646 #if defined (NEW_PROC_API)
5647 note_data = (char *) elfcore_write_lwpstatus (obfd,
5654 note_data = (char *) elfcore_write_prstatus (obfd,
5661 fill_fpregset (regcache, &fpregs, -1);
5662 note_data = (char *) elfcore_write_prfpreg (obfd,
5668 do_cleanups (old_chain);
5673 struct procfs_corefile_thread_data {
5677 enum target_signal stop_signal;
5681 procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data)
5683 struct procfs_corefile_thread_data *args = data;
5687 ptid_t ptid = MERGEPID (pi->pid, thread->tid);
5689 args->note_data = procfs_do_thread_registers (args->obfd, ptid,
5698 find_signalled_thread (struct thread_info *info, void *data)
5700 if (info->suspend.stop_signal != TARGET_SIGNAL_0
5701 && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
5707 static enum target_signal
5708 find_stop_signal (void)
5710 struct thread_info *info =
5711 iterate_over_threads (find_signalled_thread, NULL);
5714 return info->suspend.stop_signal;
5716 return TARGET_SIGNAL_0;
5720 procfs_make_note_section (bfd *obfd, int *note_size)
5722 struct cleanup *old_chain;
5723 gdb_gregset_t gregs;
5724 gdb_fpregset_t fpregs;
5725 char fname[16] = {'\0'};
5726 char psargs[80] = {'\0'};
5727 procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
5728 char *note_data = NULL;
5730 struct procfs_corefile_thread_data thread_args;
5733 enum target_signal stop_signal;
5735 if (get_exec_file (0))
5737 strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
5738 strncpy (psargs, get_exec_file (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" =================== */