Written by Fred Fish at Cygnus Support. Changes for sysv4.2mp procfs
compatibility by Geoffrey Noer at Cygnus Solutions.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
-/* N O T E S
+/* N O T E S
-For information on the details of using /proc consult section proc(4)
-in the UNIX System V Release 4 System Administrator's Reference Manual.
+ For information on the details of using /proc consult section proc(4)
+ in the UNIX System V Release 4 System Administrator's Reference Manual.
-The general register and floating point register sets are manipulated
-separately. This file makes the assumption that if FP0_REGNUM is
-defined, then support for the floating point register set is desired,
-regardless of whether or not the actual target has floating point hardware.
+ The general register and floating point register sets are manipulated
+ separately. This file makes the assumption that if FP0_REGNUM is
+ defined, then support for the floating point register set is desired,
+ regardless of whether or not the actual target has floating point hardware.
*/
#include "gdbthread.h"
#if !defined(SYS_lwp_create) && defined(SYS_lwpcreate)
-# define SYS_lwp_create SYS_lwpcreate
+#define SYS_lwp_create SYS_lwpcreate
#endif
#if !defined(SYS_lwp_exit) && defined(SYS_lwpexit)
-# define SYS_lwp_exit SYS_lwpexit
+#define SYS_lwp_exit SYS_lwpexit
#endif
#if !defined(SYS_lwp_wait) && defined(SYS_lwpwait)
-# define SYS_lwp_wait SYS_lwpwait
+#define SYS_lwp_wait SYS_lwpwait
#endif
#if !defined(SYS_lwp_self) && defined(SYS_lwpself)
-# define SYS_lwp_self SYS_lwpself
+#define SYS_lwp_self SYS_lwpself
#endif
#if !defined(SYS_lwp_info) && defined(SYS_lwpinfo)
-# define SYS_lwp_info SYS_lwpinfo
+#define SYS_lwp_info SYS_lwpinfo
#endif
#if !defined(SYS_lwp_private) && defined(SYS_lwpprivate)
-# define SYS_lwp_private SYS_lwpprivate
+#define SYS_lwp_private SYS_lwpprivate
#endif
#if !defined(SYS_lwp_kill) && defined(SYS_lwpkill)
-# define SYS_lwp_kill SYS_lwpkill
+#define SYS_lwp_kill SYS_lwpkill
#endif
#if !defined(SYS_lwp_suspend) && defined(SYS_lwpsuspend)
-# define SYS_lwp_suspend SYS_lwpsuspend
+#define SYS_lwp_suspend SYS_lwpsuspend
#endif
#if !defined(SYS_lwp_continue) && defined(SYS_lwpcontinue)
-# define SYS_lwp_continue SYS_lwpcontinue
+#define SYS_lwp_continue SYS_lwpcontinue
#endif
/* the name of the proc status struct depends on the implementation */
/* Wrap Light Weight Process member in THE_PR_LWP macro for clearer code */
#ifndef HAVE_PSTATUS_T
- typedef prstatus_t gdb_prstatus_t;
+typedef prstatus_t gdb_prstatus_t;
#define THE_PR_LWP(a) a
-#else /* HAVE_PSTATUS_T */
- typedef pstatus_t gdb_prstatus_t;
+#else /* HAVE_PSTATUS_T */
+typedef pstatus_t gdb_prstatus_t;
#define THE_PR_LWP(a) a.pr_lwp
#if !defined(HAVE_PRRUN_T) && defined(HAVE_MULTIPLE_PROC_FDS)
/* Fallback definitions - for using configure information directly */
#if !defined(PROCFS_USE_READ_WRITE) && !defined(HAVE_PROCFS_PIOCSET)
#define PROCFS_USE_READ_WRITE 1
#endif
-#endif /* !HAVE_PRRUN_T && HAVE_MULTIPLE_PROC_FDS */
-#endif /* HAVE_PSTATUS_T */
+#endif /* !HAVE_PRRUN_T && HAVE_MULTIPLE_PROC_FDS */
+#endif /* HAVE_PSTATUS_T */
#define MAX_SYSCALLS 256 /* Maximum number of syscalls for table */
/* proc name formats may vary depending on the proc implementation */
#ifdef HAVE_MULTIPLE_PROC_FDS
-# ifndef CTL_PROC_NAME_FMT
-# define CTL_PROC_NAME_FMT "/proc/%d/ctl"
-# define AS_PROC_NAME_FMT "/proc/%d/as"
-# define MAP_PROC_NAME_FMT "/proc/%d/map"
-# define STATUS_PROC_NAME_FMT "/proc/%d/status"
-# endif
+#ifndef CTL_PROC_NAME_FMT
+#define CTL_PROC_NAME_FMT "/proc/%d/ctl"
+#define AS_PROC_NAME_FMT "/proc/%d/as"
+#define MAP_PROC_NAME_FMT "/proc/%d/map"
+#define STATUS_PROC_NAME_FMT "/proc/%d/status"
+#endif
#else /* HAVE_MULTIPLE_PROC_FDS */
-# ifndef CTL_PROC_NAME_FMT
-# define CTL_PROC_NAME_FMT "/proc/%05d"
-# define AS_PROC_NAME_FMT "/proc/%05d"
-# define MAP_PROC_NAME_FMT "/proc/%05d"
-# define STATUS_PROC_NAME_FMT "/proc/%05d"
-# endif
+#ifndef CTL_PROC_NAME_FMT
+#define CTL_PROC_NAME_FMT "/proc/%05d"
+#define AS_PROC_NAME_FMT "/proc/%05d"
+#define MAP_PROC_NAME_FMT "/proc/%05d"
+#define STATUS_PROC_NAME_FMT "/proc/%05d"
+#endif
#endif /* HAVE_MULTIPLE_PROC_FDS */
use prgregset_t (and prfpregset_t) everywhere. */
#ifdef GDB_GREGSET_TYPE
- typedef GDB_GREGSET_TYPE gdb_gregset_t;
+typedef GDB_GREGSET_TYPE gdb_gregset_t;
#else
- typedef gregset_t gdb_gregset_t;
+typedef gregset_t gdb_gregset_t;
#endif
#ifdef GDB_FPREGSET_TYPE
- typedef GDB_FPREGSET_TYPE gdb_fpregset_t;
+typedef GDB_FPREGSET_TYPE gdb_fpregset_t;
#else
- typedef fpregset_t gdb_fpregset_t;
+typedef fpregset_t gdb_fpregset_t;
#endif
that can sit atop procfs, such as solaris
thread support. */
-#if 1 /* FIXME: Gross and ugly hack to resolve coredep.c global */
+#if 1 /* FIXME: Gross and ugly hack to resolve coredep.c global */
CORE_ADDR kernel_u_addr;
#endif
/* Define structures for passing commands to /proc/pid/ctl file. Note that
while we create these for the PROCFS_USE_READ_WRITE world, we use them
and ignore the extra cmd int in other proc schemes.
-*/
+ */
/* generic ctl msg */
-struct proc_ctl {
- int cmd;
- long data;
-};
+struct proc_ctl
+ {
+ int cmd;
+ long data;
+ };
/* set general registers */
-struct greg_ctl {
- int cmd;
- gdb_gregset_t gregset;
-};
+struct greg_ctl
+ {
+ int cmd;
+ gdb_gregset_t gregset;
+ };
/* set fp registers */
-struct fpreg_ctl {
- int cmd;
- gdb_fpregset_t fpregset;
-};
+struct fpreg_ctl
+ {
+ int cmd;
+ gdb_fpregset_t fpregset;
+ };
/* set signals to be traced */
-struct sig_ctl {
- int cmd;
- sigset_t sigset;
-};
+struct sig_ctl
+ {
+ int cmd;
+ sigset_t sigset;
+ };
/* set faults to be traced */
-struct flt_ctl {
- int cmd;
- fltset_t fltset;
-};
+struct flt_ctl
+ {
+ int cmd;
+ fltset_t fltset;
+ };
/* set system calls to be traced */
-struct sys_ctl {
- int cmd;
- sysset_t sysset;
-};
+struct sys_ctl
+ {
+ int cmd;
+ sysset_t sysset;
+ };
/* set current signal to be traced */
-struct sigi_ctl {
- int cmd;
- siginfo_t siginfo;
-};
+struct sigi_ctl
+ {
+ int cmd;
+ siginfo_t siginfo;
+ };
/* All access to the inferior, either one started by gdb or one that has
- been attached to, is controlled by an instance of a procinfo structure,
- defined below. Since gdb currently only handles one inferior at a time,
- the procinfo structure for the inferior is statically allocated and
- only one exists at any given time. There is a separate procinfo
- structure for use by the "info proc" command, so that we can print
- useful information about any random process without interfering with
- the inferior's procinfo information. */
-
-struct procinfo {
- struct procinfo *next;
- int pid; /* Process ID of inferior */
- int ctl_fd; /* File descriptor for /proc ctl file */
- int status_fd; /* File descriptor for /proc status file */
- int as_fd; /* File descriptor for /proc as file */
- int map_fd; /* File descriptor for /proc map file */
- char *pathname; /* Pathname to /proc entry */
- int had_event; /* poll/select says something happened */
- int was_stopped; /* Nonzero if was stopped prior to attach */
- int nopass_next_sigstop; /* Don't pass a sigstop on next resume */
+ been attached to, is controlled by an instance of a procinfo structure,
+ defined below. Since gdb currently only handles one inferior at a time,
+ the procinfo structure for the inferior is statically allocated and
+ only one exists at any given time. There is a separate procinfo
+ structure for use by the "info proc" command, so that we can print
+ useful information about any random process without interfering with
+ the inferior's procinfo information. */
+
+struct procinfo
+ {
+ struct procinfo *next;
+ int pid; /* Process ID of inferior */
+ int ctl_fd; /* File descriptor for /proc ctl file */
+ int status_fd; /* File descriptor for /proc status file */
+ int as_fd; /* File descriptor for /proc as file */
+ int map_fd; /* File descriptor for /proc map file */
+ char *pathname; /* Pathname to /proc entry */
+ int had_event; /* poll/select says something happened */
+ int was_stopped; /* Nonzero if was stopped prior to attach */
+ int nopass_next_sigstop; /* Don't pass a sigstop on next resume */
#ifdef HAVE_PRRUN_T
- prrun_t prrun; /* Control state when it is run */
-#endif
- gdb_prstatus_t prstatus; /* Current process status info */
- struct greg_ctl gregset; /* General register set */
- struct fpreg_ctl fpregset; /* Floating point register set */
- struct flt_ctl fltset; /* Current traced hardware fault set */
- struct sig_ctl trace; /* Current traced signal set */
- struct sys_ctl exitset; /* Current traced system call exit set */
- struct sys_ctl entryset; /* Current traced system call entry set */
- struct sig_ctl saved_sighold; /* Saved held signal set */
- struct flt_ctl saved_fltset; /* Saved traced hardware fault set */
- struct sig_ctl saved_trace; /* Saved traced signal set */
- struct sys_ctl saved_exitset; /* Saved traced system call exit set */
- struct sys_ctl saved_entryset;/* Saved traced system call entry set */
- int num_syscall_handlers; /* Number of syscall trap handlers
+ prrun_t prrun; /* Control state when it is run */
+#endif
+ gdb_prstatus_t prstatus; /* Current process status info */
+ struct greg_ctl gregset; /* General register set */
+ struct fpreg_ctl fpregset; /* Floating point register set */
+ struct flt_ctl fltset; /* Current traced hardware fault set */
+ struct sig_ctl trace; /* Current traced signal set */
+ struct sys_ctl exitset; /* Current traced system call exit set */
+ struct sys_ctl entryset; /* Current traced system call entry set */
+ struct sig_ctl saved_sighold; /* Saved held signal set */
+ struct flt_ctl saved_fltset; /* Saved traced hardware fault set */
+ struct sig_ctl saved_trace; /* Saved traced signal set */
+ struct sys_ctl saved_exitset; /* Saved traced system call exit set */
+ struct sys_ctl saved_entryset; /* Saved traced system call entry set */
+ int num_syscall_handlers; /* Number of syscall trap handlers
currently installed */
- /* Pointer to list of syscall trap handlers */
- struct procfs_syscall_handler *syscall_handlers;
- int saved_rtnval; /* return value and status for wait(), */
- int saved_statval; /* as supplied by a syscall handler. */
- int new_child; /* Non-zero if it's a new thread */
-};
+ /* Pointer to list of syscall trap handlers */
+ struct procfs_syscall_handler *syscall_handlers;
+ int saved_rtnval; /* return value and status for wait(), */
+ int saved_statval; /* as supplied by a syscall handler. */
+ int new_child; /* Non-zero if it's a new thread */
+ };
/* List of inferior process information */
static struct procinfo *procinfo_list = NULL;
-static struct pollfd *poll_list; /* pollfds used for waiting on /proc */
+static struct pollfd *poll_list; /* pollfds used for waiting on /proc */
static int num_poll_list = 0; /* Number of entries in poll_list */
/* Much of the information used in the /proc interface, particularly for
- printing status information, is kept as tables of structures of the
- following form. These tables can be used to map numeric values to
- their symbolic names and to a string that describes their specific use. */
-
-struct trans {
- int value; /* The numeric value */
- char *name; /* The equivalent symbolic value */
- char *desc; /* Short description of value */
-};
+ printing status information, is kept as tables of structures of the
+ following form. These tables can be used to map numeric values to
+ their symbolic names and to a string that describes their specific use. */
+
+struct trans
+ {
+ int value; /* The numeric value */
+ char *name; /* The equivalent symbolic value */
+ char *desc; /* Short description of value */
+ };
/* Translate bits in the pr_flags member of the prstatus structure, into the
- names and desc information. */
+ names and desc information. */
static struct trans pr_flag_table[] =
{
#if defined (PR_STOPPED)
- { PR_STOPPED, "PR_STOPPED", "Process is stopped" },
+ {PR_STOPPED, "PR_STOPPED", "Process is stopped"},
#endif
#if defined (PR_ISTOP)
- { PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest" },
+ {PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest"},
#endif
#if defined (PR_DSTOP)
- { PR_DSTOP, "PR_DSTOP", "A stop directive is in effect" },
+ {PR_DSTOP, "PR_DSTOP", "A stop directive is in effect"},
#endif
#if defined (PR_ASLEEP)
- { PR_ASLEEP, "PR_ASLEEP", "Sleeping in an interruptible system call" },
+ {PR_ASLEEP, "PR_ASLEEP", "Sleeping in an interruptible system call"},
#endif
#if defined (PR_FORK)
- { PR_FORK, "PR_FORK", "Inherit-on-fork is in effect" },
+ {PR_FORK, "PR_FORK", "Inherit-on-fork is in effect"},
#endif
#if defined (PR_RLC)
- { PR_RLC, "PR_RLC", "Run-on-last-close is in effect" },
+ {PR_RLC, "PR_RLC", "Run-on-last-close is in effect"},
#endif
#if defined (PR_PTRACE)
- { PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace" },
+ {PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace"},
#endif
#if defined (PR_PCINVAL)
- { PR_PCINVAL, "PR_PCINVAL", "PC refers to an invalid virtual address" },
+ {PR_PCINVAL, "PR_PCINVAL", "PC refers to an invalid virtual address"},
#endif
#if defined (PR_ISSYS)
- { PR_ISSYS, "PR_ISSYS", "Is a system process" },
+ {PR_ISSYS, "PR_ISSYS", "Is a system process"},
#endif
#if defined (PR_STEP)
- { PR_STEP, "PR_STEP", "Process has single step pending" },
+ {PR_STEP, "PR_STEP", "Process has single step pending"},
#endif
#if defined (PR_KLC)
- { PR_KLC, "PR_KLC", "Kill-on-last-close is in effect" },
+ {PR_KLC, "PR_KLC", "Kill-on-last-close is in effect"},
#endif
#if defined (PR_ASYNC)
- { PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect" },
+ {PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect"},
#endif
#if defined (PR_PCOMPAT)
- { PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect" },
+ {PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect"},
#endif
#if defined (PR_MSACCT)
- { PR_MSACCT, "PR_MSACCT", "Microstate accounting enabled" },
+ {PR_MSACCT, "PR_MSACCT", "Microstate accounting enabled"},
#endif
#if defined (PR_BPTADJ)
- { PR_BPTADJ, "PR_BPTADJ", "Breakpoint PC adjustment in effect" },
+ {PR_BPTADJ, "PR_BPTADJ", "Breakpoint PC adjustment in effect"},
#endif
#if defined (PR_ASLWP)
- { PR_ASLWP, "PR_ASLWP", "Asynchronus signal LWP" },
+ {PR_ASLWP, "PR_ASLWP", "Asynchronus signal LWP"},
#endif
- { 0, NULL, NULL }
+ {0, NULL, NULL}
};
/* Translate values in the pr_why field of the prstatus struct. */
static struct trans pr_why_table[] =
{
#if defined (PR_REQUESTED)
- { PR_REQUESTED, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP" },
+ {PR_REQUESTED, "PR_REQUESTED", "Directed to stop via PIOCSTOP/PIOCWSTOP"},
#endif
#if defined (PR_SIGNALLED)
- { PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal" },
+ {PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal"},
#endif
#if defined (PR_SYSENTRY)
- { PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call" },
+ {PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call"},
#endif
#if defined (PR_SYSEXIT)
- { PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call" },
+ {PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call"},
#endif
#if defined (PR_JOBCONTROL)
- { PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action" },
+ {PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action"},
#endif
#if defined (PR_FAULTED)
- { PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault" },
+ {PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault"},
#endif
#if defined (PR_SUSPENDED)
- { PR_SUSPENDED, "PR_SUSPENDED", "Process suspended" },
+ {PR_SUSPENDED, "PR_SUSPENDED", "Process suspended"},
#endif
#if defined (PR_CHECKPOINT)
- { PR_CHECKPOINT, "PR_CHECKPOINT", "(???)" },
+ {PR_CHECKPOINT, "PR_CHECKPOINT", "(???)"},
#endif
- { 0, NULL, NULL }
+ {0, NULL, NULL}
};
/* Hardware fault translation table. */
static struct trans faults_table[] =
{
#if defined (FLTILL)
- { FLTILL, "FLTILL", "Illegal instruction" },
+ {FLTILL, "FLTILL", "Illegal instruction"},
#endif
#if defined (FLTPRIV)
- { FLTPRIV, "FLTPRIV", "Privileged instruction" },
+ {FLTPRIV, "FLTPRIV", "Privileged instruction"},
#endif
#if defined (FLTBPT)
- { FLTBPT, "FLTBPT", "Breakpoint trap" },
+ {FLTBPT, "FLTBPT", "Breakpoint trap"},
#endif
#if defined (FLTTRACE)
- { FLTTRACE, "FLTTRACE", "Trace trap" },
+ {FLTTRACE, "FLTTRACE", "Trace trap"},
#endif
#if defined (FLTACCESS)
- { FLTACCESS, "FLTACCESS", "Memory access fault" },
+ {FLTACCESS, "FLTACCESS", "Memory access fault"},
#endif
#if defined (FLTBOUNDS)
- { FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation" },
+ {FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation"},
#endif
#if defined (FLTIOVF)
- { FLTIOVF, "FLTIOVF", "Integer overflow" },
+ {FLTIOVF, "FLTIOVF", "Integer overflow"},
#endif
#if defined (FLTIZDIV)
- { FLTIZDIV, "FLTIZDIV", "Integer zero divide" },
+ {FLTIZDIV, "FLTIZDIV", "Integer zero divide"},
#endif
#if defined (FLTFPE)
- { FLTFPE, "FLTFPE", "Floating-point exception" },
+ {FLTFPE, "FLTFPE", "Floating-point exception"},
#endif
#if defined (FLTSTACK)
- { FLTSTACK, "FLTSTACK", "Unrecoverable stack fault" },
+ {FLTSTACK, "FLTSTACK", "Unrecoverable stack fault"},
#endif
#if defined (FLTPAGE)
- { FLTPAGE, "FLTPAGE", "Recoverable page fault" },
+ {FLTPAGE, "FLTPAGE", "Recoverable page fault"},
#endif
- { 0, NULL, NULL }
+ {0, NULL, NULL}
};
/* Translation table for signal generation information. See UNIX System
V Release 4 Programmer's Reference Manual, siginfo(5). */
-static struct sigcode {
- int signo;
- int code;
- char *codename;
- char *desc;
-} siginfo_table[] = {
+static struct sigcode
+ {
+ int signo;
+ int code;
+ char *codename;
+ char *desc;
+ }
+siginfo_table[] =
+{
#if defined (SIGILL) && defined (ILL_ILLOPC)
- { SIGILL, ILL_ILLOPC, "ILL_ILLOPC", "Illegal opcode" },
+ {
+ SIGILL, ILL_ILLOPC, "ILL_ILLOPC", "Illegal opcode"
+ }
+ ,
#endif
#if defined (SIGILL) && defined (ILL_ILLOPN)
- { SIGILL, ILL_ILLOPN, "ILL_ILLOPN", "Illegal operand", },
+ {
+ SIGILL, ILL_ILLOPN, "ILL_ILLOPN", "Illegal operand",
+ }
+ ,
#endif
#if defined (SIGILL) && defined (ILL_ILLADR)
- { SIGILL, ILL_ILLADR, "ILL_ILLADR", "Illegal addressing mode" },
+ {
+ SIGILL, ILL_ILLADR, "ILL_ILLADR", "Illegal addressing mode"
+ }
+ ,
#endif
#if defined (SIGILL) && defined (ILL_ILLTRP)
- { SIGILL, ILL_ILLTRP, "ILL_ILLTRP", "Illegal trap" },
+ {
+ SIGILL, ILL_ILLTRP, "ILL_ILLTRP", "Illegal trap"
+ }
+ ,
#endif
#if defined (SIGILL) && defined (ILL_PRVOPC)
- { SIGILL, ILL_PRVOPC, "ILL_PRVOPC", "Privileged opcode" },
+ {
+ SIGILL, ILL_PRVOPC, "ILL_PRVOPC", "Privileged opcode"
+ }
+ ,
#endif
#if defined (SIGILL) && defined (ILL_PRVREG)
- { SIGILL, ILL_PRVREG, "ILL_PRVREG", "Privileged register" },
+ {
+ SIGILL, ILL_PRVREG, "ILL_PRVREG", "Privileged register"
+ }
+ ,
#endif
#if defined (SIGILL) && defined (ILL_COPROC)
- { SIGILL, ILL_COPROC, "ILL_COPROC", "Coprocessor error" },
+ {
+ SIGILL, ILL_COPROC, "ILL_COPROC", "Coprocessor error"
+ }
+ ,
#endif
#if defined (SIGILL) && defined (ILL_BADSTK)
- { SIGILL, ILL_BADSTK, "ILL_BADSTK", "Internal stack error" },
+ {
+ SIGILL, ILL_BADSTK, "ILL_BADSTK", "Internal stack error"
+ }
+ ,
#endif
#if defined (SIGFPE) && defined (FPE_INTDIV)
- { SIGFPE, FPE_INTDIV, "FPE_INTDIV", "Integer divide by zero" },
+ {
+ SIGFPE, FPE_INTDIV, "FPE_INTDIV", "Integer divide by zero"
+ }
+ ,
#endif
#if defined (SIGFPE) && defined (FPE_INTOVF)
- { SIGFPE, FPE_INTOVF, "FPE_INTOVF", "Integer overflow" },
+ {
+ SIGFPE, FPE_INTOVF, "FPE_INTOVF", "Integer overflow"
+ }
+ ,
#endif
#if defined (SIGFPE) && defined (FPE_FLTDIV)
- { SIGFPE, FPE_FLTDIV, "FPE_FLTDIV", "Floating point divide by zero" },
+ {
+ SIGFPE, FPE_FLTDIV, "FPE_FLTDIV", "Floating point divide by zero"
+ }
+ ,
#endif
#if defined (SIGFPE) && defined (FPE_FLTOVF)
- { SIGFPE, FPE_FLTOVF, "FPE_FLTOVF", "Floating point overflow" },
+ {
+ SIGFPE, FPE_FLTOVF, "FPE_FLTOVF", "Floating point overflow"
+ }
+ ,
#endif
#if defined (SIGFPE) && defined (FPE_FLTUND)
- { SIGFPE, FPE_FLTUND, "FPE_FLTUND", "Floating point underflow" },
+ {
+ SIGFPE, FPE_FLTUND, "FPE_FLTUND", "Floating point underflow"
+ }
+ ,
#endif
#if defined (SIGFPE) && defined (FPE_FLTRES)
- { SIGFPE, FPE_FLTRES, "FPE_FLTRES", "Floating point inexact result" },
+ {
+ SIGFPE, FPE_FLTRES, "FPE_FLTRES", "Floating point inexact result"
+ }
+ ,
#endif
#if defined (SIGFPE) && defined (FPE_FLTINV)
- { SIGFPE, FPE_FLTINV, "FPE_FLTINV", "Invalid floating point operation" },
+ {
+ SIGFPE, FPE_FLTINV, "FPE_FLTINV", "Invalid floating point operation"
+ }
+ ,
#endif
#if defined (SIGFPE) && defined (FPE_FLTSUB)
- { SIGFPE, FPE_FLTSUB, "FPE_FLTSUB", "Subscript out of range" },
+ {
+ SIGFPE, FPE_FLTSUB, "FPE_FLTSUB", "Subscript out of range"
+ }
+ ,
#endif
#if defined (SIGSEGV) && defined (SEGV_MAPERR)
- { SIGSEGV, SEGV_MAPERR, "SEGV_MAPERR", "Address not mapped to object" },
+ {
+ SIGSEGV, SEGV_MAPERR, "SEGV_MAPERR", "Address not mapped to object"
+ }
+ ,
#endif
#if defined (SIGSEGV) && defined (SEGV_ACCERR)
- { SIGSEGV, SEGV_ACCERR, "SEGV_ACCERR", "Invalid permissions for object" },
+ {
+ SIGSEGV, SEGV_ACCERR, "SEGV_ACCERR", "Invalid permissions for object"
+ }
+ ,
#endif
#if defined (SIGBUS) && defined (BUS_ADRALN)
- { SIGBUS, BUS_ADRALN, "BUS_ADRALN", "Invalid address alignment" },
+ {
+ SIGBUS, BUS_ADRALN, "BUS_ADRALN", "Invalid address alignment"
+ }
+ ,
#endif
#if defined (SIGBUS) && defined (BUS_ADRERR)
- { SIGBUS, BUS_ADRERR, "BUS_ADRERR", "Non-existent physical address" },
+ {
+ SIGBUS, BUS_ADRERR, "BUS_ADRERR", "Non-existent physical address"
+ }
+ ,
#endif
#if defined (SIGBUS) && defined (BUS_OBJERR)
- { SIGBUS, BUS_OBJERR, "BUS_OBJERR", "Object specific hardware error" },
+ {
+ SIGBUS, BUS_OBJERR, "BUS_OBJERR", "Object specific hardware error"
+ }
+ ,
#endif
#if defined (SIGTRAP) && defined (TRAP_BRKPT)
- { SIGTRAP, TRAP_BRKPT, "TRAP_BRKPT", "Process breakpoint" },
+ {
+ SIGTRAP, TRAP_BRKPT, "TRAP_BRKPT", "Process breakpoint"
+ }
+ ,
#endif
#if defined (SIGTRAP) && defined (TRAP_TRACE)
- { SIGTRAP, TRAP_TRACE, "TRAP_TRACE", "Process trace trap" },
+ {
+ SIGTRAP, TRAP_TRACE, "TRAP_TRACE", "Process trace trap"
+ }
+ ,
#endif
#if defined (SIGCLD) && defined (CLD_EXITED)
- { SIGCLD, CLD_EXITED, "CLD_EXITED", "Child has exited" },
+ {
+ SIGCLD, CLD_EXITED, "CLD_EXITED", "Child has exited"
+ }
+ ,
#endif
#if defined (SIGCLD) && defined (CLD_KILLED)
- { SIGCLD, CLD_KILLED, "CLD_KILLED", "Child was killed" },
+ {
+ SIGCLD, CLD_KILLED, "CLD_KILLED", "Child was killed"
+ }
+ ,
#endif
#if defined (SIGCLD) && defined (CLD_DUMPED)
- { SIGCLD, CLD_DUMPED, "CLD_DUMPED", "Child has terminated abnormally" },
+ {
+ SIGCLD, CLD_DUMPED, "CLD_DUMPED", "Child has terminated abnormally"
+ }
+ ,
#endif
#if defined (SIGCLD) && defined (CLD_TRAPPED)
- { SIGCLD, CLD_TRAPPED, "CLD_TRAPPED", "Traced child has trapped" },
+ {
+ SIGCLD, CLD_TRAPPED, "CLD_TRAPPED", "Traced child has trapped"
+ }
+ ,
#endif
#if defined (SIGCLD) && defined (CLD_STOPPED)
- { SIGCLD, CLD_STOPPED, "CLD_STOPPED", "Child has stopped" },
+ {
+ SIGCLD, CLD_STOPPED, "CLD_STOPPED", "Child has stopped"
+ }
+ ,
#endif
#if defined (SIGCLD) && defined (CLD_CONTINUED)
- { SIGCLD, CLD_CONTINUED, "CLD_CONTINUED", "Stopped child had continued" },
+ {
+ SIGCLD, CLD_CONTINUED, "CLD_CONTINUED", "Stopped child had continued"
+ }
+ ,
#endif
#if defined (SIGPOLL) && defined (POLL_IN)
- { SIGPOLL, POLL_IN, "POLL_IN", "Input input available" },
+ {
+ SIGPOLL, POLL_IN, "POLL_IN", "Input input available"
+ }
+ ,
#endif
#if defined (SIGPOLL) && defined (POLL_OUT)
- { SIGPOLL, POLL_OUT, "POLL_OUT", "Output buffers available" },
+ {
+ SIGPOLL, POLL_OUT, "POLL_OUT", "Output buffers available"
+ }
+ ,
#endif
#if defined (SIGPOLL) && defined (POLL_MSG)
- { SIGPOLL, POLL_MSG, "POLL_MSG", "Input message available" },
+ {
+ SIGPOLL, POLL_MSG, "POLL_MSG", "Input message available"
+ }
+ ,
#endif
#if defined (SIGPOLL) && defined (POLL_ERR)
- { SIGPOLL, POLL_ERR, "POLL_ERR", "I/O error" },
+ {
+ SIGPOLL, POLL_ERR, "POLL_ERR", "I/O error"
+ }
+ ,
#endif
#if defined (SIGPOLL) && defined (POLL_PRI)
- { SIGPOLL, POLL_PRI, "POLL_PRI", "High priority input available" },
+ {
+ SIGPOLL, POLL_PRI, "POLL_PRI", "High priority input available"
+ }
+ ,
#endif
#if defined (SIGPOLL) && defined (POLL_HUP)
- { SIGPOLL, POLL_HUP, "POLL_HUP", "Device disconnected" },
+ {
+ SIGPOLL, POLL_HUP, "POLL_HUP", "Device disconnected"
+ }
+ ,
#endif
- { 0, 0, NULL, NULL }
+ {
+ 0, 0, NULL, NULL
+ }
};
static char *syscall_table[MAX_SYSCALLS];
static void proc_set_exec_trap PARAMS ((void));
-static void procfs_init_inferior PARAMS ((int));
+static void procfs_init_inferior PARAMS ((int));
static struct procinfo *create_procinfo PARAMS ((int));
static void close_proc_file PARAMS ((struct procinfo *));
-static void close_proc_file_cleanup PARAMS ((void*));
+static void close_proc_file_cleanup PARAMS ((void *));
static struct cleanup *make_cleanup_close_proc_file PARAMS ((struct procinfo *));
static void unconditionally_kill_inferior PARAMS ((struct procinfo *));
-static NORETURN void proc_init_failed PARAMS ((struct procinfo *, char *, int)) ATTR_NORETURN;
+static NORETURN void proc_init_failed
+PARAMS ((struct procinfo *, char *, int)) ATTR_NORETURN;
-static void info_proc PARAMS ((char *, int));
+ static void info_proc PARAMS ((char *, int));
-static void info_proc_flags PARAMS ((struct procinfo *, int));
+ static void info_proc_flags PARAMS ((struct procinfo *, int));
-static void info_proc_stop PARAMS ((struct procinfo *, int));
+ static void info_proc_stop PARAMS ((struct procinfo *, int));
-static void info_proc_siginfo PARAMS ((struct procinfo *, int));
+ static void info_proc_siginfo PARAMS ((struct procinfo *, int));
-static void info_proc_syscalls PARAMS ((struct procinfo *, int));
+ static void info_proc_syscalls PARAMS ((struct procinfo *, int));
-static void info_proc_mappings PARAMS ((struct procinfo *, int));
+ static void info_proc_mappings PARAMS ((struct procinfo *, int));
-static void info_proc_signals PARAMS ((struct procinfo *, int));
+ static void info_proc_signals PARAMS ((struct procinfo *, int));
-static void info_proc_faults PARAMS ((struct procinfo *, int));
+ static void info_proc_faults PARAMS ((struct procinfo *, int));
-static char *mappingflags PARAMS ((long));
+ static char *mappingflags PARAMS ((long));
-static char *lookupname PARAMS ((struct trans *, unsigned int, char *));
+ static char *lookupname PARAMS ((struct trans *, unsigned int, char *));
-static char *lookupdesc PARAMS ((struct trans *, unsigned int));
+ static char *lookupdesc PARAMS ((struct trans *, unsigned int));
-static int do_attach PARAMS ((int pid));
+ static int do_attach PARAMS ((int pid));
-static void do_detach PARAMS ((int siggnal));
+ static void do_detach PARAMS ((int siggnal));
-static void procfs_create_inferior PARAMS ((char *, char *, char **));
+ static void procfs_create_inferior PARAMS ((char *, char *, char **));
-static void procfs_notice_signals PARAMS ((int pid));
+ static void procfs_notice_signals PARAMS ((int pid));
-static void notice_signals PARAMS ((struct procinfo *, struct sig_ctl *));
+ static void notice_signals PARAMS ((struct procinfo *, struct sig_ctl *));
-static struct procinfo *find_procinfo PARAMS ((pid_t pid, int okfail));
+ static struct procinfo *find_procinfo PARAMS ((pid_t pid, int okfail));
-static int procfs_write_pcwstop PARAMS ((struct procinfo *));
-static int procfs_read_status PARAMS ((struct procinfo *));
-static void procfs_write_pckill PARAMS ((struct procinfo *));
+ static int procfs_write_pcwstop PARAMS ((struct procinfo *));
+ static int procfs_read_status PARAMS ((struct procinfo *));
+ static void procfs_write_pckill PARAMS ((struct procinfo *));
-typedef int syscall_func_t PARAMS ((struct procinfo *pi, int syscall_num,
- int why, int *rtnval, int *statval));
+ typedef int syscall_func_t PARAMS ((struct procinfo * pi, int syscall_num,
+ int why, int *rtnval, int *statval));
-static void procfs_set_syscall_trap PARAMS ((struct procinfo *pi,
- int syscall_num, int flags,
- syscall_func_t *func));
+ static void procfs_set_syscall_trap PARAMS ((struct procinfo * pi,
+ int syscall_num, int flags,
+ syscall_func_t * func));
-static void procfs_clear_syscall_trap PARAMS ((struct procinfo *pi,
+ static void procfs_clear_syscall_trap PARAMS ((struct procinfo * pi,
int syscall_num, int errok));
-#define PROCFS_SYSCALL_ENTRY 0x1 /* Trap on entry to sys call */
+#define PROCFS_SYSCALL_ENTRY 0x1 /* Trap on entry to sys call */
#define PROCFS_SYSCALL_EXIT 0x2 /* Trap on exit from sys call */
-static syscall_func_t procfs_exit_handler;
+ static syscall_func_t procfs_exit_handler;
-static syscall_func_t procfs_exec_handler;
+ static syscall_func_t procfs_exec_handler;
#ifdef SYS_sproc
-static syscall_func_t procfs_sproc_handler;
-static syscall_func_t procfs_fork_handler;
+ static syscall_func_t procfs_sproc_handler;
+ static syscall_func_t procfs_fork_handler;
#endif
#ifdef SYS_lwp_create
-static syscall_func_t procfs_lwp_creation_handler;
+ static syscall_func_t procfs_lwp_creation_handler;
#endif
-static void modify_inherit_on_fork_flag PARAMS ((int fd, int flag));
-static void modify_run_on_last_close_flag PARAMS ((int fd, int flag));
+ static void modify_inherit_on_fork_flag PARAMS ((int fd, int flag));
+ static void modify_run_on_last_close_flag PARAMS ((int fd, int flag));
/* */
-struct procfs_syscall_handler
-{
- int syscall_num; /* The number of the system call being handled */
- /* The function to be called */
- syscall_func_t *func;
-};
+ struct procfs_syscall_handler
+ {
+ int syscall_num; /* The number of the system call being handled */
+ /* The function to be called */
+ syscall_func_t *func;
+ };
-static void procfs_resume PARAMS ((int pid, int step,
- enum target_signal signo));
+ static void procfs_resume PARAMS ((int pid, int step,
+ enum target_signal signo));
-static void init_procfs_ops PARAMS ((void));
+ static void init_procfs_ops PARAMS ((void));
/* External function prototypes that can't be easily included in any
header file because the args are typedefs in system include files. */
-extern void supply_gregset PARAMS ((gdb_gregset_t *));
+ extern void supply_gregset PARAMS ((gdb_gregset_t *));
-extern void fill_gregset PARAMS ((gdb_gregset_t *, int));
+ extern void fill_gregset PARAMS ((gdb_gregset_t *, int));
#ifdef FP0_REGNUM
-extern void supply_fpregset PARAMS ((gdb_fpregset_t *));
+ extern void supply_fpregset PARAMS ((gdb_fpregset_t *));
-extern void fill_fpregset PARAMS ((gdb_fpregset_t *, int));
+ extern void fill_fpregset PARAMS ((gdb_fpregset_t *, int));
#endif
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
+
+ find_procinfo -- convert a process id to a struct procinfo
- find_procinfo -- convert a process id to a struct procinfo
+ SYNOPSIS
-SYNOPSIS
+ static struct procinfo * find_procinfo (pid_t pid, int okfail);
- static struct procinfo * find_procinfo (pid_t pid, int okfail);
+ DESCRIPTION
-DESCRIPTION
-
- Given a process id, look it up in the procinfo chain. Returns
- a struct procinfo *. If can't find pid, then call error(),
- unless okfail is set, in which case, return NULL;
+ Given a process id, look it up in the procinfo chain. Returns
+ a struct procinfo *. If can't find pid, then call error(),
+ unless okfail is set, in which case, return NULL;
*/
-static struct procinfo *
-find_procinfo (pid, okfail)
+ static struct procinfo *
+ find_procinfo (pid, okfail)
pid_t pid;
int okfail;
{
/*
-LOCAL MACRO
+ LOCAL MACRO
+
+ current_procinfo -- convert inferior_pid to a struct procinfo
- current_procinfo -- convert inferior_pid to a struct procinfo
+ SYNOPSIS
-SYNOPSIS
+ static struct procinfo * current_procinfo;
- static struct procinfo * current_procinfo;
+ DESCRIPTION
-DESCRIPTION
-
- Looks up inferior_pid in the procinfo chain. Always returns a
- struct procinfo *. If process can't be found, we error() out.
+ Looks up inferior_pid in the procinfo chain. Always returns a
+ struct procinfo *. If process can't be found, we error() out.
*/
#define current_procinfo find_procinfo (inferior_pid, 0)
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- add_fd -- Add the fd to the poll/select list
+ add_fd -- Add the fd to the poll/select list
-SYNOPSIS
+ SYNOPSIS
- static void add_fd (struct procinfo *);
+ static void add_fd (struct procinfo *);
-DESCRIPTION
-
- Add the fd of the supplied procinfo to the list of fds used for
- poll/select operations.
+ DESCRIPTION
+
+ Add the fd of the supplied procinfo to the list of fds used for
+ poll/select operations.
*/
static void
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
+
+ remove_fd -- Remove the fd from the poll/select list
- remove_fd -- Remove the fd from the poll/select list
+ SYNOPSIS
-SYNOPSIS
+ static void remove_fd (struct procinfo *);
- static void remove_fd (struct procinfo *);
+ DESCRIPTION
-DESCRIPTION
-
- Remove the fd of the supplied procinfo from the list of fds used
- for poll/select operations.
+ Remove the fd of the supplied procinfo from the list of fds used
+ for poll/select operations.
*/
static void
else
poll_list = (struct pollfd *) xrealloc (poll_list,
num_poll_list
- * sizeof (struct pollfd));
+ * sizeof (struct pollfd));
return;
}
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_read_status - get procfs fd status
+ procfs_read_status - get procfs fd status
-SYNOPSIS
+ SYNOPSIS
- static int procfs_read_status (pi) struct procinfo *pi;
+ static int procfs_read_status (pi) struct procinfo *pi;
-DESCRIPTION
-
- Given a pointer to a procinfo struct, get the status of
- the status_fd in the appropriate way. Returns 0 on failure,
- 1 on success.
+ DESCRIPTION
+
+ Given a pointer to a procinfo struct, get the status of
+ the status_fd in the appropriate way. Returns 0 on failure,
+ 1 on success.
*/
static int
procfs_read_status (pi)
- struct procinfo *pi;
+ struct procinfo *pi;
{
#ifdef PROCFS_USE_READ_WRITE
- if ((lseek (pi->status_fd, 0, SEEK_SET) < 0) ||
- (read (pi->status_fd, (char *) &pi->prstatus,
- sizeof (gdb_prstatus_t)) != sizeof (gdb_prstatus_t)))
+ if ((lseek (pi->status_fd, 0, SEEK_SET) < 0) ||
+ (read (pi->status_fd, (char *) &pi->prstatus,
+ sizeof (gdb_prstatus_t)) != sizeof (gdb_prstatus_t)))
#else
if (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) < 0)
#endif
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
+
+ procfs_write_pcwstop - send a PCWSTOP to procfs fd
- procfs_write_pcwstop - send a PCWSTOP to procfs fd
+ SYNOPSIS
-SYNOPSIS
+ static int procfs_write_pcwstop (pi) struct procinfo *pi;
- static int procfs_write_pcwstop (pi) struct procinfo *pi;
+ DESCRIPTION
-DESCRIPTION
-
- Given a pointer to a procinfo struct, send a PCWSTOP to
- the ctl_fd in the appropriate way. Returns 0 on failure,
- 1 on success.
+ Given a pointer to a procinfo struct, send a PCWSTOP to
+ the ctl_fd in the appropriate way. Returns 0 on failure,
+ 1 on success.
*/
static int
procfs_write_pcwstop (pi)
- struct procinfo *pi;
+ struct procinfo *pi;
{
#ifdef PROCFS_USE_READ_WRITE
long cmd = PCWSTOP;
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_write_pckill - send a kill to procfs fd
+ procfs_write_pckill - send a kill to procfs fd
-SYNOPSIS
+ SYNOPSIS
- static void procfs_write_pckill (pi) struct procinfo *pi;
+ static void procfs_write_pckill (pi) struct procinfo *pi;
-DESCRIPTION
-
- Given a pointer to a procinfo struct, send a kill to
- the ctl_fd in the appropriate way. Returns 0 on failure,
- 1 on success.
+ DESCRIPTION
+
+ Given a pointer to a procinfo struct, send a kill to
+ the ctl_fd in the appropriate way. Returns 0 on failure,
+ 1 on success.
*/
static void
procfs_write_pckill (pi)
- struct procinfo *pi;
+ struct procinfo *pi;
{
#ifdef PROCFS_USE_READ_WRITE
struct proc_ctl pctl;
int i;
#endif
- set_sigint_trap (); /* Causes SIGINT to be passed on to the
- attached process. */
+ set_sigint_trap (); /* Causes SIGINT to be passed on to the
+ attached process. */
set_sigio_trap ();
- wait_again:
+wait_again:
#ifndef LOSING_POLL
while (1)
{
}
pi->had_event = 1;
#endif /* LOSING_POLL */
-
+
clear_sigint_trap ();
clear_sigio_trap ();
for (i = 0; i < num_poll_list && num_fds > 0; i++)
{
- if (0 == (poll_list[i].revents &
+ if (0 == (poll_list[i].revents &
(POLLWRNORM | POLLPRI | POLLERR | POLLHUP | POLLNVAL)))
continue;
for (pi = procinfo_list; pi; pi = next_pi)
if (poll_list[i].fd == pi->ctl_fd)
{
num_fds--;
- if ((poll_list[i].revents & POLLHUP) != 0 ||
- !procfs_read_status(pi))
- { /* The LWP has apparently terminated. */
+ if ((poll_list[i].revents & POLLHUP) != 0 ||
+ !procfs_read_status (pi))
+ { /* The LWP has apparently terminated. */
if (num_poll_list <= 1)
{
pi->prstatus.pr_flags = 0;
break;
}
if (info_verbose)
- printf_filtered ("LWP %d exited.\n",
+ printf_filtered ("LWP %d exited.\n",
(pi->pid >> 16) & 0xffff);
close_proc_file (pi);
- i--; /* don't skip deleted entry */
+ i--; /* don't skip deleted entry */
if (num_fds != 0)
- break; /* already another event to process */
+ break; /* already another event to process */
else
- goto wait_again; /* wait for another event */
+ goto wait_again; /* wait for another event */
}
pi->had_event = 1;
break;
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- lookupdesc -- translate a value to a summary desc string
+ lookupdesc -- translate a value to a summary desc string
-SYNOPSIS
+ SYNOPSIS
- static char *lookupdesc (struct trans *transp, unsigned int val);
+ static char *lookupdesc (struct trans *transp, unsigned int val);
-DESCRIPTION
-
- Given a pointer to a translation table and a value to be translated,
- lookup the desc string and return it.
+ DESCRIPTION
+
+ Given a pointer to a translation table and a value to be translated,
+ lookup the desc string and return it.
*/
static char *
unsigned int val;
{
char *desc;
-
- for (desc = NULL; transp -> name != NULL; transp++)
+
+ for (desc = NULL; transp->name != NULL; transp++)
{
- if (transp -> value == val)
+ if (transp->value == val)
{
- desc = transp -> desc;
+ desc = transp->desc;
break;
}
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- lookupname -- translate a value to symbolic name
+ lookupname -- translate a value to symbolic name
-SYNOPSIS
+ SYNOPSIS
- static char *lookupname (struct trans *transp, unsigned int val,
- char *prefix);
+ static char *lookupname (struct trans *transp, unsigned int val,
+ char *prefix);
-DESCRIPTION
-
- Given a pointer to a translation table, a value to be translated,
- and a default prefix to return if the value can't be translated,
- match the value with one of the translation table entries and
- return a pointer to the symbolic name.
+ DESCRIPTION
- If no match is found it just returns the value as a printable string,
- with the given prefix. The previous such value, if any, is freed
- at this time.
+ Given a pointer to a translation table, a value to be translated,
+ and a default prefix to return if the value can't be translated,
+ match the value with one of the translation table entries and
+ return a pointer to the symbolic name.
+
+ If no match is found it just returns the value as a printable string,
+ with the given prefix. The previous such value, if any, is freed
+ at this time.
*/
static char *
{
static char *locbuf;
char *name;
-
- for (name = NULL; transp -> name != NULL; transp++)
+
+ for (name = NULL; transp->name != NULL; transp++)
{
- if (transp -> value == val)
+ if (transp->value == val)
{
- name = transp -> name;
+ name = transp->name;
break;
}
}
struct sigcode *scp;
char *name = NULL;
static char locbuf[32];
-
- for (scp = siginfo_table; scp -> codename != NULL; scp++)
+
+ for (scp = siginfo_table; scp->codename != NULL; scp++)
{
- if ((scp -> signo == sip -> si_signo) &&
- (scp -> code == sip -> si_code))
+ if ((scp->signo == sip->si_signo) &&
+ (scp->code == sip->si_code))
{
- name = scp -> codename;
+ name = scp->codename;
break;
}
}
if (name == NULL)
{
- sprintf (locbuf, "sigcode %u", sip -> si_signo);
+ sprintf (locbuf, "sigcode %u", sip->si_signo);
name = locbuf;
}
return (name);
{
struct sigcode *scp;
char *desc = NULL;
-
- for (scp = siginfo_table; scp -> codename != NULL; scp++)
+
+ for (scp = siginfo_table; scp->codename != NULL; scp++)
{
- if ((scp -> signo == sip -> si_signo) &&
- (scp -> code == sip -> si_code))
+ if ((scp->signo == sip->si_signo) &&
+ (scp->code == sip->si_code))
{
- desc = scp -> desc;
+ desc = scp->desc;
break;
}
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- syscallname - translate a system call number into a system call name
+ syscallname - translate a system call number into a system call name
-SYNOPSIS
+ SYNOPSIS
- char *syscallname (int syscallnum)
+ char *syscallname (int syscallnum)
-DESCRIPTION
+ DESCRIPTION
- Given a system call number, translate it into the printable name
- of a system call, or into "syscall <num>" if it is an unknown
- number.
+ Given a system call number, translate it into the printable name
+ of a system call, or into "syscall <num>" if it is an unknown
+ number.
*/
static char *
int syscallnum;
{
static char locbuf[32];
-
+
if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS
&& syscall_table[syscallnum] != NULL)
return syscall_table[syscallnum];
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- init_syscall_table - initialize syscall translation table
+ init_syscall_table - initialize syscall translation table
-SYNOPSIS
+ SYNOPSIS
- void init_syscall_table (void)
+ void init_syscall_table (void)
-DESCRIPTION
+ DESCRIPTION
- Dynamically initialize the translation table to convert system
- call numbers into printable system call names. Done once per
- gdb run, on initialization.
+ Dynamically initialize the translation table to convert system
+ call numbers into printable system call names. Done once per
+ gdb run, on initialization.
-NOTES
+ NOTES
- This is awfully ugly, but preprocessor tricks to make it prettier
- tend to be nonportable.
+ This is awfully ugly, but preprocessor tricks to make it prettier
+ tend to be nonportable.
*/
static void
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_kill_inferior - kill any current inferior
+ procfs_kill_inferior - kill any current inferior
-SYNOPSIS
+ SYNOPSIS
- void procfs_kill_inferior (void)
+ void procfs_kill_inferior (void)
-DESCRIPTION
+ DESCRIPTION
- Kill any current inferior.
+ Kill any current inferior.
-NOTES
+ NOTES
- Kills even attached inferiors. Presumably the user has already
- been prompted that the inferior is an attached one rather than
- one started by gdb. (FIXME?)
+ Kills even attached inferiors. Presumably the user has already
+ been prompted that the inferior is an attached one rather than
+ one started by gdb. (FIXME?)
-*/
+ */
static void
procfs_kill_inferior ()
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- unconditionally_kill_inferior - terminate the inferior
+ unconditionally_kill_inferior - terminate the inferior
-SYNOPSIS
+ SYNOPSIS
- static void unconditionally_kill_inferior (struct procinfo *)
+ static void unconditionally_kill_inferior (struct procinfo *)
-DESCRIPTION
+ DESCRIPTION
- Kill the specified inferior.
+ Kill the specified inferior.
-NOTE
+ NOTE
- A possibly useful enhancement would be to first try sending
- the inferior a terminate signal, politely asking it to commit
- suicide, before we murder it (we could call that
- politely_kill_inferior()).
+ A possibly useful enhancement would be to first try sending
+ the inferior a terminate signal, politely asking it to commit
+ suicide, before we murder it (we could call that
+ politely_kill_inferior()).
-*/
+ */
static void
unconditionally_kill_inferior (pi)
{
int ppid;
struct proc_ctl pctl;
-
+
ppid = pi->prstatus.pr_ppid;
#ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
/* Only wait() for our direct children. Our grandchildren zombies are killed
by the death of their parents. */
- if (ppid == getpid())
+ if (ppid == getpid ())
wait ((int *) 0);
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
+
+ procfs_xfer_memory -- copy data to or from inferior memory space
- procfs_xfer_memory -- copy data to or from inferior memory space
+ SYNOPSIS
-SYNOPSIS
+ int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+ int dowrite, struct target_ops target)
- int procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
- int dowrite, struct target_ops target)
+ DESCRIPTION
-DESCRIPTION
+ Copy LEN bytes to/from inferior's memory starting at MEMADDR
+ from/to debugger memory starting at MYADDR. Copy from inferior
+ if DOWRITE is zero or to inferior if DOWRITE is nonzero.
- Copy LEN bytes to/from inferior's memory starting at MEMADDR
- from/to debugger memory starting at MYADDR. Copy from inferior
- if DOWRITE is zero or to inferior if DOWRITE is nonzero.
-
- Returns the length copied, which is either the LEN argument or
- zero. This xfer function does not do partial moves, since procfs_ops
- doesn't allow memory operations to cross below us in the target stack
- anyway.
+ Returns the length copied, which is either the LEN argument or
+ zero. This xfer function does not do partial moves, since procfs_ops
+ doesn't allow memory operations to cross below us in the target stack
+ anyway.
-NOTES
+ NOTES
- The /proc interface makes this an almost trivial task.
+ The /proc interface makes this an almost trivial task.
*/
static int
char *myaddr;
int len;
int dowrite;
- struct target_ops *target; /* ignored */
+ struct target_ops *target; /* ignored */
{
int nbytes = 0;
struct procinfo *pi;
pi = current_procinfo;
- if (lseek(pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
+ if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
{
if (dowrite)
{
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_store_registers -- copy register values back to inferior
+ procfs_store_registers -- copy register values back to inferior
-SYNOPSIS
+ SYNOPSIS
- void procfs_store_registers (int regno)
+ void procfs_store_registers (int regno)
-DESCRIPTION
+ DESCRIPTION
- Store our current register values back into the inferior. If
- REGNO is -1 then store all the register, otherwise store just
- the value specified by REGNO.
+ Store our current register values back into the inferior. If
+ REGNO is -1 then store all the register, otherwise store just
+ the value specified by REGNO.
-NOTES
+ NOTES
- If we are storing only a single register, we first have to get all
- the current values from the process, overwrite the desired register
- in the gregset with the one we want from gdb's registers, and then
- send the whole set back to the process. For writing all the
- registers, all we have to do is generate the gregset and send it to
- the process.
+ If we are storing only a single register, we first have to get all
+ the current values from the process, overwrite the desired register
+ in the gregset with the one we want from gdb's registers, and then
+ send the whole set back to the process. For writing all the
+ registers, all we have to do is generate the gregset and send it to
+ the process.
- Also note that the process has to be stopped on an event of interest
- for this to work, which basically means that it has to have been
- run under the control of one of the other /proc ioctl calls and not
- ptrace. Since we don't use ptrace anyway, we don't worry about this
- fine point, but it is worth noting for future reference.
+ Also note that the process has to be stopped on an event of interest
+ for this to work, which basically means that it has to have been
+ run under the control of one of the other /proc ioctl calls and not
+ ptrace. Since we don't use ptrace anyway, we don't worry about this
+ fine point, but it is worth noting for future reference.
- Gdb is confused about what this function is supposed to return.
- Some versions return a value, others return nothing. Some are
- declared to return a value and actually return nothing. Gdb ignores
- anything returned. (FIXME)
+ Gdb is confused about what this function is supposed to return.
+ Some versions return a value, others return nothing. Some are
+ declared to return a value and actually return nothing. Gdb ignores
+ anything returned. (FIXME)
*/
{
procfs_read_status (pi);
memcpy ((char *) &greg.gregset,
- (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs,
- sizeof (gdb_gregset_t));
+ (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs,
+ sizeof (gdb_gregset_t));
}
fill_gregset (&greg.gregset, regno);
greg.cmd = PCSREG;
{
procfs_read_status (pi);
memcpy ((char *) &fpreg.fpregset,
- (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs,
- sizeof (gdb_fpregset_t));
+ (char *) &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs,
+ sizeof (gdb_fpregset_t));
}
fill_fpregset (&fpreg.fpregset, regno);
fpreg.cmd = PCSFPREG;
ioctl (pi->ctl_fd, PIOCSFPREG, &pi->fpregset.fpregset);
#endif /* PROCFS_USE_READ_WRITE */
-#endif /* FP0_REGNUM */
+#endif /* FP0_REGNUM */
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- init_procinfo - setup a procinfo struct and connect it to a process
+ init_procinfo - setup a procinfo struct and connect it to a process
-SYNOPSIS
+ SYNOPSIS
- struct procinfo * init_procinfo (int pid)
+ struct procinfo * init_procinfo (int pid)
-DESCRIPTION
+ DESCRIPTION
- Allocate a procinfo structure, open the /proc file and then set up the
- set of signals and faults that are to be traced. Returns a pointer to
- the new procinfo structure.
+ Allocate a procinfo structure, open the /proc file and then set up the
+ set of signals and faults that are to be traced. Returns a pointer to
+ the new procinfo structure.
-NOTES
+ NOTES
- If proc_init_failed ever gets called, control returns to the command
- processing loop via the standard error handling code.
+ If proc_init_failed ever gets called, control returns to the command
+ processing loop via the standard error handling code.
*/
int pid;
int kill;
{
- struct procinfo *pi = (struct procinfo *)
- xmalloc (sizeof (struct procinfo));
- struct sig_ctl sctl;
- struct flt_ctl fctl;
+ struct procinfo *pi = (struct procinfo *)
+ xmalloc (sizeof (struct procinfo));
+ struct sig_ctl sctl;
+ struct flt_ctl fctl;
memset ((char *) pi, 0, sizeof (*pi));
if (!open_proc_file (pid, pi, O_RDWR, 1))
/* open_proc_file may modify pid. */
- pid = pi -> pid;
+ pid = pi->pid;
/* Add new process to process info list */
add_fd (pi); /* Add to list for poll/select */
/* Remember some things about the inferior that we will, or might, change
- so that we can restore them when we detach. */
+ so that we can restore them when we detach. */
#ifdef UNIXWARE
memcpy ((char *) &pi->saved_trace.sigset,
(char *) &pi->prstatus.pr_sigtrace, sizeof (sigset_t));
ioctl (pi->ctl_fd, PIOCGFAULT, &pi->saved_fltset.fltset);
ioctl (pi->ctl_fd, PIOCGENTRY, &pi->saved_entryset.sysset);
ioctl (pi->ctl_fd, PIOCGEXIT, &pi->saved_exitset.sysset);
-
+
/* Set up trace and fault sets, as gdb expects them. */
-
+
memset ((char *) &pi->prrun, 0, sizeof (pi->prrun));
prfillset (&pi->prrun.pr_trace);
procfs_notice_signals (pid);
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- create_procinfo - initialize access to a /proc entry
+ create_procinfo - initialize access to a /proc entry
-SYNOPSIS
+ SYNOPSIS
- struct procinfo * create_procinfo (int pid)
+ struct procinfo * create_procinfo (int pid)
-DESCRIPTION
+ DESCRIPTION
- Allocate a procinfo structure, open the /proc file and then set up the
- set of signals and faults that are to be traced. Returns a pointer to
- the new procinfo structure.
+ Allocate a procinfo structure, open the /proc file and then set up the
+ set of signals and faults that are to be traced. Returns a pointer to
+ the new procinfo structure.
-NOTES
+ NOTES
- If proc_init_failed ever gets called, control returns to the command
- processing loop via the standard error handling code.
+ If proc_init_failed ever gets called, control returns to the command
+ processing loop via the standard error handling code.
*/
int pid;
{
struct procinfo *pi;
- struct sig_ctl sctl;
- struct flt_ctl fctl;
+ struct sig_ctl sctl;
+ struct flt_ctl fctl;
pi = find_procinfo (pid, 1);
if (pi != NULL)
#ifdef PROCFS_USE_READ_WRITE
fctl.cmd = PCSFAULT;
if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
- proc_init_failed (pi, "PCSFAULT failed", 1);
+ proc_init_failed (pi, "PCSFAULT failed", 1);
#else
if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0)
proc_init_failed (pi, "PIOCSFAULT failed", 1);
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_exit_handler - handle entry into the _exit syscall
+ procfs_exit_handler - handle entry into the _exit syscall
-SYNOPSIS
+ SYNOPSIS
- int procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ int procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
-DESCRIPTION
+ DESCRIPTION
- This routine is called when an inferior process enters the _exit()
- system call. It continues the process, and then collects the exit
- status and pid which are returned in *statvalp and *rtnvalp. After
- that it returns non-zero to indicate that procfs_wait should wake up.
+ This routine is called when an inferior process enters the _exit()
+ system call. It continues the process, and then collects the exit
+ status and pid which are returned in *statvalp and *rtnvalp. After
+ that it returns non-zero to indicate that procfs_wait should wake up.
-NOTES
- There is probably a better way to do this.
+ NOTES
+ There is probably a better way to do this.
*/
#endif
#ifdef PROCFS_USE_READ_WRITE
- if (write (pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
+ if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
#else
if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0)
#endif
if (info_verbose)
printf_filtered ("(attached process has exited)\n");
*statvalp = 0;
- *rtnvalp = inferior_pid;
+ *rtnvalp = inferior_pid;
}
else
{
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_exec_handler - handle exit from the exec family of syscalls
+ procfs_exec_handler - handle exit from the exec family of syscalls
-SYNOPSIS
+ SYNOPSIS
- int procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ int procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
-DESCRIPTION
+ DESCRIPTION
- This routine is called when an inferior process is about to finish any
- of the exec() family of system calls. It pretends that we got a
- SIGTRAP (for compatibility with ptrace behavior), and returns non-zero
- to tell procfs_wait to wake up.
+ This routine is called when an inferior process is about to finish any
+ of the exec() family of system calls. It pretends that we got a
+ SIGTRAP (for compatibility with ptrace behavior), and returns non-zero
+ to tell procfs_wait to wake up.
-NOTES
- This need for compatibility with ptrace is questionable. In the
- future, it shouldn't be necessary.
+ NOTES
+ This need for compatibility with ptrace is questionable. In the
+ future, it shouldn't be necessary.
*/
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_sproc_handler - handle exit from the sproc syscall
+ procfs_sproc_handler - handle exit from the sproc syscall
-SYNOPSIS
+ SYNOPSIS
- int procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ int procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
-DESCRIPTION
+ DESCRIPTION
- This routine is called when an inferior process is about to finish an
- sproc() system call. This is the system call that IRIX uses to create
- a lightweight process. When the target process gets this event, we can
- look at rval1 to find the new child processes ID, and create a new
- procinfo struct from that.
+ This routine is called when an inferior process is about to finish an
+ sproc() system call. This is the system call that IRIX uses to create
+ a lightweight process. When the target process gets this event, we can
+ look at rval1 to find the new child processes ID, and create a new
+ procinfo struct from that.
- After that, it pretends that we got a SIGTRAP, and returns non-zero
- to tell procfs_wait to wake up. Subsequently, wait_for_inferior gets
- woken up, sees the new process and continues it.
+ After that, it pretends that we got a SIGTRAP, and returns non-zero
+ to tell procfs_wait to wake up. Subsequently, wait_for_inferior gets
+ woken up, sees the new process and continues it.
-NOTES
- We actually never see the child exiting from sproc because we will
- shortly stop the child with PIOCSTOP, which is then registered as the
- event of interest.
+ NOTES
+ We actually never see the child exiting from sproc because we will
+ shortly stop the child with PIOCSTOP, which is then registered as the
+ event of interest.
*/
static int
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_fork_handler - handle exit from the fork syscall
+ procfs_fork_handler - handle exit from the fork syscall
-SYNOPSIS
+ SYNOPSIS
- int procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ int procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
-DESCRIPTION
+ DESCRIPTION
- This routine is called when an inferior process is about to finish a
- fork() system call. We will open up the new process, and then close
- it, which releases it from the clutches of the debugger.
+ This routine is called when an inferior process is about to finish a
+ fork() system call. We will open up the new process, and then close
+ it, which releases it from the clutches of the debugger.
- After that, we continue the target process as though nothing had
- happened.
+ After that, we continue the target process as though nothing had
+ happened.
-NOTES
- This is necessary for IRIX because we have to set PR_FORK in order
- to catch the creation of lwps (via sproc()). When an actual fork
- occurs, it becomes necessary to reset the forks debugger flags and
- continue it because we can't hack multiple processes yet.
+ NOTES
+ This is necessary for IRIX because we have to set PR_FORK in order
+ to catch the creation of lwps (via sproc()). When an actual fork
+ occurs, it becomes necessary to reset the forks debugger flags and
+ continue it because we can't hack multiple processes yet.
*/
static int
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_set_inferior_syscall_traps - setup the syscall traps
+ procfs_set_inferior_syscall_traps - setup the syscall traps
-SYNOPSIS
+ SYNOPSIS
- void procfs_set_inferior_syscall_traps (struct procinfo *pip)
+ void procfs_set_inferior_syscall_traps (struct procinfo *pip)
-DESCRIPTION
+ DESCRIPTION
- Called for each "procinfo" (process, thread, or LWP) in the
- inferior, to register for notification of and handlers for
- syscall traps in the inferior.
+ Called for each "procinfo" (process, thread, or LWP) in the
+ inferior, to register for notification of and handlers for
+ syscall traps in the inferior.
*/
procfs_set_syscall_trap (pip, SYS_execve, PROCFS_SYSCALL_EXIT,
procfs_exec_handler);
#endif
-#endif /* PRFS_STOPEXEC */
+#endif /* PRFS_STOPEXEC */
/* Setup traps on exit from sproc() */
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_init_inferior - initialize target vector and access to a
- /proc entry
+ procfs_init_inferior - initialize target vector and access to a
+ /proc entry
-SYNOPSIS
+ SYNOPSIS
- void procfs_init_inferior (int pid)
+ void procfs_init_inferior (int pid)
-DESCRIPTION
+ DESCRIPTION
- When gdb starts an inferior, this function is called in the parent
- process immediately after the fork. It waits for the child to stop
- on the return from the exec system call (the child itself takes care
- of ensuring that this is set up), then sets up the set of signals
- and faults that are to be traced. Returns the pid, which may have had
- the thread-id added to it.
+ When gdb starts an inferior, this function is called in the parent
+ process immediately after the fork. It waits for the child to stop
+ on the return from the exec system call (the child itself takes care
+ of ensuring that this is set up), then sets up the set of signals
+ and faults that are to be traced. Returns the pid, which may have had
+ the thread-id added to it.
-NOTES
+ NOTES
- If proc_init_failed ever gets called, control returns to the command
- processing loop via the standard error handling code.
+ If proc_init_failed ever gets called, control returns to the command
+ processing loop via the standard error handling code.
*/
-static void
+static void
procfs_init_inferior (pid)
int pid;
{
/* create_procinfo may change the pid, so we have to update inferior_pid
here before calling other gdb routines that need the right pid. */
- pid = pip -> pid;
+ pid = pip->pid;
inferior_pid = pid;
- add_thread (pip -> pid); /* Setup initial thread */
+ add_thread (pip->pid); /* Setup initial thread */
#ifdef START_INFERIOR_TRAPS_EXPECTED
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
/*
-GLOBAL FUNCTION
+ GLOBAL FUNCTION
- procfs_notice_signals
+ procfs_notice_signals
-SYNOPSIS
+ SYNOPSIS
- static void procfs_notice_signals (int pid);
+ static void procfs_notice_signals (int pid);
-DESCRIPTION
+ DESCRIPTION
- When the user changes the state of gdb's signal handling via the
- "handle" command, this function gets called to see if any change
- in the /proc interface is required. It is also called internally
- by other /proc interface functions to initialize the state of
- the traced signal set.
+ When the user changes the state of gdb's signal handling via the
+ "handle" command, this function gets called to see if any change
+ in the /proc interface is required. It is also called internally
+ by other /proc interface functions to initialize the state of
+ the traced signal set.
- One thing it does is that signals for which the state is "nostop",
- "noprint", and "pass", have their trace bits reset in the pr_trace
- field, so that they are no longer traced. This allows them to be
- delivered directly to the inferior without the debugger ever being
- involved.
+ One thing it does is that signals for which the state is "nostop",
+ "noprint", and "pass", have their trace bits reset in the pr_trace
+ field, so that they are no longer traced. This allows them to be
+ delivered directly to the inferior without the debugger ever being
+ involved.
*/
static void
int pid;
{
struct procinfo *pi;
- struct sig_ctl sctl;
+ struct sig_ctl sctl;
pi = find_procinfo (pid, 0);
static void
notice_signals (pi, sctl)
- struct procinfo *pi;
- struct sig_ctl *sctl;
+ struct procinfo *pi;
+ struct sig_ctl *sctl;
{
int signo;
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- proc_set_exec_trap -- arrange for exec'd child to halt at startup
+ proc_set_exec_trap -- arrange for exec'd child to halt at startup
-SYNOPSIS
+ SYNOPSIS
- void proc_set_exec_trap (void)
+ void proc_set_exec_trap (void)
-DESCRIPTION
+ DESCRIPTION
- This function is called in the child process when starting up
- an inferior, prior to doing the exec of the actual inferior.
- It sets the child process's exitset to make exit from the exec
- system call an event of interest to stop on, and then simply
- returns. The child does the exec, the system call returns, and
- the child stops at the first instruction, ready for the gdb
- parent process to take control of it.
+ This function is called in the child process when starting up
+ an inferior, prior to doing the exec of the actual inferior.
+ It sets the child process's exitset to make exit from the exec
+ system call an event of interest to stop on, and then simply
+ returns. The child does the exec, the system call returns, and
+ the child stops at the first instruction, ready for the gdb
+ parent process to take control of it.
-NOTE
+ NOTE
- We need to use all local variables since the child may be sharing
- it's data space with the parent, if vfork was used rather than
- fork.
+ We need to use all local variables since the child may be sharing
+ it's data space with the parent, if vfork was used rather than
+ fork.
- Also note that we want to turn off the inherit-on-fork flag in
- the child process so that any grand-children start with all
- tracing flags cleared.
+ Also note that we want to turn off the inherit-on-fork flag in
+ the child process so that any grand-children start with all
+ tracing flags cleared.
*/
static void
struct sys_ctl entryset;
char procname[MAX_PROC_NAME_SIZE];
int fd;
-
+
sprintf (procname, CTL_PROC_NAME_FMT, getpid ());
#ifdef UNIXWARE
if ((fd = open (procname, O_WRONLY)) < 0)
modify_run_on_last_close_flag (fd, 1);
-#ifndef UNIXWARE /* since this is a solaris-ism, we don't want it */
- /* NOTE: revisit when doing thread support for UW */
+#ifndef UNIXWARE /* since this is a solaris-ism, we don't want it */
+ /* NOTE: revisit when doing thread support for UW */
#ifdef PR_ASYNC
{
long pr_flags;
pr_flags = PR_ASYNC;
#ifdef PROCFS_USE_READ_WRITE
pctl.cmd = PCSET;
- pctl.data = PR_FORK|PR_ASYNC;
+ pctl.data = PR_FORK | PR_ASYNC;
write (fd, (char *) &pctl, sizeof (struct proc_ctl));
#else
ioctl (fd, PIOCSET, &pr_flags);
#endif
}
-#endif /* PR_ASYNC */
-#endif /* !UNIXWARE */
+#endif /* PR_ASYNC */
+#endif /* !UNIXWARE */
}
/*
-GLOBAL FUNCTION
+ GLOBAL FUNCTION
- proc_iterate_over_mappings -- call function for every mapped space
+ proc_iterate_over_mappings -- call function for every mapped space
-SYNOPSIS
+ SYNOPSIS
- int proc_iterate_over_mappings (int (*func)())
+ int proc_iterate_over_mappings (int (*func)())
-DESCRIPTION
+ DESCRIPTION
- Given a pointer to a function, call that function for every
- mapped address space, passing it an open file descriptor for
- the file corresponding to that mapped address space (if any)
- and the base address of the mapped space. Quit when we hit
- the end of the mappings or the function returns nonzero.
+ Given a pointer to a function, call that function for every
+ mapped address space, passing it an open file descriptor for
+ the file corresponding to that mapped address space (if any)
+ and the base address of the mapped space. Quit when we hit
+ the end of the mappings or the function returns nonzero.
*/
#ifdef UNIXWARE
return 0;
nmap = sbuf.st_size / sizeof (prmap_t);
- prmaps = (prmap_t *) alloca (nmap * sizeof(prmap_t));
+ prmaps = (prmap_t *) alloca (nmap * sizeof (prmap_t));
if ((lseek (pi->map_fd, 0, SEEK_SET) == 0) &&
- (read (pi->map_fd, (char *) prmaps, nmap * sizeof (prmap_t)) ==
- (nmap * sizeof (prmap_t))))
+ (read (pi->map_fd, (char *) prmaps, nmap * sizeof (prmap_t)) ==
+ (nmap * sizeof (prmap_t))))
{
int i = 0;
for (prmap = prmaps; i < nmap && funcstat == 0; ++prmap, ++i)
- {
- char name[sizeof ("/proc/1234567890/object") +
- sizeof (prmap->pr_mapname)];
- sprintf (name, "/proc/%d/object/%s", pi->pid, prmap->pr_mapname);
- if ((fd = open (name, O_RDONLY)) == -1)
- {
- funcstat = 1;
- break;
- }
- funcstat = (*func) (fd, (CORE_ADDR) prmap->pr_vaddr);
- close (fd);
- }
+ {
+ char name[sizeof ("/proc/1234567890/object") +
+ sizeof (prmap->pr_mapname)];
+ sprintf (name, "/proc/%d/object/%s", pi->pid, prmap->pr_mapname);
+ if ((fd = open (name, O_RDONLY)) == -1)
+ {
+ funcstat = 1;
+ break;
+ }
+ funcstat = (*func) (fd, (CORE_ADDR) prmap->pr_vaddr);
+ close (fd);
+ }
}
return (funcstat);
}
prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
if (ioctl (pi->map_fd, PIOCMAP, prmaps) == 0)
{
- for (prmap = prmaps; prmap -> pr_size && funcstat == 0; ++prmap)
+ for (prmap = prmaps; prmap->pr_size && funcstat == 0; ++prmap)
{
- fd = proc_address_to_fd (pi, (CORE_ADDR) prmap -> pr_vaddr, 0);
- funcstat = (*func) (fd, (CORE_ADDR) prmap -> pr_vaddr);
+ fd = proc_address_to_fd (pi, (CORE_ADDR) prmap->pr_vaddr, 0);
+ funcstat = (*func) (fd, (CORE_ADDR) prmap->pr_vaddr);
close (fd);
}
}
}
#endif /* UNIXWARE */
-#if 0 /* Currently unused */
+#if 0 /* Currently unused */
/*
-GLOBAL FUNCTION
+ GLOBAL FUNCTION
- proc_base_address -- find base address for segment containing address
+ proc_base_address -- find base address for segment containing address
-SYNOPSIS
+ SYNOPSIS
- CORE_ADDR proc_base_address (CORE_ADDR addr)
+ CORE_ADDR proc_base_address (CORE_ADDR addr)
-DESCRIPTION
+ DESCRIPTION
- Given an address of a location in the inferior, find and return
- the base address of the mapped segment containing that address.
+ Given an address of a location in the inferior, find and return
+ the base address of the mapped segment containing that address.
- This is used for example, by the shared library support code,
- where we have the pc value for some location in the shared library
- where we are stopped, and need to know the base address of the
- segment containing that address.
-*/
+ This is used for example, by the shared library support code,
+ where we have the pc value for some location in the shared library
+ where we are stopped, and need to know the base address of the
+ segment containing that address.
+ */
CORE_ADDR
proc_base_address (addr)
prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
if (ioctl (pi->map_fd, PIOCMAP, prmaps) == 0)
{
- for (prmap = prmaps; prmap -> pr_size; ++prmap)
+ for (prmap = prmaps; prmap->pr_size; ++prmap)
{
- if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
- (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
+ if ((prmap->pr_vaddr <= (caddr_t) addr) &&
+ (prmap->pr_vaddr + prmap->pr_size > (caddr_t) addr))
{
- baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
+ baseaddr = (CORE_ADDR) prmap->pr_vaddr;
break;
}
}
return (baseaddr);
}
-#endif /* 0 */
+#endif /* 0 */
#ifndef UNIXWARE
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- proc_address_to_fd -- return open fd for file mapped to address
+ proc_address_to_fd -- return open fd for file mapped to address
-SYNOPSIS
+ SYNOPSIS
- int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
+ int proc_address_to_fd (struct procinfo *pi, CORE_ADDR addr, complain)
-DESCRIPTION
+ DESCRIPTION
- Given an address in the current inferior's address space, use the
- /proc interface to find an open file descriptor for the file that
- this address was mapped in from. Return -1 if there is no current
- inferior. Print a warning message if there is an inferior but
- the address corresponds to no file (IE a bogus address).
+ Given an address in the current inferior's address space, use the
+ /proc interface to find an open file descriptor for the file that
+ this address was mapped in from. Return -1 if there is no current
+ inferior. Print a warning message if there is an inferior but
+ the address corresponds to no file (IE a bogus address).
-*/
+ */
static int
proc_address_to_fd (pi, addr, complain)
{
int fd = -1;
- if ((fd = ioctl (pi->ctl_fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
+ if ((fd = ioctl (pi->ctl_fd, PIOCOPENM, (caddr_t *) & addr)) < 0)
{
if (complain)
{
pid = atoi (args);
- if (pid == getpid()) /* Trying to masturbate? */
+ if (pid == getpid ()) /* Trying to masturbate? */
error ("I refuse to debug myself!");
if (from_tty)
if (exec_file == 0)
exec_file = "";
printf_unfiltered ("Detaching from program: %s %s\n",
- exec_file, target_pid_to_str (inferior_pid));
+ exec_file, target_pid_to_str (inferior_pid));
gdb_flush (gdb_stdout);
}
if (args)
siggnal = atoi (args);
-
+
do_detach (siggnal);
inferior_pid = 0;
- unpush_target (&procfs_ops); /* Pop out of handling an inferior */
+ unpush_target (&procfs_ops); /* Pop out of handling an inferior */
}
/* Get ready to modify the registers array. On machines which store
struct target_ops *ignore;
{
printf_unfiltered ("\tUsing the running image of %s %s via /proc.\n",
- attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
+ attach_flag ? "attached" : "child", target_pid_to_str (inferior_pid));
}
/* ARGSUSED */
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- do_attach -- attach to an already existing process
+ do_attach -- attach to an already existing process
-SYNOPSIS
+ SYNOPSIS
- int do_attach (int pid)
+ int do_attach (int pid)
-DESCRIPTION
+ DESCRIPTION
- Attach to an already existing process with the specified process
- id. If the process is not already stopped, query whether to
- stop it or not.
+ Attach to an already existing process with the specified process
+ id. If the process is not already stopped, query whether to
+ stop it or not.
-NOTES
+ NOTES
- The option of stopping at attach time is specific to the /proc
- versions of gdb. Versions using ptrace force the attachee
- to stop. (I have changed this version to do so, too. All you
- have to do is "continue" to make it go on. -- gnu@cygnus.com)
+ The option of stopping at attach time is specific to the /proc
+ versions of gdb. Versions using ptrace force the attachee
+ to stop. (I have changed this version to do so, too. All you
+ have to do is "continue" to make it go on. -- gnu@cygnus.com)
-*/
+ */
static int
do_attach (pid)
struct flt_ctl fctl;
int nlwp, *lwps;
- pi = init_procinfo (pid, 0);
+ pi = init_procinfo (pid, 0);
#ifdef PIOCLWPIDS
nlwp = pi->prstatus.pr_nlwp;
if (ioctl (pi->ctl_fd, PIOCLWPIDS, lwps))
{
- print_sys_errmsg (pi -> pathname, errno);
+ print_sys_errmsg (pi->pathname, errno);
error ("PIOCLWPIDS failed");
}
#else /* PIOCLWPIDS */
if ((pi = find_procinfo ((*lwps << 16) | pid, 1)) == 0)
pi = init_procinfo ((*lwps << 16) | pid, 0);
- if (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
+ if (THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
{
pi->was_stopped = 1;
}
print_sys_errmsg (pi->pathname, errno);
close_proc_file (pi);
error ("procfs_read_status failed");
- }
+ }
#endif
pi->nopass_next_sigstop = 1;
}
else
{
- printf_unfiltered ("Ok, gdb will wait for %s to stop.\n",
+ printf_unfiltered ("Ok, gdb will wait for %s to stop.\n",
target_pid_to_str (pi->pid));
}
}
#ifdef PROCFS_USE_READ_WRITE
fctl.cmd = PCSFAULT;
if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0)
- print_sys_errmsg ("PCSFAULT failed", errno);
+ print_sys_errmsg ("PCSFAULT failed", errno);
#else /* PROCFS_USE_READ_WRITE */
if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault))
{
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- do_detach -- detach from an attached-to process
+ do_detach -- detach from an attached-to process
-SYNOPSIS
+ SYNOPSIS
- void do_detach (int signal)
+ void do_detach (int signal)
-DESCRIPTION
+ DESCRIPTION
- Detach from the current attachee.
+ Detach from the current attachee.
- If signal is non-zero, the attachee is started running again and sent
- the specified signal.
+ If signal is non-zero, the attachee is started running again and sent
+ the specified signal.
- If signal is zero and the attachee was not already stopped when we
- attached to it, then we make it runnable again when we detach.
+ If signal is zero and the attachee was not already stopped when we
+ attached to it, then we make it runnable again when we detach.
- Otherwise, we query whether or not to make the attachee runnable
- again, since we may simply want to leave it in the state it was in
- when we attached.
+ Otherwise, we query whether or not to make the attachee runnable
+ again, since we may simply want to leave it in the state it was in
+ when we attached.
- We report any problems, but do not consider them errors, since we
- MUST detach even if some things don't seem to go right. This may not
- be the ideal situation. (FIXME).
+ We report any problems, but do not consider them errors, since we
+ MUST detach even if some things don't seem to go right. This may not
+ be the ideal situation. (FIXME).
*/
static void
if (write (pi->ctl_fd, (char *) &pi->saved_exitset,
sizeof (struct sys_ctl)) < 0)
#else
- if (ioctl (pi->ctl_fd, PIOCSEXIT, &pi->saved_exitset.sysset) < 0)
+ if (ioctl (pi->ctl_fd, PIOCSEXIT, &pi->saved_exitset.sysset) < 0)
#endif
- {
- print_sys_errmsg (pi->pathname, errno);
- printf_unfiltered ("PIOCSEXIT failed.\n");
- }
+ {
+ print_sys_errmsg (pi->pathname, errno);
+ printf_unfiltered ("PIOCSEXIT failed.\n");
+ }
#ifdef PROCFS_USE_READ_WRITE
pi->saved_entryset.cmd = PCSENTRY;
if (write (pi->ctl_fd, (char *) &pi->saved_entryset,
sizeof (struct sys_ctl)) < 0)
#else
- if (ioctl (pi->ctl_fd, PIOCSENTRY, &pi->saved_entryset.sysset) < 0)
+ if (ioctl (pi->ctl_fd, PIOCSENTRY, &pi->saved_entryset.sysset) < 0)
#endif
- {
- print_sys_errmsg (pi->pathname, errno);
- printf_unfiltered ("PIOCSENTRY failed.\n");
- }
+ {
+ print_sys_errmsg (pi->pathname, errno);
+ printf_unfiltered ("PIOCSENTRY failed.\n");
+ }
#ifdef PROCFS_USE_READ_WRITE
pi->saved_trace.cmd = PCSTRACE;
if (write (pi->ctl_fd, (char *) &pi->saved_trace,
sizeof (struct sig_ctl)) < 0)
#else
- if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->saved_trace.sigset) < 0)
+ if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->saved_trace.sigset) < 0)
#endif
- {
- print_sys_errmsg (pi->pathname, errno);
- printf_unfiltered ("PIOCSTRACE failed.\n");
- }
+ {
+ print_sys_errmsg (pi->pathname, errno);
+ printf_unfiltered ("PIOCSTRACE failed.\n");
+ }
#ifndef UNIXWARE
if (ioctl (pi->ctl_fd, PIOCSHOLD, &pi->saved_sighold.sigset) < 0)
{
else
{
if (signal
- || (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
+ || (THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
{
long cmd;
struct proc_ctl pctl;
if (signal || !pi->was_stopped ||
- query ("Was stopped when attached, make it runnable again? "))
+ query ("Was stopped when attached, make it runnable again? "))
{
/* Clear any pending signal if we want to detach without
a signal. */
}
/* emulate wait() as much as possible.
- Wait for child to do something. Return pid of child, or -1 in case
- of error; store status in *OURSTATUS.
-
- Not sure why we can't
- just use wait(), but it seems to have problems when applied to a
- process being controlled with the /proc interface.
-
- We have a race problem here with no obvious solution. We need to let
- the inferior run until it stops on an event of interest, which means
- that we need to use the PIOCWSTOP ioctl. However, we cannot use this
- ioctl if the process is already stopped on something that is not an
- event of interest, or the call will hang indefinitely. Thus we first
- use PIOCSTATUS to see if the process is not stopped. If not, then we
- use PIOCWSTOP. But during the window between the two, if the process
- stops for any reason that is not an event of interest (such as a job
- control signal) then gdb will hang. One possible workaround is to set
- an alarm to wake up every minute of so and check to see if the process
- is still running, and if so, then reissue the PIOCWSTOP. But this is
- a real kludge, so has not been implemented. FIXME: investigate
- alternatives.
-
- FIXME: Investigate why wait() seems to have problems with programs
- being control by /proc routines. */
+ Wait for child to do something. Return pid of child, or -1 in case
+ of error; store status in *OURSTATUS.
+
+ Not sure why we can't
+ just use wait(), but it seems to have problems when applied to a
+ process being controlled with the /proc interface.
+
+ We have a race problem here with no obvious solution. We need to let
+ the inferior run until it stops on an event of interest, which means
+ that we need to use the PIOCWSTOP ioctl. However, we cannot use this
+ ioctl if the process is already stopped on something that is not an
+ event of interest, or the call will hang indefinitely. Thus we first
+ use PIOCSTATUS to see if the process is not stopped. If not, then we
+ use PIOCWSTOP. But during the window between the two, if the process
+ stops for any reason that is not an event of interest (such as a job
+ control signal) then gdb will hang. One possible workaround is to set
+ an alarm to wake up every minute of so and check to see if the process
+ is still running, and if so, then reissue the PIOCWSTOP. But this is
+ a real kludge, so has not been implemented. FIXME: investigate
+ alternatives.
+
+ FIXME: Investigate why wait() seems to have problems with programs
+ being control by /proc routines. */
static int
procfs_wait (pid, ourstatus)
int pid;
if (!pi->had_event)
continue;
- if (! (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)) )
+ if (!(THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
continue;
- why = THE_PR_LWP(pi->prstatus).pr_why;
- what = THE_PR_LWP(pi->prstatus).pr_what;
+ why = THE_PR_LWP (pi->prstatus).pr_why;
+ what = THE_PR_LWP (pi->prstatus).pr_what;
if (why == PR_SYSENTRY || why == PR_SYSEXIT)
{
int i;
}
if (!checkerr
- && !(THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
+ && !(THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP)))
{
if (!procfs_write_pcwstop (pi))
{
/* NOTREACHED */
}
}
- else if (THE_PR_LWP(pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
+ else if (THE_PR_LWP (pi->prstatus).pr_flags & (PR_STOPPED | PR_ISTOP))
{
#ifdef UNIXWARE
rtnval = pi->prstatus.pr_pid;
#else
rtnval = pi->pid;
#endif
- why = THE_PR_LWP(pi->prstatus).pr_why;
- what = THE_PR_LWP(pi->prstatus).pr_what;
+ why = THE_PR_LWP (pi->prstatus).pr_why;
+ what = THE_PR_LWP (pi->prstatus).pr_what;
switch (why)
{
#endif
#ifndef FAULTED_USE_SIGINFO
/* Irix, contrary to the documentation, fills in 0 for si_signo.
- Solaris fills in si_signo. I'm not sure about others. */
+ Solaris fills in si_signo. I'm not sure about others. */
case FLTPRIV:
case FLTILL:
statval = (SIGILL << 8) | 0177;
case FLTFPE:
statval = (SIGFPE << 8) | 0177;
break;
- case FLTPAGE: /* Recoverable page fault */
+ case FLTPAGE: /* Recoverable page fault */
#endif /* not FAULTED_USE_SIGINFO */
default:
/* Use the signal which the kernel assigns. This is better than
- trying to second-guess it from the fault. In fact, I suspect
- that FLTACCESS can be either SIGSEGV or SIGBUS. */
- statval =
- ((THE_PR_LWP(pi->prstatus).pr_info.si_signo) << 8) | 0177;
+ trying to second-guess it from the fault. In fact, I suspect
+ that FLTACCESS can be either SIGSEGV or SIGBUS. */
+ statval =
+ ((THE_PR_LWP (pi->prstatus).pr_info.si_signo) << 8) | 0177;
break;
}
break;
{
/* The LWP has apparently terminated. */
if (info_verbose)
- printf_filtered ("LWP %d doesn't respond.\n",
+ printf_filtered ("LWP %d doesn't respond.\n",
(procinfo->pid >> 16) & 0xffff);
close_proc_file (procinfo);
continue;
else
{
error ("PIOCWSTOP, stopped for unknown/unhandled reason, flags %#x",
- THE_PR_LWP(pi->prstatus).pr_flags);
+ THE_PR_LWP (pi->prstatus).pr_flags);
}
store_waitstatus (ourstatus, statval);
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- set_proc_siginfo - set a process's current signal info
+ set_proc_siginfo - set a process's current signal info
-SYNOPSIS
+ SYNOPSIS
- void set_proc_siginfo (struct procinfo *pip, int signo);
+ void set_proc_siginfo (struct procinfo *pip, int signo);
-DESCRIPTION
+ DESCRIPTION
- Given a pointer to a process info struct in PIP and a signal number
- in SIGNO, set the process's current signal and its associated signal
- information. The signal will be delivered to the process immediately
- after execution is resumed, even if it is being held. In addition,
- this particular delivery will not cause another PR_SIGNALLED stop
- even if the signal is being traced.
+ Given a pointer to a process info struct in PIP and a signal number
+ in SIGNO, set the process's current signal and its associated signal
+ information. The signal will be delivered to the process immediately
+ after execution is resumed, even if it is being held. In addition,
+ this particular delivery will not cause another PR_SIGNALLED stop
+ even if the signal is being traced.
- If we are not delivering the same signal that the prstatus siginfo
- struct contains information about, then synthesize a siginfo struct
- to match the signal we are going to deliver, make it of the type
- "generated by a user process", and send this synthesized copy. When
- used to set the inferior's signal state, this will be required if we
- are not currently stopped because of a traced signal, or if we decide
- to continue with a different signal.
+ If we are not delivering the same signal that the prstatus siginfo
+ struct contains information about, then synthesize a siginfo struct
+ to match the signal we are going to deliver, make it of the type
+ "generated by a user process", and send this synthesized copy. When
+ used to set the inferior's signal state, this will be required if we
+ are not currently stopped because of a traced signal, or if we decide
+ to continue with a different signal.
- Note that when continuing the inferior from a stop due to receipt
- of a traced signal, we either have set PRCSIG to clear the existing
- signal, or we have to call this function to do a PIOCSSIG with either
- the existing siginfo struct from pr_info, or one we have synthesized
- appropriately for the signal we want to deliver. Otherwise if the
- signal is still being traced, the inferior will immediately stop
- again.
+ Note that when continuing the inferior from a stop due to receipt
+ of a traced signal, we either have set PRCSIG to clear the existing
+ signal, or we have to call this function to do a PIOCSSIG with either
+ the existing siginfo struct from pr_info, or one we have synthesized
+ appropriately for the signal we want to deliver. Otherwise if the
+ signal is still being traced, the inferior will immediately stop
+ again.
- See siginfo(5) for more details.
-*/
+ See siginfo(5) for more details.
+ */
static void
set_proc_siginfo (pip, signo)
/* With Alpha OSF/1 procfs, the kernel gets really confused if it
receives a PIOCSSIG with a signal identical to the current signal,
it messes up the current signal. Work around the kernel bug. */
- if (signo == THE_PR_LWP(pip->prstatus).pr_cursig)
+ if (signo == THE_PR_LWP (pip->prstatus).pr_cursig)
return;
#endif
#ifdef UNIXWARE
- if (signo == THE_PR_LWP(pip->prstatus).pr_info.si_signo)
+ if (signo == THE_PR_LWP (pip->prstatus).pr_info.si_signo)
{
memcpy ((char *) &sictl.siginfo, (char *) &pip->prstatus.pr_lwp.pr_info,
- sizeof (siginfo_t));
+ sizeof (siginfo_t));
}
#else
- if (signo == THE_PR_LWP(pip->prstatus).pr_info.si_signo)
+ if (signo == THE_PR_LWP (pip->prstatus).pr_info.si_signo)
{
- sip = &pip -> prstatus.pr_info;
+ sip = &pip->prstatus.pr_info;
}
#endif
else
memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
sip = &newsiginfo;
#endif
- sip -> si_signo = signo;
- sip -> si_code = 0;
- sip -> si_errno = 0;
- sip -> si_pid = getpid ();
- sip -> si_uid = getuid ();
+ sip->si_signo = signo;
+ sip->si_code = 0;
+ sip->si_errno = 0;
+ sip->si_pid = getpid ();
+ sip->si_uid = getuid ();
}
#ifdef PROCFS_USE_READ_WRITE
sictl.cmd = PCSSIG;
if (ioctl (pip->ctl_fd, PIOCSSIG, sip) < 0)
#endif
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
warning ("PIOCSSIG failed");
}
}
#if 0
/* It should not be necessary. If the user explicitly changes the value,
value_assign calls write_register_bytes, which writes it. */
-/* It may not be absolutely necessary to specify the PC value for
- restarting, but to be safe we use the value that gdb considers
- to be current. One case where this might be necessary is if the
- user explicitly changes the PC value that gdb considers to be
- current. FIXME: Investigate if this is necessary or not. */
+/* It may not be absolutely necessary to specify the PC value for
+ restarting, but to be safe we use the value that gdb considers
+ to be current. One case where this might be necessary is if the
+ user explicitly changes the PC value that gdb considers to be
+ current. FIXME: Investigate if this is necessary or not. */
#ifdef PRSVADDR_BROKEN
/* Can't do this under Solaris running on a Sparc, as there seems to be no
random garbage. We have to rely on the fact that PC and nPC have been
written previously via PIOCSREG during a register flush. */
- pi->prrun.pr_vaddr = (caddr_t) *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)];
+ pi->prrun.pr_vaddr = (caddr_t) * (int *) ®isters[REGISTER_BYTE (PC_REGNUM)];
pi->prrun.pr_flags != PRSVADDR;
#endif
#endif
an inferior to continue running at the same time as gdb. (FIXME?) */
signal_to_pass = 0;
else if (signo == TARGET_SIGNAL_TSTP
- && THE_PR_LWP(pi->prstatus).pr_cursig == SIGTSTP
- && THE_PR_LWP(pi->prstatus).pr_action.sa_handler == SIG_DFL
- )
+ && THE_PR_LWP (pi->prstatus).pr_cursig == SIGTSTP
+ && THE_PR_LWP (pi->prstatus).pr_action.sa_handler == SIG_DFL
+ )
/* We are about to pass the inferior a SIGTSTP whose action is
SIG_DFL. The SIG_DFL action for a SIGTSTP is to stop
{
/* The LWP has apparently terminated. */
if (info_verbose)
- printf_filtered ("LWP %d doesn't respond.\n",
+ printf_filtered ("LWP %d doesn't respond.\n",
(pi->pid >> 16) & 0xffff);
close_proc_file (pi);
}
{
/* The LWP has apparently terminated. */
if (info_verbose)
- printf_filtered ("LWP %d doesn't respond.\n",
+ printf_filtered ("LWP %d doesn't respond.\n",
(pi->pid >> 16) & 0xffff);
close_proc_file (pi);
}
{
next_pi = procinfo->next;
if (pi != procinfo)
- if (!procinfo->had_event ||
+ if (!procinfo->had_event ||
(procinfo->nopass_next_sigstop && signo == TARGET_SIGNAL_STOP))
{
procinfo->had_event = procinfo->nopass_next_sigstop = 0;
sizeof (struct proc_ctl)) < 0)
{
if (!procfs_read_status (procinfo))
- fprintf_unfiltered(gdb_stderr,
- "procfs_read_status failed, errno=%d\n",
- errno);
+ fprintf_unfiltered (gdb_stderr,
+ "procfs_read_status failed, errno=%d\n",
+ errno);
print_sys_errmsg (procinfo->pathname, errno);
error ("PCRUN failed");
}
{
/* The LWP has apparently terminated. */
if (info_verbose)
- printf_filtered ("LWP %d doesn't respond.\n",
+ printf_filtered ("LWP %d doesn't respond.\n",
(procinfo->pid >> 16) & 0xffff);
close_proc_file (procinfo);
continue;
}
/* Don't try to start a process unless it's stopped on an
- `event of interest'. Doing so will cause errors. */
+ `event of interest'. Doing so will cause errors. */
if ((procinfo->prstatus.pr_flags & PR_ISTOP)
&& ioctl (procinfo->ctl_fd, PIOCRUN, &procinfo->prrun) < 0)
{
if (!procfs_read_status (procinfo))
- fprintf_unfiltered(gdb_stderr,
- "procfs_read_status failed, errno=%d\n",
- errno);
+ fprintf_unfiltered (gdb_stderr,
+ "procfs_read_status failed, errno=%d\n",
+ errno);
print_sys_errmsg (procinfo->pathname, errno);
warning ("PIOCRUN failed");
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_fetch_registers -- fetch current registers from inferior
+ procfs_fetch_registers -- fetch current registers from inferior
-SYNOPSIS
+ SYNOPSIS
- void procfs_fetch_registers (int regno)
+ void procfs_fetch_registers (int regno)
-DESCRIPTION
+ DESCRIPTION
- Read the current values of the inferior's registers, both the
- general register set and floating point registers (if supported)
- and update gdb's idea of their current values.
+ Read the current values of the inferior's registers, both the
+ general register set and floating point registers (if supported)
+ and update gdb's idea of their current values.
-*/
+ */
static void
procfs_fetch_registers (regno)
{
supply_gregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs);
#if defined (FP0_REGNUM)
- supply_fpregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs);
+ supply_fpregset (&pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs);
#endif
}
#else /* UNIXWARE */
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- proc_init_failed - called when /proc access initialization fails
-fails
+ proc_init_failed - called when /proc access initialization fails
+ fails
-SYNOPSIS
+ SYNOPSIS
- static void proc_init_failed (struct procinfo *pi,
- char *why, int kill_p)
+ static void proc_init_failed (struct procinfo *pi,
+ char *why, int kill_p)
-DESCRIPTION
+ DESCRIPTION
- This function is called whenever initialization of access to a /proc
- entry fails. It prints a suitable error message, does some cleanup,
- and then invokes the standard error processing routine which dumps
- us back into the command loop. If KILL_P is true, sends SIGKILL.
+ This function is called whenever initialization of access to a /proc
+ entry fails. It prints a suitable error message, does some cleanup,
+ and then invokes the standard error processing routine which dumps
+ us back into the command loop. If KILL_P is true, sends SIGKILL.
*/
static void
proc_init_failed (pi, why, kill_p)
struct procinfo *pi;
char *why;
- int kill_p;
+ int kill_p;
{
print_sys_errmsg (pi->pathname, errno);
if (kill_p)
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- close_proc_file - close any currently open /proc entry
+ close_proc_file - close any currently open /proc entry
-SYNOPSIS
+ SYNOPSIS
- static void close_proc_file (struct procinfo *pip)
+ static void close_proc_file (struct procinfo *pip)
-DESCRIPTION
+ DESCRIPTION
- Close any currently open /proc entry and mark the process information
- entry as invalid. In order to ensure that we don't try to reuse any
- stale information, the pid, fd, and pathnames are explicitly
- invalidated, which may be overkill.
+ Close any currently open /proc entry and mark the process information
+ entry as invalid. In order to ensure that we don't try to reuse any
+ stale information, the pid, fd, and pathnames are explicitly
+ invalidated, which may be overkill.
*/
close (pip->map_fd);
#endif
- free (pip -> pathname);
+ free (pip->pathname);
/* Unlink pip from the procinfo chain. Note pip might not be on the list. */
else
{
for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
- {
- if (procinfo->next == pip)
+ {
+ if (procinfo->next == pip)
{
procinfo->next = pip->next;
break;
}
- }
+ }
free (pip);
}
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- open_proc_file - open a /proc entry for a given process id
+ open_proc_file - open a /proc entry for a given process id
-SYNOPSIS
+ SYNOPSIS
- static int open_proc_file (int pid, struct procinfo *pip, int mode)
+ static int open_proc_file (int pid, struct procinfo *pip, int mode)
-DESCRIPTION
+ DESCRIPTION
- Given a process id and a mode, close the existing open /proc
- entry (if any) and open one for the new process id, in the
- specified mode. Once it is open, then mark the local process
- information structure as valid, which guarantees that the pid,
- fd, and pathname fields match an open /proc entry. Returns
- zero if the open fails, nonzero otherwise.
+ Given a process id and a mode, close the existing open /proc
+ entry (if any) and open one for the new process id, in the
+ specified mode. Once it is open, then mark the local process
+ information structure as valid, which guarantees that the pid,
+ fd, and pathname fields match an open /proc entry. Returns
+ zero if the open fails, nonzero otherwise.
- Note that the pathname is left intact, even when the open fails,
- so that callers can use it to construct meaningful error messages
- rather than just "file open failed".
+ Note that the pathname is left intact, even when the open fails,
+ so that callers can use it to construct meaningful error messages
+ rather than just "file open failed".
- Note that for Solaris, the process-id also includes an LWP-id, so we
- actually attempt to open that. If we are handed a pid with a 0 LWP-id,
- then we will ask the kernel what it is and add it to the pid. Hence,
- the pid can be changed by us.
+ Note that for Solaris, the process-id also includes an LWP-id, so we
+ actually attempt to open that. If we are handed a pid with a 0 LWP-id,
+ then we will ask the kernel what it is and add it to the pid. Hence,
+ the pid can be changed by us.
*/
static int
{
int tmp, tmpfd;
- pip -> next = NULL;
- pip -> had_event = 0;
- pip -> pathname = xmalloc (MAX_PROC_NAME_SIZE);
- pip -> pid = pid;
+ pip->next = NULL;
+ pip->had_event = 0;
+ pip->pathname = xmalloc (MAX_PROC_NAME_SIZE);
+ pip->pid = pid;
#ifndef PIOCOPENLWP
tmp = pid;
if ((pip->ctl_fd = open (pip->pathname, O_WRONLY)) < 0)
{
close (pip->status_fd);
- close (pip->as_fd);
- close (pip->map_fd);
- return 0;
- }
+ close (pip->as_fd);
+ close (pip->map_fd);
+ return 0;
+ }
}
#else /* HAVE_MULTIPLE_PROC_FDS */
- sprintf (pip -> pathname, CTL_PROC_NAME_FMT, tmp);
+ sprintf (pip->pathname, CTL_PROC_NAME_FMT, tmp);
- if ((tmpfd = open (pip -> pathname, mode)) < 0)
+ if ((tmpfd = open (pip->pathname, mode)) < 0)
return 0;
#ifndef PIOCOPENLWP
- pip -> ctl_fd = tmpfd;
- pip -> as_fd = tmpfd;
- pip -> map_fd = tmpfd;
- pip -> status_fd = tmpfd;
+ pip->ctl_fd = tmpfd;
+ pip->as_fd = tmpfd;
+ pip->map_fd = tmpfd;
+ pip->status_fd = tmpfd;
#else
tmp = (pid >> 16) & 0xffff; /* Extract thread id */
if (tmp == 0)
{ /* Don't know thread id yet */
- if (ioctl (tmpfd, PIOCSTATUS, &pip -> prstatus) < 0)
+ if (ioctl (tmpfd, PIOCSTATUS, &pip->prstatus) < 0)
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
close (tmpfd);
error ("open_proc_file: PIOCSTATUS failed");
}
- tmp = pip -> prstatus.pr_who; /* Get thread id from prstatus_t */
- pip -> pid = (tmp << 16) | pid; /* Update pip */
+ tmp = pip->prstatus.pr_who; /* Get thread id from prstatus_t */
+ pip->pid = (tmp << 16) | pid; /* Update pip */
}
- if ((pip -> ctl_fd = ioctl (tmpfd, PIOCOPENLWP, &tmp)) < 0)
+ if ((pip->ctl_fd = ioctl (tmpfd, PIOCOPENLWP, &tmp)) < 0)
{
close (tmpfd);
return 0;
#ifdef PIOCSET /* New method */
{
- long pr_flags;
- pr_flags = PR_ASYNC;
- ioctl (pip -> ctl_fd, PIOCSET, &pr_flags);
+ long pr_flags;
+ pr_flags = PR_ASYNC;
+ ioctl (pip->ctl_fd, PIOCSET, &pr_flags);
}
#endif
pip->status_fd = pip->ctl_fd;
close (tmpfd); /* All done with main pid */
-#endif /* PIOCOPENLWP */
+#endif /* PIOCOPENLWP */
#endif /* HAVE_MULTIPLE_PROC_FDS */
long flags;
{
static char asciiflags[8];
-
+
strcpy (asciiflags, "-------");
#if defined (MA_PHYS)
- if (flags & MA_PHYS) asciiflags[0] = 'd';
-#endif
- if (flags & MA_STACK) asciiflags[1] = 's';
- if (flags & MA_BREAK) asciiflags[2] = 'b';
- if (flags & MA_SHARED) asciiflags[3] = 's';
- if (flags & MA_READ) asciiflags[4] = 'r';
- if (flags & MA_WRITE) asciiflags[5] = 'w';
- if (flags & MA_EXEC) asciiflags[6] = 'x';
+ if (flags & MA_PHYS)
+ asciiflags[0] = 'd';
+#endif
+ if (flags & MA_STACK)
+ asciiflags[1] = 's';
+ if (flags & MA_BREAK)
+ asciiflags[2] = 'b';
+ if (flags & MA_SHARED)
+ asciiflags[3] = 's';
+ if (flags & MA_READ)
+ asciiflags[4] = 'r';
+ if (flags & MA_WRITE)
+ asciiflags[5] = 'w';
+ if (flags & MA_EXEC)
+ asciiflags[6] = 'x';
return (asciiflags);
}
{
printf_filtered ("\n\n");
}
- for (transp = pr_flag_table; transp -> name != NULL; transp++)
+ for (transp = pr_flag_table; transp->name != NULL; transp++)
{
- if (flags & transp -> value)
+ if (flags & transp->value)
{
if (summary)
{
- printf_filtered ("%s ", transp -> name);
+ printf_filtered ("%s ", transp->name);
}
else
{
- printf_filtered ("\t%-16s %s.\n", transp -> name, transp -> desc);
+ printf_filtered ("\t%-16s %s.\n", transp->name, transp->desc);
}
}
}
int why;
int what;
- why = THE_PR_LWP(pip->prstatus).pr_why;
- what = THE_PR_LWP(pip->prstatus).pr_what;
+ why = THE_PR_LWP (pip->prstatus).pr_why;
+ what = THE_PR_LWP (pip->prstatus).pr_what;
- if (THE_PR_LWP(pip->prstatus).pr_flags & PR_STOPPED)
+ if (THE_PR_LWP (pip->prstatus).pr_flags & PR_STOPPED)
{
printf_filtered ("%-32s", "Reason for stopping:");
if (!summary)
{
printf_filtered ("\n\n");
}
- for (transp = pr_why_table; transp -> name != NULL; transp++)
+ for (transp = pr_why_table; transp->name != NULL; transp++)
{
- if (why == transp -> value)
+ if (why == transp->value)
{
if (summary)
{
- printf_filtered ("%s ", transp -> name);
+ printf_filtered ("%s ", transp->name);
}
else
{
printf_filtered ("\t%-16s %s.\n",
- transp -> name, transp -> desc);
+ transp->name, transp->desc);
}
break;
}
}
-
+
/* Use the pr_why field to determine what the pr_what field means, and
- print more information. */
-
+ print more information. */
+
switch (why)
{
- case PR_REQUESTED:
- /* pr_what is unused for this case */
- break;
- case PR_JOBCONTROL:
- case PR_SIGNALLED:
- if (summary)
- {
- printf_filtered ("%s ", signalname (what));
- }
- else
- {
- printf_filtered ("\t%-16s %s.\n", signalname (what),
- safe_strsignal (what));
- }
- break;
- case PR_SYSENTRY:
- if (summary)
- {
- printf_filtered ("%s ", syscallname (what));
- }
- else
- {
- printf_filtered ("\t%-16s %s.\n", syscallname (what),
- "Entered this system call");
- }
- break;
- case PR_SYSEXIT:
- if (summary)
- {
- printf_filtered ("%s ", syscallname (what));
- }
- else
- {
- printf_filtered ("\t%-16s %s.\n", syscallname (what),
- "Returned from this system call");
- }
- break;
- case PR_FAULTED:
- if (summary)
- {
- printf_filtered ("%s ",
- lookupname (faults_table, what, "fault"));
- }
- else
- {
- printf_filtered ("\t%-16s %s.\n",
- lookupname (faults_table, what, "fault"),
- lookupdesc (faults_table, what));
- }
- break;
- }
+ case PR_REQUESTED:
+ /* pr_what is unused for this case */
+ break;
+ case PR_JOBCONTROL:
+ case PR_SIGNALLED:
+ if (summary)
+ {
+ printf_filtered ("%s ", signalname (what));
+ }
+ else
+ {
+ printf_filtered ("\t%-16s %s.\n", signalname (what),
+ safe_strsignal (what));
+ }
+ break;
+ case PR_SYSENTRY:
+ if (summary)
+ {
+ printf_filtered ("%s ", syscallname (what));
+ }
+ else
+ {
+ printf_filtered ("\t%-16s %s.\n", syscallname (what),
+ "Entered this system call");
+ }
+ break;
+ case PR_SYSEXIT:
+ if (summary)
+ {
+ printf_filtered ("%s ", syscallname (what));
+ }
+ else
+ {
+ printf_filtered ("\t%-16s %s.\n", syscallname (what),
+ "Returned from this system call");
+ }
+ break;
+ case PR_FAULTED:
+ if (summary)
+ {
+ printf_filtered ("%s ",
+ lookupname (faults_table, what, "fault"));
+ }
+ else
+ {
+ printf_filtered ("\t%-16s %s.\n",
+ lookupname (faults_table, what, "fault"),
+ lookupdesc (faults_table, what));
+ }
+ break;
+ }
printf_filtered ("\n");
}
}
{
struct siginfo *sip;
- if ((THE_PR_LWP(pip->prstatus).pr_flags & PR_STOPPED) &&
- (THE_PR_LWP(pip->prstatus).pr_why == PR_SIGNALLED ||
- THE_PR_LWP(pip->prstatus).pr_why == PR_FAULTED))
+ if ((THE_PR_LWP (pip->prstatus).pr_flags & PR_STOPPED) &&
+ (THE_PR_LWP (pip->prstatus).pr_why == PR_SIGNALLED ||
+ THE_PR_LWP (pip->prstatus).pr_why == PR_FAULTED))
{
printf_filtered ("%-32s", "Additional signal/fault info:");
- sip = &(THE_PR_LWP(pip->prstatus).pr_info);
+ sip = &(THE_PR_LWP (pip->prstatus).pr_info);
if (summary)
{
- printf_filtered ("%s ", signalname (sip -> si_signo));
- if (sip -> si_errno > 0)
+ printf_filtered ("%s ", signalname (sip->si_signo));
+ if (sip->si_errno > 0)
{
- printf_filtered ("%s ", errnoname (sip -> si_errno));
+ printf_filtered ("%s ", errnoname (sip->si_errno));
}
- if (sip -> si_code <= 0)
+ if (sip->si_code <= 0)
{
printf_filtered ("sent by %s, uid %d ",
- target_pid_to_str (sip -> si_pid),
- sip -> si_uid);
+ target_pid_to_str (sip->si_pid),
+ sip->si_uid);
}
else
{
printf_filtered ("%s ", sigcodename (sip));
- if ((sip -> si_signo == SIGILL) ||
- (sip -> si_signo == SIGFPE) ||
- (sip -> si_signo == SIGSEGV) ||
- (sip -> si_signo == SIGBUS))
+ if ((sip->si_signo == SIGILL) ||
+ (sip->si_signo == SIGFPE) ||
+ (sip->si_signo == SIGSEGV) ||
+ (sip->si_signo == SIGBUS))
{
printf_filtered ("addr=%#lx ",
- (unsigned long) sip -> si_addr);
+ (unsigned long) sip->si_addr);
}
- else if ((sip -> si_signo == SIGCHLD))
+ else if ((sip->si_signo == SIGCHLD))
{
printf_filtered ("child %s, status %u ",
- target_pid_to_str (sip -> si_pid),
- sip -> si_status);
+ target_pid_to_str (sip->si_pid),
+ sip->si_status);
}
- else if ((sip -> si_signo == SIGPOLL))
+ else if ((sip->si_signo == SIGPOLL))
{
- printf_filtered ("band %u ", sip -> si_band);
+ printf_filtered ("band %u ", sip->si_band);
}
}
}
else
{
printf_filtered ("\n\n");
- printf_filtered ("\t%-16s %s.\n", signalname (sip -> si_signo),
- safe_strsignal (sip -> si_signo));
- if (sip -> si_errno > 0)
+ printf_filtered ("\t%-16s %s.\n", signalname (sip->si_signo),
+ safe_strsignal (sip->si_signo));
+ if (sip->si_errno > 0)
{
printf_filtered ("\t%-16s %s.\n",
- errnoname (sip -> si_errno),
- safe_strerror (sip -> si_errno));
+ errnoname (sip->si_errno),
+ safe_strerror (sip->si_errno));
}
- if (sip -> si_code <= 0)
+ if (sip->si_code <= 0)
{
- printf_filtered ("\t%-16u %s\n", sip -> si_pid, /* XXX need target_pid_to_str() */
+ printf_filtered ("\t%-16u %s\n", sip->si_pid, /* XXX need target_pid_to_str() */
"PID of process sending signal");
- printf_filtered ("\t%-16u %s\n", sip -> si_uid,
+ printf_filtered ("\t%-16u %s\n", sip->si_uid,
"UID of process sending signal");
}
else
{
printf_filtered ("\t%-16s %s.\n", sigcodename (sip),
sigcodedesc (sip));
- if ((sip -> si_signo == SIGILL) ||
- (sip -> si_signo == SIGFPE))
+ if ((sip->si_signo == SIGILL) ||
+ (sip->si_signo == SIGFPE))
{
printf_filtered ("\t%#-16lx %s.\n",
- (unsigned long) sip -> si_addr,
+ (unsigned long) sip->si_addr,
"Address of faulting instruction");
}
- else if ((sip -> si_signo == SIGSEGV) ||
- (sip -> si_signo == SIGBUS))
+ else if ((sip->si_signo == SIGSEGV) ||
+ (sip->si_signo == SIGBUS))
{
printf_filtered ("\t%#-16lx %s.\n",
- (unsigned long) sip -> si_addr,
+ (unsigned long) sip->si_addr,
"Address of faulting memory reference");
}
- else if ((sip -> si_signo == SIGCHLD))
+ else if ((sip->si_signo == SIGCHLD))
{
- printf_filtered ("\t%-16u %s.\n", sip -> si_pid, /* XXX need target_pid_to_str() */
+ printf_filtered ("\t%-16u %s.\n", sip->si_pid, /* XXX need target_pid_to_str() */
"Child process ID");
- printf_filtered ("\t%-16u %s.\n", sip -> si_status,
+ printf_filtered ("\t%-16u %s.\n", sip->si_status,
"Child process exit value or signal");
}
- else if ((sip -> si_signo == SIGPOLL))
+ else if ((sip->si_signo == SIGPOLL))
{
- printf_filtered ("\t%-16u %s.\n", sip -> si_band,
+ printf_filtered ("\t%-16u %s.\n", sip->si_band,
"Band event for POLL_{IN,OUT,MSG}");
}
}
if (!summary)
{
-#if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
- if (pip -> prstatus.pr_flags & PR_ASLEEP)
+#if 0 /* FIXME: Needs to use gdb-wide configured info about system calls. */
+ if (pip->prstatus.pr_flags & PR_ASLEEP)
{
- int syscallnum = pip -> prstatus.pr_reg[R_D0];
+ int syscallnum = pip->prstatus.pr_reg[R_D0];
if (summary)
{
printf_filtered ("%-32s", "Sleeping in system call:");
#endif
#ifndef UNIXWARE
- if (ioctl (pip -> ctl_fd, PIOCGENTRY, &pip -> entryset) < 0)
+ if (ioctl (pip->ctl_fd, PIOCGENTRY, &pip->entryset) < 0)
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
error ("PIOCGENTRY failed");
}
-
- if (ioctl (pip -> ctl_fd, PIOCGEXIT, &pip -> exitset) < 0)
+
+ if (ioctl (pip->ctl_fd, PIOCGEXIT, &pip->exitset) < 0)
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
error ("PIOCGEXIT failed");
}
#endif
-
+
printf_filtered ("System call tracing information:\n\n");
-
+
printf_filtered ("\t%-12s %-8s %-8s\n",
"System call",
"Entry",
#ifdef UNIXWARE
printf_filtered ("%-8s ",
- prismember (&pip->prstatus.pr_sysentry, syscallnum)
+ prismember (&pip->prstatus.pr_sysentry, syscallnum)
? "on" : "off");
printf_filtered ("%-8s ",
prismember (&pip->prstatus.pr_sysexit, syscallnum)
? "on" : "off");
#else
printf_filtered ("%-8s ",
- prismember (&pip -> entryset, syscallnum)
+ prismember (&pip->entryset, syscallnum)
? "on" : "off");
printf_filtered ("%-8s ",
- prismember (&pip -> exitset, syscallnum)
+ prismember (&pip->exitset, syscallnum)
? "on" : "off");
#endif
printf_filtered ("\n");
if (!summary)
{
#ifndef PROCFS_USE_READ_WRITE
- if (ioctl (pip -> ctl_fd, PIOCGTRACE, &pip -> trace) < 0)
+ if (ioctl (pip->ctl_fd, PIOCGTRACE, &pip->trace) < 0)
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
error ("PIOCGTRACE failed");
}
#endif
-
+
printf_filtered ("Disposition of signals:\n\n");
printf_filtered ("\t%-15s %-8s %-8s %-8s %s\n\n",
"Signal", "Trace", "Hold", "Pending", "Description");
printf_filtered ("\t%-15s ", signalname (signo));
#ifdef UNIXWARE
printf_filtered ("%-8s ",
- prismember (&pip -> prstatus.pr_sigtrace, signo)
+ prismember (&pip->prstatus.pr_sigtrace, signo)
? "on" : "off");
printf_filtered ("%-8s ",
- prismember (&pip -> prstatus.pr_lwp.pr_context.uc_sigmask, signo)
+ prismember (&pip->prstatus.pr_lwp.pr_context.uc_sigmask, signo)
? "on" : "off");
#else
printf_filtered ("%-8s ",
- prismember (&pip -> trace, signo)
+ prismember (&pip->trace, signo)
? "on" : "off");
printf_filtered ("%-8s ",
- prismember (&pip -> prstatus.pr_sighold, signo)
+ prismember (&pip->prstatus.pr_sighold, signo)
? "on" : "off");
#endif
#ifdef UNIXWARE
if (prismember (&pip->prstatus.pr_sigpend, signo) ||
- prismember (&pip->prstatus.pr_lwp.pr_lwppend, signo))
- printf_filtered("%-8s ", "yes");
+ prismember (&pip->prstatus.pr_lwp.pr_lwppend, signo))
+ printf_filtered ("%-8s ", "yes");
else
- printf_filtered("%-8s ", "no");
+ printf_filtered ("%-8s ", "no");
#else /* UNIXWARE */
#ifdef PROCFS_SIGPEND_OFFSET
/* Alpha OSF/1 numbers the pending signals from 1. */
printf_filtered ("%-8s ",
- (signo ? prismember (&pip -> prstatus.pr_sigpend,
+ (signo ? prismember (&pip->prstatus.pr_sigpend,
signo - 1)
- : 0)
+ : 0)
? "yes" : "no");
#else
printf_filtered ("%-8s ",
- prismember (&pip -> prstatus.pr_sigpend, signo)
+ prismember (&pip->prstatus.pr_sigpend, signo)
? "yes" : "no");
#endif
#endif /* UNIXWARE */
if (!summary)
{
#ifndef UNIXWARE
- if (ioctl (pip -> ctl_fd, PIOCGFAULT, &pip->fltset.fltset) < 0)
+ if (ioctl (pip->ctl_fd, PIOCGFAULT, &pip->fltset.fltset) < 0)
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
error ("PIOCGFAULT failed");
}
#endif
-
+
printf_filtered ("Current traced hardware fault set:\n\n");
printf_filtered ("\t%-12s %-8s\n", "Fault", "Trace");
- for (transp = faults_table; transp -> name != NULL; transp++)
+ for (transp = faults_table; transp->name != NULL; transp++)
{
QUIT;
- printf_filtered ("\t%-12s ", transp -> name);
+ printf_filtered ("\t%-12s ", transp->name);
#ifdef UNIXWARE
- printf_filtered ("%-8s", prismember (&pip->prstatus.pr_flttrace, transp -> value)
+ printf_filtered ("%-8s", prismember (&pip->prstatus.pr_flttrace, transp->value)
? "on" : "off");
#else
- printf_filtered ("%-8s", prismember (&pip->fltset.fltset, transp -> value)
+ printf_filtered ("%-8s", prismember (&pip->fltset.fltset, transp->value)
? "on" : "off");
#endif
printf_filtered ("\n");
"Flags");
#ifdef PROCFS_USE_READ_WRITE
if (fstat (pip->map_fd, &sbuf) == 0)
- {
- nmap = sbuf.st_size / sizeof (prmap_t);
+ {
+ nmap = sbuf.st_size / sizeof (prmap_t);
prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
- if ((lseek (pip->map_fd, 0, SEEK_SET) == 0) &&
- (read (pip->map_fd, (char *) prmaps,
- nmap * sizeof (*prmaps)) == (nmap * sizeof (*prmaps))))
+ if ((lseek (pip->map_fd, 0, SEEK_SET) == 0) &&
+ (read (pip->map_fd, (char *) prmaps,
+ nmap * sizeof (*prmaps)) == (nmap * sizeof (*prmaps))))
{
int i = 0;
for (prmap = prmaps; i < nmap; ++prmap, ++i)
#else
- if (ioctl (pip -> ctl_fd, PIOCNMAP, &nmap) == 0)
+ if (ioctl (pip->ctl_fd, PIOCNMAP, &nmap) == 0)
{
prmaps = (struct prmap *) alloca ((nmap + 1) * sizeof (*prmaps));
- if (ioctl (pip -> ctl_fd, PIOCMAP, prmaps) == 0)
+ if (ioctl (pip->ctl_fd, PIOCMAP, prmaps) == 0)
{
- for (prmap = prmaps; prmap -> pr_size; ++prmap)
+ for (prmap = prmaps; prmap->pr_size; ++prmap)
#endif /* PROCFS_USE_READ_WRITE */
{
#ifdef BFD_HOST_64_BIT
#else
printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
#endif
- (unsigned long)prmap -> pr_vaddr,
- (unsigned long)prmap -> pr_vaddr
- + prmap -> pr_size - 1,
- prmap -> pr_size,
- prmap -> pr_off,
- mappingflags (prmap -> pr_mflags));
+ (unsigned long) prmap->pr_vaddr,
+ (unsigned long) prmap->pr_vaddr
+ + prmap->pr_size - 1,
+ prmap->pr_size,
+ prmap->pr_off,
+ mappingflags (prmap->pr_mflags));
}
}
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- info_proc -- implement the "info proc" command
+ info_proc -- implement the "info proc" command
-SYNOPSIS
+ SYNOPSIS
- void info_proc (char *args, int from_tty)
+ void info_proc (char *args, int from_tty)
-DESCRIPTION
+ DESCRIPTION
- Implement gdb's "info proc" command by using the /proc interface
- to print status information about any currently running process.
+ Implement gdb's "info proc" command by using the /proc interface
+ to print status information about any currently running process.
- Examples of the use of "info proc" are:
+ Examples of the use of "info proc" are:
- info proc (prints summary info for current inferior)
- info proc 123 (prints summary info for process with pid 123)
- info proc mappings (prints address mappings)
- info proc times (prints process/children times)
- info proc id (prints pid, ppid, gid, sid, etc)
- FIXME: i proc id not implemented.
- info proc status (prints general process state info)
- FIXME: i proc status not implemented.
- info proc signals (prints info about signal handling)
- info proc all (prints all info)
+ info proc (prints summary info for current inferior)
+ info proc 123 (prints summary info for process with pid 123)
+ info proc mappings (prints address mappings)
+ info proc times (prints process/children times)
+ info proc id (prints pid, ppid, gid, sid, etc)
+ FIXME: i proc id not implemented.
+ info proc status (prints general process state info)
+ FIXME: i proc status not implemented.
+ info proc signals (prints info about signal handling)
+ info proc all (prints all info)
*/
/* Default to using the current inferior if no pid specified. Note
that inferior_pid may be 0, hence we set okerr. */
- pid = inferior_pid & 0x7fffffff; /* strip off sol-thread bit */
- if (!(pip = find_procinfo (pid, 1))) /* inferior_pid no good? */
- pip = procinfo_list; /* take first available */
- pid = pid & 0xffff; /* extract "real" pid */
+ pid = inferior_pid & 0x7fffffff; /* strip off sol-thread bit */
+ if (!(pip = find_procinfo (pid, 1))) /* inferior_pid no good? */
+ pip = procinfo_list; /* take first available */
+ pid = pid & 0xffff; /* extract "real" pid */
if (args != NULL)
{
pip->pid = pid;
if (!open_proc_file (pid, pip, O_RDONLY, 0))
{
- perror_with_name (pip -> pathname);
+ perror_with_name (pip->pathname);
/* NOTREACHED */
}
pid = pip->pid;
if (!procfs_read_status (pip))
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
error ("procfs_read_status failed");
}
if (ioctl (pip->ctl_fd, PIOCLWPIDS, lwps))
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
error ("PIOCLWPIDS failed");
}
#else /* PIOCLWPIDS */
if (!procfs_read_status (pip))
{
- print_sys_errmsg (pip -> pathname, errno);
+ print_sys_errmsg (pip->pathname, errno);
error ("procfs_read_status failed");
}
}
#endif /* PROCFS_USE_READ_WRITE */
/* Print verbose information of the requested type(s), or just a summary
- of the information for all types. */
+ of the information for all types. */
- printf_filtered ("\nInformation for %s.%d:\n\n", pip -> pathname, *lwps);
+ printf_filtered ("\nInformation for %s.%d:\n\n", pip->pathname, *lwps);
if (summary || all || flags)
{
info_proc_flags (pip, summary);
printf_filtered ("\n");
/* All done, deal with closing any temporary process info structure,
- freeing temporary memory , etc. */
+ freeing temporary memory , etc. */
do_cleanups (old_chain);
#ifndef PROCFS_USE_READ_WRITE
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- modify_inherit_on_fork_flag - Change the inherit-on-fork flag
+ modify_inherit_on_fork_flag - Change the inherit-on-fork flag
-SYNOPSIS
+ SYNOPSIS
- void modify_inherit_on_fork_flag (fd, flag)
+ void modify_inherit_on_fork_flag (fd, flag)
-DESCRIPTION
+ DESCRIPTION
- Call this routine to modify the inherit-on-fork flag. This routine is
- just a nice wrapper to hide the #ifdefs needed by various systems to
- control this flag.
+ Call this routine to modify the inherit-on-fork flag. This routine is
+ just a nice wrapper to hide the #ifdefs needed by various systems to
+ control this flag.
*/
pctl.cmd = PCSET;
pctl.data = PR_FORK;
if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
- retval = -1;
+ retval = -1;
#else
retval = ioctl (fd, PIOCSET, &pr_flags);
#endif
pctl.cmd = PCRESET;
pctl.data = PR_FORK;
if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
- retval = -1;
+ retval = -1;
#else
retval = ioctl (fd, PIOCRESET, &pr_flags);
#endif
retval = ioctl (fd, PIOCRFORK, NULL);
}
#else
- Neither PR_FORK nor PIOCSFORK exist!!!
+ Neither PR_FORK nor PIOCSFORK exist ! !!
#endif
#endif
if (!retval)
- return;
+ return;
print_sys_errmsg ("modify_inherit_on_fork_flag", errno);
error ("PIOCSFORK or PR_FORK modification failed");
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- modify_run_on_last_close_flag - Change the run-on-last-close flag
+ modify_run_on_last_close_flag - Change the run-on-last-close flag
-SYNOPSIS
+ SYNOPSIS
- void modify_run_on_last_close_flag (fd, flag)
+ void modify_run_on_last_close_flag (fd, flag)
-DESCRIPTION
+ DESCRIPTION
- Call this routine to modify the run-on-last-close flag. This routine
- is just a nice wrapper to hide the #ifdefs needed by various systems to
- control this flag.
+ Call this routine to modify the run-on-last-close flag. This routine
+ is just a nice wrapper to hide the #ifdefs needed by various systems to
+ control this flag.
*/
pctl.cmd = PCSET;
pctl.data = PR_RLC;
if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
- retval = -1;
+ retval = -1;
#else
retval = ioctl (fd, PIOCSET, &pr_flags);
#endif
pctl.cmd = PCRESET;
pctl.data = PR_RLC;
if (write (fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
- retval = -1;
+ retval = -1;
#else
retval = ioctl (fd, PIOCRESET, &pr_flags);
#endif
else
retval = ioctl (fd, PIOCRRLC, NULL);
#else
- Neither PR_RLC nor PIOCSRLC exist!!!
+ Neither PR_RLC nor PIOCSRLC exist ! !!
#endif
#endif
if (!retval)
- return;
+ return;
print_sys_errmsg ("modify_run_on_last_close_flag", errno);
error ("PIOCSRLC or PR_RLC modification failed");
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_clear_syscall_trap -- Deletes the trap for the specified system call.
+ procfs_clear_syscall_trap -- Deletes the trap for the specified system call.
-SYNOPSIS
+ SYNOPSIS
- void procfs_clear_syscall_trap (struct procinfo *, int syscall_num, int errok)
+ void procfs_clear_syscall_trap (struct procinfo *, int syscall_num, int errok)
-DESCRIPTION
+ DESCRIPTION
- This function function disables traps for the specified system call.
- errok is non-zero if errors should be ignored.
+ This function function disables traps for the specified system call.
+ errok is non-zero if errors should be ignored.
*/
static void
pi->syscall_handlers = xrealloc (pi->syscall_handlers,
(pi->num_syscall_handlers - 1)
- * sizeof (struct procfs_syscall_handler));
+ * sizeof (struct procfs_syscall_handler));
pi->num_syscall_handlers--;
return;
}
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_set_syscall_trap -- arrange for a function to be called when the
- child executes the specified system call.
+ procfs_set_syscall_trap -- arrange for a function to be called when the
+ child executes the specified system call.
-SYNOPSIS
+ SYNOPSIS
- void procfs_set_syscall_trap (struct procinfo *, int syscall_num, int flags,
- syscall_func_t *function)
+ void procfs_set_syscall_trap (struct procinfo *, int syscall_num, int flags,
+ syscall_func_t *function)
-DESCRIPTION
+ DESCRIPTION
- This function sets up an entry and/or exit trap for the specified system
- call. When the child executes the specified system call, your function
- will be called with the call #, a flag that indicates entry or exit, and
- pointers to rtnval and statval (which are used by procfs_wait). The
- function should return non-zero if something interesting happened, zero
- otherwise.
+ This function sets up an entry and/or exit trap for the specified system
+ call. When the child executes the specified system call, your function
+ will be called with the call #, a flag that indicates entry or exit, and
+ pointers to rtnval and statval (which are used by procfs_wait). The
+ function should return non-zero if something interesting happened, zero
+ otherwise.
*/
static void
}
pi->syscall_handlers = xrealloc (pi->syscall_handlers, (i + 1)
- * sizeof (struct procfs_syscall_handler));
+ * sizeof (struct procfs_syscall_handler));
pi->syscall_handlers[i].syscall_num = syscall_num;
pi->syscall_handlers[i].func = func;
pi->num_syscall_handlers++;
/*
-LOCAL FUNCTION
+ LOCAL FUNCTION
- procfs_lwp_creation_handler - handle exit from the _lwp_create syscall
+ procfs_lwp_creation_handler - handle exit from the _lwp_create syscall
-SYNOPSIS
+ SYNOPSIS
- int procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ int procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
-DESCRIPTION
+ DESCRIPTION
- This routine is called both when an inferior process and it's new lwp
- are about to finish a _lwp_create() system call. This is the system
- call that Solaris uses to create a lightweight process. When the
- target process gets this event, we can look at sysarg[2] to find the
- new childs lwp ID, and create a procinfo struct from that. After that,
- we pretend that we got a SIGTRAP, and return non-zero to tell
- procfs_wait to wake up. Subsequently, wait_for_inferior gets woken up,
- sees the new process and continues it.
+ This routine is called both when an inferior process and it's new lwp
+ are about to finish a _lwp_create() system call. This is the system
+ call that Solaris uses to create a lightweight process. When the
+ target process gets this event, we can look at sysarg[2] to find the
+ new childs lwp ID, and create a procinfo struct from that. After that,
+ we pretend that we got a SIGTRAP, and return non-zero to tell
+ procfs_wait to wake up. Subsequently, wait_for_inferior gets woken up,
+ sees the new process and continues it.
- When we see the child exiting from lwp_create, we just contine it,
- since everything was handled when the parent trapped.
+ When we see the child exiting from lwp_create, we just contine it,
+ since everything was handled when the parent trapped.
-NOTES
- In effect, we are only paying attention to the parent's completion of
- the lwp_create syscall. If we only paid attention to the child
- instead, then we wouldn't detect the creation of a suspended thread.
+ NOTES
+ In effect, we are only paying attention to the parent's completion of
+ the lwp_create syscall. If we only paid attention to the child
+ instead, then we wouldn't detect the creation of a suspended thread.
*/
static int
#ifdef UNIXWARE
/* Joel ... can you check this logic out please? JKJ */
if (pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs[R_EFL] & 1)
- { /* _lwp_create failed */
+ { /* _lwp_create failed */
pctl.cmd = PCRUN;
pctl.data = PRCFAULT;
if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
- perror_with_name (pi->pathname);
+ perror_with_name (pi->pathname);
return 0;
}
pctl.cmd = PCRUN;
pctl.data = PRCFAULT;
- if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
+ if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
#else /* !UNIXWARE */
pi->prrun.pr_flags &= PRSTEP;
pi->prrun.pr_flags |= PRCFAULT;
/* Third arg is pointer to new thread id. */
lwp_id = read_memory_integer (
- THE_PR_LWP(pi->prstatus).pr_sysarg[2], sizeof (int));
+ THE_PR_LWP (pi->prstatus).pr_sysarg[2], sizeof (int));
lwp_id = (lwp_id << 16) | PIDGET (pi->pid);
pctl.cmd = PCRUN;
pctl.data = PRCFAULT;
- if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
+ if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
#else
pi->prrun.pr_flags &= PRSTEP;
pi->prrun.pr_flags |= PRCFAULT;
SUSPENDED or RUNNABLE. If runnable, we will simply signal it to run.
If suspended, we flag it to be continued later, when it has an event. */
- if (THE_PR_LWP(childpi->prstatus).pr_why == PR_SUSPENDED)
+ if (THE_PR_LWP (childpi->prstatus).pr_why == PR_SUSPENDED)
childpi->new_child = 1; /* Flag this as an unseen child process */
else
{
pctl.cmd = PCRUN;
pctl.data = PRCFAULT;
- if (write(pi->ctl_fd, (char *)&pctl, sizeof (struct proc_ctl)) < 0)
+ if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0)
#else
childpi->prrun.pr_flags &= PRSTEP;
childpi->prrun.pr_flags |= PRCFAULT;
{
/* We will be looking down the PATH to find shell_file. If we
- just do this the normal way (via execlp, which operates by
- attempting an exec for each element of the PATH until it
- finds one which succeeds), then there will be an exec for
- each failed attempt, each of which will cause a PR_SYSEXIT
- stop, and we won't know how to distinguish the PR_SYSEXIT's
- for these failed execs with the ones for successful execs
- (whether the exec has succeeded is stored at that time in the
- carry bit or some such architecture-specific and
- non-ABI-specified place).
-
- So I can't think of anything better than to search the PATH
- now. This has several disadvantages: (1) There is a race
- condition; if we find a file now and it is deleted before we
- exec it, we lose, even if the deletion leaves a valid file
- further down in the PATH, (2) there is no way to know exactly
- what an executable (in the sense of "capable of being
- exec'd") file is. Using access() loses because it may lose
- if the caller is the superuser; failing to use it loses if
- there are ACLs or some such. */
+ just do this the normal way (via execlp, which operates by
+ attempting an exec for each element of the PATH until it
+ finds one which succeeds), then there will be an exec for
+ each failed attempt, each of which will cause a PR_SYSEXIT
+ stop, and we won't know how to distinguish the PR_SYSEXIT's
+ for these failed execs with the ones for successful execs
+ (whether the exec has succeeded is stored at that time in the
+ carry bit or some such architecture-specific and
+ non-ABI-specified place).
+
+ So I can't think of anything better than to search the PATH
+ now. This has several disadvantages: (1) There is a race
+ condition; if we find a file now and it is deleted before we
+ exec it, we lose, even if the deletion leaves a valid file
+ further down in the PATH, (2) there is no way to know exactly
+ what an executable (in the sense of "capable of being
+ exec'd") file is. Using access() loses because it may lose
+ if the caller is the superuser; failing to use it loses if
+ there are ACLs or some such. */
char *p;
char *p1;
/* FIXME-maybe: might want "set path" command so user can change what
- path is used from within GDB. */
+ path is used from within GDB. */
char *path = getenv ("PATH");
int len;
struct stat statbuf;
path = "/bin:/usr/bin";
tryname = alloca (strlen (path) + strlen (shell_file) + 2);
- for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
+ for (p = path; p != NULL; p = p1 ? p1 + 1 : NULL)
{
p1 = strchr (p, ':');
if (p1 != NULL)
/* We are at the first instruction we care about. */
/* Pedal to the metal... */
- proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
+ proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
}
/* Clean up after the inferior dies. */
\f
/* Insert a watchpoint */
int
-procfs_set_watchpoint(pid, addr, len, rw)
- int pid;
- CORE_ADDR addr;
- int len;
- int rw;
+procfs_set_watchpoint (pid, addr, len, rw)
+ int pid;
+ CORE_ADDR addr;
+ int len;
+ int rw;
{
- struct procinfo *pi;
- prwatch_t wpt;
+ struct procinfo *pi;
+ prwatch_t wpt;
pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
- wpt.pr_vaddr = (caddr_t)addr;
+ wpt.pr_vaddr = (caddr_t) addr;
wpt.pr_size = len;
wpt.pr_wflags = ((rw & 1) ? MA_READ : 0) | ((rw & 2) ? MA_WRITE : 0);
if (ioctl (pi->ctl_fd, PIOCSWATCH, &wpt) < 0)
if (errno == E2BIG)
return -1;
/* Currently it sometimes happens that the same watchpoint gets
- deleted twice - don't die in this case (FIXME please) */
+ deleted twice - don't die in this case (FIXME please) */
if (errno == ESRCH && len == 0)
return 0;
print_sys_errmsg (pi->pathname, errno);
}
int
-procfs_stopped_by_watchpoint(pid)
- int pid;
+procfs_stopped_by_watchpoint (pid)
+ int pid;
{
- struct procinfo *pi;
- short what;
- short why;
+ struct procinfo *pi;
+ short what;
+ short why;
pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0);
if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
{
why = pi->prstatus.pr_why;
what = pi->prstatus.pr_what;
- if (why == PR_FAULTED
+ if (why == PR_FAULTED
#if defined (FLTWATCH) && defined (FLTKWATCH)
&& (what == FLTWATCH || what == FLTKWATCH)
#else
#ifdef FLTWATCH
- && (what == FLTWATCH)
+ && (what == FLTWATCH)
#endif
#ifdef FLTKWATCH
&& (what == FLTKWATCH)
#endif
#endif
- )
+ )
return what;
}
return 0;
for (pi = procinfo_list; pi; pi = next_pi)
{
next_pi = pi->next;
- if (pi -> pid == pid)
+ if (pi->pid == pid)
if (procfs_read_status (pi)) /* alive */
return 1;
- else /* defunct (exited) */
+ else
+ /* defunct (exited) */
{
close_proc_file (pi);
return 0;
return buf;
}
#endif /* TIDGET */
-
\f
+
static void
init_procfs_ops ()
{
init_procfs_ops ();
add_target (&procfs_ops);
- add_info ("processes", info_proc,
-"Show process status information using /proc entry.\n\
+ add_info ("processes", info_proc,
+ "Show process status information using /proc entry.\n\
Specify process id or use current inferior by default.\n\
Specify keywords for detailed information; default is summary.\n\
Keywords are: `all', `faults', `flags', `id', `mappings', `signals',\n\
projects / thirdparty / binutils-gdb.git / blobdiff