/* Machine independent support for SVR4 /proc (process file system) for GDB.
|
/* Machine independent support for SVR4 /proc (process file system) for GDB.
|
Copyright 1999 Free Software Foundation, Inc.
|
Copyright 1999 Free Software Foundation, Inc.
|
Written by Michael Snyder at Cygnus Solutions.
|
Written by Michael Snyder at Cygnus Solutions.
|
Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
|
Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 2 of the License, or
|
the Free Software Foundation; either version 2 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software Foundation,
|
along with this program; if not, write to the Free Software Foundation,
|
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "target.h"
|
#include "target.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "gdbthread.h"
|
#include "gdbthread.h"
|
|
|
#if defined (NEW_PROC_API)
|
#if defined (NEW_PROC_API)
|
#define _STRUCTURED_PROC 1 /* Should be done by configure script. */
|
#define _STRUCTURED_PROC 1 /* Should be done by configure script. */
|
#endif
|
#endif
|
|
|
#include <sys/procfs.h>
|
#include <sys/procfs.h>
|
#include <sys/fault.h>
|
#include <sys/fault.h>
|
#include <sys/syscall.h>
|
#include <sys/syscall.h>
|
#include <sys/errno.h>
|
#include <sys/errno.h>
|
#include <sys/wait.h>
|
#include <sys/wait.h>
|
#include <signal.h>
|
#include <signal.h>
|
#include <ctype.h>
|
#include <ctype.h>
|
|
|
#include "proc-utils.h"
|
#include "proc-utils.h"
|
|
|
/*
|
/*
|
* PROCFS.C
|
* PROCFS.C
|
*
|
*
|
* This module provides the interface between GDB and the
|
* This module provides the interface between GDB and the
|
* /proc file system, which is used on many versions of Unix
|
* /proc file system, which is used on many versions of Unix
|
* as a means for debuggers to control other processes.
|
* as a means for debuggers to control other processes.
|
* Examples of the systems that use this interface are:
|
* Examples of the systems that use this interface are:
|
* Irix
|
* Irix
|
* Solaris
|
* Solaris
|
* OSF
|
* OSF
|
* Unixware
|
* Unixware
|
*
|
*
|
* /proc works by immitating a file system: you open a simulated file
|
* /proc works by immitating a file system: you open a simulated file
|
* that represents the process you wish to interact with, and
|
* that represents the process you wish to interact with, and
|
* perform operations on that "file" in order to examine or change
|
* perform operations on that "file" in order to examine or change
|
* the state of the other process.
|
* the state of the other process.
|
*
|
*
|
* The most important thing to know about /proc and this module
|
* The most important thing to know about /proc and this module
|
* is that there are two very different interfaces to /proc:
|
* is that there are two very different interfaces to /proc:
|
* One that uses the ioctl system call, and
|
* One that uses the ioctl system call, and
|
* another that uses read and write system calls.
|
* another that uses read and write system calls.
|
* This module has to support both /proc interfaces. This means
|
* This module has to support both /proc interfaces. This means
|
* that there are two different ways of doing every basic operation.
|
* that there are two different ways of doing every basic operation.
|
*
|
*
|
* In order to keep most of the code simple and clean, I have
|
* In order to keep most of the code simple and clean, I have
|
* defined an interface "layer" which hides all these system calls.
|
* defined an interface "layer" which hides all these system calls.
|
* An ifdef (NEW_PROC_API) determines which interface we are using,
|
* An ifdef (NEW_PROC_API) determines which interface we are using,
|
* and most or all occurrances of this ifdef should be confined to
|
* and most or all occurrances of this ifdef should be confined to
|
* this interface layer.
|
* this interface layer.
|
*/
|
*/
|
|
|
|
|
/* Determine which /proc API we are using:
|
/* Determine which /proc API we are using:
|
The ioctl API defines PIOCSTATUS, while
|
The ioctl API defines PIOCSTATUS, while
|
the read/write (multiple fd) API never does. */
|
the read/write (multiple fd) API never does. */
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include <dirent.h> /* opendir/readdir, for listing the LWP's */
|
#include <dirent.h> /* opendir/readdir, for listing the LWP's */
|
#endif
|
#endif
|
|
|
#include <fcntl.h> /* for O_RDONLY */
|
#include <fcntl.h> /* for O_RDONLY */
|
#include <unistd.h> /* for "X_OK" */
|
#include <unistd.h> /* for "X_OK" */
|
#include "gdb_stat.h" /* for struct stat */
|
#include "gdb_stat.h" /* for struct stat */
|
|
|
/* =================== TARGET_OPS "MODULE" =================== */
|
/* =================== TARGET_OPS "MODULE" =================== */
|
|
|
/*
|
/*
|
* This module defines the GDB target vector and its methods.
|
* This module defines the GDB target vector and its methods.
|
*/
|
*/
|
|
|
static void procfs_open PARAMS((char *, int));
|
static void procfs_open PARAMS((char *, int));
|
static void procfs_attach PARAMS ((char *, int));
|
static void procfs_attach PARAMS ((char *, int));
|
static void procfs_detach PARAMS ((char *, int));
|
static void procfs_detach PARAMS ((char *, int));
|
static void procfs_resume PARAMS ((int, int, enum target_signal));
|
static void procfs_resume PARAMS ((int, int, enum target_signal));
|
static int procfs_can_run PARAMS ((void));
|
static int procfs_can_run PARAMS ((void));
|
static void procfs_stop PARAMS ((void));
|
static void procfs_stop PARAMS ((void));
|
static void procfs_files_info PARAMS ((struct target_ops *));
|
static void procfs_files_info PARAMS ((struct target_ops *));
|
static void procfs_fetch_registers PARAMS ((int));
|
static void procfs_fetch_registers PARAMS ((int));
|
static void procfs_store_registers PARAMS ((int));
|
static void procfs_store_registers PARAMS ((int));
|
static void procfs_notice_signals PARAMS ((int));
|
static void procfs_notice_signals PARAMS ((int));
|
static void procfs_prepare_to_store PARAMS ((void));
|
static void procfs_prepare_to_store PARAMS ((void));
|
static void procfs_kill_inferior PARAMS ((void));
|
static void procfs_kill_inferior PARAMS ((void));
|
static void procfs_mourn_inferior PARAMS ((void));
|
static void procfs_mourn_inferior PARAMS ((void));
|
static void procfs_create_inferior PARAMS ((char *, char *, char **));
|
static void procfs_create_inferior PARAMS ((char *, char *, char **));
|
static int procfs_wait PARAMS ((int,
|
static int procfs_wait PARAMS ((int,
|
struct target_waitstatus *));
|
struct target_waitstatus *));
|
static int procfs_xfer_memory PARAMS ((CORE_ADDR,
|
static int procfs_xfer_memory PARAMS ((CORE_ADDR,
|
char *, int, int,
|
char *, int, int,
|
struct target_ops *));
|
struct target_ops *));
|
|
|
static int procfs_thread_alive PARAMS ((int));
|
static int procfs_thread_alive PARAMS ((int));
|
|
|
void procfs_find_new_threads PARAMS ((void));
|
void procfs_find_new_threads PARAMS ((void));
|
char *procfs_pid_to_str PARAMS ((int));
|
char *procfs_pid_to_str PARAMS ((int));
|
|
|
struct target_ops procfs_ops; /* the target vector */
|
struct target_ops procfs_ops; /* the target vector */
|
|
|
static void
|
static void
|
init_procfs_ops ()
|
init_procfs_ops ()
|
{
|
{
|
procfs_ops.to_shortname = "procfs";
|
procfs_ops.to_shortname = "procfs";
|
procfs_ops.to_longname = "Unix /proc child process";
|
procfs_ops.to_longname = "Unix /proc child process";
|
procfs_ops.to_doc =
|
procfs_ops.to_doc =
|
"Unix /proc child process (started by the \"run\" command).";
|
"Unix /proc child process (started by the \"run\" command).";
|
procfs_ops.to_open = procfs_open;
|
procfs_ops.to_open = procfs_open;
|
procfs_ops.to_can_run = procfs_can_run;
|
procfs_ops.to_can_run = procfs_can_run;
|
procfs_ops.to_create_inferior = procfs_create_inferior;
|
procfs_ops.to_create_inferior = procfs_create_inferior;
|
procfs_ops.to_kill = procfs_kill_inferior;
|
procfs_ops.to_kill = procfs_kill_inferior;
|
procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
|
procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
|
procfs_ops.to_attach = procfs_attach;
|
procfs_ops.to_attach = procfs_attach;
|
procfs_ops.to_detach = procfs_detach;
|
procfs_ops.to_detach = procfs_detach;
|
procfs_ops.to_wait = procfs_wait;
|
procfs_ops.to_wait = procfs_wait;
|
procfs_ops.to_resume = procfs_resume;
|
procfs_ops.to_resume = procfs_resume;
|
procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
|
procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
|
procfs_ops.to_fetch_registers = procfs_fetch_registers;
|
procfs_ops.to_fetch_registers = procfs_fetch_registers;
|
procfs_ops.to_store_registers = procfs_store_registers;
|
procfs_ops.to_store_registers = procfs_store_registers;
|
procfs_ops.to_xfer_memory = procfs_xfer_memory;
|
procfs_ops.to_xfer_memory = procfs_xfer_memory;
|
procfs_ops.to_insert_breakpoint = memory_insert_breakpoint;
|
procfs_ops.to_insert_breakpoint = memory_insert_breakpoint;
|
procfs_ops.to_remove_breakpoint = memory_remove_breakpoint;
|
procfs_ops.to_remove_breakpoint = memory_remove_breakpoint;
|
procfs_ops.to_notice_signals = procfs_notice_signals;
|
procfs_ops.to_notice_signals = procfs_notice_signals;
|
procfs_ops.to_files_info = procfs_files_info;
|
procfs_ops.to_files_info = procfs_files_info;
|
procfs_ops.to_stop = procfs_stop;
|
procfs_ops.to_stop = procfs_stop;
|
|
|
procfs_ops.to_terminal_init = terminal_init_inferior;
|
procfs_ops.to_terminal_init = terminal_init_inferior;
|
procfs_ops.to_terminal_inferior = terminal_inferior;
|
procfs_ops.to_terminal_inferior = terminal_inferior;
|
procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
|
procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
|
procfs_ops.to_terminal_ours = terminal_ours;
|
procfs_ops.to_terminal_ours = terminal_ours;
|
procfs_ops.to_terminal_info = child_terminal_info;
|
procfs_ops.to_terminal_info = child_terminal_info;
|
|
|
procfs_ops.to_find_new_threads = procfs_find_new_threads;
|
procfs_ops.to_find_new_threads = procfs_find_new_threads;
|
procfs_ops.to_thread_alive = procfs_thread_alive;
|
procfs_ops.to_thread_alive = procfs_thread_alive;
|
procfs_ops.to_pid_to_str = procfs_pid_to_str;
|
procfs_ops.to_pid_to_str = procfs_pid_to_str;
|
|
|
procfs_ops.to_has_all_memory = 1;
|
procfs_ops.to_has_all_memory = 1;
|
procfs_ops.to_has_memory = 1;
|
procfs_ops.to_has_memory = 1;
|
procfs_ops.to_has_execution = 1;
|
procfs_ops.to_has_execution = 1;
|
procfs_ops.to_has_stack = 1;
|
procfs_ops.to_has_stack = 1;
|
procfs_ops.to_has_registers = 1;
|
procfs_ops.to_has_registers = 1;
|
procfs_ops.to_stratum = process_stratum;
|
procfs_ops.to_stratum = process_stratum;
|
procfs_ops.to_has_thread_control = tc_schedlock;
|
procfs_ops.to_has_thread_control = tc_schedlock;
|
procfs_ops.to_magic = OPS_MAGIC;
|
procfs_ops.to_magic = OPS_MAGIC;
|
}
|
}
|
|
|
/* =================== END, TARGET_OPS "MODULE" =================== */
|
/* =================== END, TARGET_OPS "MODULE" =================== */
|
|
|
/*
|
/*
|
* Temporary debugging code:
|
* Temporary debugging code:
|
*
|
*
|
* These macros allow me to trace the system calls that we make
|
* These macros allow me to trace the system calls that we make
|
* to control the child process. This is quite handy for comparing
|
* to control the child process. This is quite handy for comparing
|
* with the older version of procfs.
|
* with the older version of procfs.
|
*/
|
*/
|
|
|
#ifdef TRACE_PROCFS
|
#ifdef TRACE_PROCFS
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
extern int write_with_trace PARAMS ((int, void *, size_t, char *, int));
|
extern int write_with_trace PARAMS ((int, void *, size_t, char *, int));
|
extern off_t lseek_with_trace PARAMS ((int, off_t, int, char *, int));
|
extern off_t lseek_with_trace PARAMS ((int, off_t, int, char *, int));
|
#define write(X,Y,Z) write_with_trace (X, Y, Z, __FILE__, __LINE__)
|
#define write(X,Y,Z) write_with_trace (X, Y, Z, __FILE__, __LINE__)
|
#define lseek(X,Y,Z) lseek_with_trace (X, Y, Z, __FILE__, __LINE__)
|
#define lseek(X,Y,Z) lseek_with_trace (X, Y, Z, __FILE__, __LINE__)
|
#else
|
#else
|
extern int ioctl_with_trace PARAMS ((int, long, void *, char *, int));
|
extern int ioctl_with_trace PARAMS ((int, long, void *, char *, int));
|
#define ioctl(X,Y,Z) ioctl_with_trace (X, Y, Z, __FILE__, __LINE__)
|
#define ioctl(X,Y,Z) ioctl_with_trace (X, Y, Z, __FILE__, __LINE__)
|
#endif
|
#endif
|
#define open(X,Y) open_with_trace (X, Y, __FILE__, __LINE__)
|
#define open(X,Y) open_with_trace (X, Y, __FILE__, __LINE__)
|
#define close(X) close_with_trace (X, __FILE__, __LINE__)
|
#define close(X) close_with_trace (X, __FILE__, __LINE__)
|
#define wait(X) wait_with_trace (X, __FILE__, __LINE__)
|
#define wait(X) wait_with_trace (X, __FILE__, __LINE__)
|
#define PROCFS_NOTE(X) procfs_note (X, __FILE__, __LINE__)
|
#define PROCFS_NOTE(X) procfs_note (X, __FILE__, __LINE__)
|
#define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T) \
|
#define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T) \
|
proc_prettyfprint_status (X, Y, Z, T)
|
proc_prettyfprint_status (X, Y, Z, T)
|
#else
|
#else
|
#define PROCFS_NOTE(X)
|
#define PROCFS_NOTE(X)
|
#define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T)
|
#define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T)
|
#endif
|
#endif
|
|
|
|
|
/*
|
/*
|
* World Unification:
|
* World Unification:
|
*
|
*
|
* Put any typedefs, defines etc. here that are required for
|
* Put any typedefs, defines etc. here that are required for
|
* the unification of code that handles different versions of /proc.
|
* the unification of code that handles different versions of /proc.
|
*/
|
*/
|
|
|
#ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
|
#ifdef NEW_PROC_API /* Solaris 7 && 8 method for watchpoints */
|
#ifndef UNIXWARE
|
#ifndef UNIXWARE
|
enum { READ_WATCHFLAG = WA_READ,
|
enum { READ_WATCHFLAG = WA_READ,
|
WRITE_WATCHFLAG = WA_WRITE,
|
WRITE_WATCHFLAG = WA_WRITE,
|
EXEC_WATCHFLAG = WA_EXEC,
|
EXEC_WATCHFLAG = WA_EXEC,
|
AFTER_WATCHFLAG = WA_TRAPAFTER
|
AFTER_WATCHFLAG = WA_TRAPAFTER
|
};
|
};
|
#endif
|
#endif
|
#else /* Irix method for watchpoints */
|
#else /* Irix method for watchpoints */
|
enum { READ_WATCHFLAG = MA_READ,
|
enum { READ_WATCHFLAG = MA_READ,
|
WRITE_WATCHFLAG = MA_WRITE,
|
WRITE_WATCHFLAG = MA_WRITE,
|
EXEC_WATCHFLAG = MA_EXEC,
|
EXEC_WATCHFLAG = MA_EXEC,
|
AFTER_WATCHFLAG = 0 /* trapafter not implemented */
|
AFTER_WATCHFLAG = 0 /* trapafter not implemented */
|
};
|
};
|
#endif
|
#endif
|
|
|
|
|
|
|
|
|
/* =================== STRUCT PROCINFO "MODULE" =================== */
|
/* =================== STRUCT PROCINFO "MODULE" =================== */
|
|
|
/* FIXME: this comment will soon be out of date W.R.T. threads. */
|
/* FIXME: this comment will soon be out of date W.R.T. threads. */
|
|
|
/* The procinfo struct is a wrapper to hold all the state information
|
/* The procinfo struct is a wrapper to hold all the state information
|
concerning a /proc process. There should be exactly one procinfo
|
concerning a /proc process. There should be exactly one procinfo
|
for each process, and since GDB currently can debug only one
|
for each process, and since GDB currently can debug only one
|
process at a time, that means there should be only one procinfo.
|
process at a time, that means there should be only one procinfo.
|
All of the LWP's of a process can be accessed indirectly thru the
|
All of the LWP's of a process can be accessed indirectly thru the
|
single process procinfo.
|
single process procinfo.
|
|
|
However, against the day when GDB may debug more than one process,
|
However, against the day when GDB may debug more than one process,
|
this data structure is kept in a list (which for now will hold no
|
this data structure is kept in a list (which for now will hold no
|
more than one member), and many functions will have a pointer to a
|
more than one member), and many functions will have a pointer to a
|
procinfo as an argument.
|
procinfo as an argument.
|
|
|
There will be a separate procinfo structure for use by the (not yet
|
There will be a separate procinfo structure for use by the (not yet
|
implemented) "info proc" command, so that we can print useful
|
implemented) "info proc" command, so that we can print useful
|
information about any random process without interfering with the
|
information about any random process without interfering with the
|
inferior's procinfo information. */
|
inferior's procinfo information. */
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
/* format strings for /proc paths */
|
/* format strings for /proc paths */
|
# ifndef CTL_PROC_NAME_FMT
|
# ifndef CTL_PROC_NAME_FMT
|
# define MAIN_PROC_NAME_FMT "/proc/%d"
|
# define MAIN_PROC_NAME_FMT "/proc/%d"
|
# define CTL_PROC_NAME_FMT "/proc/%d/ctl"
|
# define CTL_PROC_NAME_FMT "/proc/%d/ctl"
|
# define AS_PROC_NAME_FMT "/proc/%d/as"
|
# define AS_PROC_NAME_FMT "/proc/%d/as"
|
# define MAP_PROC_NAME_FMT "/proc/%d/map"
|
# define MAP_PROC_NAME_FMT "/proc/%d/map"
|
# define STATUS_PROC_NAME_FMT "/proc/%d/status"
|
# define STATUS_PROC_NAME_FMT "/proc/%d/status"
|
# define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
|
# define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")
|
# endif
|
# endif
|
/* the name of the proc status struct depends on the implementation */
|
/* the name of the proc status struct depends on the implementation */
|
typedef pstatus_t gdb_prstatus_t;
|
typedef pstatus_t gdb_prstatus_t;
|
typedef lwpstatus_t gdb_lwpstatus_t;
|
typedef lwpstatus_t gdb_lwpstatus_t;
|
#else /* ! NEW_PROC_API */
|
#else /* ! NEW_PROC_API */
|
/* format strings for /proc paths */
|
/* format strings for /proc paths */
|
# ifndef CTL_PROC_NAME_FMT
|
# ifndef CTL_PROC_NAME_FMT
|
# define MAIN_PROC_NAME_FMT "/proc/%05d"
|
# define MAIN_PROC_NAME_FMT "/proc/%05d"
|
# define CTL_PROC_NAME_FMT "/proc/%05d"
|
# define CTL_PROC_NAME_FMT "/proc/%05d"
|
# define AS_PROC_NAME_FMT "/proc/%05d"
|
# define AS_PROC_NAME_FMT "/proc/%05d"
|
# define MAP_PROC_NAME_FMT "/proc/%05d"
|
# define MAP_PROC_NAME_FMT "/proc/%05d"
|
# define STATUS_PROC_NAME_FMT "/proc/%05d"
|
# define STATUS_PROC_NAME_FMT "/proc/%05d"
|
# define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
|
# define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")
|
# endif
|
# endif
|
/* the name of the proc status struct depends on the implementation */
|
/* the name of the proc status struct depends on the implementation */
|
typedef prstatus_t gdb_prstatus_t;
|
typedef prstatus_t gdb_prstatus_t;
|
typedef prstatus_t gdb_lwpstatus_t;
|
typedef prstatus_t gdb_lwpstatus_t;
|
#endif /* NEW_PROC_API */
|
#endif /* NEW_PROC_API */
|
|
|
|
|
/* These #ifdefs are for sol2.x in particular. sol2.x has
|
/* These #ifdefs are for sol2.x in particular. sol2.x has
|
both a "gregset_t" and a "prgregset_t", which have
|
both a "gregset_t" and a "prgregset_t", which have
|
similar uses but different layouts. sol2.x gdb tries to
|
similar uses but different layouts. sol2.x gdb tries to
|
use prgregset_t (and prfpregset_t) everywhere. */
|
use prgregset_t (and prfpregset_t) everywhere. */
|
|
|
#ifdef GDB_GREGSET_TYPE
|
#ifdef GDB_GREGSET_TYPE
|
typedef GDB_GREGSET_TYPE gdb_gregset_t;
|
typedef GDB_GREGSET_TYPE gdb_gregset_t;
|
#else
|
#else
|
typedef gregset_t gdb_gregset_t;
|
typedef gregset_t gdb_gregset_t;
|
#endif
|
#endif
|
|
|
#ifdef GDB_FPREGSET_TYPE
|
#ifdef GDB_FPREGSET_TYPE
|
typedef GDB_FPREGSET_TYPE gdb_fpregset_t;
|
typedef GDB_FPREGSET_TYPE gdb_fpregset_t;
|
#else
|
#else
|
typedef fpregset_t gdb_fpregset_t;
|
typedef fpregset_t gdb_fpregset_t;
|
#endif
|
#endif
|
|
|
/* Provide default composite pid manipulation macros for systems that
|
/* Provide default composite pid manipulation macros for systems that
|
don't have threads. */
|
don't have threads. */
|
|
|
#ifndef PIDGET
|
#ifndef PIDGET
|
#define PIDGET(PID) (PID)
|
#define PIDGET(PID) (PID)
|
#define TIDGET(PID) (PID)
|
#define TIDGET(PID) (PID)
|
#endif
|
#endif
|
#ifndef MERGEPID
|
#ifndef MERGEPID
|
#define MERGEPID(PID, TID) (PID)
|
#define MERGEPID(PID, TID) (PID)
|
#endif
|
#endif
|
|
|
typedef struct procinfo {
|
typedef struct procinfo {
|
struct procinfo *next;
|
struct procinfo *next;
|
int pid; /* Process ID */
|
int pid; /* Process ID */
|
int tid; /* Thread/LWP id */
|
int tid; /* Thread/LWP id */
|
|
|
/* process state */
|
/* process state */
|
int was_stopped;
|
int was_stopped;
|
int ignore_next_sigstop;
|
int ignore_next_sigstop;
|
|
|
/* The following four fd fields may be identical, or may contain
|
/* The following four fd fields may be identical, or may contain
|
several different fd's, depending on the version of /proc
|
several different fd's, depending on the version of /proc
|
(old ioctl or new read/write). */
|
(old ioctl or new read/write). */
|
|
|
int ctl_fd; /* File descriptor for /proc control file */
|
int ctl_fd; /* File descriptor for /proc control file */
|
/*
|
/*
|
* The next three file descriptors are actually only needed in the
|
* The next three file descriptors are actually only needed in the
|
* read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
|
* read/write, multiple-file-descriptor implemenation (NEW_PROC_API).
|
* However, to avoid a bunch of #ifdefs in the code, we will use
|
* However, to avoid a bunch of #ifdefs in the code, we will use
|
* them uniformly by (in the case of the ioctl single-file-descriptor
|
* them uniformly by (in the case of the ioctl single-file-descriptor
|
* implementation) filling them with copies of the control fd.
|
* implementation) filling them with copies of the control fd.
|
*/
|
*/
|
int status_fd; /* File descriptor for /proc status file */
|
int status_fd; /* File descriptor for /proc status file */
|
int as_fd; /* File descriptor for /proc as file */
|
int as_fd; /* File descriptor for /proc as file */
|
|
|
char pathname[MAX_PROC_NAME_SIZE]; /* Pathname to /proc entry */
|
char pathname[MAX_PROC_NAME_SIZE]; /* Pathname to /proc entry */
|
|
|
fltset_t saved_fltset; /* Saved traced hardware fault set */
|
fltset_t saved_fltset; /* Saved traced hardware fault set */
|
sigset_t saved_sigset; /* Saved traced signal set */
|
sigset_t saved_sigset; /* Saved traced signal set */
|
sigset_t saved_sighold; /* Saved held signal set */
|
sigset_t saved_sighold; /* Saved held signal set */
|
sysset_t saved_exitset; /* Saved traced system call exit set */
|
sysset_t saved_exitset; /* Saved traced system call exit set */
|
sysset_t saved_entryset; /* Saved traced system call entry set */
|
sysset_t saved_entryset; /* Saved traced system call entry set */
|
|
|
gdb_prstatus_t prstatus; /* Current process status info */
|
gdb_prstatus_t prstatus; /* Current process status info */
|
|
|
#ifndef NEW_PROC_API
|
#ifndef NEW_PROC_API
|
gdb_fpregset_t fpregset; /* Current floating point registers */
|
gdb_fpregset_t fpregset; /* Current floating point registers */
|
#endif
|
#endif
|
|
|
struct procinfo *thread_list;
|
struct procinfo *thread_list;
|
|
|
int status_valid : 1;
|
int status_valid : 1;
|
int gregs_valid : 1;
|
int gregs_valid : 1;
|
int fpregs_valid : 1;
|
int fpregs_valid : 1;
|
int threads_valid: 1;
|
int threads_valid: 1;
|
} procinfo;
|
} procinfo;
|
|
|
static char errmsg[128]; /* shared error msg buffer */
|
static char errmsg[128]; /* shared error msg buffer */
|
|
|
/* Function prototypes for procinfo module: */
|
/* Function prototypes for procinfo module: */
|
|
|
static procinfo *find_procinfo_or_die PARAMS ((int pid, int tid));
|
static procinfo *find_procinfo_or_die PARAMS ((int pid, int tid));
|
static procinfo *find_procinfo PARAMS ((int pid, int tid));
|
static procinfo *find_procinfo PARAMS ((int pid, int tid));
|
static procinfo *create_procinfo PARAMS ((int pid, int tid));
|
static procinfo *create_procinfo PARAMS ((int pid, int tid));
|
static void destroy_procinfo PARAMS ((procinfo *p));
|
static void destroy_procinfo PARAMS ((procinfo *p));
|
static void dead_procinfo PARAMS ((procinfo *p,
|
static void dead_procinfo PARAMS ((procinfo *p,
|
char *msg, int killp));
|
char *msg, int killp));
|
static int open_procinfo_files PARAMS ((procinfo *p, int which));
|
static int open_procinfo_files PARAMS ((procinfo *p, int which));
|
static void close_procinfo_files PARAMS ((procinfo *p));
|
static void close_procinfo_files PARAMS ((procinfo *p));
|
|
|
/* The head of the procinfo list: */
|
/* The head of the procinfo list: */
|
static procinfo * procinfo_list;
|
static procinfo * procinfo_list;
|
|
|
/*
|
/*
|
* Function: find_procinfo
|
* Function: find_procinfo
|
*
|
*
|
* Search the procinfo list.
|
* Search the procinfo list.
|
*
|
*
|
* Returns: pointer to procinfo, or NULL if not found.
|
* Returns: pointer to procinfo, or NULL if not found.
|
*/
|
*/
|
|
|
static procinfo *
|
static procinfo *
|
find_procinfo (pid, tid)
|
find_procinfo (pid, tid)
|
int pid;
|
int pid;
|
int tid;
|
int tid;
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
|
|
for (pi = procinfo_list; pi; pi = pi->next)
|
for (pi = procinfo_list; pi; pi = pi->next)
|
if (pi->pid == pid)
|
if (pi->pid == pid)
|
break;
|
break;
|
|
|
if (pi)
|
if (pi)
|
if (tid)
|
if (tid)
|
{
|
{
|
/* Don't check threads_valid. If we're updating the
|
/* Don't check threads_valid. If we're updating the
|
thread_list, we want to find whatever threads are already
|
thread_list, we want to find whatever threads are already
|
here. This means that in general it is the caller's
|
here. This means that in general it is the caller's
|
responsibility to check threads_valid and update before
|
responsibility to check threads_valid and update before
|
calling find_procinfo, if the caller wants to find a new
|
calling find_procinfo, if the caller wants to find a new
|
thread. */
|
thread. */
|
|
|
for (pi = pi->thread_list; pi; pi = pi->next)
|
for (pi = pi->thread_list; pi; pi = pi->next)
|
if (pi->tid == tid)
|
if (pi->tid == tid)
|
break;
|
break;
|
}
|
}
|
|
|
return pi;
|
return pi;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: find_procinfo_or_die
|
* Function: find_procinfo_or_die
|
*
|
*
|
* Calls find_procinfo, but errors on failure.
|
* Calls find_procinfo, but errors on failure.
|
*/
|
*/
|
|
|
static procinfo *
|
static procinfo *
|
find_procinfo_or_die (pid, tid)
|
find_procinfo_or_die (pid, tid)
|
int pid;
|
int pid;
|
int tid;
|
int tid;
|
{
|
{
|
procinfo *pi = find_procinfo (pid, tid);
|
procinfo *pi = find_procinfo (pid, tid);
|
|
|
if (pi == NULL)
|
if (pi == NULL)
|
{
|
{
|
if (tid)
|
if (tid)
|
error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",
|
error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",
|
pid, tid);
|
pid, tid);
|
else
|
else
|
error ("procfs: couldn't find pid %d in procinfo list.", pid);
|
error ("procfs: couldn't find pid %d in procinfo list.", pid);
|
}
|
}
|
return pi;
|
return pi;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: open_procinfo_files
|
* Function: open_procinfo_files
|
*
|
*
|
* Open the file descriptor for the process or LWP.
|
* Open the file descriptor for the process or LWP.
|
* ifdef NEW_PROC_API, we only open the control file descriptor;
|
* ifdef NEW_PROC_API, we only open the control file descriptor;
|
* the others are opened lazily as needed.
|
* the others are opened lazily as needed.
|
* else (if not NEW_PROC_API), there is only one real
|
* else (if not NEW_PROC_API), there is only one real
|
* file descriptor, but we keep multiple copies of it so that
|
* file descriptor, but we keep multiple copies of it so that
|
* the code that uses them does not have to be #ifdef'd.
|
* the code that uses them does not have to be #ifdef'd.
|
*
|
*
|
* Return: file descriptor, or zero for failure.
|
* Return: file descriptor, or zero for failure.
|
*/
|
*/
|
|
|
enum { FD_CTL, FD_STATUS, FD_AS };
|
enum { FD_CTL, FD_STATUS, FD_AS };
|
|
|
static int
|
static int
|
open_procinfo_files (pi, which)
|
open_procinfo_files (pi, which)
|
procinfo *pi;
|
procinfo *pi;
|
int which;
|
int which;
|
{
|
{
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
char tmp[MAX_PROC_NAME_SIZE];
|
char tmp[MAX_PROC_NAME_SIZE];
|
#endif
|
#endif
|
int fd;
|
int fd;
|
|
|
/*
|
/*
|
* This function is getting ALMOST long enough to break up into several.
|
* This function is getting ALMOST long enough to break up into several.
|
* Here is some rationale:
|
* Here is some rationale:
|
*
|
*
|
* NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
|
* NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
|
* There are several file descriptors that may need to be open
|
* There are several file descriptors that may need to be open
|
* for any given process or LWP. The ones we're intereted in are:
|
* for any given process or LWP. The ones we're intereted in are:
|
* - control (ctl) write-only change the state
|
* - control (ctl) write-only change the state
|
* - status (status) read-only query the state
|
* - status (status) read-only query the state
|
* - address space (as) read/write access memory
|
* - address space (as) read/write access memory
|
* - map (map) read-only virtual addr map
|
* - map (map) read-only virtual addr map
|
* Most of these are opened lazily as they are needed.
|
* Most of these are opened lazily as they are needed.
|
* The pathnames for the 'files' for an LWP look slightly
|
* The pathnames for the 'files' for an LWP look slightly
|
* different from those of a first-class process:
|
* different from those of a first-class process:
|
* Pathnames for a process (<proc-id>):
|
* Pathnames for a process (<proc-id>):
|
* /proc/<proc-id>/ctl
|
* /proc/<proc-id>/ctl
|
* /proc/<proc-id>/status
|
* /proc/<proc-id>/status
|
* /proc/<proc-id>/as
|
* /proc/<proc-id>/as
|
* /proc/<proc-id>/map
|
* /proc/<proc-id>/map
|
* Pathnames for an LWP (lwp-id):
|
* Pathnames for an LWP (lwp-id):
|
* /proc/<proc-id>/lwp/<lwp-id>/lwpctl
|
* /proc/<proc-id>/lwp/<lwp-id>/lwpctl
|
* /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
|
* /proc/<proc-id>/lwp/<lwp-id>/lwpstatus
|
* An LWP has no map or address space file descriptor, since
|
* An LWP has no map or address space file descriptor, since
|
* the memory map and address space are shared by all LWPs.
|
* the memory map and address space are shared by all LWPs.
|
*
|
*
|
* Everyone else (Solaris 2.5, Irix, OSF)
|
* Everyone else (Solaris 2.5, Irix, OSF)
|
* There is only one file descriptor for each process or LWP.
|
* There is only one file descriptor for each process or LWP.
|
* For convenience, we copy the same file descriptor into all
|
* For convenience, we copy the same file descriptor into all
|
* three fields of the procinfo struct (ctl_fd, status_fd, and
|
* three fields of the procinfo struct (ctl_fd, status_fd, and
|
* as_fd, see NEW_PROC_API above) so that code that uses them
|
* as_fd, see NEW_PROC_API above) so that code that uses them
|
* doesn't need any #ifdef's.
|
* doesn't need any #ifdef's.
|
* Pathname for all:
|
* Pathname for all:
|
* /proc/<proc-id>
|
* /proc/<proc-id>
|
*
|
*
|
* Solaris 2.5 LWP's:
|
* Solaris 2.5 LWP's:
|
* Each LWP has an independent file descriptor, but these
|
* Each LWP has an independent file descriptor, but these
|
* are not obtained via the 'open' system call like the rest:
|
* are not obtained via the 'open' system call like the rest:
|
* instead, they're obtained thru an ioctl call (PIOCOPENLWP)
|
* instead, they're obtained thru an ioctl call (PIOCOPENLWP)
|
* to the file descriptor of the parent process.
|
* to the file descriptor of the parent process.
|
*
|
*
|
* OSF threads:
|
* OSF threads:
|
* These do not even have their own independent file descriptor.
|
* These do not even have their own independent file descriptor.
|
* All operations are carried out on the file descriptor of the
|
* All operations are carried out on the file descriptor of the
|
* parent process. Therefore we just call open again for each
|
* parent process. Therefore we just call open again for each
|
* thread, getting a new handle for the same 'file'.
|
* thread, getting a new handle for the same 'file'.
|
*/
|
*/
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
/*
|
/*
|
* In this case, there are several different file descriptors that
|
* In this case, there are several different file descriptors that
|
* we might be asked to open. The control file descriptor will be
|
* we might be asked to open. The control file descriptor will be
|
* opened early, but the others will be opened lazily as they are
|
* opened early, but the others will be opened lazily as they are
|
* needed.
|
* needed.
|
*/
|
*/
|
|
|
strcpy (tmp, pi->pathname);
|
strcpy (tmp, pi->pathname);
|
switch (which) { /* which file descriptor to open? */
|
switch (which) { /* which file descriptor to open? */
|
case FD_CTL:
|
case FD_CTL:
|
if (pi->tid)
|
if (pi->tid)
|
strcat (tmp, "/lwpctl");
|
strcat (tmp, "/lwpctl");
|
else
|
else
|
strcat (tmp, "/ctl");
|
strcat (tmp, "/ctl");
|
fd = open (tmp, O_WRONLY);
|
fd = open (tmp, O_WRONLY);
|
if (fd <= 0)
|
if (fd <= 0)
|
return 0; /* fail */
|
return 0; /* fail */
|
pi->ctl_fd = fd;
|
pi->ctl_fd = fd;
|
break;
|
break;
|
case FD_AS:
|
case FD_AS:
|
if (pi->tid)
|
if (pi->tid)
|
return 0; /* there is no 'as' file descriptor for an lwp */
|
return 0; /* there is no 'as' file descriptor for an lwp */
|
strcat (tmp, "/as");
|
strcat (tmp, "/as");
|
fd = open (tmp, O_RDWR);
|
fd = open (tmp, O_RDWR);
|
if (fd <= 0)
|
if (fd <= 0)
|
return 0; /* fail */
|
return 0; /* fail */
|
pi->as_fd = fd;
|
pi->as_fd = fd;
|
break;
|
break;
|
case FD_STATUS:
|
case FD_STATUS:
|
if (pi->tid)
|
if (pi->tid)
|
strcat (tmp, "/lwpstatus");
|
strcat (tmp, "/lwpstatus");
|
else
|
else
|
strcat (tmp, "/status");
|
strcat (tmp, "/status");
|
fd = open (tmp, O_RDONLY);
|
fd = open (tmp, O_RDONLY);
|
if (fd <= 0)
|
if (fd <= 0)
|
return 0; /* fail */
|
return 0; /* fail */
|
pi->status_fd = fd;
|
pi->status_fd = fd;
|
break;
|
break;
|
default:
|
default:
|
return 0; /* unknown file descriptor */
|
return 0; /* unknown file descriptor */
|
}
|
}
|
#else /* not NEW_PROC_API */
|
#else /* not NEW_PROC_API */
|
/*
|
/*
|
* In this case, there is only one file descriptor for each procinfo
|
* In this case, there is only one file descriptor for each procinfo
|
* (ie. each process or LWP). In fact, only the file descriptor for
|
* (ie. each process or LWP). In fact, only the file descriptor for
|
* the process can actually be opened by an 'open' system call.
|
* the process can actually be opened by an 'open' system call.
|
* The ones for the LWPs have to be obtained thru an IOCTL call
|
* The ones for the LWPs have to be obtained thru an IOCTL call
|
* on the process's file descriptor.
|
* on the process's file descriptor.
|
*
|
*
|
* For convenience, we copy each procinfo's single file descriptor
|
* For convenience, we copy each procinfo's single file descriptor
|
* into all of the fields occupied by the several file descriptors
|
* into all of the fields occupied by the several file descriptors
|
* of the NEW_PROC_API implementation. That way, the code that uses
|
* of the NEW_PROC_API implementation. That way, the code that uses
|
* them can be written without ifdefs.
|
* them can be written without ifdefs.
|
*/
|
*/
|
|
|
|
|
#ifdef PIOCTSTATUS /* OSF */
|
#ifdef PIOCTSTATUS /* OSF */
|
if ((fd = open (pi->pathname, O_RDWR)) == 0) /* Only one FD; just open it. */
|
if ((fd = open (pi->pathname, O_RDWR)) == 0) /* Only one FD; just open it. */
|
return 0;
|
return 0;
|
#else /* Sol 2.5, Irix, other? */
|
#else /* Sol 2.5, Irix, other? */
|
if (pi->tid == 0) /* Master procinfo for the process */
|
if (pi->tid == 0) /* Master procinfo for the process */
|
{
|
{
|
fd = open (pi->pathname, O_RDWR);
|
fd = open (pi->pathname, O_RDWR);
|
if (fd <= 0)
|
if (fd <= 0)
|
return 0; /* fail */
|
return 0; /* fail */
|
}
|
}
|
else /* LWP thread procinfo */
|
else /* LWP thread procinfo */
|
{
|
{
|
#ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
|
#ifdef PIOCOPENLWP /* Sol 2.5, thread/LWP */
|
procinfo *process;
|
procinfo *process;
|
int lwpid = pi->tid;
|
int lwpid = pi->tid;
|
|
|
/* Find the procinfo for the entire process. */
|
/* Find the procinfo for the entire process. */
|
if ((process = find_procinfo (pi->pid, 0)) == NULL)
|
if ((process = find_procinfo (pi->pid, 0)) == NULL)
|
return 0; /* fail */
|
return 0; /* fail */
|
|
|
/* Now obtain the file descriptor for the LWP. */
|
/* Now obtain the file descriptor for the LWP. */
|
if ((fd = ioctl (process->ctl_fd, PIOCOPENLWP, &lwpid)) <= 0)
|
if ((fd = ioctl (process->ctl_fd, PIOCOPENLWP, &lwpid)) <= 0)
|
return 0; /* fail */
|
return 0; /* fail */
|
#else /* Irix, other? */
|
#else /* Irix, other? */
|
return 0; /* Don't know how to open threads */
|
return 0; /* Don't know how to open threads */
|
#endif /* Sol 2.5 PIOCOPENLWP */
|
#endif /* Sol 2.5 PIOCOPENLWP */
|
}
|
}
|
#endif /* OSF PIOCTSTATUS */
|
#endif /* OSF PIOCTSTATUS */
|
pi->ctl_fd = pi->as_fd = pi->status_fd = fd;
|
pi->ctl_fd = pi->as_fd = pi->status_fd = fd;
|
#endif /* NEW_PROC_API */
|
#endif /* NEW_PROC_API */
|
|
|
return 1; /* success */
|
return 1; /* success */
|
}
|
}
|
|
|
/*
|
/*
|
* Function: create_procinfo
|
* Function: create_procinfo
|
*
|
*
|
* Allocate a data structure and link it into the procinfo list.
|
* Allocate a data structure and link it into the procinfo list.
|
* (First tries to find a pre-existing one (FIXME: why???)
|
* (First tries to find a pre-existing one (FIXME: why???)
|
*
|
*
|
* Return: pointer to new procinfo struct.
|
* Return: pointer to new procinfo struct.
|
*/
|
*/
|
|
|
static procinfo *
|
static procinfo *
|
create_procinfo (pid, tid)
|
create_procinfo (pid, tid)
|
int pid;
|
int pid;
|
int tid;
|
int tid;
|
{
|
{
|
procinfo *pi, *parent;
|
procinfo *pi, *parent;
|
|
|
if ((pi = find_procinfo (pid, tid)))
|
if ((pi = find_procinfo (pid, tid)))
|
return pi; /* Already exists, nothing to do. */
|
return pi; /* Already exists, nothing to do. */
|
|
|
/* find parent before doing malloc, to save having to cleanup */
|
/* find parent before doing malloc, to save having to cleanup */
|
if (tid != 0)
|
if (tid != 0)
|
parent = find_procinfo_or_die (pid, 0); /* FIXME: should I
|
parent = find_procinfo_or_die (pid, 0); /* FIXME: should I
|
create it if it
|
create it if it
|
doesn't exist yet? */
|
doesn't exist yet? */
|
|
|
pi = (procinfo *) xmalloc (sizeof (procinfo));
|
pi = (procinfo *) xmalloc (sizeof (procinfo));
|
memset (pi, 0, sizeof (procinfo));
|
memset (pi, 0, sizeof (procinfo));
|
pi->pid = pid;
|
pi->pid = pid;
|
pi->tid = tid;
|
pi->tid = tid;
|
|
|
/* Chain into list. */
|
/* Chain into list. */
|
if (tid == 0)
|
if (tid == 0)
|
{
|
{
|
sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
|
sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
|
pi->next = procinfo_list;
|
pi->next = procinfo_list;
|
procinfo_list = pi;
|
procinfo_list = pi;
|
}
|
}
|
else
|
else
|
{
|
{
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
sprintf (pi->pathname, "/proc/%05d/lwp/%d", pid, tid);
|
sprintf (pi->pathname, "/proc/%05d/lwp/%d", pid, tid);
|
#else
|
#else
|
sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
|
sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
|
#endif
|
#endif
|
pi->next = parent->thread_list;
|
pi->next = parent->thread_list;
|
parent->thread_list = pi;
|
parent->thread_list = pi;
|
}
|
}
|
return pi;
|
return pi;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: close_procinfo_files
|
* Function: close_procinfo_files
|
*
|
*
|
* Close all file descriptors associated with the procinfo
|
* Close all file descriptors associated with the procinfo
|
*/
|
*/
|
|
|
static void
|
static void
|
close_procinfo_files (pi)
|
close_procinfo_files (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (pi->ctl_fd > 0)
|
if (pi->ctl_fd > 0)
|
close (pi->ctl_fd);
|
close (pi->ctl_fd);
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (pi->as_fd > 0)
|
if (pi->as_fd > 0)
|
close (pi->as_fd);
|
close (pi->as_fd);
|
if (pi->status_fd > 0)
|
if (pi->status_fd > 0)
|
close (pi->status_fd);
|
close (pi->status_fd);
|
#endif
|
#endif
|
pi->ctl_fd = pi->as_fd = pi->status_fd = 0;
|
pi->ctl_fd = pi->as_fd = pi->status_fd = 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: destroy_procinfo
|
* Function: destroy_procinfo
|
*
|
*
|
* Destructor function. Close, unlink and deallocate the object.
|
* Destructor function. Close, unlink and deallocate the object.
|
*/
|
*/
|
|
|
static void
|
static void
|
destroy_one_procinfo (list, pi)
|
destroy_one_procinfo (list, pi)
|
procinfo **list;
|
procinfo **list;
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
procinfo *ptr;
|
procinfo *ptr;
|
|
|
/* Step one: unlink the procinfo from its list */
|
/* Step one: unlink the procinfo from its list */
|
if (pi == *list)
|
if (pi == *list)
|
*list = pi->next;
|
*list = pi->next;
|
else
|
else
|
for (ptr = *list; ptr; ptr = ptr->next)
|
for (ptr = *list; ptr; ptr = ptr->next)
|
if (ptr->next == pi)
|
if (ptr->next == pi)
|
{
|
{
|
ptr->next = pi->next;
|
ptr->next = pi->next;
|
break;
|
break;
|
}
|
}
|
|
|
/* Step two: close any open file descriptors */
|
/* Step two: close any open file descriptors */
|
close_procinfo_files (pi);
|
close_procinfo_files (pi);
|
|
|
/* Step three: free the memory. */
|
/* Step three: free the memory. */
|
free (pi);
|
free (pi);
|
}
|
}
|
|
|
static void
|
static void
|
destroy_procinfo (pi)
|
destroy_procinfo (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
procinfo *tmp;
|
procinfo *tmp;
|
|
|
if (pi->tid != 0) /* destroy a thread procinfo */
|
if (pi->tid != 0) /* destroy a thread procinfo */
|
{
|
{
|
tmp = find_procinfo (pi->pid, 0); /* find the parent process */
|
tmp = find_procinfo (pi->pid, 0); /* find the parent process */
|
destroy_one_procinfo (&tmp->thread_list, pi);
|
destroy_one_procinfo (&tmp->thread_list, pi);
|
}
|
}
|
else /* destroy a process procinfo and all its threads */
|
else /* destroy a process procinfo and all its threads */
|
{
|
{
|
/* First destroy the children, if any; */
|
/* First destroy the children, if any; */
|
while (pi->thread_list != NULL)
|
while (pi->thread_list != NULL)
|
destroy_one_procinfo (&pi->thread_list, pi->thread_list);
|
destroy_one_procinfo (&pi->thread_list, pi->thread_list);
|
/* Then destroy the parent. Genocide!!! */
|
/* Then destroy the parent. Genocide!!! */
|
destroy_one_procinfo (&procinfo_list, pi);
|
destroy_one_procinfo (&procinfo_list, pi);
|
}
|
}
|
}
|
}
|
|
|
enum { NOKILL, KILL };
|
enum { NOKILL, KILL };
|
|
|
/*
|
/*
|
* Function: dead_procinfo
|
* Function: dead_procinfo
|
*
|
*
|
* To be called on a non_recoverable error for a procinfo.
|
* To be called on a non_recoverable error for a procinfo.
|
* Prints error messages, optionally sends a SIGKILL to the process,
|
* Prints error messages, optionally sends a SIGKILL to the process,
|
* then destroys the data structure.
|
* then destroys the data structure.
|
*/
|
*/
|
|
|
static void
|
static void
|
dead_procinfo (pi, msg, kill_p)
|
dead_procinfo (pi, msg, kill_p)
|
procinfo *pi;
|
procinfo *pi;
|
char *msg;
|
char *msg;
|
int kill_p;
|
int kill_p;
|
{
|
{
|
char procfile[80];
|
char procfile[80];
|
|
|
if (pi->pathname)
|
if (pi->pathname)
|
{
|
{
|
print_sys_errmsg (pi->pathname, errno);
|
print_sys_errmsg (pi->pathname, errno);
|
}
|
}
|
else
|
else
|
{
|
{
|
sprintf (procfile, "process %d", pi->pid);
|
sprintf (procfile, "process %d", pi->pid);
|
print_sys_errmsg (procfile, errno);
|
print_sys_errmsg (procfile, errno);
|
}
|
}
|
if (kill_p == KILL)
|
if (kill_p == KILL)
|
kill (pi->pid, SIGKILL);
|
kill (pi->pid, SIGKILL);
|
|
|
destroy_procinfo (pi);
|
destroy_procinfo (pi);
|
error (msg);
|
error (msg);
|
}
|
}
|
|
|
/* =================== END, STRUCT PROCINFO "MODULE" =================== */
|
/* =================== END, STRUCT PROCINFO "MODULE" =================== */
|
|
|
/* =================== /proc "MODULE" =================== */
|
/* =================== /proc "MODULE" =================== */
|
|
|
/*
|
/*
|
* This "module" is the interface layer between the /proc system API
|
* This "module" is the interface layer between the /proc system API
|
* and the gdb target vector functions. This layer consists of
|
* and the gdb target vector functions. This layer consists of
|
* access functions that encapsulate each of the basic operations
|
* access functions that encapsulate each of the basic operations
|
* that we need to use from the /proc API.
|
* that we need to use from the /proc API.
|
*
|
*
|
* The main motivation for this layer is to hide the fact that
|
* The main motivation for this layer is to hide the fact that
|
* there are two very different implementations of the /proc API.
|
* there are two very different implementations of the /proc API.
|
* Rather than have a bunch of #ifdefs all thru the gdb target vector
|
* Rather than have a bunch of #ifdefs all thru the gdb target vector
|
* functions, we do our best to hide them all in here.
|
* functions, we do our best to hide them all in here.
|
*/
|
*/
|
|
|
int proc_get_status PARAMS ((procinfo *pi));
|
int proc_get_status PARAMS ((procinfo *pi));
|
long proc_flags PARAMS ((procinfo *pi));
|
long proc_flags PARAMS ((procinfo *pi));
|
int proc_why PARAMS ((procinfo *pi));
|
int proc_why PARAMS ((procinfo *pi));
|
int proc_what PARAMS ((procinfo *pi));
|
int proc_what PARAMS ((procinfo *pi));
|
int proc_set_run_on_last_close PARAMS ((procinfo *pi));
|
int proc_set_run_on_last_close PARAMS ((procinfo *pi));
|
int proc_unset_run_on_last_close PARAMS ((procinfo *pi));
|
int proc_unset_run_on_last_close PARAMS ((procinfo *pi));
|
int proc_set_inherit_on_fork PARAMS ((procinfo *pi));
|
int proc_set_inherit_on_fork PARAMS ((procinfo *pi));
|
int proc_unset_inherit_on_fork PARAMS ((procinfo *pi));
|
int proc_unset_inherit_on_fork PARAMS ((procinfo *pi));
|
int proc_set_async PARAMS ((procinfo *pi));
|
int proc_set_async PARAMS ((procinfo *pi));
|
int proc_unset_async PARAMS ((procinfo *pi));
|
int proc_unset_async PARAMS ((procinfo *pi));
|
int proc_stop_process PARAMS ((procinfo *pi));
|
int proc_stop_process PARAMS ((procinfo *pi));
|
int proc_trace_signal PARAMS ((procinfo *pi, int signo));
|
int proc_trace_signal PARAMS ((procinfo *pi, int signo));
|
int proc_ignore_signal PARAMS ((procinfo *pi, int signo));
|
int proc_ignore_signal PARAMS ((procinfo *pi, int signo));
|
int proc_clear_current_fault PARAMS ((procinfo *pi));
|
int proc_clear_current_fault PARAMS ((procinfo *pi));
|
int proc_set_current_signal PARAMS ((procinfo *pi, int signo));
|
int proc_set_current_signal PARAMS ((procinfo *pi, int signo));
|
int proc_clear_current_signal PARAMS ((procinfo *pi));
|
int proc_clear_current_signal PARAMS ((procinfo *pi));
|
int proc_set_gregs PARAMS ((procinfo *pi));
|
int proc_set_gregs PARAMS ((procinfo *pi));
|
int proc_set_fpregs PARAMS ((procinfo *pi));
|
int proc_set_fpregs PARAMS ((procinfo *pi));
|
int proc_wait_for_stop PARAMS ((procinfo *pi));
|
int proc_wait_for_stop PARAMS ((procinfo *pi));
|
int proc_run_process PARAMS ((procinfo *pi, int step, int signo));
|
int proc_run_process PARAMS ((procinfo *pi, int step, int signo));
|
int proc_kill PARAMS ((procinfo *pi, int signo));
|
int proc_kill PARAMS ((procinfo *pi, int signo));
|
int proc_parent_pid PARAMS ((procinfo *pi));
|
int proc_parent_pid PARAMS ((procinfo *pi));
|
int proc_get_nthreads PARAMS ((procinfo *pi));
|
int proc_get_nthreads PARAMS ((procinfo *pi));
|
int proc_get_current_thread PARAMS ((procinfo *pi));
|
int proc_get_current_thread PARAMS ((procinfo *pi));
|
int proc_set_held_signals PARAMS ((procinfo *pi, sigset_t *sighold));
|
int proc_set_held_signals PARAMS ((procinfo *pi, sigset_t *sighold));
|
int proc_set_traced_sysexit PARAMS ((procinfo *pi, sysset_t *sysset));
|
int proc_set_traced_sysexit PARAMS ((procinfo *pi, sysset_t *sysset));
|
int proc_set_traced_sysentry PARAMS ((procinfo *pi, sysset_t *sysset));
|
int proc_set_traced_sysentry PARAMS ((procinfo *pi, sysset_t *sysset));
|
int proc_set_traced_faults PARAMS ((procinfo *pi, fltset_t *fltset));
|
int proc_set_traced_faults PARAMS ((procinfo *pi, fltset_t *fltset));
|
int proc_set_traced_signals PARAMS ((procinfo *pi, sigset_t *sigset));
|
int proc_set_traced_signals PARAMS ((procinfo *pi, sigset_t *sigset));
|
|
|
int proc_update_threads PARAMS ((procinfo *pi));
|
int proc_update_threads PARAMS ((procinfo *pi));
|
int proc_iterate_over_threads PARAMS ((procinfo *pi,
|
int proc_iterate_over_threads PARAMS ((procinfo *pi,
|
int (*func) PARAMS ((procinfo *,
|
int (*func) PARAMS ((procinfo *,
|
procinfo *,
|
procinfo *,
|
void *)),
|
void *)),
|
void *ptr));
|
void *ptr));
|
|
|
gdb_gregset_t *proc_get_gregs PARAMS ((procinfo *pi));
|
gdb_gregset_t *proc_get_gregs PARAMS ((procinfo *pi));
|
gdb_fpregset_t *proc_get_fpregs PARAMS ((procinfo *pi));
|
gdb_fpregset_t *proc_get_fpregs PARAMS ((procinfo *pi));
|
sysset_t *proc_get_traced_sysexit PARAMS ((procinfo *pi, sysset_t *save));
|
sysset_t *proc_get_traced_sysexit PARAMS ((procinfo *pi, sysset_t *save));
|
sysset_t *proc_get_traced_sysentry PARAMS ((procinfo *pi, sysset_t *save));
|
sysset_t *proc_get_traced_sysentry PARAMS ((procinfo *pi, sysset_t *save));
|
fltset_t *proc_get_traced_faults PARAMS ((procinfo *pi, fltset_t *save));
|
fltset_t *proc_get_traced_faults PARAMS ((procinfo *pi, fltset_t *save));
|
sigset_t *proc_get_traced_signals PARAMS ((procinfo *pi, sigset_t *save));
|
sigset_t *proc_get_traced_signals PARAMS ((procinfo *pi, sigset_t *save));
|
sigset_t *proc_get_held_signals PARAMS ((procinfo *pi, sigset_t *save));
|
sigset_t *proc_get_held_signals PARAMS ((procinfo *pi, sigset_t *save));
|
sigset_t *proc_get_pending_signals PARAMS ((procinfo *pi, sigset_t *save));
|
sigset_t *proc_get_pending_signals PARAMS ((procinfo *pi, sigset_t *save));
|
struct sigaction *proc_get_signal_actions PARAMS ((procinfo *pi,
|
struct sigaction *proc_get_signal_actions PARAMS ((procinfo *pi,
|
struct sigaction *save));
|
struct sigaction *save));
|
|
|
void proc_warn PARAMS ((procinfo *pi, char *func, int line));
|
void proc_warn PARAMS ((procinfo *pi, char *func, int line));
|
void proc_error PARAMS ((procinfo *pi, char *func, int line));
|
void proc_error PARAMS ((procinfo *pi, char *func, int line));
|
|
|
void
|
void
|
proc_warn (pi, func, line)
|
proc_warn (pi, func, line)
|
procinfo *pi;
|
procinfo *pi;
|
char *func;
|
char *func;
|
int line;
|
int line;
|
{
|
{
|
sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
|
sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
|
print_sys_errmsg (errmsg, errno);
|
print_sys_errmsg (errmsg, errno);
|
}
|
}
|
|
|
void
|
void
|
proc_error (pi, func, line)
|
proc_error (pi, func, line)
|
procinfo *pi;
|
procinfo *pi;
|
char *func;
|
char *func;
|
int line;
|
int line;
|
{
|
{
|
sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
|
sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
|
perror_with_name (errmsg);
|
perror_with_name (errmsg);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_status
|
* Function: proc_get_status
|
*
|
*
|
* Updates the status struct in the procinfo.
|
* Updates the status struct in the procinfo.
|
* There is a 'valid' flag, to let other functions know when
|
* There is a 'valid' flag, to let other functions know when
|
* this function needs to be called (so the status is only
|
* this function needs to be called (so the status is only
|
* read when it is needed). The status file descriptor is
|
* read when it is needed). The status file descriptor is
|
* also only opened when it is needed.
|
* also only opened when it is needed.
|
*
|
*
|
* Return: non-zero for success, zero for failure.
|
* Return: non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_get_status (pi)
|
proc_get_status (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
/* Status file descriptor is opened "lazily" */
|
/* Status file descriptor is opened "lazily" */
|
if (pi->status_fd == 0 &&
|
if (pi->status_fd == 0 &&
|
open_procinfo_files (pi, FD_STATUS) == 0)
|
open_procinfo_files (pi, FD_STATUS) == 0)
|
{
|
{
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (lseek (pi->status_fd, 0, SEEK_SET) < 0)
|
if (lseek (pi->status_fd, 0, SEEK_SET) < 0)
|
pi->status_valid = 0; /* fail */
|
pi->status_valid = 0; /* fail */
|
else
|
else
|
{
|
{
|
/* Sigh... I have to read a different data structure,
|
/* Sigh... I have to read a different data structure,
|
depending on whether this is a main process or an LWP. */
|
depending on whether this is a main process or an LWP. */
|
if (pi->tid)
|
if (pi->tid)
|
pi->status_valid = (read (pi->status_fd,
|
pi->status_valid = (read (pi->status_fd,
|
(char *) &pi->prstatus.pr_lwp,
|
(char *) &pi->prstatus.pr_lwp,
|
sizeof (lwpstatus_t))
|
sizeof (lwpstatus_t))
|
== sizeof (lwpstatus_t));
|
== sizeof (lwpstatus_t));
|
else
|
else
|
{
|
{
|
pi->status_valid = (read (pi->status_fd,
|
pi->status_valid = (read (pi->status_fd,
|
(char *) &pi->prstatus,
|
(char *) &pi->prstatus,
|
sizeof (gdb_prstatus_t))
|
sizeof (gdb_prstatus_t))
|
== sizeof (gdb_prstatus_t));
|
== sizeof (gdb_prstatus_t));
|
#if 0 /*def UNIXWARE*/
|
#if 0 /*def UNIXWARE*/
|
if (pi->status_valid &&
|
if (pi->status_valid &&
|
(pi->prstatus.pr_lwp.pr_flags & PR_ISTOP) &&
|
(pi->prstatus.pr_lwp.pr_flags & PR_ISTOP) &&
|
pi->prstatus.pr_lwp.pr_why == PR_REQUESTED)
|
pi->prstatus.pr_lwp.pr_why == PR_REQUESTED)
|
/* Unixware peculiarity -- read the damn thing again! */
|
/* Unixware peculiarity -- read the damn thing again! */
|
pi->status_valid = (read (pi->status_fd,
|
pi->status_valid = (read (pi->status_fd,
|
(char *) &pi->prstatus,
|
(char *) &pi->prstatus,
|
sizeof (gdb_prstatus_t))
|
sizeof (gdb_prstatus_t))
|
== sizeof (gdb_prstatus_t));
|
== sizeof (gdb_prstatus_t));
|
#endif /* UNIXWARE */
|
#endif /* UNIXWARE */
|
}
|
}
|
}
|
}
|
#else /* ioctl method */
|
#else /* ioctl method */
|
#ifdef PIOCTSTATUS /* osf */
|
#ifdef PIOCTSTATUS /* osf */
|
if (pi->tid == 0) /* main process */
|
if (pi->tid == 0) /* main process */
|
{
|
{
|
/* Just read the danged status. Now isn't that simple? */
|
/* Just read the danged status. Now isn't that simple? */
|
pi->status_valid =
|
pi->status_valid =
|
(ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
|
(ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
|
}
|
}
|
else
|
else
|
{
|
{
|
int win;
|
int win;
|
struct {
|
struct {
|
long pr_count;
|
long pr_count;
|
tid_t pr_error_thread;
|
tid_t pr_error_thread;
|
struct prstatus status;
|
struct prstatus status;
|
} thread_status;
|
} thread_status;
|
|
|
thread_status.pr_count = 1;
|
thread_status.pr_count = 1;
|
thread_status.status.pr_tid = pi->tid;
|
thread_status.status.pr_tid = pi->tid;
|
win = (ioctl (pi->status_fd, PIOCTSTATUS, &thread_status) >= 0);
|
win = (ioctl (pi->status_fd, PIOCTSTATUS, &thread_status) >= 0);
|
if (win)
|
if (win)
|
{
|
{
|
memcpy (&pi->prstatus, &thread_status.status,
|
memcpy (&pi->prstatus, &thread_status.status,
|
sizeof (pi->prstatus));
|
sizeof (pi->prstatus));
|
pi->status_valid = 1;
|
pi->status_valid = 1;
|
}
|
}
|
}
|
}
|
#else
|
#else
|
/* Just read the danged status. Now isn't that simple? */
|
/* Just read the danged status. Now isn't that simple? */
|
pi->status_valid = (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
|
pi->status_valid = (ioctl (pi->status_fd, PIOCSTATUS, &pi->prstatus) >= 0);
|
#endif
|
#endif
|
#endif
|
#endif
|
|
|
if (pi->status_valid)
|
if (pi->status_valid)
|
{
|
{
|
PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
|
PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
|
proc_why (pi),
|
proc_why (pi),
|
proc_what (pi),
|
proc_what (pi),
|
proc_get_current_thread (pi));
|
proc_get_current_thread (pi));
|
}
|
}
|
|
|
/* The status struct includes general regs, so mark them valid too */
|
/* The status struct includes general regs, so mark them valid too */
|
pi->gregs_valid = pi->status_valid;
|
pi->gregs_valid = pi->status_valid;
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
/* In the read/write multiple-fd model,
|
/* In the read/write multiple-fd model,
|
the status struct includes the fp regs too, so mark them valid too */
|
the status struct includes the fp regs too, so mark them valid too */
|
pi->fpregs_valid = pi->status_valid;
|
pi->fpregs_valid = pi->status_valid;
|
#endif
|
#endif
|
return pi->status_valid; /* True if success, false if failure. */
|
return pi->status_valid; /* True if success, false if failure. */
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_flags
|
* Function: proc_flags
|
*
|
*
|
* returns the process flags (pr_flags field).
|
* returns the process flags (pr_flags field).
|
*/
|
*/
|
|
|
long
|
long
|
proc_flags (pi)
|
proc_flags (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0; /* FIXME: not a good failure value (but what is?) */
|
return 0; /* FIXME: not a good failure value (but what is?) */
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
# ifdef UNIXWARE
|
# ifdef UNIXWARE
|
/* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
|
/* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
|
pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
|
pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
|
The two sets of flags don't overlap. */
|
The two sets of flags don't overlap. */
|
return pi->prstatus.pr_flags | pi->prstatus.pr_lwp.pr_flags;
|
return pi->prstatus.pr_flags | pi->prstatus.pr_lwp.pr_flags;
|
# else
|
# else
|
return pi->prstatus.pr_lwp.pr_flags;
|
return pi->prstatus.pr_lwp.pr_flags;
|
# endif
|
# endif
|
#else
|
#else
|
return pi->prstatus.pr_flags;
|
return pi->prstatus.pr_flags;
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_why
|
* Function: proc_why
|
*
|
*
|
* returns the pr_why field (why the process stopped).
|
* returns the pr_why field (why the process stopped).
|
*/
|
*/
|
|
|
int
|
int
|
proc_why (pi)
|
proc_why (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0; /* FIXME: not a good failure value (but what is?) */
|
return 0; /* FIXME: not a good failure value (but what is?) */
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
return pi->prstatus.pr_lwp.pr_why;
|
return pi->prstatus.pr_lwp.pr_why;
|
#else
|
#else
|
return pi->prstatus.pr_why;
|
return pi->prstatus.pr_why;
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_what
|
* Function: proc_what
|
*
|
*
|
* returns the pr_what field (details of why the process stopped).
|
* returns the pr_what field (details of why the process stopped).
|
*/
|
*/
|
|
|
int
|
int
|
proc_what (pi)
|
proc_what (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0; /* FIXME: not a good failure value (but what is?) */
|
return 0; /* FIXME: not a good failure value (but what is?) */
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
return pi->prstatus.pr_lwp.pr_what;
|
return pi->prstatus.pr_lwp.pr_what;
|
#else
|
#else
|
return pi->prstatus.pr_what;
|
return pi->prstatus.pr_what;
|
#endif
|
#endif
|
}
|
}
|
|
|
#ifndef PIOCSSPCACT /* The following is not supported on OSF. */
|
#ifndef PIOCSSPCACT /* The following is not supported on OSF. */
|
/*
|
/*
|
* Function: proc_nsysarg
|
* Function: proc_nsysarg
|
*
|
*
|
* returns the pr_nsysarg field (number of args to the current syscall).
|
* returns the pr_nsysarg field (number of args to the current syscall).
|
*/
|
*/
|
|
|
int
|
int
|
proc_nsysarg (pi)
|
proc_nsysarg (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0;
|
return 0;
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
return pi->prstatus.pr_lwp.pr_nsysarg;
|
return pi->prstatus.pr_lwp.pr_nsysarg;
|
#else
|
#else
|
return pi->prstatus.pr_nsysarg;
|
return pi->prstatus.pr_nsysarg;
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_sysargs
|
* Function: proc_sysargs
|
*
|
*
|
* returns the pr_sysarg field (pointer to the arguments of current syscall).
|
* returns the pr_sysarg field (pointer to the arguments of current syscall).
|
*/
|
*/
|
|
|
long *
|
long *
|
proc_sysargs (pi)
|
proc_sysargs (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
return (long *) &pi->prstatus.pr_lwp.pr_sysarg;
|
return (long *) &pi->prstatus.pr_lwp.pr_sysarg;
|
#else
|
#else
|
return (long *) &pi->prstatus.pr_sysarg;
|
return (long *) &pi->prstatus.pr_sysarg;
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_syscall
|
* Function: proc_syscall
|
*
|
*
|
* returns the pr_syscall field (id of current syscall if we are in one).
|
* returns the pr_syscall field (id of current syscall if we are in one).
|
*/
|
*/
|
|
|
int
|
int
|
proc_syscall (pi)
|
proc_syscall (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0;
|
return 0;
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
return pi->prstatus.pr_lwp.pr_syscall;
|
return pi->prstatus.pr_lwp.pr_syscall;
|
#else
|
#else
|
return pi->prstatus.pr_syscall;
|
return pi->prstatus.pr_syscall;
|
#endif
|
#endif
|
}
|
}
|
#endif /* PIOCSSPCACT */
|
#endif /* PIOCSSPCACT */
|
|
|
/*
|
/*
|
* Function: proc_cursig:
|
* Function: proc_cursig:
|
*
|
*
|
* returns the pr_cursig field (current signal).
|
* returns the pr_cursig field (current signal).
|
*/
|
*/
|
|
|
long
|
long
|
proc_cursig (struct procinfo *pi)
|
proc_cursig (struct procinfo *pi)
|
{
|
{
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0; /* FIXME: not a good failure value (but what is?) */
|
return 0; /* FIXME: not a good failure value (but what is?) */
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
return pi->prstatus.pr_lwp.pr_cursig;
|
return pi->prstatus.pr_lwp.pr_cursig;
|
#else
|
#else
|
return pi->prstatus.pr_cursig;
|
return pi->prstatus.pr_cursig;
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_modify_flag
|
* Function: proc_modify_flag
|
*
|
*
|
* === I appologize for the messiness of this function.
|
* === I appologize for the messiness of this function.
|
* === This is an area where the different versions of
|
* === This is an area where the different versions of
|
* === /proc are more inconsistent than usual. MVS
|
* === /proc are more inconsistent than usual. MVS
|
*
|
*
|
* Set or reset any of the following process flags:
|
* Set or reset any of the following process flags:
|
* PR_FORK -- forked child will inherit trace flags
|
* PR_FORK -- forked child will inherit trace flags
|
* PR_RLC -- traced process runs when last /proc file closed.
|
* PR_RLC -- traced process runs when last /proc file closed.
|
* PR_KLC -- traced process is killed when last /proc file closed.
|
* PR_KLC -- traced process is killed when last /proc file closed.
|
* PR_ASYNC -- LWP's get to run/stop independently.
|
* PR_ASYNC -- LWP's get to run/stop independently.
|
*
|
*
|
* There are three methods for doing this function:
|
* There are three methods for doing this function:
|
* 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
|
* 1) Newest: read/write [PCSET/PCRESET/PCUNSET]
|
* [Sol6, Sol7, UW]
|
* [Sol6, Sol7, UW]
|
* 2) Middle: PIOCSET/PIOCRESET
|
* 2) Middle: PIOCSET/PIOCRESET
|
* [Irix, Sol5]
|
* [Irix, Sol5]
|
* 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
|
* 3) Oldest: PIOCSFORK/PIOCRFORK/PIOCSRLC/PIOCRRLC
|
* [OSF, Sol5]
|
* [OSF, Sol5]
|
*
|
*
|
* Note: Irix does not define PR_ASYNC.
|
* Note: Irix does not define PR_ASYNC.
|
* Note: OSF does not define PR_KLC.
|
* Note: OSF does not define PR_KLC.
|
* Note: OSF is the only one that can ONLY use the oldest method.
|
* Note: OSF is the only one that can ONLY use the oldest method.
|
*
|
*
|
* Arguments:
|
* Arguments:
|
* pi -- the procinfo
|
* pi -- the procinfo
|
* flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
|
* flag -- one of PR_FORK, PR_RLC, or PR_ASYNC
|
* mode -- 1 for set, 0 for reset.
|
* mode -- 1 for set, 0 for reset.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
enum { FLAG_RESET, FLAG_SET };
|
enum { FLAG_RESET, FLAG_SET };
|
|
|
static int
|
static int
|
proc_modify_flag (pi, flag, mode)
|
proc_modify_flag (pi, flag, mode)
|
procinfo *pi;
|
procinfo *pi;
|
long flag;
|
long flag;
|
long mode;
|
long mode;
|
{
|
{
|
long win = 0; /* default to fail */
|
long win = 0; /* default to fail */
|
|
|
/*
|
/*
|
* These operations affect the process as a whole, and applying
|
* These operations affect the process as a whole, and applying
|
* them to an individual LWP has the same meaning as applying them
|
* them to an individual LWP has the same meaning as applying them
|
* to the main process. Therefore, if we're ever called with a
|
* to the main process. Therefore, if we're ever called with a
|
* pointer to an LWP's procinfo, let's substitute the process's
|
* pointer to an LWP's procinfo, let's substitute the process's
|
* procinfo and avoid opening the LWP's file descriptor
|
* procinfo and avoid opening the LWP's file descriptor
|
* unnecessarily.
|
* unnecessarily.
|
*/
|
*/
|
|
|
if (pi->pid != 0)
|
if (pi->pid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
|
#ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii */
|
/* First normalize the PCUNSET/PCRESET command opcode
|
/* First normalize the PCUNSET/PCRESET command opcode
|
(which for no obvious reason has a different definition
|
(which for no obvious reason has a different definition
|
from one operating system to the next...) */
|
from one operating system to the next...) */
|
#ifdef PCUNSET
|
#ifdef PCUNSET
|
#define GDBRESET PCUNSET
|
#define GDBRESET PCUNSET
|
#endif
|
#endif
|
#ifdef PCRESET
|
#ifdef PCRESET
|
#define GDBRESET PCRESET
|
#define GDBRESET PCRESET
|
#endif
|
#endif
|
{
|
{
|
long arg[2];
|
long arg[2];
|
|
|
if (mode == FLAG_SET) /* Set the flag (RLC, FORK, or ASYNC) */
|
if (mode == FLAG_SET) /* Set the flag (RLC, FORK, or ASYNC) */
|
arg[0] = PCSET;
|
arg[0] = PCSET;
|
else /* Reset the flag */
|
else /* Reset the flag */
|
arg[0] = GDBRESET;
|
arg[0] = GDBRESET;
|
|
|
arg[1] = flag;
|
arg[1] = flag;
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
}
|
}
|
#else
|
#else
|
#ifdef PIOCSET /* Irix/Sol5 method */
|
#ifdef PIOCSET /* Irix/Sol5 method */
|
if (mode == FLAG_SET) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
|
if (mode == FLAG_SET) /* Set the flag (hopefully RLC, FORK, or ASYNC) */
|
{
|
{
|
win = (ioctl (pi->ctl_fd, PIOCSET, &flag) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSET, &flag) >= 0);
|
}
|
}
|
else /* Reset the flag */
|
else /* Reset the flag */
|
{
|
{
|
win = (ioctl (pi->ctl_fd, PIOCRESET, &flag) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCRESET, &flag) >= 0);
|
}
|
}
|
|
|
#else
|
#else
|
#ifdef PIOCSRLC /* Oldest method: OSF */
|
#ifdef PIOCSRLC /* Oldest method: OSF */
|
switch (flag) {
|
switch (flag) {
|
case PR_RLC:
|
case PR_RLC:
|
if (mode == FLAG_SET) /* Set run-on-last-close */
|
if (mode == FLAG_SET) /* Set run-on-last-close */
|
{
|
{
|
win = (ioctl (pi->ctl_fd, PIOCSRLC, NULL) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSRLC, NULL) >= 0);
|
}
|
}
|
else /* Clear run-on-last-close */
|
else /* Clear run-on-last-close */
|
{
|
{
|
win = (ioctl (pi->ctl_fd, PIOCRRLC, NULL) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCRRLC, NULL) >= 0);
|
}
|
}
|
break;
|
break;
|
case PR_FORK:
|
case PR_FORK:
|
if (mode == FLAG_SET) /* Set inherit-on-fork */
|
if (mode == FLAG_SET) /* Set inherit-on-fork */
|
{
|
{
|
win = (ioctl (pi->ctl_fd, PIOCSFORK, NULL) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSFORK, NULL) >= 0);
|
}
|
}
|
else /* Clear inherit-on-fork */
|
else /* Clear inherit-on-fork */
|
{
|
{
|
win = (ioctl (pi->ctl_fd, PIOCRFORK, NULL) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCRFORK, NULL) >= 0);
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
win = 0; /* fail -- unknown flag (can't do PR_ASYNC) */
|
win = 0; /* fail -- unknown flag (can't do PR_ASYNC) */
|
break;
|
break;
|
}
|
}
|
#endif
|
#endif
|
#endif
|
#endif
|
#endif
|
#endif
|
#undef GDBRESET
|
#undef GDBRESET
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
|
|
if (!win)
|
if (!win)
|
warning ("procfs: modify_flag failed to turn %s %s",
|
warning ("procfs: modify_flag failed to turn %s %s",
|
flag == PR_FORK ? "PR_FORK" :
|
flag == PR_FORK ? "PR_FORK" :
|
flag == PR_RLC ? "PR_RLC" :
|
flag == PR_RLC ? "PR_RLC" :
|
#ifdef PR_ASYNC
|
#ifdef PR_ASYNC
|
flag == PR_ASYNC ? "PR_ASYNC" :
|
flag == PR_ASYNC ? "PR_ASYNC" :
|
#endif
|
#endif
|
#ifdef PR_KLC
|
#ifdef PR_KLC
|
flag == PR_KLC ? "PR_KLC" :
|
flag == PR_KLC ? "PR_KLC" :
|
#endif
|
#endif
|
"<unknown flag>",
|
"<unknown flag>",
|
mode == FLAG_RESET ? "off" : "on");
|
mode == FLAG_RESET ? "off" : "on");
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_run_on_last_close
|
* Function: proc_set_run_on_last_close
|
*
|
*
|
* Set the run_on_last_close flag.
|
* Set the run_on_last_close flag.
|
* Process with all threads will become runnable
|
* Process with all threads will become runnable
|
* when debugger closes all /proc fds.
|
* when debugger closes all /proc fds.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_run_on_last_close (pi)
|
proc_set_run_on_last_close (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return proc_modify_flag (pi, PR_RLC, FLAG_SET);
|
return proc_modify_flag (pi, PR_RLC, FLAG_SET);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_unset_run_on_last_close
|
* Function: proc_unset_run_on_last_close
|
*
|
*
|
* Reset the run_on_last_close flag.
|
* Reset the run_on_last_close flag.
|
* Process will NOT become runnable
|
* Process will NOT become runnable
|
* when debugger closes its file handles.
|
* when debugger closes its file handles.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_unset_run_on_last_close (pi)
|
proc_unset_run_on_last_close (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
|
return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
|
}
|
}
|
|
|
#ifdef PR_KLC
|
#ifdef PR_KLC
|
/*
|
/*
|
* Function: proc_set_kill_on_last_close
|
* Function: proc_set_kill_on_last_close
|
*
|
*
|
* Set the kill_on_last_close flag.
|
* Set the kill_on_last_close flag.
|
* Process with all threads will be killed when debugger
|
* Process with all threads will be killed when debugger
|
* closes all /proc fds (or debugger exits or dies).
|
* closes all /proc fds (or debugger exits or dies).
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_kill_on_last_close (pi)
|
proc_set_kill_on_last_close (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return proc_modify_flag (pi, PR_KLC, FLAG_SET);
|
return proc_modify_flag (pi, PR_KLC, FLAG_SET);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_unset_kill_on_last_close
|
* Function: proc_unset_kill_on_last_close
|
*
|
*
|
* Reset the kill_on_last_close flag.
|
* Reset the kill_on_last_close flag.
|
* Process will NOT be killed when debugger
|
* Process will NOT be killed when debugger
|
* closes its file handles (or exits or dies).
|
* closes its file handles (or exits or dies).
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_unset_kill_on_last_close (pi)
|
proc_unset_kill_on_last_close (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return proc_modify_flag (pi, PR_KLC, FLAG_RESET);
|
return proc_modify_flag (pi, PR_KLC, FLAG_RESET);
|
}
|
}
|
#endif /* PR_KLC */
|
#endif /* PR_KLC */
|
|
|
/*
|
/*
|
* Function: proc_set_inherit_on_fork
|
* Function: proc_set_inherit_on_fork
|
*
|
*
|
* Set inherit_on_fork flag.
|
* Set inherit_on_fork flag.
|
* If the process forks a child while we are registered for events
|
* If the process forks a child while we are registered for events
|
* in the parent, then we will also recieve events from the child.
|
* in the parent, then we will also recieve events from the child.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_inherit_on_fork (pi)
|
proc_set_inherit_on_fork (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return proc_modify_flag (pi, PR_FORK, FLAG_SET);
|
return proc_modify_flag (pi, PR_FORK, FLAG_SET);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_unset_inherit_on_fork
|
* Function: proc_unset_inherit_on_fork
|
*
|
*
|
* Reset inherit_on_fork flag.
|
* Reset inherit_on_fork flag.
|
* If the process forks a child while we are registered for events
|
* If the process forks a child while we are registered for events
|
* in the parent, then we will NOT recieve events from the child.
|
* in the parent, then we will NOT recieve events from the child.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_unset_inherit_on_fork (pi)
|
proc_unset_inherit_on_fork (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return proc_modify_flag (pi, PR_FORK, FLAG_RESET);
|
return proc_modify_flag (pi, PR_FORK, FLAG_RESET);
|
}
|
}
|
|
|
#ifdef PR_ASYNC
|
#ifdef PR_ASYNC
|
/*
|
/*
|
* Function: proc_set_async
|
* Function: proc_set_async
|
*
|
*
|
* Set PR_ASYNC flag.
|
* Set PR_ASYNC flag.
|
* If one LWP stops because of a debug event (signal etc.),
|
* If one LWP stops because of a debug event (signal etc.),
|
* the remaining LWPs will continue to run.
|
* the remaining LWPs will continue to run.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_async (pi)
|
proc_set_async (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return proc_modify_flag (pi, PR_ASYNC, FLAG_SET);
|
return proc_modify_flag (pi, PR_ASYNC, FLAG_SET);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_unset_async
|
* Function: proc_unset_async
|
*
|
*
|
* Reset PR_ASYNC flag.
|
* Reset PR_ASYNC flag.
|
* If one LWP stops because of a debug event (signal etc.),
|
* If one LWP stops because of a debug event (signal etc.),
|
* then all other LWPs will stop as well.
|
* then all other LWPs will stop as well.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_unset_async (pi)
|
proc_unset_async (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET);
|
return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET);
|
}
|
}
|
#endif /* PR_ASYNC */
|
#endif /* PR_ASYNC */
|
|
|
/*
|
/*
|
* Function: proc_stop_process
|
* Function: proc_stop_process
|
*
|
*
|
* Request the process/LWP to stop. Does not wait.
|
* Request the process/LWP to stop. Does not wait.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_stop_process (pi)
|
proc_stop_process (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We might conceivably apply this operation to an LWP, and
|
* We might conceivably apply this operation to an LWP, and
|
* the LWP's ctl file descriptor might not be open.
|
* the LWP's ctl file descriptor might not be open.
|
*/
|
*/
|
|
|
if (pi->ctl_fd == 0 &&
|
if (pi->ctl_fd == 0 &&
|
open_procinfo_files (pi, FD_CTL) == 0)
|
open_procinfo_files (pi, FD_CTL) == 0)
|
return 0;
|
return 0;
|
else
|
else
|
{
|
{
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
int cmd = PCSTOP;
|
int cmd = PCSTOP;
|
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
#else /* ioctl method */
|
#else /* ioctl method */
|
win = (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) >= 0);
|
/* Note: the call also reads the prstatus. */
|
/* Note: the call also reads the prstatus. */
|
if (win)
|
if (win)
|
{
|
{
|
pi->status_valid = 1;
|
pi->status_valid = 1;
|
PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
|
PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
|
proc_why (pi),
|
proc_why (pi),
|
proc_what (pi),
|
proc_what (pi),
|
proc_get_current_thread (pi));
|
proc_get_current_thread (pi));
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_wait_for_stop
|
* Function: proc_wait_for_stop
|
*
|
*
|
* Wait for the process or LWP to stop (block until it does).
|
* Wait for the process or LWP to stop (block until it does).
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_wait_for_stop (pi)
|
proc_wait_for_stop (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
int cmd = PCWSTOP;
|
int cmd = PCWSTOP;
|
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
/* We been runnin' and we stopped -- need to update status. */
|
/* We been runnin' and we stopped -- need to update status. */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
}
|
}
|
#else /* ioctl method */
|
#else /* ioctl method */
|
win = (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCWSTOP, &pi->prstatus) >= 0);
|
/* Above call also refreshes the prstatus. */
|
/* Above call also refreshes the prstatus. */
|
if (win)
|
if (win)
|
{
|
{
|
pi->status_valid = 1;
|
pi->status_valid = 1;
|
PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
|
PROC_PRETTYFPRINT_STATUS (proc_flags (pi),
|
proc_why (pi),
|
proc_why (pi),
|
proc_what (pi),
|
proc_what (pi),
|
proc_get_current_thread (pi));
|
proc_get_current_thread (pi));
|
}
|
}
|
#endif
|
#endif
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_run_process
|
* Function: proc_run_process
|
*
|
*
|
* Make the process or LWP runnable.
|
* Make the process or LWP runnable.
|
* Options (not all are implemented):
|
* Options (not all are implemented):
|
* - single-step
|
* - single-step
|
* - clear current fault
|
* - clear current fault
|
* - clear current signal
|
* - clear current signal
|
* - abort the current system call
|
* - abort the current system call
|
* - stop as soon as finished with system call
|
* - stop as soon as finished with system call
|
* - (ioctl): set traced signal set
|
* - (ioctl): set traced signal set
|
* - (ioctl): set held signal set
|
* - (ioctl): set held signal set
|
* - (ioctl): set traced fault set
|
* - (ioctl): set traced fault set
|
* - (ioctl): set start pc (vaddr)
|
* - (ioctl): set start pc (vaddr)
|
* Always clear the current fault.
|
* Always clear the current fault.
|
* Clear the current signal if 'signo' is zero.
|
* Clear the current signal if 'signo' is zero.
|
*
|
*
|
* Arguments:
|
* Arguments:
|
* pi the process or LWP to operate on.
|
* pi the process or LWP to operate on.
|
* step if true, set the process or LWP to trap after one instr.
|
* step if true, set the process or LWP to trap after one instr.
|
* signo if zero, clear the current signal if any.
|
* signo if zero, clear the current signal if any.
|
* if non-zero, set the current signal to this one.
|
* if non-zero, set the current signal to this one.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_run_process (pi, step, signo)
|
proc_run_process (pi, step, signo)
|
procinfo *pi;
|
procinfo *pi;
|
int step;
|
int step;
|
int signo;
|
int signo;
|
{
|
{
|
int win;
|
int win;
|
int runflags;
|
int runflags;
|
|
|
/*
|
/*
|
* We will probably have to apply this operation to individual threads,
|
* We will probably have to apply this operation to individual threads,
|
* so make sure the control file descriptor is open.
|
* so make sure the control file descriptor is open.
|
*/
|
*/
|
|
|
if (pi->ctl_fd == 0 &&
|
if (pi->ctl_fd == 0 &&
|
open_procinfo_files (pi, FD_CTL) == 0)
|
open_procinfo_files (pi, FD_CTL) == 0)
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
runflags = PRCFAULT; /* always clear current fault */
|
runflags = PRCFAULT; /* always clear current fault */
|
if (step)
|
if (step)
|
runflags |= PRSTEP;
|
runflags |= PRSTEP;
|
if (signo == 0)
|
if (signo == 0)
|
runflags |= PRCSIG;
|
runflags |= PRCSIG;
|
else if (signo != -1) /* -1 means do nothing W.R.T. signals */
|
else if (signo != -1) /* -1 means do nothing W.R.T. signals */
|
proc_set_current_signal (pi, signo);
|
proc_set_current_signal (pi, signo);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
int cmd[2];
|
int cmd[2];
|
|
|
cmd[0] = PCRUN;
|
cmd[0] = PCRUN;
|
cmd[1] = runflags;
|
cmd[1] = runflags;
|
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
}
|
}
|
#else /* ioctl method */
|
#else /* ioctl method */
|
{
|
{
|
prrun_t prrun;
|
prrun_t prrun;
|
|
|
memset (&prrun, 0, sizeof (prrun));
|
memset (&prrun, 0, sizeof (prrun));
|
prrun.pr_flags = runflags;
|
prrun.pr_flags = runflags;
|
win = (ioctl (pi->ctl_fd, PIOCRUN, &prrun) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCRUN, &prrun) >= 0);
|
}
|
}
|
#endif
|
#endif
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_traced_signals
|
* Function: proc_set_traced_signals
|
*
|
*
|
* Register to trace signals in the process or LWP.
|
* Register to trace signals in the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_traced_signals (pi, sigset)
|
proc_set_traced_signals (pi, sigset)
|
procinfo *pi;
|
procinfo *pi;
|
sigset_t *sigset;
|
sigset_t *sigset;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char sigset[sizeof (sigset_t)];
|
char sigset[sizeof (sigset_t)];
|
} arg;
|
} arg;
|
|
|
arg.cmd = PCSTRACE;
|
arg.cmd = PCSTRACE;
|
memcpy (&arg.sigset, sigset, sizeof (sigset_t));
|
memcpy (&arg.sigset, sigset, sizeof (sigset_t));
|
|
|
win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
|
}
|
}
|
#else /* ioctl method */
|
#else /* ioctl method */
|
win = (ioctl (pi->ctl_fd, PIOCSTRACE, sigset) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSTRACE, sigset) >= 0);
|
#endif
|
#endif
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
|
|
if (!win)
|
if (!win)
|
warning ("procfs: set_traced_signals failed");
|
warning ("procfs: set_traced_signals failed");
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_traced_faults
|
* Function: proc_set_traced_faults
|
*
|
*
|
* Register to trace hardware faults in the process or LWP.
|
* Register to trace hardware faults in the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_traced_faults (pi, fltset)
|
proc_set_traced_faults (pi, fltset)
|
procinfo *pi;
|
procinfo *pi;
|
fltset_t *fltset;
|
fltset_t *fltset;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char fltset[sizeof (fltset_t)];
|
char fltset[sizeof (fltset_t)];
|
} arg;
|
} arg;
|
|
|
arg.cmd = PCSFAULT;
|
arg.cmd = PCSFAULT;
|
memcpy (&arg.fltset, fltset, sizeof (fltset_t));
|
memcpy (&arg.fltset, fltset, sizeof (fltset_t));
|
|
|
win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
|
}
|
}
|
#else /* ioctl method */
|
#else /* ioctl method */
|
win = (ioctl (pi->ctl_fd, PIOCSFAULT, fltset) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSFAULT, fltset) >= 0);
|
#endif
|
#endif
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_traced_sysentry
|
* Function: proc_set_traced_sysentry
|
*
|
*
|
* Register to trace entry to system calls in the process or LWP.
|
* Register to trace entry to system calls in the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_traced_sysentry (pi, sysset)
|
proc_set_traced_sysentry (pi, sysset)
|
procinfo *pi;
|
procinfo *pi;
|
sysset_t *sysset;
|
sysset_t *sysset;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char sysset[sizeof (sysset_t)];
|
char sysset[sizeof (sysset_t)];
|
} arg;
|
} arg;
|
|
|
arg.cmd = PCSENTRY;
|
arg.cmd = PCSENTRY;
|
memcpy (&arg.sysset, sysset, sizeof (sysset_t));
|
memcpy (&arg.sysset, sysset, sizeof (sysset_t));
|
|
|
win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
|
}
|
}
|
#else /* ioctl method */
|
#else /* ioctl method */
|
win = (ioctl (pi->ctl_fd, PIOCSENTRY, sysset) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSENTRY, sysset) >= 0);
|
#endif
|
#endif
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_traced_sysexit
|
* Function: proc_set_traced_sysexit
|
*
|
*
|
* Register to trace exit from system calls in the process or LWP.
|
* Register to trace exit from system calls in the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_traced_sysexit (pi, sysset)
|
proc_set_traced_sysexit (pi, sysset)
|
procinfo *pi;
|
procinfo *pi;
|
sysset_t *sysset;
|
sysset_t *sysset;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char sysset[sizeof (sysset_t)];
|
char sysset[sizeof (sysset_t)];
|
} arg;
|
} arg;
|
|
|
arg.cmd = PCSEXIT;
|
arg.cmd = PCSEXIT;
|
memcpy (&arg.sysset, sysset, sizeof (sysset_t));
|
memcpy (&arg.sysset, sysset, sizeof (sysset_t));
|
|
|
win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
|
}
|
}
|
#else /* ioctl method */
|
#else /* ioctl method */
|
win = (ioctl (pi->ctl_fd, PIOCSEXIT, sysset) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSEXIT, sysset) >= 0);
|
#endif
|
#endif
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_held_signals
|
* Function: proc_set_held_signals
|
*
|
*
|
* Specify the set of blocked / held signals in the process or LWP.
|
* Specify the set of blocked / held signals in the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_held_signals (pi, sighold)
|
proc_set_held_signals (pi, sighold)
|
procinfo *pi;
|
procinfo *pi;
|
sigset_t *sighold;
|
sigset_t *sighold;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char hold[sizeof (sigset_t)];
|
char hold[sizeof (sigset_t)];
|
} arg;
|
} arg;
|
|
|
arg.cmd = PCSHOLD;
|
arg.cmd = PCSHOLD;
|
memcpy (&arg.hold, sighold, sizeof (sigset_t));
|
memcpy (&arg.hold, sighold, sizeof (sigset_t));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
}
|
}
|
#else
|
#else
|
win = (ioctl (pi->ctl_fd, PIOCSHOLD, sighold) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSHOLD, sighold) >= 0);
|
#endif
|
#endif
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
/* The above operation renders the procinfo's cached pstatus obsolete. */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_pending_signals
|
* Function: proc_get_pending_signals
|
*
|
*
|
* returns the set of signals that are pending in the process or LWP.
|
* returns the set of signals that are pending in the process or LWP.
|
* Will also copy the sigset if 'save' is non-zero.
|
* Will also copy the sigset if 'save' is non-zero.
|
*/
|
*/
|
|
|
sigset_t *
|
sigset_t *
|
proc_get_pending_signals (pi, save)
|
proc_get_pending_signals (pi, save)
|
procinfo *pi;
|
procinfo *pi;
|
sigset_t *save;
|
sigset_t *save;
|
{
|
{
|
sigset_t *ret = NULL;
|
sigset_t *ret = NULL;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
ret = &pi->prstatus.pr_lwp.pr_lwppend;
|
ret = &pi->prstatus.pr_lwp.pr_lwppend;
|
#else
|
#else
|
ret = &pi->prstatus.pr_sigpend;
|
ret = &pi->prstatus.pr_sigpend;
|
#endif
|
#endif
|
if (save && ret)
|
if (save && ret)
|
memcpy (save, ret, sizeof (sigset_t));
|
memcpy (save, ret, sizeof (sigset_t));
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_signal_actions
|
* Function: proc_get_signal_actions
|
*
|
*
|
* returns the set of signal actions.
|
* returns the set of signal actions.
|
* Will also copy the sigactionset if 'save' is non-zero.
|
* Will also copy the sigactionset if 'save' is non-zero.
|
*/
|
*/
|
|
|
struct sigaction *
|
struct sigaction *
|
proc_get_signal_actions (pi, save)
|
proc_get_signal_actions (pi, save)
|
procinfo *pi;
|
procinfo *pi;
|
struct sigaction *save;
|
struct sigaction *save;
|
{
|
{
|
struct sigaction *ret = NULL;
|
struct sigaction *ret = NULL;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
ret = &pi->prstatus.pr_lwp.pr_action;
|
ret = &pi->prstatus.pr_lwp.pr_action;
|
#else
|
#else
|
ret = &pi->prstatus.pr_action;
|
ret = &pi->prstatus.pr_action;
|
#endif
|
#endif
|
if (save && ret)
|
if (save && ret)
|
memcpy (save, ret, sizeof (struct sigaction));
|
memcpy (save, ret, sizeof (struct sigaction));
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_held_signals
|
* Function: proc_get_held_signals
|
*
|
*
|
* returns the set of signals that are held / blocked.
|
* returns the set of signals that are held / blocked.
|
* Will also copy the sigset if 'save' is non-zero.
|
* Will also copy the sigset if 'save' is non-zero.
|
*/
|
*/
|
|
|
sigset_t *
|
sigset_t *
|
proc_get_held_signals (pi, save)
|
proc_get_held_signals (pi, save)
|
procinfo *pi;
|
procinfo *pi;
|
sigset_t *save;
|
sigset_t *save;
|
{
|
{
|
sigset_t *ret = NULL;
|
sigset_t *ret = NULL;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
#ifdef UNIXWARE
|
#ifdef UNIXWARE
|
ret = &pi->prstatus.pr_lwp.pr_context.uc_sigmask;
|
ret = &pi->prstatus.pr_lwp.pr_context.uc_sigmask;
|
#else
|
#else
|
ret = &pi->prstatus.pr_lwp.pr_lwphold;
|
ret = &pi->prstatus.pr_lwp.pr_lwphold;
|
#endif /* UNIXWARE */
|
#endif /* UNIXWARE */
|
#else /* not NEW_PROC_API */
|
#else /* not NEW_PROC_API */
|
{
|
{
|
static sigset_t sigheld;
|
static sigset_t sigheld;
|
|
|
if (ioctl (pi->ctl_fd, PIOCGHOLD, &sigheld) >= 0)
|
if (ioctl (pi->ctl_fd, PIOCGHOLD, &sigheld) >= 0)
|
ret = &sigheld;
|
ret = &sigheld;
|
}
|
}
|
#endif /* NEW_PROC_API */
|
#endif /* NEW_PROC_API */
|
if (save && ret)
|
if (save && ret)
|
memcpy (save, ret, sizeof (sigset_t));
|
memcpy (save, ret, sizeof (sigset_t));
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_traced_signals
|
* Function: proc_get_traced_signals
|
*
|
*
|
* returns the set of signals that are traced / debugged.
|
* returns the set of signals that are traced / debugged.
|
* Will also copy the sigset if 'save' is non-zero.
|
* Will also copy the sigset if 'save' is non-zero.
|
*/
|
*/
|
|
|
sigset_t *
|
sigset_t *
|
proc_get_traced_signals (pi, save)
|
proc_get_traced_signals (pi, save)
|
procinfo *pi;
|
procinfo *pi;
|
sigset_t *save;
|
sigset_t *save;
|
{
|
{
|
sigset_t *ret = NULL;
|
sigset_t *ret = NULL;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
ret = &pi->prstatus.pr_sigtrace;
|
ret = &pi->prstatus.pr_sigtrace;
|
#else
|
#else
|
{
|
{
|
static sigset_t sigtrace;
|
static sigset_t sigtrace;
|
|
|
if (ioctl (pi->ctl_fd, PIOCGTRACE, &sigtrace) >= 0)
|
if (ioctl (pi->ctl_fd, PIOCGTRACE, &sigtrace) >= 0)
|
ret = &sigtrace;
|
ret = &sigtrace;
|
}
|
}
|
#endif
|
#endif
|
if (save && ret)
|
if (save && ret)
|
memcpy (save, ret, sizeof (sigset_t));
|
memcpy (save, ret, sizeof (sigset_t));
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_trace_signal
|
* Function: proc_trace_signal
|
*
|
*
|
* Add 'signo' to the set of signals that are traced.
|
* Add 'signo' to the set of signals that are traced.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_trace_signal (pi, signo)
|
proc_trace_signal (pi, signo)
|
procinfo *pi;
|
procinfo *pi;
|
int signo;
|
int signo;
|
{
|
{
|
sigset_t temp;
|
sigset_t temp;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
if (pi)
|
if (pi)
|
{
|
{
|
if (proc_get_traced_signals (pi, &temp))
|
if (proc_get_traced_signals (pi, &temp))
|
{
|
{
|
praddset (&temp, signo);
|
praddset (&temp, signo);
|
return proc_set_traced_signals (pi, &temp);
|
return proc_set_traced_signals (pi, &temp);
|
}
|
}
|
}
|
}
|
|
|
return 0; /* failure */
|
return 0; /* failure */
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_ignore_signal
|
* Function: proc_ignore_signal
|
*
|
*
|
* Remove 'signo' from the set of signals that are traced.
|
* Remove 'signo' from the set of signals that are traced.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_ignore_signal (pi, signo)
|
proc_ignore_signal (pi, signo)
|
procinfo *pi;
|
procinfo *pi;
|
int signo;
|
int signo;
|
{
|
{
|
sigset_t temp;
|
sigset_t temp;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
if (pi)
|
if (pi)
|
{
|
{
|
if (proc_get_traced_signals (pi, &temp))
|
if (proc_get_traced_signals (pi, &temp))
|
{
|
{
|
prdelset (&temp, signo);
|
prdelset (&temp, signo);
|
return proc_set_traced_signals (pi, &temp);
|
return proc_set_traced_signals (pi, &temp);
|
}
|
}
|
}
|
}
|
|
|
return 0; /* failure */
|
return 0; /* failure */
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_traced_faults
|
* Function: proc_get_traced_faults
|
*
|
*
|
* returns the set of hardware faults that are traced /debugged.
|
* returns the set of hardware faults that are traced /debugged.
|
* Will also copy the faultset if 'save' is non-zero.
|
* Will also copy the faultset if 'save' is non-zero.
|
*/
|
*/
|
|
|
fltset_t *
|
fltset_t *
|
proc_get_traced_faults (pi, save)
|
proc_get_traced_faults (pi, save)
|
procinfo *pi;
|
procinfo *pi;
|
fltset_t *save;
|
fltset_t *save;
|
{
|
{
|
fltset_t *ret = NULL;
|
fltset_t *ret = NULL;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
ret = &pi->prstatus.pr_flttrace;
|
ret = &pi->prstatus.pr_flttrace;
|
#else
|
#else
|
{
|
{
|
static fltset_t flttrace;
|
static fltset_t flttrace;
|
|
|
if (ioctl (pi->ctl_fd, PIOCGFAULT, &flttrace) >= 0)
|
if (ioctl (pi->ctl_fd, PIOCGFAULT, &flttrace) >= 0)
|
ret = &flttrace;
|
ret = &flttrace;
|
}
|
}
|
#endif
|
#endif
|
if (save && ret)
|
if (save && ret)
|
memcpy (save, ret, sizeof (fltset_t));
|
memcpy (save, ret, sizeof (fltset_t));
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_traced_sysentry
|
* Function: proc_get_traced_sysentry
|
*
|
*
|
* returns the set of syscalls that are traced /debugged on entry.
|
* returns the set of syscalls that are traced /debugged on entry.
|
* Will also copy the syscall set if 'save' is non-zero.
|
* Will also copy the syscall set if 'save' is non-zero.
|
*/
|
*/
|
|
|
sysset_t *
|
sysset_t *
|
proc_get_traced_sysentry (pi, save)
|
proc_get_traced_sysentry (pi, save)
|
procinfo *pi;
|
procinfo *pi;
|
sysset_t *save;
|
sysset_t *save;
|
{
|
{
|
sysset_t *ret = NULL;
|
sysset_t *ret = NULL;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
ret = &pi->prstatus.pr_sysentry;
|
ret = &pi->prstatus.pr_sysentry;
|
#else
|
#else
|
{
|
{
|
static sysset_t sysentry;
|
static sysset_t sysentry;
|
|
|
if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysentry) >= 0)
|
if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysentry) >= 0)
|
ret = &sysentry;
|
ret = &sysentry;
|
}
|
}
|
#endif
|
#endif
|
if (save && ret)
|
if (save && ret)
|
memcpy (save, ret, sizeof (sysset_t));
|
memcpy (save, ret, sizeof (sysset_t));
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_traced_sysexit
|
* Function: proc_get_traced_sysexit
|
*
|
*
|
* returns the set of syscalls that are traced /debugged on exit.
|
* returns the set of syscalls that are traced /debugged on exit.
|
* Will also copy the syscall set if 'save' is non-zero.
|
* Will also copy the syscall set if 'save' is non-zero.
|
*/
|
*/
|
|
|
sysset_t *
|
sysset_t *
|
proc_get_traced_sysexit (pi, save)
|
proc_get_traced_sysexit (pi, save)
|
procinfo *pi;
|
procinfo *pi;
|
sysset_t *save;
|
sysset_t *save;
|
{
|
{
|
sysset_t * ret = NULL;
|
sysset_t * ret = NULL;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
ret = &pi->prstatus.pr_sysexit;
|
ret = &pi->prstatus.pr_sysexit;
|
#else
|
#else
|
{
|
{
|
static sysset_t sysexit;
|
static sysset_t sysexit;
|
|
|
if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysexit) >= 0)
|
if (ioctl (pi->ctl_fd, PIOCGEXIT, &sysexit) >= 0)
|
ret = &sysexit;
|
ret = &sysexit;
|
}
|
}
|
#endif
|
#endif
|
if (save && ret)
|
if (save && ret)
|
memcpy (save, ret, sizeof (sysset_t));
|
memcpy (save, ret, sizeof (sysset_t));
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_clear_current_fault
|
* Function: proc_clear_current_fault
|
*
|
*
|
* The current fault (if any) is cleared; the associated signal
|
* The current fault (if any) is cleared; the associated signal
|
* will not be sent to the process or LWP when it resumes.
|
* will not be sent to the process or LWP when it resumes.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_clear_current_fault (pi)
|
proc_clear_current_fault (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
int cmd = PCCFAULT;
|
int cmd = PCCFAULT;
|
win = (write (pi->ctl_fd, (void *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
win = (write (pi->ctl_fd, (void *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
}
|
}
|
#else
|
#else
|
win = (ioctl (pi->ctl_fd, PIOCCFAULT, 0) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCCFAULT, 0) >= 0);
|
#endif
|
#endif
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_current_signal
|
* Function: proc_set_current_signal
|
*
|
*
|
* Set the "current signal" that will be delivered next to the process.
|
* Set the "current signal" that will be delivered next to the process.
|
* NOTE: semantics are different from those of KILL.
|
* NOTE: semantics are different from those of KILL.
|
* This signal will be delivered to the process or LWP
|
* This signal will be delivered to the process or LWP
|
* immediately when it is resumed (even if the signal is held/blocked);
|
* immediately when it is resumed (even if the signal is held/blocked);
|
* it will NOT immediately cause another event of interest, and will NOT
|
* it will NOT immediately cause another event of interest, and will NOT
|
* first trap back to the debugger.
|
* first trap back to the debugger.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_current_signal (pi, signo)
|
proc_set_current_signal (pi, signo)
|
procinfo *pi;
|
procinfo *pi;
|
int signo;
|
int signo;
|
{
|
{
|
int win;
|
int win;
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char sinfo[sizeof (struct siginfo)];
|
char sinfo[sizeof (struct siginfo)];
|
} arg;
|
} arg;
|
struct siginfo *mysinfo;
|
struct siginfo *mysinfo;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef PROCFS_DONT_PIOCSSIG_CURSIG
|
#ifdef PROCFS_DONT_PIOCSSIG_CURSIG
|
/* With Alpha OSF/1 procfs, the kernel gets really confused if it
|
/* With Alpha OSF/1 procfs, the kernel gets really confused if it
|
* receives a PIOCSSIG with a signal identical to the current signal,
|
* receives a PIOCSSIG with a signal identical to the current signal,
|
* it messes up the current signal. Work around the kernel bug.
|
* it messes up the current signal. Work around the kernel bug.
|
*/
|
*/
|
if (signo > 0 &&
|
if (signo > 0 &&
|
signo == proc_cursig (pi))
|
signo == proc_cursig (pi))
|
return 1; /* I assume this is a success? */
|
return 1; /* I assume this is a success? */
|
#endif
|
#endif
|
|
|
/* The pointer is just a type alias. */
|
/* The pointer is just a type alias. */
|
mysinfo = (struct siginfo *) &arg.sinfo;
|
mysinfo = (struct siginfo *) &arg.sinfo;
|
mysinfo->si_signo = signo;
|
mysinfo->si_signo = signo;
|
mysinfo->si_code = 0;
|
mysinfo->si_code = 0;
|
mysinfo->si_pid = getpid (); /* ?why? */
|
mysinfo->si_pid = getpid (); /* ?why? */
|
mysinfo->si_uid = getuid (); /* ?why? */
|
mysinfo->si_uid = getuid (); /* ?why? */
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
arg.cmd = PCSSIG;
|
arg.cmd = PCSSIG;
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
#else
|
#else
|
win = (ioctl (pi->ctl_fd, PIOCSSIG, (void *) &arg.sinfo) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSSIG, (void *) &arg.sinfo) >= 0);
|
#endif
|
#endif
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_clear_current_signal
|
* Function: proc_clear_current_signal
|
*
|
*
|
* The current signal (if any) is cleared, and
|
* The current signal (if any) is cleared, and
|
* is not sent to the process or LWP when it resumes.
|
* is not sent to the process or LWP when it resumes.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_clear_current_signal (pi)
|
proc_clear_current_signal (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
{
|
{
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char sinfo[sizeof (struct siginfo)];
|
char sinfo[sizeof (struct siginfo)];
|
} arg;
|
} arg;
|
struct siginfo *mysinfo;
|
struct siginfo *mysinfo;
|
|
|
arg.cmd = PCSSIG;
|
arg.cmd = PCSSIG;
|
/* The pointer is just a type alias. */
|
/* The pointer is just a type alias. */
|
mysinfo = (struct siginfo *) &arg.sinfo;
|
mysinfo = (struct siginfo *) &arg.sinfo;
|
mysinfo->si_signo = 0;
|
mysinfo->si_signo = 0;
|
mysinfo->si_code = 0;
|
mysinfo->si_code = 0;
|
mysinfo->si_errno = 0;
|
mysinfo->si_errno = 0;
|
mysinfo->si_pid = getpid (); /* ?why? */
|
mysinfo->si_pid = getpid (); /* ?why? */
|
mysinfo->si_uid = getuid (); /* ?why? */
|
mysinfo->si_uid = getuid (); /* ?why? */
|
|
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
}
|
}
|
#else
|
#else
|
win = (ioctl (pi->ctl_fd, PIOCSSIG, 0) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSSIG, 0) >= 0);
|
#endif
|
#endif
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_gregs
|
* Function: proc_get_gregs
|
*
|
*
|
* Get the general registers for the process or LWP.
|
* Get the general registers for the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
gdb_gregset_t *
|
gdb_gregset_t *
|
proc_get_gregs (pi)
|
proc_get_gregs (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (!pi->status_valid || !pi->gregs_valid)
|
if (!pi->status_valid || !pi->gregs_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
/*
|
/*
|
* OK, sorry about the ifdef's.
|
* OK, sorry about the ifdef's.
|
* There's three cases instead of two, because
|
* There's three cases instead of two, because
|
* in this instance Unixware and Solaris/RW differ.
|
* in this instance Unixware and Solaris/RW differ.
|
*/
|
*/
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
#ifdef UNIXWARE /* ugh, a true architecture dependency */
|
#ifdef UNIXWARE /* ugh, a true architecture dependency */
|
return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs;
|
return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs;
|
#else /* not Unixware */
|
#else /* not Unixware */
|
return &pi->prstatus.pr_lwp.pr_reg;
|
return &pi->prstatus.pr_lwp.pr_reg;
|
#endif /* Unixware */
|
#endif /* Unixware */
|
#else /* not NEW_PROC_API */
|
#else /* not NEW_PROC_API */
|
return &pi->prstatus.pr_reg;
|
return &pi->prstatus.pr_reg;
|
#endif /* NEW_PROC_API */
|
#endif /* NEW_PROC_API */
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_get_fpregs
|
* Function: proc_get_fpregs
|
*
|
*
|
* Get the floating point registers for the process or LWP.
|
* Get the floating point registers for the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
gdb_fpregset_t *
|
gdb_fpregset_t *
|
proc_get_fpregs (pi)
|
proc_get_fpregs (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (!pi->status_valid || !pi->fpregs_valid)
|
if (!pi->status_valid || !pi->fpregs_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return NULL;
|
return NULL;
|
|
|
#ifdef UNIXWARE /* a true architecture dependency */
|
#ifdef UNIXWARE /* a true architecture dependency */
|
return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs;
|
return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs;
|
#else
|
#else
|
return &pi->prstatus.pr_lwp.pr_fpreg;
|
return &pi->prstatus.pr_lwp.pr_fpreg;
|
#endif /* Unixware */
|
#endif /* Unixware */
|
|
|
#else /* not NEW_PROC_API */
|
#else /* not NEW_PROC_API */
|
if (pi->fpregs_valid)
|
if (pi->fpregs_valid)
|
return &pi->fpregset; /* already got 'em */
|
return &pi->fpregset; /* already got 'em */
|
else
|
else
|
{
|
{
|
if (pi->ctl_fd == 0 &&
|
if (pi->ctl_fd == 0 &&
|
open_procinfo_files (pi, FD_CTL) == 0)
|
open_procinfo_files (pi, FD_CTL) == 0)
|
{
|
{
|
return NULL;
|
return NULL;
|
}
|
}
|
else
|
else
|
{
|
{
|
#ifdef PIOCTGFPREG
|
#ifdef PIOCTGFPREG
|
struct {
|
struct {
|
long pr_count;
|
long pr_count;
|
tid_t pr_error_thread;
|
tid_t pr_error_thread;
|
tfpregset_t thread_1;
|
tfpregset_t thread_1;
|
} thread_fpregs;
|
} thread_fpregs;
|
|
|
thread_fpregs.pr_count = 1;
|
thread_fpregs.pr_count = 1;
|
thread_fpregs.thread_1.tid = pi->tid;
|
thread_fpregs.thread_1.tid = pi->tid;
|
|
|
if (pi->tid == 0 &&
|
if (pi->tid == 0 &&
|
ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
|
ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
|
{
|
{
|
pi->fpregs_valid = 1;
|
pi->fpregs_valid = 1;
|
return &pi->fpregset; /* got 'em now! */
|
return &pi->fpregset; /* got 'em now! */
|
}
|
}
|
else if (pi->tid != 0 &&
|
else if (pi->tid != 0 &&
|
ioctl (pi->ctl_fd, PIOCTGFPREG, &thread_fpregs) >= 0)
|
ioctl (pi->ctl_fd, PIOCTGFPREG, &thread_fpregs) >= 0)
|
{
|
{
|
memcpy (&pi->fpregset, &thread_fpregs.thread_1.pr_fpregs,
|
memcpy (&pi->fpregset, &thread_fpregs.thread_1.pr_fpregs,
|
sizeof (pi->fpregset));
|
sizeof (pi->fpregset));
|
pi->fpregs_valid = 1;
|
pi->fpregs_valid = 1;
|
return &pi->fpregset; /* got 'em now! */
|
return &pi->fpregset; /* got 'em now! */
|
}
|
}
|
else
|
else
|
{
|
{
|
return NULL;
|
return NULL;
|
}
|
}
|
#else
|
#else
|
if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
|
if (ioctl (pi->ctl_fd, PIOCGFPREG, &pi->fpregset) >= 0)
|
{
|
{
|
pi->fpregs_valid = 1;
|
pi->fpregs_valid = 1;
|
return &pi->fpregset; /* got 'em now! */
|
return &pi->fpregset; /* got 'em now! */
|
}
|
}
|
else
|
else
|
{
|
{
|
return NULL;
|
return NULL;
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_gregs
|
* Function: proc_set_gregs
|
*
|
*
|
* Write the general registers back to the process or LWP.
|
* Write the general registers back to the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_gregs (pi)
|
proc_set_gregs (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
gdb_gregset_t *gregs;
|
gdb_gregset_t *gregs;
|
int win;
|
int win;
|
|
|
if ((gregs = proc_get_gregs (pi)) == NULL)
|
if ((gregs = proc_get_gregs (pi)) == NULL)
|
return 0; /* get_regs has already warned */
|
return 0; /* get_regs has already warned */
|
|
|
if (pi->ctl_fd == 0 &&
|
if (pi->ctl_fd == 0 &&
|
open_procinfo_files (pi, FD_CTL) == 0)
|
open_procinfo_files (pi, FD_CTL) == 0)
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char gregs[sizeof (gdb_gregset_t)];
|
char gregs[sizeof (gdb_gregset_t)];
|
} arg;
|
} arg;
|
|
|
arg.cmd = PCSREG;
|
arg.cmd = PCSREG;
|
memcpy (&arg.gregs, gregs, sizeof (arg.gregs));
|
memcpy (&arg.gregs, gregs, sizeof (arg.gregs));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
#else
|
#else
|
win = (ioctl (pi->ctl_fd, PIOCSREG, gregs) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSREG, gregs) >= 0);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Policy: writing the regs invalidates our cache. */
|
/* Policy: writing the regs invalidates our cache. */
|
pi->gregs_valid = 0;
|
pi->gregs_valid = 0;
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_set_fpregs
|
* Function: proc_set_fpregs
|
*
|
*
|
* Modify the floating point register set of the process or LWP.
|
* Modify the floating point register set of the process or LWP.
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_fpregs (pi)
|
proc_set_fpregs (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
gdb_fpregset_t *fpregs;
|
gdb_fpregset_t *fpregs;
|
int win;
|
int win;
|
|
|
if ((fpregs = proc_get_fpregs (pi)) == NULL)
|
if ((fpregs = proc_get_fpregs (pi)) == NULL)
|
return 0; /* get_fpregs has already warned */
|
return 0; /* get_fpregs has already warned */
|
|
|
if (pi->ctl_fd == 0 &&
|
if (pi->ctl_fd == 0 &&
|
open_procinfo_files (pi, FD_CTL) == 0)
|
open_procinfo_files (pi, FD_CTL) == 0)
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
/* Use char array to avoid alignment issues. */
|
/* Use char array to avoid alignment issues. */
|
char fpregs[sizeof (gdb_fpregset_t)];
|
char fpregs[sizeof (gdb_fpregset_t)];
|
} arg;
|
} arg;
|
|
|
arg.cmd = PCSFPREG;
|
arg.cmd = PCSFPREG;
|
memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs));
|
memcpy (&arg.fpregs, fpregs, sizeof (arg.fpregs));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
win = (write (pi->ctl_fd, (void *) &arg, sizeof (arg)) == sizeof (arg));
|
#else
|
#else
|
#ifdef PIOCTSFPREG
|
#ifdef PIOCTSFPREG
|
if (pi->tid == 0)
|
if (pi->tid == 0)
|
win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
|
else
|
else
|
{
|
{
|
struct {
|
struct {
|
long pr_count;
|
long pr_count;
|
tid_t pr_error_thread;
|
tid_t pr_error_thread;
|
tfpregset_t thread_1;
|
tfpregset_t thread_1;
|
} thread_fpregs;
|
} thread_fpregs;
|
|
|
thread_fpregs.pr_count = 1;
|
thread_fpregs.pr_count = 1;
|
thread_fpregs.thread_1.tid = pi->tid;
|
thread_fpregs.thread_1.tid = pi->tid;
|
memcpy (&thread_fpregs.thread_1.pr_fpregs, fpregs,
|
memcpy (&thread_fpregs.thread_1.pr_fpregs, fpregs,
|
sizeof (*fpregs));
|
sizeof (*fpregs));
|
win = (ioctl (pi->ctl_fd, PIOCTSFPREG, &thread_fpregs) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCTSFPREG, &thread_fpregs) >= 0);
|
}
|
}
|
#else
|
#else
|
win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCSFPREG, fpregs) >= 0);
|
#endif /* osf PIOCTSFPREG */
|
#endif /* osf PIOCTSFPREG */
|
#endif /* NEW_PROC_API */
|
#endif /* NEW_PROC_API */
|
}
|
}
|
|
|
/* Policy: writing the regs invalidates our cache. */
|
/* Policy: writing the regs invalidates our cache. */
|
pi->fpregs_valid = 0;
|
pi->fpregs_valid = 0;
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_kill
|
* Function: proc_kill
|
*
|
*
|
* Send a signal to the proc or lwp with the semantics of "kill()".
|
* Send a signal to the proc or lwp with the semantics of "kill()".
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_kill (pi, signo)
|
proc_kill (pi, signo)
|
procinfo *pi;
|
procinfo *pi;
|
int signo;
|
int signo;
|
{
|
{
|
int win;
|
int win;
|
|
|
/*
|
/*
|
* We might conceivably apply this operation to an LWP, and
|
* We might conceivably apply this operation to an LWP, and
|
* the LWP's ctl file descriptor might not be open.
|
* the LWP's ctl file descriptor might not be open.
|
*/
|
*/
|
|
|
if (pi->ctl_fd == 0 &&
|
if (pi->ctl_fd == 0 &&
|
open_procinfo_files (pi, FD_CTL) == 0)
|
open_procinfo_files (pi, FD_CTL) == 0)
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
int cmd[2];
|
int cmd[2];
|
|
|
cmd[0] = PCKILL;
|
cmd[0] = PCKILL;
|
cmd[1] = signo;
|
cmd[1] = signo;
|
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
win = (write (pi->ctl_fd, (char *) &cmd, sizeof (cmd)) == sizeof (cmd));
|
#else /* ioctl method */
|
#else /* ioctl method */
|
/* FIXME: do I need the Alpha OSF fixups present in
|
/* FIXME: do I need the Alpha OSF fixups present in
|
procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
|
procfs.c/unconditionally_kill_inferior? Perhaps only for SIGKILL? */
|
win = (ioctl (pi->ctl_fd, PIOCKILL, &signo) >= 0);
|
win = (ioctl (pi->ctl_fd, PIOCKILL, &signo) >= 0);
|
#endif
|
#endif
|
}
|
}
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_parent_pid
|
* Function: proc_parent_pid
|
*
|
*
|
* Find the pid of the process that started this one.
|
* Find the pid of the process that started this one.
|
* Returns the parent process pid, or zero.
|
* Returns the parent process pid, or zero.
|
*/
|
*/
|
|
|
int
|
int
|
proc_parent_pid (pi)
|
proc_parent_pid (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0;
|
return 0;
|
|
|
return pi->prstatus.pr_ppid;
|
return pi->prstatus.pr_ppid;
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Function: proc_set_watchpoint
|
* Function: proc_set_watchpoint
|
*
|
*
|
*/
|
*/
|
|
|
int
|
int
|
proc_set_watchpoint (pi, addr, len, wflags)
|
proc_set_watchpoint (pi, addr, len, wflags)
|
procinfo *pi;
|
procinfo *pi;
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int len;
|
int len;
|
int wflags;
|
int wflags;
|
{
|
{
|
#if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
|
#if !defined (TARGET_HAS_HARDWARE_WATCHPOINTS)
|
return 0;
|
return 0;
|
#else
|
#else
|
/* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
|
/* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5 */
|
#if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
|
#if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out */
|
return 0;
|
return 0;
|
#else
|
#else
|
struct {
|
struct {
|
int cmd;
|
int cmd;
|
char watch[sizeof (prwatch_t)];
|
char watch[sizeof (prwatch_t)];
|
} arg;
|
} arg;
|
prwatch_t *pwatch;
|
prwatch_t *pwatch;
|
|
|
pwatch = (prwatch_t *) &arg.watch;
|
pwatch = (prwatch_t *) &arg.watch;
|
pwatch->pr_vaddr = addr;
|
pwatch->pr_vaddr = addr;
|
pwatch->pr_size = len;
|
pwatch->pr_size = len;
|
pwatch->pr_wflags = wflags;
|
pwatch->pr_wflags = wflags;
|
#if defined(NEW_PROC_API) && defined (PCWATCH)
|
#if defined(NEW_PROC_API) && defined (PCWATCH)
|
arg.cmd = PCWATCH;
|
arg.cmd = PCWATCH;
|
return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg));
|
return (write (pi->ctl_fd, &arg, sizeof (arg)) == sizeof (arg));
|
#else
|
#else
|
#if defined (PIOCSWATCH)
|
#if defined (PIOCSWATCH)
|
return (ioctl (pi->ctl_fd, PIOCSWATCH, pwatch) >= 0);
|
return (ioctl (pi->ctl_fd, PIOCSWATCH, pwatch) >= 0);
|
#else
|
#else
|
return 0; /* Fail */
|
return 0; /* Fail */
|
#endif
|
#endif
|
#endif
|
#endif
|
#endif
|
#endif
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* Function: proc_iterate_over_mappings
|
* Function: proc_iterate_over_mappings
|
*
|
*
|
* Given a pointer to a function, call that function once for every
|
* Given a pointer to a function, call that function once for every
|
* mapped address space in the process. The callback function
|
* mapped address space in the process. The callback function
|
* receives an open file descriptor for the file corresponding to
|
* receives an open file descriptor for the file corresponding to
|
* that mapped address space (if there is one), and the base address
|
* that mapped address space (if there is one), and the base address
|
* of the mapped space. Quit when the callback function returns a
|
* of the mapped space. Quit when the callback function returns a
|
* nonzero value, or at teh end of the mappings.
|
* nonzero value, or at teh end of the mappings.
|
*
|
*
|
* Returns: the first non-zero return value of the callback function,
|
* Returns: the first non-zero return value of the callback function,
|
* or zero.
|
* or zero.
|
*/
|
*/
|
|
|
/* FIXME: it's probably a waste to cache this FD.
|
/* FIXME: it's probably a waste to cache this FD.
|
It doesn't get called that often... and if I open it
|
It doesn't get called that often... and if I open it
|
every time, I don't need to lseek it. */
|
every time, I don't need to lseek it. */
|
int
|
int
|
proc_iterate_over_mappings (func)
|
proc_iterate_over_mappings (func)
|
int (*func) PARAMS ((int, CORE_ADDR));
|
int (*func) PARAMS ((int, CORE_ADDR));
|
{
|
{
|
struct prmap *map;
|
struct prmap *map;
|
procinfo *pi;
|
procinfo *pi;
|
#ifndef NEW_PROC_API /* avoid compiler warning */
|
#ifndef NEW_PROC_API /* avoid compiler warning */
|
int nmaps = 0;
|
int nmaps = 0;
|
int i;
|
int i;
|
#else
|
#else
|
int map_fd;
|
int map_fd;
|
char pathname[MAX_PROC_NAME_SIZE];
|
char pathname[MAX_PROC_NAME_SIZE];
|
#endif
|
#endif
|
int funcstat = 0;
|
int funcstat = 0;
|
int fd;
|
int fd;
|
|
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
/* Open map fd. */
|
/* Open map fd. */
|
sprintf (pathname, "/proc/%d/map", pi->pid);
|
sprintf (pathname, "/proc/%d/map", pi->pid);
|
if ((map_fd = open (pathname, O_RDONLY)) < 0)
|
if ((map_fd = open (pathname, O_RDONLY)) < 0)
|
proc_error (pi, "proc_iterate_over_mappings (open)", __LINE__);
|
proc_error (pi, "proc_iterate_over_mappings (open)", __LINE__);
|
|
|
/* Make sure it gets closed again. */
|
/* Make sure it gets closed again. */
|
make_cleanup ((make_cleanup_func) close, (void *) map_fd);
|
make_cleanup ((make_cleanup_func) close, (void *) map_fd);
|
|
|
/* Allocate space for mapping (lifetime only for this function). */
|
/* Allocate space for mapping (lifetime only for this function). */
|
map = alloca (sizeof (struct prmap));
|
map = alloca (sizeof (struct prmap));
|
|
|
/* Now read the mappings from the file,
|
/* Now read the mappings from the file,
|
open a file descriptor for those that have a name,
|
open a file descriptor for those that have a name,
|
and call the callback function. */
|
and call the callback function. */
|
while (read (map_fd,
|
while (read (map_fd,
|
(void *) map,
|
(void *) map,
|
sizeof (struct prmap)) == sizeof (struct prmap))
|
sizeof (struct prmap)) == sizeof (struct prmap))
|
{
|
{
|
char name[MAX_PROC_NAME_SIZE + sizeof (map->pr_mapname)];
|
char name[MAX_PROC_NAME_SIZE + sizeof (map->pr_mapname)];
|
|
|
if (map->pr_vaddr == 0 && map->pr_size == 0)
|
if (map->pr_vaddr == 0 && map->pr_size == 0)
|
break; /* sanity */
|
break; /* sanity */
|
|
|
if (map->pr_mapname[0] == 0)
|
if (map->pr_mapname[0] == 0)
|
{
|
{
|
fd = -1; /* no map file */
|
fd = -1; /* no map file */
|
}
|
}
|
else
|
else
|
{
|
{
|
sprintf (name, "/proc/%d/object/%s", pi->pid, map->pr_mapname);
|
sprintf (name, "/proc/%d/object/%s", pi->pid, map->pr_mapname);
|
/* Note: caller's responsibility to close this fd! */
|
/* Note: caller's responsibility to close this fd! */
|
fd = open (name, O_RDONLY);
|
fd = open (name, O_RDONLY);
|
/* Note: we don't test the above call for failure;
|
/* Note: we don't test the above call for failure;
|
we just pass the FD on as given. Sometimes there is
|
we just pass the FD on as given. Sometimes there is
|
no file, so the ioctl may return failure, but that's
|
no file, so the ioctl may return failure, but that's
|
not a problem. */
|
not a problem. */
|
}
|
}
|
|
|
/* Stop looping if the callback returns non-zero. */
|
/* Stop looping if the callback returns non-zero. */
|
if ((funcstat = (*func) (fd, (CORE_ADDR) map->pr_vaddr)) != 0)
|
if ((funcstat = (*func) (fd, (CORE_ADDR) map->pr_vaddr)) != 0)
|
break;
|
break;
|
}
|
}
|
#else
|
#else
|
/* Get the number of mapping entries. */
|
/* Get the number of mapping entries. */
|
if (ioctl (pi->ctl_fd, PIOCNMAP, &nmaps) < 0)
|
if (ioctl (pi->ctl_fd, PIOCNMAP, &nmaps) < 0)
|
proc_error (pi, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__);
|
proc_error (pi, "proc_iterate_over_mappings (PIOCNMAP)", __LINE__);
|
|
|
/* Allocate space for mappings (lifetime only this function). */
|
/* Allocate space for mappings (lifetime only this function). */
|
map = (struct prmap *) alloca ((nmaps + 1) * sizeof (struct prmap));
|
map = (struct prmap *) alloca ((nmaps + 1) * sizeof (struct prmap));
|
|
|
/* Read in all the mappings. */
|
/* Read in all the mappings. */
|
if (ioctl (pi->ctl_fd, PIOCMAP, map) < 0)
|
if (ioctl (pi->ctl_fd, PIOCMAP, map) < 0)
|
proc_error (pi, "proc_iterate_over_mappings (PIOCMAP)", __LINE__);
|
proc_error (pi, "proc_iterate_over_mappings (PIOCMAP)", __LINE__);
|
|
|
/* Now loop through the mappings, open an fd for each, and
|
/* Now loop through the mappings, open an fd for each, and
|
call the callback function. */
|
call the callback function. */
|
for (i = 0;
|
for (i = 0;
|
i < nmaps && map[i].pr_size != 0;
|
i < nmaps && map[i].pr_size != 0;
|
i++)
|
i++)
|
{
|
{
|
/* Note: caller's responsibility to close this fd! */
|
/* Note: caller's responsibility to close this fd! */
|
fd = ioctl (pi->ctl_fd, PIOCOPENM, &map[i].pr_vaddr);
|
fd = ioctl (pi->ctl_fd, PIOCOPENM, &map[i].pr_vaddr);
|
/* Note: we don't test the above call for failure;
|
/* Note: we don't test the above call for failure;
|
we just pass the FD on as given. Sometimes there is
|
we just pass the FD on as given. Sometimes there is
|
no file, so the ioctl may return failure, but that's
|
no file, so the ioctl may return failure, but that's
|
not a problem. */
|
not a problem. */
|
|
|
/* Stop looping if the callback returns non-zero. */
|
/* Stop looping if the callback returns non-zero. */
|
if ((funcstat = (*func) (fd, (CORE_ADDR) map[i].pr_vaddr)) != 0)
|
if ((funcstat = (*func) (fd, (CORE_ADDR) map[i].pr_vaddr)) != 0)
|
break;
|
break;
|
}
|
}
|
#endif
|
#endif
|
|
|
return funcstat;
|
return funcstat;
|
}
|
}
|
|
|
#ifdef TM_I386SOL2_H /* Is it hokey to use this? */
|
#ifdef TM_I386SOL2_H /* Is it hokey to use this? */
|
|
|
#include <sys/sysi86.h>
|
#include <sys/sysi86.h>
|
|
|
/*
|
/*
|
* Function: proc_get_LDT_entry
|
* Function: proc_get_LDT_entry
|
*
|
*
|
* Inputs:
|
* Inputs:
|
* procinfo *pi;
|
* procinfo *pi;
|
* int key;
|
* int key;
|
*
|
*
|
* The 'key' is actually the value of the lower 16 bits of
|
* The 'key' is actually the value of the lower 16 bits of
|
* the GS register for the LWP that we're interested in.
|
* the GS register for the LWP that we're interested in.
|
*
|
*
|
* Return: matching ssh struct (LDT entry).
|
* Return: matching ssh struct (LDT entry).
|
*/
|
*/
|
|
|
struct ssd *
|
struct ssd *
|
proc_get_LDT_entry (pi, key)
|
proc_get_LDT_entry (pi, key)
|
procinfo *pi;
|
procinfo *pi;
|
int key;
|
int key;
|
{
|
{
|
static struct ssd *ldt_entry = NULL;
|
static struct ssd *ldt_entry = NULL;
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
char pathname[MAX_PROC_NAME_SIZE];
|
char pathname[MAX_PROC_NAME_SIZE];
|
struct cleanup *old_chain = NULL;
|
struct cleanup *old_chain = NULL;
|
int fd;
|
int fd;
|
|
|
/* Allocate space for one LDT entry.
|
/* Allocate space for one LDT entry.
|
This alloc must persist, because we return a pointer to it. */
|
This alloc must persist, because we return a pointer to it. */
|
if (ldt_entry == NULL)
|
if (ldt_entry == NULL)
|
ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd));
|
ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd));
|
|
|
/* Open the file descriptor for the LDT table. */
|
/* Open the file descriptor for the LDT table. */
|
sprintf (pathname, "/proc/%d/ldt", pi->pid);
|
sprintf (pathname, "/proc/%d/ldt", pi->pid);
|
if ((fd = open (pathname, O_RDONLY)) < 0)
|
if ((fd = open (pathname, O_RDONLY)) < 0)
|
{
|
{
|
proc_warn (pi, "proc_get_LDT_entry (open)", __LINE__);
|
proc_warn (pi, "proc_get_LDT_entry (open)", __LINE__);
|
return NULL;
|
return NULL;
|
}
|
}
|
/* Make sure it gets closed again! */
|
/* Make sure it gets closed again! */
|
old_chain = make_cleanup ((make_cleanup_func) close, (void *) fd);
|
old_chain = make_cleanup ((make_cleanup_func) close, (void *) fd);
|
|
|
/* Now 'read' thru the table, find a match and return it. */
|
/* Now 'read' thru the table, find a match and return it. */
|
while (read (fd, ldt_entry, sizeof (struct ssd)) == sizeof (struct ssd))
|
while (read (fd, ldt_entry, sizeof (struct ssd)) == sizeof (struct ssd))
|
{
|
{
|
if (ldt_entry->sel == 0 &&
|
if (ldt_entry->sel == 0 &&
|
ldt_entry->bo == 0 &&
|
ldt_entry->bo == 0 &&
|
ldt_entry->acc1 == 0 &&
|
ldt_entry->acc1 == 0 &&
|
ldt_entry->acc2 == 0)
|
ldt_entry->acc2 == 0)
|
break; /* end of table */
|
break; /* end of table */
|
/* If key matches, return this entry. */
|
/* If key matches, return this entry. */
|
if (ldt_entry->sel == key)
|
if (ldt_entry->sel == key)
|
return ldt_entry;
|
return ldt_entry;
|
}
|
}
|
/* Loop ended, match not found. */
|
/* Loop ended, match not found. */
|
return NULL;
|
return NULL;
|
#else
|
#else
|
int nldt, i;
|
int nldt, i;
|
static int nalloc = 0;
|
static int nalloc = 0;
|
|
|
/* Get the number of LDT entries. */
|
/* Get the number of LDT entries. */
|
if (ioctl (pi->ctl_fd, PIOCNLDT, &nldt) < 0)
|
if (ioctl (pi->ctl_fd, PIOCNLDT, &nldt) < 0)
|
{
|
{
|
proc_warn (pi, "proc_get_LDT_entry (PIOCNLDT)", __LINE__);
|
proc_warn (pi, "proc_get_LDT_entry (PIOCNLDT)", __LINE__);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Allocate space for the number of LDT entries. */
|
/* Allocate space for the number of LDT entries. */
|
/* This alloc has to persist, 'cause we return a pointer to it. */
|
/* This alloc has to persist, 'cause we return a pointer to it. */
|
if (nldt > nalloc)
|
if (nldt > nalloc)
|
{
|
{
|
ldt_entry = (struct ssd *)
|
ldt_entry = (struct ssd *)
|
xrealloc (ldt_entry, (nldt + 1) * sizeof (struct ssd));
|
xrealloc (ldt_entry, (nldt + 1) * sizeof (struct ssd));
|
nalloc = nldt;
|
nalloc = nldt;
|
}
|
}
|
|
|
/* Read the whole table in one gulp. */
|
/* Read the whole table in one gulp. */
|
if (ioctl (pi->ctl_fd, PIOCLDT, ldt_entry) < 0)
|
if (ioctl (pi->ctl_fd, PIOCLDT, ldt_entry) < 0)
|
{
|
{
|
proc_warn (pi, "proc_get_LDT_entry (PIOCLDT)", __LINE__);
|
proc_warn (pi, "proc_get_LDT_entry (PIOCLDT)", __LINE__);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Search the table and return the (first) entry matching 'key'. */
|
/* Search the table and return the (first) entry matching 'key'. */
|
for (i = 0; i < nldt; i++)
|
for (i = 0; i < nldt; i++)
|
if (ldt_entry[i].sel == key)
|
if (ldt_entry[i].sel == key)
|
return &ldt_entry[i];
|
return &ldt_entry[i];
|
|
|
/* Loop ended, match not found. */
|
/* Loop ended, match not found. */
|
return NULL;
|
return NULL;
|
#endif
|
#endif
|
}
|
}
|
|
|
#endif /* TM_I386SOL2_H */
|
#endif /* TM_I386SOL2_H */
|
|
|
/* =============== END, non-thread part of /proc "MODULE" =============== */
|
/* =============== END, non-thread part of /proc "MODULE" =============== */
|
|
|
/* =================== Thread "MODULE" =================== */
|
/* =================== Thread "MODULE" =================== */
|
|
|
/* NOTE: you'll see more ifdefs and duplication of functions here,
|
/* NOTE: you'll see more ifdefs and duplication of functions here,
|
since there is a different way to do threads on every OS. */
|
since there is a different way to do threads on every OS. */
|
|
|
/*
|
/*
|
* Function: proc_get_nthreads
|
* Function: proc_get_nthreads
|
*
|
*
|
* Return the number of threads for the process
|
* Return the number of threads for the process
|
*/
|
*/
|
|
|
#if defined (PIOCNTHR) && defined (PIOCTLIST)
|
#if defined (PIOCNTHR) && defined (PIOCTLIST)
|
/*
|
/*
|
* OSF version
|
* OSF version
|
*/
|
*/
|
int
|
int
|
proc_get_nthreads (pi)
|
proc_get_nthreads (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
int nthreads = 0;
|
int nthreads = 0;
|
|
|
if (ioctl (pi->ctl_fd, PIOCNTHR, &nthreads) < 0)
|
if (ioctl (pi->ctl_fd, PIOCNTHR, &nthreads) < 0)
|
proc_warn (pi, "procfs: PIOCNTHR failed", __LINE__);
|
proc_warn (pi, "procfs: PIOCNTHR failed", __LINE__);
|
|
|
return nthreads;
|
return nthreads;
|
}
|
}
|
|
|
#else
|
#else
|
#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
|
#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
|
/*
|
/*
|
* Solaris and Unixware version
|
* Solaris and Unixware version
|
*/
|
*/
|
int
|
int
|
proc_get_nthreads (pi)
|
proc_get_nthreads (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0;
|
return 0;
|
|
|
/*
|
/*
|
* NEW_PROC_API: only works for the process procinfo,
|
* NEW_PROC_API: only works for the process procinfo,
|
* because the LWP procinfos do not get prstatus filled in.
|
* because the LWP procinfos do not get prstatus filled in.
|
*/
|
*/
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
if (pi->tid != 0) /* find the parent process procinfo */
|
if (pi->tid != 0) /* find the parent process procinfo */
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
#endif
|
#endif
|
return pi->prstatus.pr_nlwp;
|
return pi->prstatus.pr_nlwp;
|
}
|
}
|
|
|
#else
|
#else
|
/*
|
/*
|
* Default version
|
* Default version
|
*/
|
*/
|
int
|
int
|
proc_get_nthreads (pi)
|
proc_get_nthreads (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
#endif
|
#endif
|
#endif
|
#endif
|
|
|
/*
|
/*
|
* Function: proc_get_current_thread (LWP version)
|
* Function: proc_get_current_thread (LWP version)
|
*
|
*
|
* Return the ID of the thread that had an event of interest.
|
* Return the ID of the thread that had an event of interest.
|
* (ie. the one that hit a breakpoint or other traced event).
|
* (ie. the one that hit a breakpoint or other traced event).
|
* All other things being equal, this should be the ID of a
|
* All other things being equal, this should be the ID of a
|
* thread that is currently executing.
|
* thread that is currently executing.
|
*/
|
*/
|
|
|
#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
|
#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
|
/*
|
/*
|
* Solaris and Unixware version
|
* Solaris and Unixware version
|
*/
|
*/
|
int
|
int
|
proc_get_current_thread (pi)
|
proc_get_current_thread (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
/*
|
/*
|
* Note: this should be applied to the root procinfo for the process,
|
* Note: this should be applied to the root procinfo for the process,
|
* not to the procinfo for an LWP. If applied to the procinfo for
|
* not to the procinfo for an LWP. If applied to the procinfo for
|
* an LWP, it will simply return that LWP's ID. In that case,
|
* an LWP, it will simply return that LWP's ID. In that case,
|
* find the parent process procinfo.
|
* find the parent process procinfo.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
if (!pi->status_valid)
|
if (!pi->status_valid)
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
return 0;
|
return 0;
|
|
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
return pi->prstatus.pr_lwp.pr_lwpid;
|
return pi->prstatus.pr_lwp.pr_lwpid;
|
#else
|
#else
|
return pi->prstatus.pr_who;
|
return pi->prstatus.pr_who;
|
#endif
|
#endif
|
}
|
}
|
|
|
#else
|
#else
|
#if defined (PIOCNTHR) && defined (PIOCTLIST)
|
#if defined (PIOCNTHR) && defined (PIOCTLIST)
|
/*
|
/*
|
* OSF version
|
* OSF version
|
*/
|
*/
|
int
|
int
|
proc_get_current_thread (pi)
|
proc_get_current_thread (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
#if 0 /* FIXME: not ready for prime time? */
|
#if 0 /* FIXME: not ready for prime time? */
|
return pi->prstatus.pr_tid;
|
return pi->prstatus.pr_tid;
|
#else
|
#else
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
#else
|
#else
|
/*
|
/*
|
* Default version
|
* Default version
|
*/
|
*/
|
int
|
int
|
proc_get_current_thread (pi)
|
proc_get_current_thread (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#endif
|
#endif
|
#endif
|
#endif
|
|
|
/*
|
/*
|
* Function: proc_update_threads
|
* Function: proc_update_threads
|
*
|
*
|
* Discover the IDs of all the threads within the process, and
|
* Discover the IDs of all the threads within the process, and
|
* create a procinfo for each of them (chained to the parent).
|
* create a procinfo for each of them (chained to the parent).
|
*
|
*
|
* This unfortunately requires a different method on every OS.
|
* This unfortunately requires a different method on every OS.
|
*
|
*
|
* Return: non-zero for success, zero for failure.
|
* Return: non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
int
|
int
|
proc_delete_dead_threads (parent, thread, ignore)
|
proc_delete_dead_threads (parent, thread, ignore)
|
procinfo *parent;
|
procinfo *parent;
|
procinfo *thread;
|
procinfo *thread;
|
void *ignore;
|
void *ignore;
|
{
|
{
|
if (thread && parent) /* sanity */
|
if (thread && parent) /* sanity */
|
{
|
{
|
thread->status_valid = 0;
|
thread->status_valid = 0;
|
if (!proc_get_status (thread))
|
if (!proc_get_status (thread))
|
destroy_one_procinfo (&parent->thread_list, thread);
|
destroy_one_procinfo (&parent->thread_list, thread);
|
}
|
}
|
return 0; /* keep iterating */
|
return 0; /* keep iterating */
|
}
|
}
|
|
|
#if defined (PIOCLSTATUS)
|
#if defined (PIOCLSTATUS)
|
/*
|
/*
|
* Solaris 2.5 (ioctl) version
|
* Solaris 2.5 (ioctl) version
|
*/
|
*/
|
int
|
int
|
proc_update_threads (pi)
|
proc_update_threads (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
gdb_prstatus_t *prstatus;
|
gdb_prstatus_t *prstatus;
|
struct cleanup *old_chain = NULL;
|
struct cleanup *old_chain = NULL;
|
procinfo *thread;
|
procinfo *thread;
|
int nlwp, i;
|
int nlwp, i;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
|
proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
|
|
|
if ((nlwp = proc_get_nthreads (pi)) <= 1)
|
if ((nlwp = proc_get_nthreads (pi)) <= 1)
|
return 1; /* Process is not multi-threaded; nothing to do. */
|
return 1; /* Process is not multi-threaded; nothing to do. */
|
|
|
if ((prstatus = (gdb_prstatus_t *)
|
if ((prstatus = (gdb_prstatus_t *)
|
malloc (sizeof (gdb_prstatus_t) * (nlwp + 1))) == 0)
|
malloc (sizeof (gdb_prstatus_t) * (nlwp + 1))) == 0)
|
perror_with_name ("procfs: malloc failed in update_threads");
|
perror_with_name ("procfs: malloc failed in update_threads");
|
|
|
old_chain = make_cleanup (free, prstatus);
|
old_chain = make_cleanup (free, prstatus);
|
if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0)
|
if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0)
|
proc_error (pi, "update_threads (PIOCLSTATUS)", __LINE__);
|
proc_error (pi, "update_threads (PIOCLSTATUS)", __LINE__);
|
|
|
/* Skip element zero, which represents the process as a whole. */
|
/* Skip element zero, which represents the process as a whole. */
|
for (i = 1; i < nlwp + 1; i++)
|
for (i = 1; i < nlwp + 1; i++)
|
{
|
{
|
if ((thread = create_procinfo (pi->pid, prstatus[i].pr_who)) == NULL)
|
if ((thread = create_procinfo (pi->pid, prstatus[i].pr_who)) == NULL)
|
proc_error (pi, "update_threads, create_procinfo", __LINE__);
|
proc_error (pi, "update_threads, create_procinfo", __LINE__);
|
|
|
memcpy (&thread->prstatus, &prstatus[i], sizeof (*prstatus));
|
memcpy (&thread->prstatus, &prstatus[i], sizeof (*prstatus));
|
thread->status_valid = 1;
|
thread->status_valid = 1;
|
}
|
}
|
pi->threads_valid = 1;
|
pi->threads_valid = 1;
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
return 1;
|
return 1;
|
}
|
}
|
#else
|
#else
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
/*
|
/*
|
* Unixware and Solaris 6 (and later) version
|
* Unixware and Solaris 6 (and later) version
|
*/
|
*/
|
int
|
int
|
proc_update_threads (pi)
|
proc_update_threads (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
char pathname[MAX_PROC_NAME_SIZE + 16];
|
char pathname[MAX_PROC_NAME_SIZE + 16];
|
struct dirent *direntry;
|
struct dirent *direntry;
|
struct cleanup *old_chain = NULL;
|
struct cleanup *old_chain = NULL;
|
procinfo *thread;
|
procinfo *thread;
|
DIR *dirp;
|
DIR *dirp;
|
int lwpid;
|
int lwpid;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
|
proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
|
|
|
/*
|
/*
|
* Unixware
|
* Unixware
|
*
|
*
|
* Note: this brute-force method is the only way I know of
|
* Note: this brute-force method is the only way I know of
|
* to accomplish this task on Unixware. This method will
|
* to accomplish this task on Unixware. This method will
|
* also work on Solaris 2.6 and 2.7. There is a much simpler
|
* also work on Solaris 2.6 and 2.7. There is a much simpler
|
* and more elegant way to do this on Solaris, but the margins
|
* and more elegant way to do this on Solaris, but the margins
|
* of this manuscript are too small to write it here... ;-)
|
* of this manuscript are too small to write it here... ;-)
|
*/
|
*/
|
|
|
strcpy (pathname, pi->pathname);
|
strcpy (pathname, pi->pathname);
|
strcat (pathname, "/lwp");
|
strcat (pathname, "/lwp");
|
if ((dirp = opendir (pathname)) == NULL)
|
if ((dirp = opendir (pathname)) == NULL)
|
proc_error (pi, "update_threads, opendir", __LINE__);
|
proc_error (pi, "update_threads, opendir", __LINE__);
|
|
|
old_chain = make_cleanup ((make_cleanup_func) closedir, dirp);
|
old_chain = make_cleanup ((make_cleanup_func) closedir, dirp);
|
while ((direntry = readdir (dirp)) != NULL)
|
while ((direntry = readdir (dirp)) != NULL)
|
if (direntry->d_name[0] != '.') /* skip '.' and '..' */
|
if (direntry->d_name[0] != '.') /* skip '.' and '..' */
|
{
|
{
|
lwpid = atoi (&direntry->d_name[0]);
|
lwpid = atoi (&direntry->d_name[0]);
|
if ((thread = create_procinfo (pi->pid, lwpid)) == NULL)
|
if ((thread = create_procinfo (pi->pid, lwpid)) == NULL)
|
proc_error (pi, "update_threads, create_procinfo", __LINE__);
|
proc_error (pi, "update_threads, create_procinfo", __LINE__);
|
}
|
}
|
pi->threads_valid = 1;
|
pi->threads_valid = 1;
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
return 1;
|
return 1;
|
}
|
}
|
#else
|
#else
|
#ifdef PIOCTLIST
|
#ifdef PIOCTLIST
|
/*
|
/*
|
* OSF version
|
* OSF version
|
*/
|
*/
|
int
|
int
|
proc_update_threads (pi)
|
proc_update_threads (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
int nthreads, i;
|
int nthreads, i;
|
tid_t *threads;
|
tid_t *threads;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
|
proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
|
|
|
nthreads = proc_get_nthreads (pi);
|
nthreads = proc_get_nthreads (pi);
|
if (nthreads < 2)
|
if (nthreads < 2)
|
return 0; /* nothing to do for 1 or fewer threads */
|
return 0; /* nothing to do for 1 or fewer threads */
|
|
|
if ((threads = malloc (nthreads * sizeof (tid_t))) == NULL)
|
if ((threads = malloc (nthreads * sizeof (tid_t))) == NULL)
|
proc_error (pi, "update_threads, malloc", __LINE__);
|
proc_error (pi, "update_threads, malloc", __LINE__);
|
|
|
if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0)
|
if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0)
|
proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__);
|
proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__);
|
|
|
for (i = 0; i < nthreads; i++)
|
for (i = 0; i < nthreads; i++)
|
{
|
{
|
if (!find_procinfo (pi->pid, threads[i]))
|
if (!find_procinfo (pi->pid, threads[i]))
|
if (!create_procinfo (pi->pid, threads[i]))
|
if (!create_procinfo (pi->pid, threads[i]))
|
proc_error (pi, "update_threads, create_procinfo", __LINE__);
|
proc_error (pi, "update_threads, create_procinfo", __LINE__);
|
}
|
}
|
pi->threads_valid = 1;
|
pi->threads_valid = 1;
|
return 1;
|
return 1;
|
}
|
}
|
#else
|
#else
|
/*
|
/*
|
* Default version
|
* Default version
|
*/
|
*/
|
int
|
int
|
proc_update_threads (pi)
|
proc_update_threads (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
#endif /* OSF PIOCTLIST */
|
#endif /* OSF PIOCTLIST */
|
#endif /* NEW_PROC_API */
|
#endif /* NEW_PROC_API */
|
#endif /* SOL 2.5 PIOCLSTATUS */
|
#endif /* SOL 2.5 PIOCLSTATUS */
|
|
|
/*
|
/*
|
* Function: proc_iterate_over_threads
|
* Function: proc_iterate_over_threads
|
*
|
*
|
* Description:
|
* Description:
|
* Given a pointer to a function, call that function once
|
* Given a pointer to a function, call that function once
|
* for each lwp in the procinfo list, until the function
|
* for each lwp in the procinfo list, until the function
|
* returns non-zero, in which event return the value
|
* returns non-zero, in which event return the value
|
* returned by the function.
|
* returned by the function.
|
*
|
*
|
* Note: this function does NOT call update_threads.
|
* Note: this function does NOT call update_threads.
|
* If you want to discover new threads first, you must
|
* If you want to discover new threads first, you must
|
* call that function explicitly. This function just makes
|
* call that function explicitly. This function just makes
|
* a quick pass over the currently-known procinfos.
|
* a quick pass over the currently-known procinfos.
|
*
|
*
|
* Arguments:
|
* Arguments:
|
* pi - parent process procinfo
|
* pi - parent process procinfo
|
* func - per-thread function
|
* func - per-thread function
|
* ptr - opaque parameter for function.
|
* ptr - opaque parameter for function.
|
*
|
*
|
* Return:
|
* Return:
|
* First non-zero return value from the callee, or zero.
|
* First non-zero return value from the callee, or zero.
|
*/
|
*/
|
|
|
int
|
int
|
proc_iterate_over_threads (pi, func, ptr)
|
proc_iterate_over_threads (pi, func, ptr)
|
procinfo *pi;
|
procinfo *pi;
|
int (*func) PARAMS ((procinfo *, procinfo *, void *));
|
int (*func) PARAMS ((procinfo *, procinfo *, void *));
|
void *ptr;
|
void *ptr;
|
{
|
{
|
procinfo *thread, *next;
|
procinfo *thread, *next;
|
int retval = 0;
|
int retval = 0;
|
|
|
/*
|
/*
|
* We should never have to apply this operation to any procinfo
|
* We should never have to apply this operation to any procinfo
|
* except the one for the main process. If that ever changes
|
* except the one for the main process. If that ever changes
|
* for any reason, then take out the following clause and
|
* for any reason, then take out the following clause and
|
* replace it with one that makes sure the ctl_fd is open.
|
* replace it with one that makes sure the ctl_fd is open.
|
*/
|
*/
|
|
|
if (pi->tid != 0)
|
if (pi->tid != 0)
|
pi = find_procinfo_or_die (pi->pid, 0);
|
pi = find_procinfo_or_die (pi->pid, 0);
|
|
|
for (thread = pi->thread_list; thread != NULL; thread = next)
|
for (thread = pi->thread_list; thread != NULL; thread = next)
|
{
|
{
|
next = thread->next; /* in case thread is destroyed */
|
next = thread->next; /* in case thread is destroyed */
|
if ((retval = (*func) (pi, thread, ptr)) != 0)
|
if ((retval = (*func) (pi, thread, ptr)) != 0)
|
break;
|
break;
|
}
|
}
|
|
|
return retval;
|
return retval;
|
}
|
}
|
|
|
/* =================== END, Thread "MODULE" =================== */
|
/* =================== END, Thread "MODULE" =================== */
|
|
|
/* =================== END, /proc "MODULE" =================== */
|
/* =================== END, /proc "MODULE" =================== */
|
|
|
/* =================== GDB "MODULE" =================== */
|
/* =================== GDB "MODULE" =================== */
|
|
|
/*
|
/*
|
* Here are all of the gdb target vector functions and their friends.
|
* Here are all of the gdb target vector functions and their friends.
|
*/
|
*/
|
|
|
static int do_attach PARAMS ((int pid));
|
static int do_attach PARAMS ((int pid));
|
static void do_detach PARAMS ((int signo));
|
static void do_detach PARAMS ((int signo));
|
static int register_gdb_signals PARAMS ((procinfo *, sigset_t *));
|
static int register_gdb_signals PARAMS ((procinfo *, sigset_t *));
|
|
|
/*
|
/*
|
* Function: procfs_debug_inferior
|
* Function: procfs_debug_inferior
|
*
|
*
|
* Sets up the inferior to be debugged.
|
* Sets up the inferior to be debugged.
|
* Registers to trace signals, hardware faults, and syscalls.
|
* Registers to trace signals, hardware faults, and syscalls.
|
* Note: does not set RLC flag: caller may want to customize that.
|
* Note: does not set RLC flag: caller may want to customize that.
|
*
|
*
|
* Returns: zero for success (note! unlike most functions in this module)
|
* Returns: zero for success (note! unlike most functions in this module)
|
* On failure, returns the LINE NUMBER where it failed!
|
* On failure, returns the LINE NUMBER where it failed!
|
*/
|
*/
|
|
|
static int
|
static int
|
procfs_debug_inferior (pi)
|
procfs_debug_inferior (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
fltset_t traced_faults;
|
fltset_t traced_faults;
|
sigset_t traced_signals;
|
sigset_t traced_signals;
|
sysset_t traced_syscall_entries;
|
sysset_t traced_syscall_entries;
|
sysset_t traced_syscall_exits;
|
sysset_t traced_syscall_exits;
|
|
|
#ifdef PROCFS_DONT_TRACE_FAULTS
|
#ifdef PROCFS_DONT_TRACE_FAULTS
|
/* On some systems (OSF), we don't trace hardware faults.
|
/* On some systems (OSF), we don't trace hardware faults.
|
Apparently it's enough that we catch them as signals.
|
Apparently it's enough that we catch them as signals.
|
Wonder why we don't just do that in general? */
|
Wonder why we don't just do that in general? */
|
premptyset (&traced_faults); /* don't trace faults. */
|
premptyset (&traced_faults); /* don't trace faults. */
|
#else
|
#else
|
/* Register to trace hardware faults in the child. */
|
/* Register to trace hardware faults in the child. */
|
prfillset (&traced_faults); /* trace all faults... */
|
prfillset (&traced_faults); /* trace all faults... */
|
prdelset (&traced_faults, FLTPAGE); /* except page fault. */
|
prdelset (&traced_faults, FLTPAGE); /* except page fault. */
|
#endif
|
#endif
|
if (!proc_set_traced_faults (pi, &traced_faults))
|
if (!proc_set_traced_faults (pi, &traced_faults))
|
return __LINE__;
|
return __LINE__;
|
|
|
/* Register to trace selected signals in the child. */
|
/* Register to trace selected signals in the child. */
|
premptyset (&traced_signals);
|
premptyset (&traced_signals);
|
if (!register_gdb_signals (pi, &traced_signals))
|
if (!register_gdb_signals (pi, &traced_signals))
|
return __LINE__;
|
return __LINE__;
|
|
|
/* Register to trace the 'exit' system call (on entry). */
|
/* Register to trace the 'exit' system call (on entry). */
|
premptyset (&traced_syscall_entries);
|
premptyset (&traced_syscall_entries);
|
praddset (&traced_syscall_entries, SYS_exit);
|
praddset (&traced_syscall_entries, SYS_exit);
|
#ifdef SYS_lwpexit
|
#ifdef SYS_lwpexit
|
praddset (&traced_syscall_entries, SYS_lwpexit); /* And _lwp_exit... */
|
praddset (&traced_syscall_entries, SYS_lwpexit); /* And _lwp_exit... */
|
#endif
|
#endif
|
#ifdef SYS_lwp_exit
|
#ifdef SYS_lwp_exit
|
praddset (&traced_syscall_entries, SYS_lwp_exit);
|
praddset (&traced_syscall_entries, SYS_lwp_exit);
|
#endif
|
#endif
|
|
|
if (!proc_set_traced_sysentry (pi, &traced_syscall_entries))
|
if (!proc_set_traced_sysentry (pi, &traced_syscall_entries))
|
return __LINE__;
|
return __LINE__;
|
|
|
#ifdef PRFS_STOPEXEC /* defined on OSF */
|
#ifdef PRFS_STOPEXEC /* defined on OSF */
|
/* OSF method for tracing exec syscalls. Quoting:
|
/* OSF method for tracing exec syscalls. Quoting:
|
Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
|
Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
|
exits from exec system calls because of the user level loader. */
|
exits from exec system calls because of the user level loader. */
|
/* FIXME: make nice and maybe move into an access function. */
|
/* FIXME: make nice and maybe move into an access function. */
|
{
|
{
|
int prfs_flags;
|
int prfs_flags;
|
|
|
if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
|
if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
|
return __LINE__;
|
return __LINE__;
|
|
|
prfs_flags |= PRFS_STOPEXEC;
|
prfs_flags |= PRFS_STOPEXEC;
|
|
|
if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
|
if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
|
return __LINE__;
|
return __LINE__;
|
}
|
}
|
#else /* not PRFS_STOPEXEC */
|
#else /* not PRFS_STOPEXEC */
|
/* Everyone else's (except OSF) method for tracing exec syscalls */
|
/* Everyone else's (except OSF) method for tracing exec syscalls */
|
/* GW: Rationale...
|
/* GW: Rationale...
|
Not all systems with /proc have all the exec* syscalls with the same
|
Not all systems with /proc have all the exec* syscalls with the same
|
names. On the SGI, for example, there is no SYS_exec, but there
|
names. On the SGI, for example, there is no SYS_exec, but there
|
*is* a SYS_execv. So, we try to account for that. */
|
*is* a SYS_execv. So, we try to account for that. */
|
|
|
premptyset (&traced_syscall_exits);
|
premptyset (&traced_syscall_exits);
|
#ifdef SYS_exec
|
#ifdef SYS_exec
|
praddset (&traced_syscall_exits, SYS_exec);
|
praddset (&traced_syscall_exits, SYS_exec);
|
#endif
|
#endif
|
#ifdef SYS_execve
|
#ifdef SYS_execve
|
praddset (&traced_syscall_exits, SYS_execve);
|
praddset (&traced_syscall_exits, SYS_execve);
|
#endif
|
#endif
|
#ifdef SYS_execv
|
#ifdef SYS_execv
|
praddset (&traced_syscall_exits, SYS_execv);
|
praddset (&traced_syscall_exits, SYS_execv);
|
#endif
|
#endif
|
|
|
#ifdef SYS_lwpcreate
|
#ifdef SYS_lwpcreate
|
praddset (&traced_syscall_exits, SYS_lwpcreate);
|
praddset (&traced_syscall_exits, SYS_lwpcreate);
|
praddset (&traced_syscall_exits, SYS_lwpexit);
|
praddset (&traced_syscall_exits, SYS_lwpexit);
|
#endif
|
#endif
|
|
|
#ifdef SYS_lwp_create /* FIXME: once only, please */
|
#ifdef SYS_lwp_create /* FIXME: once only, please */
|
praddset (&traced_syscall_exits, SYS_lwp_create);
|
praddset (&traced_syscall_exits, SYS_lwp_create);
|
praddset (&traced_syscall_exits, SYS_lwp_exit);
|
praddset (&traced_syscall_exits, SYS_lwp_exit);
|
#endif
|
#endif
|
|
|
|
|
if (!proc_set_traced_sysexit (pi, &traced_syscall_exits))
|
if (!proc_set_traced_sysexit (pi, &traced_syscall_exits))
|
return __LINE__;
|
return __LINE__;
|
|
|
#endif /* PRFS_STOPEXEC */
|
#endif /* PRFS_STOPEXEC */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
procfs_attach (args, from_tty)
|
procfs_attach (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
char *exec_file;
|
char *exec_file;
|
int pid;
|
int pid;
|
|
|
if (!args)
|
if (!args)
|
error_no_arg ("process-id to attach");
|
error_no_arg ("process-id to attach");
|
|
|
pid = atoi (args);
|
pid = atoi (args);
|
if (pid == getpid ())
|
if (pid == getpid ())
|
error ("Attaching GDB to itself is not a good idea...");
|
error ("Attaching GDB to itself is not a good idea...");
|
|
|
if (from_tty)
|
if (from_tty)
|
{
|
{
|
exec_file = get_exec_file (0);
|
exec_file = get_exec_file (0);
|
|
|
if (exec_file)
|
if (exec_file)
|
printf_filtered ("Attaching to program `%s', %s\n",
|
printf_filtered ("Attaching to program `%s', %s\n",
|
exec_file, target_pid_to_str (pid));
|
exec_file, target_pid_to_str (pid));
|
else
|
else
|
printf_filtered ("Attaching to %s\n", target_pid_to_str (pid));
|
printf_filtered ("Attaching to %s\n", target_pid_to_str (pid));
|
|
|
fflush (stdout);
|
fflush (stdout);
|
}
|
}
|
inferior_pid = do_attach (pid);
|
inferior_pid = do_attach (pid);
|
push_target (&procfs_ops);
|
push_target (&procfs_ops);
|
}
|
}
|
|
|
static void
|
static void
|
procfs_detach (args, from_tty)
|
procfs_detach (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
char *exec_file;
|
char *exec_file;
|
int signo = 0;
|
int signo = 0;
|
|
|
if (from_tty)
|
if (from_tty)
|
{
|
{
|
exec_file = get_exec_file (0);
|
exec_file = get_exec_file (0);
|
if (exec_file == 0)
|
if (exec_file == 0)
|
exec_file = "";
|
exec_file = "";
|
printf_filtered ("Detaching from program: %s %s\n",
|
printf_filtered ("Detaching from program: %s %s\n",
|
exec_file, target_pid_to_str (inferior_pid));
|
exec_file, target_pid_to_str (inferior_pid));
|
fflush (stdout);
|
fflush (stdout);
|
}
|
}
|
if (args)
|
if (args)
|
signo = atoi (args);
|
signo = atoi (args);
|
|
|
do_detach (signo);
|
do_detach (signo);
|
inferior_pid = 0;
|
inferior_pid = 0;
|
unpush_target (&procfs_ops); /* Pop out of handling an inferior */
|
unpush_target (&procfs_ops); /* Pop out of handling an inferior */
|
}
|
}
|
|
|
static int
|
static int
|
do_attach (pid)
|
do_attach (pid)
|
int pid;
|
int pid;
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
int fail;
|
int fail;
|
|
|
if ((pi = create_procinfo (pid, 0)) == NULL)
|
if ((pi = create_procinfo (pid, 0)) == NULL)
|
perror ("procfs: out of memory in 'attach'");
|
perror ("procfs: out of memory in 'attach'");
|
|
|
if (!open_procinfo_files (pi, FD_CTL))
|
if (!open_procinfo_files (pi, FD_CTL))
|
{
|
{
|
fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__);
|
fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__);
|
sprintf (errmsg, "do_attach: couldn't open /proc file for process %d",
|
sprintf (errmsg, "do_attach: couldn't open /proc file for process %d",
|
pid);
|
pid);
|
dead_procinfo (pi, errmsg, NOKILL);
|
dead_procinfo (pi, errmsg, NOKILL);
|
}
|
}
|
|
|
/* Stop the process (if it isn't already stopped). */
|
/* Stop the process (if it isn't already stopped). */
|
if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
|
if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
|
{
|
{
|
pi->was_stopped = 1;
|
pi->was_stopped = 1;
|
proc_prettyprint_why (proc_why (pi), proc_what (pi), 1);
|
proc_prettyprint_why (proc_why (pi), proc_what (pi), 1);
|
}
|
}
|
else
|
else
|
{
|
{
|
pi->was_stopped = 0;
|
pi->was_stopped = 0;
|
/* Set the process to run again when we close it. */
|
/* Set the process to run again when we close it. */
|
if (!proc_set_run_on_last_close (pi))
|
if (!proc_set_run_on_last_close (pi))
|
dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL);
|
dead_procinfo (pi, "do_attach: couldn't set RLC.", NOKILL);
|
|
|
/* Now stop the process. */
|
/* Now stop the process. */
|
if (!proc_stop_process (pi))
|
if (!proc_stop_process (pi))
|
dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL);
|
dead_procinfo (pi, "do_attach: couldn't stop the process.", NOKILL);
|
pi->ignore_next_sigstop = 1;
|
pi->ignore_next_sigstop = 1;
|
}
|
}
|
/* Save some of the /proc state to be restored if we detach. */
|
/* Save some of the /proc state to be restored if we detach. */
|
if (!proc_get_traced_faults (pi, &pi->saved_fltset))
|
if (!proc_get_traced_faults (pi, &pi->saved_fltset))
|
dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL);
|
dead_procinfo (pi, "do_attach: couldn't save traced faults.", NOKILL);
|
if (!proc_get_traced_signals (pi, &pi->saved_sigset))
|
if (!proc_get_traced_signals (pi, &pi->saved_sigset))
|
dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL);
|
dead_procinfo (pi, "do_attach: couldn't save traced signals.", NOKILL);
|
if (!proc_get_traced_sysentry (pi, &pi->saved_entryset))
|
if (!proc_get_traced_sysentry (pi, &pi->saved_entryset))
|
dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.",
|
dead_procinfo (pi, "do_attach: couldn't save traced syscall entries.",
|
NOKILL);
|
NOKILL);
|
if (!proc_get_traced_sysexit (pi, &pi->saved_exitset))
|
if (!proc_get_traced_sysexit (pi, &pi->saved_exitset))
|
dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.",
|
dead_procinfo (pi, "do_attach: couldn't save traced syscall exits.",
|
NOKILL);
|
NOKILL);
|
if (!proc_get_held_signals (pi, &pi->saved_sighold))
|
if (!proc_get_held_signals (pi, &pi->saved_sighold))
|
dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL);
|
dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL);
|
|
|
if ((fail = procfs_debug_inferior (pi)) != 0)
|
if ((fail = procfs_debug_inferior (pi)) != 0)
|
dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL);
|
dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL);
|
|
|
/* Let GDB know that the inferior was attached. */
|
/* Let GDB know that the inferior was attached. */
|
attach_flag = 1;
|
attach_flag = 1;
|
return MERGEPID (pi->pid, proc_get_current_thread (pi));
|
return MERGEPID (pi->pid, proc_get_current_thread (pi));
|
}
|
}
|
|
|
static void
|
static void
|
do_detach (signo)
|
do_detach (signo)
|
int signo;
|
int signo;
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
|
|
/* Find procinfo for the main process */
|
/* Find procinfo for the main process */
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0); /* FIXME: threads */
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0); /* FIXME: threads */
|
if (signo)
|
if (signo)
|
if (!proc_set_current_signal (pi, signo))
|
if (!proc_set_current_signal (pi, signo))
|
proc_warn (pi, "do_detach, set_current_signal", __LINE__);
|
proc_warn (pi, "do_detach, set_current_signal", __LINE__);
|
|
|
if (!proc_set_traced_signals (pi, &pi->saved_sigset))
|
if (!proc_set_traced_signals (pi, &pi->saved_sigset))
|
proc_warn (pi, "do_detach, set_traced_signal", __LINE__);
|
proc_warn (pi, "do_detach, set_traced_signal", __LINE__);
|
|
|
if (!proc_set_traced_faults (pi, &pi->saved_fltset))
|
if (!proc_set_traced_faults (pi, &pi->saved_fltset))
|
proc_warn (pi, "do_detach, set_traced_faults", __LINE__);
|
proc_warn (pi, "do_detach, set_traced_faults", __LINE__);
|
|
|
if (!proc_set_traced_sysentry (pi, &pi->saved_entryset))
|
if (!proc_set_traced_sysentry (pi, &pi->saved_entryset))
|
proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__);
|
proc_warn (pi, "do_detach, set_traced_sysentry", __LINE__);
|
|
|
if (!proc_set_traced_sysexit (pi, &pi->saved_exitset))
|
if (!proc_set_traced_sysexit (pi, &pi->saved_exitset))
|
proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__);
|
proc_warn (pi, "do_detach, set_traced_sysexit", __LINE__);
|
|
|
if (!proc_set_held_signals (pi, &pi->saved_sighold))
|
if (!proc_set_held_signals (pi, &pi->saved_sighold))
|
proc_warn (pi, "do_detach, set_held_signals", __LINE__);
|
proc_warn (pi, "do_detach, set_held_signals", __LINE__);
|
|
|
if (signo || (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)))
|
if (signo || (proc_flags (pi) & (PR_STOPPED | PR_ISTOP)))
|
if (signo || !(pi->was_stopped) ||
|
if (signo || !(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. */
|
/* Clear any pending signal. */
|
if (!proc_clear_current_fault (pi))
|
if (!proc_clear_current_fault (pi))
|
proc_warn (pi, "do_detach, clear_current_fault", __LINE__);
|
proc_warn (pi, "do_detach, clear_current_fault", __LINE__);
|
|
|
if (!proc_set_run_on_last_close (pi))
|
if (!proc_set_run_on_last_close (pi))
|
proc_warn (pi, "do_detach, set_rlc", __LINE__);
|
proc_warn (pi, "do_detach, set_rlc", __LINE__);
|
}
|
}
|
|
|
attach_flag = 0;
|
attach_flag = 0;
|
destroy_procinfo (pi);
|
destroy_procinfo (pi);
|
}
|
}
|
|
|
/*
|
/*
|
* fetch_registers
|
* fetch_registers
|
*
|
*
|
* Since the /proc interface cannot give us individual registers,
|
* Since the /proc interface cannot give us individual registers,
|
* we pay no attention to the (regno) argument, and just fetch them all.
|
* we pay no attention to the (regno) argument, and just fetch them all.
|
* This results in the possibility that we will do unnecessarily many
|
* This results in the possibility that we will do unnecessarily many
|
* fetches, since we may be called repeatedly for individual registers.
|
* fetches, since we may be called repeatedly for individual registers.
|
* So we cache the results, and mark the cache invalid when the process
|
* So we cache the results, and mark the cache invalid when the process
|
* is resumed.
|
* is resumed.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_fetch_registers (regno)
|
procfs_fetch_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
gdb_fpregset_t *fpregs;
|
gdb_fpregset_t *fpregs;
|
gdb_gregset_t *gregs;
|
gdb_gregset_t *gregs;
|
procinfo *pi;
|
procinfo *pi;
|
int pid;
|
int pid;
|
int tid;
|
int tid;
|
|
|
pid = PIDGET (inferior_pid);
|
pid = PIDGET (inferior_pid);
|
tid = TIDGET (inferior_pid);
|
tid = TIDGET (inferior_pid);
|
|
|
/* First look up procinfo for the main process. */
|
/* First look up procinfo for the main process. */
|
pi = find_procinfo_or_die (pid, 0);
|
pi = find_procinfo_or_die (pid, 0);
|
|
|
/* If the event thread is not the same as GDB's requested thread
|
/* If the event thread is not the same as GDB's requested thread
|
(ie. inferior_pid), then look up procinfo for the requested
|
(ie. inferior_pid), then look up procinfo for the requested
|
thread. */
|
thread. */
|
if ((tid != 0) &&
|
if ((tid != 0) &&
|
(tid != proc_get_current_thread (pi)))
|
(tid != proc_get_current_thread (pi)))
|
pi = find_procinfo_or_die (pid, tid);
|
pi = find_procinfo_or_die (pid, tid);
|
|
|
if (pi == NULL)
|
if (pi == NULL)
|
error ("procfs: fetch_registers failed to find procinfo for %s",
|
error ("procfs: fetch_registers failed to find procinfo for %s",
|
target_pid_to_str (inferior_pid));
|
target_pid_to_str (inferior_pid));
|
|
|
if ((gregs = proc_get_gregs (pi)) == NULL)
|
if ((gregs = proc_get_gregs (pi)) == NULL)
|
proc_error (pi, "fetch_registers, get_gregs", __LINE__);
|
proc_error (pi, "fetch_registers, get_gregs", __LINE__);
|
|
|
supply_gregset (gregs);
|
supply_gregset (gregs);
|
|
|
#if defined (FP0_REGNUM) /* need floating point? */
|
#if defined (FP0_REGNUM) /* need floating point? */
|
if ((regno >= 0 && regno < FP0_REGNUM) ||
|
if ((regno >= 0 && regno < FP0_REGNUM) ||
|
regno == PC_REGNUM ||
|
regno == PC_REGNUM ||
|
#ifdef NPC_REGNUM
|
#ifdef NPC_REGNUM
|
regno == NPC_REGNUM ||
|
regno == NPC_REGNUM ||
|
#endif
|
#endif
|
regno == FP_REGNUM ||
|
regno == FP_REGNUM ||
|
regno == SP_REGNUM)
|
regno == SP_REGNUM)
|
return; /* not a floating point register */
|
return; /* not a floating point register */
|
|
|
if ((fpregs = proc_get_fpregs (pi)) == NULL)
|
if ((fpregs = proc_get_fpregs (pi)) == NULL)
|
proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
|
proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
|
|
|
supply_fpregset (fpregs);
|
supply_fpregset (fpregs);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Get ready to modify the registers array. On machines which store
|
/* Get ready to modify the registers array. On machines which store
|
individual registers, this doesn't need to do anything. On
|
individual registers, this doesn't need to do anything. On
|
machines which store all the registers in one fell swoop, such as
|
machines which store all the registers in one fell swoop, such as
|
/proc, this makes sure that registers contains all the registers
|
/proc, this makes sure that registers contains all the registers
|
from the program being debugged. */
|
from the program being debugged. */
|
|
|
static void
|
static void
|
procfs_prepare_to_store ()
|
procfs_prepare_to_store ()
|
{
|
{
|
#ifdef CHILD_PREPARE_TO_STORE
|
#ifdef CHILD_PREPARE_TO_STORE
|
CHILD_PREPARE_TO_STORE ();
|
CHILD_PREPARE_TO_STORE ();
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* store_registers
|
* store_registers
|
*
|
*
|
* Since the /proc interface will not read individual registers,
|
* Since the /proc interface will not read individual registers,
|
* we will cache these requests until the process is resumed, and
|
* we will cache these requests until the process is resumed, and
|
* only then write them back to the inferior process.
|
* only then write them back to the inferior process.
|
*
|
*
|
* FIXME: is that a really bad idea? Have to think about cases
|
* FIXME: is that a really bad idea? Have to think about cases
|
* where writing one register might affect the value of others, etc.
|
* where writing one register might affect the value of others, etc.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_store_registers (regno)
|
procfs_store_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
gdb_fpregset_t *fpregs;
|
gdb_fpregset_t *fpregs;
|
gdb_gregset_t *gregs;
|
gdb_gregset_t *gregs;
|
procinfo *pi;
|
procinfo *pi;
|
int pid;
|
int pid;
|
int tid;
|
int tid;
|
|
|
pid = PIDGET (inferior_pid);
|
pid = PIDGET (inferior_pid);
|
tid = TIDGET (inferior_pid);
|
tid = TIDGET (inferior_pid);
|
|
|
/* First find procinfo for main process */
|
/* First find procinfo for main process */
|
pi = find_procinfo_or_die (pid, 0);
|
pi = find_procinfo_or_die (pid, 0);
|
|
|
/* If current lwp for process is not the same as requested thread
|
/* If current lwp for process is not the same as requested thread
|
(ie. inferior_pid), then find procinfo for the requested thread. */
|
(ie. inferior_pid), then find procinfo for the requested thread. */
|
|
|
if ((tid != 0) &&
|
if ((tid != 0) &&
|
(tid != proc_get_current_thread (pi)))
|
(tid != proc_get_current_thread (pi)))
|
pi = find_procinfo_or_die (pid, tid);
|
pi = find_procinfo_or_die (pid, tid);
|
|
|
if (pi == NULL)
|
if (pi == NULL)
|
error ("procfs: store_registers: failed to find procinfo for %s",
|
error ("procfs: store_registers: failed to find procinfo for %s",
|
target_pid_to_str (inferior_pid));
|
target_pid_to_str (inferior_pid));
|
|
|
if ((gregs = proc_get_gregs (pi)) == NULL)
|
if ((gregs = proc_get_gregs (pi)) == NULL)
|
proc_error (pi, "store_registers, get_gregs", __LINE__);
|
proc_error (pi, "store_registers, get_gregs", __LINE__);
|
|
|
fill_gregset (gregs, regno);
|
fill_gregset (gregs, regno);
|
if (!proc_set_gregs (pi))
|
if (!proc_set_gregs (pi))
|
proc_error (pi, "store_registers, set_gregs", __LINE__);
|
proc_error (pi, "store_registers, set_gregs", __LINE__);
|
|
|
#if defined (FP0_REGNUM) /* need floating point? */
|
#if defined (FP0_REGNUM) /* need floating point? */
|
if ((regno >= 0 && regno < FP0_REGNUM) ||
|
if ((regno >= 0 && regno < FP0_REGNUM) ||
|
regno == PC_REGNUM ||
|
regno == PC_REGNUM ||
|
#ifdef NPC_REGNUM
|
#ifdef NPC_REGNUM
|
regno == NPC_REGNUM ||
|
regno == NPC_REGNUM ||
|
#endif
|
#endif
|
regno == FP_REGNUM ||
|
regno == FP_REGNUM ||
|
regno == SP_REGNUM)
|
regno == SP_REGNUM)
|
return; /* not a floating point register */
|
return; /* not a floating point register */
|
|
|
if ((fpregs = proc_get_fpregs (pi)) == NULL)
|
if ((fpregs = proc_get_fpregs (pi)) == NULL)
|
proc_error (pi, "store_registers, get_fpregs", __LINE__);
|
proc_error (pi, "store_registers, get_fpregs", __LINE__);
|
|
|
fill_fpregset (fpregs, regno);
|
fill_fpregset (fpregs, regno);
|
if (!proc_set_fpregs (pi))
|
if (!proc_set_fpregs (pi))
|
proc_error (pi, "store_registers, set_fpregs", __LINE__);
|
proc_error (pi, "store_registers, set_fpregs", __LINE__);
|
#endif
|
#endif
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_wait
|
* Function: target_wait
|
*
|
*
|
* Retrieve the next stop event from the child process.
|
* Retrieve the next stop event from the child process.
|
* If child has not stopped yet, wait for it to stop.
|
* If child has not stopped yet, wait for it to stop.
|
* Translate /proc eventcodes (or possibly wait eventcodes)
|
* Translate /proc eventcodes (or possibly wait eventcodes)
|
* into gdb internal event codes.
|
* into gdb internal event codes.
|
*
|
*
|
* Return: id of process (and possibly thread) that incurred the event.
|
* Return: id of process (and possibly thread) that incurred the event.
|
* event codes are returned thru a pointer parameter.
|
* event codes are returned thru a pointer parameter.
|
*/
|
*/
|
|
|
static int
|
static int
|
procfs_wait (pid, status)
|
procfs_wait (pid, status)
|
int pid;
|
int pid;
|
struct target_waitstatus *status;
|
struct target_waitstatus *status;
|
{
|
{
|
/* First cut: loosely based on original version 2.1 */
|
/* First cut: loosely based on original version 2.1 */
|
procinfo *pi;
|
procinfo *pi;
|
int temp, wstat;
|
int temp, wstat;
|
int retval;
|
int retval;
|
int why, what, flags;
|
int why, what, flags;
|
int retry = 0;
|
int retry = 0;
|
|
|
wait_again:
|
wait_again:
|
|
|
retry++;
|
retry++;
|
wstat = 0;
|
wstat = 0;
|
retval = -1;
|
retval = -1;
|
|
|
/* Find procinfo for main process */
|
/* Find procinfo for main process */
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
if (pi)
|
if (pi)
|
{
|
{
|
/* We must assume that the status is stale now... */
|
/* We must assume that the status is stale now... */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
pi->gregs_valid = 0;
|
pi->gregs_valid = 0;
|
pi->fpregs_valid = 0;
|
pi->fpregs_valid = 0;
|
|
|
#if 0 /* just try this out... */
|
#if 0 /* just try this out... */
|
flags = proc_flags (pi);
|
flags = proc_flags (pi);
|
why = proc_why (pi);
|
why = proc_why (pi);
|
if ((flags & PR_STOPPED) && (why == PR_REQUESTED))
|
if ((flags & PR_STOPPED) && (why == PR_REQUESTED))
|
pi->status_valid = 0; /* re-read again, IMMEDIATELY... */
|
pi->status_valid = 0; /* re-read again, IMMEDIATELY... */
|
#endif
|
#endif
|
/* If child is not stopped, wait for it to stop. */
|
/* If child is not stopped, wait for it to stop. */
|
if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) &&
|
if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) &&
|
!proc_wait_for_stop (pi))
|
!proc_wait_for_stop (pi))
|
{
|
{
|
/* wait_for_stop failed: has the child terminated? */
|
/* wait_for_stop failed: has the child terminated? */
|
if (errno == ENOENT)
|
if (errno == ENOENT)
|
{
|
{
|
/* /proc file not found; presumably child has terminated. */
|
/* /proc file not found; presumably child has terminated. */
|
retval = wait (&wstat); /* "wait" for the child's exit */
|
retval = wait (&wstat); /* "wait" for the child's exit */
|
|
|
if (retval != PIDGET (inferior_pid)) /* wrong child? */
|
if (retval != PIDGET (inferior_pid)) /* wrong child? */
|
error ("procfs: couldn't stop process %d: wait returned %d\n",
|
error ("procfs: couldn't stop process %d: wait returned %d\n",
|
inferior_pid, retval);
|
inferior_pid, retval);
|
/* FIXME: might I not just use waitpid?
|
/* FIXME: might I not just use waitpid?
|
Or try find_procinfo to see if I know about this child? */
|
Or try find_procinfo to see if I know about this child? */
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Unknown error from wait_for_stop. */
|
/* Unknown error from wait_for_stop. */
|
proc_error (pi, "target_wait (wait_for_stop)", __LINE__);
|
proc_error (pi, "target_wait (wait_for_stop)", __LINE__);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* This long block is reached if either:
|
/* This long block is reached if either:
|
a) the child was already stopped, or
|
a) the child was already stopped, or
|
b) we successfully waited for the child with wait_for_stop.
|
b) we successfully waited for the child with wait_for_stop.
|
This block will analyze the /proc status, and translate it
|
This block will analyze the /proc status, and translate it
|
into a waitstatus for GDB.
|
into a waitstatus for GDB.
|
|
|
If we actually had to call wait because the /proc file
|
If we actually had to call wait because the /proc file
|
is gone (child terminated), then we skip this block,
|
is gone (child terminated), then we skip this block,
|
because we already have a waitstatus. */
|
because we already have a waitstatus. */
|
|
|
flags = proc_flags (pi);
|
flags = proc_flags (pi);
|
why = proc_why (pi);
|
why = proc_why (pi);
|
what = proc_what (pi);
|
what = proc_what (pi);
|
|
|
if (flags & (PR_STOPPED | PR_ISTOP))
|
if (flags & (PR_STOPPED | PR_ISTOP))
|
{
|
{
|
#ifdef PR_ASYNC
|
#ifdef PR_ASYNC
|
/* If it's running async (for single_thread control),
|
/* If it's running async (for single_thread control),
|
set it back to normal again. */
|
set it back to normal again. */
|
if (flags & PR_ASYNC)
|
if (flags & PR_ASYNC)
|
if (!proc_unset_async (pi))
|
if (!proc_unset_async (pi))
|
proc_error (pi, "target_wait, unset_async", __LINE__);
|
proc_error (pi, "target_wait, unset_async", __LINE__);
|
#endif
|
#endif
|
|
|
if (info_verbose)
|
if (info_verbose)
|
proc_prettyprint_why (why, what, 1);
|
proc_prettyprint_why (why, what, 1);
|
|
|
/* The 'pid' we will return to GDB is composed of
|
/* The 'pid' we will return to GDB is composed of
|
the process ID plus the lwp ID. */
|
the process ID plus the lwp ID. */
|
retval = MERGEPID (pi->pid, proc_get_current_thread (pi));
|
retval = MERGEPID (pi->pid, proc_get_current_thread (pi));
|
|
|
switch (why) {
|
switch (why) {
|
case PR_SIGNALLED:
|
case PR_SIGNALLED:
|
wstat = (what << 8) | 0177;
|
wstat = (what << 8) | 0177;
|
break;
|
break;
|
case PR_SYSENTRY:
|
case PR_SYSENTRY:
|
switch (what) {
|
switch (what) {
|
#ifdef SYS_lwp_exit
|
#ifdef SYS_lwp_exit
|
case SYS_lwp_exit:
|
case SYS_lwp_exit:
|
#endif
|
#endif
|
#ifdef SYS_lwpexit
|
#ifdef SYS_lwpexit
|
case SYS_lwpexit:
|
case SYS_lwpexit:
|
#endif
|
#endif
|
#if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
|
#if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
|
printf_filtered ("[%s exited]\n",
|
printf_filtered ("[%s exited]\n",
|
target_pid_to_str (retval));
|
target_pid_to_str (retval));
|
delete_thread (retval);
|
delete_thread (retval);
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return retval;
|
return retval;
|
#endif /* _lwp_exit */
|
#endif /* _lwp_exit */
|
|
|
case SYS_exit:
|
case SYS_exit:
|
/* Handle SYS_exit call only */
|
/* Handle SYS_exit call only */
|
/* Stopped at entry to SYS_exit.
|
/* Stopped at entry to SYS_exit.
|
Make it runnable, resume it, then use
|
Make it runnable, resume it, then use
|
the wait system call to get its exit code.
|
the wait system call to get its exit code.
|
Proc_run_process always clears the current
|
Proc_run_process always clears the current
|
fault and signal.
|
fault and signal.
|
Then return its exit status. */
|
Then return its exit status. */
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
wstat = 0;
|
wstat = 0;
|
/* FIXME: what we should do is return
|
/* FIXME: what we should do is return
|
TARGET_WAITKIND_SPURIOUS. */
|
TARGET_WAITKIND_SPURIOUS. */
|
if (!proc_run_process (pi, 0, 0))
|
if (!proc_run_process (pi, 0, 0))
|
proc_error (pi, "target_wait, run_process", __LINE__);
|
proc_error (pi, "target_wait, run_process", __LINE__);
|
if (attach_flag)
|
if (attach_flag)
|
{
|
{
|
/* Don't call wait: simulate waiting for exit,
|
/* Don't call wait: simulate waiting for exit,
|
return a "success" exit code. Bogus: what if
|
return a "success" exit code. Bogus: what if
|
it returns something else? */
|
it returns something else? */
|
wstat = 0;
|
wstat = 0;
|
retval = inferior_pid; /* ??? */
|
retval = inferior_pid; /* ??? */
|
}
|
}
|
else
|
else
|
{
|
{
|
int temp = wait (&wstat);
|
int temp = wait (&wstat);
|
|
|
/* FIXME: shouldn't I make sure I get the right
|
/* FIXME: shouldn't I make sure I get the right
|
event from the right process? If (for
|
event from the right process? If (for
|
instance) I have killed an earlier inferior
|
instance) I have killed an earlier inferior
|
process but failed to clean up after it
|
process but failed to clean up after it
|
somehow, I could get its termination event
|
somehow, I could get its termination event
|
here. */
|
here. */
|
|
|
/* If wait returns -1, that's what we return to GDB. */
|
/* If wait returns -1, that's what we return to GDB. */
|
if (temp < 0)
|
if (temp < 0)
|
retval = temp;
|
retval = temp;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
printf_filtered ("procfs: trapped on entry to ");
|
printf_filtered ("procfs: trapped on entry to ");
|
proc_prettyprint_syscall (proc_what (pi), 0);
|
proc_prettyprint_syscall (proc_what (pi), 0);
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
#ifndef PIOCSSPCACT
|
#ifndef PIOCSSPCACT
|
{
|
{
|
long i, nsysargs, *sysargs;
|
long i, nsysargs, *sysargs;
|
|
|
if ((nsysargs = proc_nsysarg (pi)) > 0 &&
|
if ((nsysargs = proc_nsysarg (pi)) > 0 &&
|
(sysargs = proc_sysargs (pi)) != NULL)
|
(sysargs = proc_sysargs (pi)) != NULL)
|
{
|
{
|
printf_filtered ("%ld syscall arguments:\n", nsysargs);
|
printf_filtered ("%ld syscall arguments:\n", nsysargs);
|
for (i = 0; i < nsysargs; i++)
|
for (i = 0; i < nsysargs; i++)
|
printf_filtered ("#%ld: 0x%08x\n",
|
printf_filtered ("#%ld: 0x%08x\n",
|
i, sysargs[i]);
|
i, sysargs[i]);
|
}
|
}
|
|
|
}
|
}
|
#endif
|
#endif
|
if (status)
|
if (status)
|
{
|
{
|
/* How to exit gracefully, returning "unknown event" */
|
/* How to exit gracefully, returning "unknown event" */
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return inferior_pid;
|
return inferior_pid;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* How to keep going without returning to wfi: */
|
/* How to keep going without returning to wfi: */
|
target_resume (pid, 0, TARGET_SIGNAL_0);
|
target_resume (pid, 0, TARGET_SIGNAL_0);
|
goto wait_again;
|
goto wait_again;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
case PR_SYSEXIT:
|
case PR_SYSEXIT:
|
switch (what) {
|
switch (what) {
|
#ifdef SYS_exec
|
#ifdef SYS_exec
|
case SYS_exec:
|
case SYS_exec:
|
#endif
|
#endif
|
#ifdef SYS_execv
|
#ifdef SYS_execv
|
case SYS_execv:
|
case SYS_execv:
|
#endif
|
#endif
|
#ifdef SYS_execve
|
#ifdef SYS_execve
|
case SYS_execve:
|
case SYS_execve:
|
#endif
|
#endif
|
/* Hopefully this is our own "fork-child" execing
|
/* Hopefully this is our own "fork-child" execing
|
the real child. Hoax this event into a trap, and
|
the real child. Hoax this event into a trap, and
|
GDB will see the child about to execute its start
|
GDB will see the child about to execute its start
|
address. */
|
address. */
|
wstat = (SIGTRAP << 8) | 0177;
|
wstat = (SIGTRAP << 8) | 0177;
|
break;
|
break;
|
#ifdef SYS_lwp_create
|
#ifdef SYS_lwp_create
|
case SYS_lwp_create:
|
case SYS_lwp_create:
|
#endif
|
#endif
|
#ifdef SYS_lwpcreate
|
#ifdef SYS_lwpcreate
|
case SYS_lwpcreate:
|
case SYS_lwpcreate:
|
#endif
|
#endif
|
#if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
|
#if defined(SYS_lwp_create) || defined(SYS_lwpcreate)
|
/*
|
/*
|
* This syscall is somewhat like fork/exec.
|
* This syscall is somewhat like fork/exec.
|
* We will get the event twice: once for the parent LWP,
|
* We will get the event twice: once for the parent LWP,
|
* and once for the child. We should already know about
|
* and once for the child. We should already know about
|
* the parent LWP, but the child will be new to us. So,
|
* the parent LWP, but the child will be new to us. So,
|
* whenever we get this event, if it represents a new
|
* whenever we get this event, if it represents a new
|
* thread, simply add the thread to the list.
|
* thread, simply add the thread to the list.
|
*/
|
*/
|
|
|
/* If not in procinfo list, add it. */
|
/* If not in procinfo list, add it. */
|
temp = proc_get_current_thread (pi);
|
temp = proc_get_current_thread (pi);
|
if (!find_procinfo (pi->pid, temp))
|
if (!find_procinfo (pi->pid, temp))
|
create_procinfo (pi->pid, temp);
|
create_procinfo (pi->pid, temp);
|
|
|
temp = MERGEPID (pi->pid, temp);
|
temp = MERGEPID (pi->pid, temp);
|
/* If not in GDB's thread list, add it. */
|
/* If not in GDB's thread list, add it. */
|
if (!in_thread_list (temp))
|
if (!in_thread_list (temp))
|
{
|
{
|
printf_filtered ("[New %s]\n", target_pid_to_str (temp));
|
printf_filtered ("[New %s]\n", target_pid_to_str (temp));
|
add_thread (temp);
|
add_thread (temp);
|
}
|
}
|
/* Return to WFI, but tell it to immediately resume. */
|
/* Return to WFI, but tell it to immediately resume. */
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return inferior_pid;
|
return inferior_pid;
|
#endif /* _lwp_create */
|
#endif /* _lwp_create */
|
|
|
#ifdef SYS_lwp_exit
|
#ifdef SYS_lwp_exit
|
case SYS_lwp_exit:
|
case SYS_lwp_exit:
|
#endif
|
#endif
|
#ifdef SYS_lwpexit
|
#ifdef SYS_lwpexit
|
case SYS_lwpexit:
|
case SYS_lwpexit:
|
#endif
|
#endif
|
#if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
|
#if defined (SYS_lwp_exit) || defined (SYS_lwpexit)
|
printf_filtered ("[%s exited]\n",
|
printf_filtered ("[%s exited]\n",
|
target_pid_to_str (retval));
|
target_pid_to_str (retval));
|
delete_thread (retval);
|
delete_thread (retval);
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return retval;
|
return retval;
|
#endif /* _lwp_exit */
|
#endif /* _lwp_exit */
|
|
|
#ifdef SYS_sproc
|
#ifdef SYS_sproc
|
case SYS_sproc:
|
case SYS_sproc:
|
/* Nothing to do here for now. The old procfs
|
/* Nothing to do here for now. The old procfs
|
seemed to use this event to handle threads on
|
seemed to use this event to handle threads on
|
older (non-LWP) systems, where I'm assuming that
|
older (non-LWP) systems, where I'm assuming that
|
threads were actually separate processes. Irix,
|
threads were actually separate processes. Irix,
|
maybe? Anyway, low priority for now. */
|
maybe? Anyway, low priority for now. */
|
#endif
|
#endif
|
#ifdef SYS_fork
|
#ifdef SYS_fork
|
case SYS_fork:
|
case SYS_fork:
|
/* FIXME: do we need to handle this? Investigate. */
|
/* FIXME: do we need to handle this? Investigate. */
|
#endif
|
#endif
|
#ifdef SYS_vfork
|
#ifdef SYS_vfork
|
case SYS_vfork:
|
case SYS_vfork:
|
/* FIXME: see above. */
|
/* FIXME: see above. */
|
#endif
|
#endif
|
default:
|
default:
|
printf_filtered ("procfs: trapped on exit from ");
|
printf_filtered ("procfs: trapped on exit from ");
|
proc_prettyprint_syscall (proc_what (pi), 0);
|
proc_prettyprint_syscall (proc_what (pi), 0);
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
#ifndef PIOCSSPCACT
|
#ifndef PIOCSSPCACT
|
{
|
{
|
long i, nsysargs, *sysargs;
|
long i, nsysargs, *sysargs;
|
|
|
if ((nsysargs = proc_nsysarg (pi)) > 0 &&
|
if ((nsysargs = proc_nsysarg (pi)) > 0 &&
|
(sysargs = proc_sysargs (pi)) != NULL)
|
(sysargs = proc_sysargs (pi)) != NULL)
|
{
|
{
|
printf_filtered ("%ld syscall arguments:\n", nsysargs);
|
printf_filtered ("%ld syscall arguments:\n", nsysargs);
|
for (i = 0; i < nsysargs; i++)
|
for (i = 0; i < nsysargs; i++)
|
printf_filtered ("#%ld: 0x%08x\n",
|
printf_filtered ("#%ld: 0x%08x\n",
|
i, sysargs[i]);
|
i, sysargs[i]);
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return inferior_pid;
|
return inferior_pid;
|
}
|
}
|
break;
|
break;
|
case PR_REQUESTED:
|
case PR_REQUESTED:
|
#if 0 /* FIXME */
|
#if 0 /* FIXME */
|
wstat = (SIGSTOP << 8) | 0177;
|
wstat = (SIGSTOP << 8) | 0177;
|
break;
|
break;
|
#else
|
#else
|
if (retry < 5)
|
if (retry < 5)
|
{
|
{
|
printf_filtered ("Retry #%d:\n", retry);
|
printf_filtered ("Retry #%d:\n", retry);
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
goto wait_again;
|
goto wait_again;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* If not in procinfo list, add it. */
|
/* If not in procinfo list, add it. */
|
temp = proc_get_current_thread (pi);
|
temp = proc_get_current_thread (pi);
|
if (!find_procinfo (pi->pid, temp))
|
if (!find_procinfo (pi->pid, temp))
|
create_procinfo (pi->pid, temp);
|
create_procinfo (pi->pid, temp);
|
|
|
/* If not in GDB's thread list, add it. */
|
/* If not in GDB's thread list, add it. */
|
temp = MERGEPID (pi->pid, temp);
|
temp = MERGEPID (pi->pid, temp);
|
if (!in_thread_list (temp))
|
if (!in_thread_list (temp))
|
{
|
{
|
printf_filtered ("[New %s]\n",
|
printf_filtered ("[New %s]\n",
|
target_pid_to_str (temp));
|
target_pid_to_str (temp));
|
add_thread (temp);
|
add_thread (temp);
|
}
|
}
|
|
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->value.sig = 0;
|
status->value.sig = 0;
|
return retval;
|
return retval;
|
}
|
}
|
#endif
|
#endif
|
case PR_JOBCONTROL:
|
case PR_JOBCONTROL:
|
wstat = (what << 8) | 0177;
|
wstat = (what << 8) | 0177;
|
break;
|
break;
|
case PR_FAULTED:
|
case PR_FAULTED:
|
switch (what) { /* FIXME: FAULTED_USE_SIGINFO */
|
switch (what) { /* FIXME: FAULTED_USE_SIGINFO */
|
#ifdef FLTWATCH
|
#ifdef FLTWATCH
|
case FLTWATCH:
|
case FLTWATCH:
|
wstat = (SIGTRAP << 8) | 0177;
|
wstat = (SIGTRAP << 8) | 0177;
|
break;
|
break;
|
#endif
|
#endif
|
#ifdef FLTKWATCH
|
#ifdef FLTKWATCH
|
case FLTKWATCH:
|
case FLTKWATCH:
|
wstat = (SIGTRAP << 8) | 0177;
|
wstat = (SIGTRAP << 8) | 0177;
|
break;
|
break;
|
#endif
|
#endif
|
/* FIXME: use si_signo where possible. */
|
/* FIXME: use si_signo where possible. */
|
case FLTPRIV:
|
case FLTPRIV:
|
#if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
|
#if (FLTILL != FLTPRIV) /* avoid "duplicate case" error */
|
case FLTILL:
|
case FLTILL:
|
#endif
|
#endif
|
wstat = (SIGILL << 8) | 0177;
|
wstat = (SIGILL << 8) | 0177;
|
break;
|
break;
|
case FLTBPT:
|
case FLTBPT:
|
#if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
|
#if (FLTTRACE != FLTBPT) /* avoid "duplicate case" error */
|
case FLTTRACE:
|
case FLTTRACE:
|
#endif
|
#endif
|
wstat = (SIGTRAP << 8) | 0177;
|
wstat = (SIGTRAP << 8) | 0177;
|
break;
|
break;
|
case FLTSTACK:
|
case FLTSTACK:
|
case FLTACCESS:
|
case FLTACCESS:
|
#if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
|
#if (FLTBOUNDS != FLTSTACK) /* avoid "duplicate case" error */
|
case FLTBOUNDS:
|
case FLTBOUNDS:
|
#endif
|
#endif
|
wstat = (SIGSEGV << 8) | 0177;
|
wstat = (SIGSEGV << 8) | 0177;
|
break;
|
break;
|
case FLTIOVF:
|
case FLTIOVF:
|
case FLTIZDIV:
|
case FLTIZDIV:
|
#if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
|
#if (FLTFPE != FLTIOVF) /* avoid "duplicate case" error */
|
case FLTFPE:
|
case FLTFPE:
|
#endif
|
#endif
|
wstat = (SIGFPE << 8) | 0177;
|
wstat = (SIGFPE << 8) | 0177;
|
break;
|
break;
|
case FLTPAGE: /* Recoverable page fault */
|
case FLTPAGE: /* Recoverable page fault */
|
default: /* FIXME: use si_signo if possible for fault */
|
default: /* FIXME: use si_signo if possible for fault */
|
retval = -1;
|
retval = -1;
|
printf_filtered ("procfs:%d -- ", __LINE__);
|
printf_filtered ("procfs:%d -- ", __LINE__);
|
printf_filtered ("child stopped for unknown reason:\n");
|
printf_filtered ("child stopped for unknown reason:\n");
|
proc_prettyprint_why (why, what, 1);
|
proc_prettyprint_why (why, what, 1);
|
error ("... giving up...");
|
error ("... giving up...");
|
break;
|
break;
|
}
|
}
|
break; /* case PR_FAULTED: */
|
break; /* case PR_FAULTED: */
|
default: /* switch (why) unmatched */
|
default: /* switch (why) unmatched */
|
printf_filtered ("procfs:%d -- ", __LINE__);
|
printf_filtered ("procfs:%d -- ", __LINE__);
|
printf_filtered ("child stopped for unknown reason:\n");
|
printf_filtered ("child stopped for unknown reason:\n");
|
proc_prettyprint_why (why, what, 1);
|
proc_prettyprint_why (why, what, 1);
|
error ("... giving up...");
|
error ("... giving up...");
|
break;
|
break;
|
}
|
}
|
/*
|
/*
|
* Got this far without error:
|
* Got this far without error:
|
* If retval isn't in the threads database, add it.
|
* If retval isn't in the threads database, add it.
|
*/
|
*/
|
if (retval > 0 &&
|
if (retval > 0 &&
|
retval != inferior_pid &&
|
retval != inferior_pid &&
|
!in_thread_list (retval))
|
!in_thread_list (retval))
|
{
|
{
|
/*
|
/*
|
* We have a new thread.
|
* We have a new thread.
|
* We need to add it both to GDB's list and to our own.
|
* We need to add it both to GDB's list and to our own.
|
* If we don't create a procinfo, resume may be unhappy
|
* If we don't create a procinfo, resume may be unhappy
|
* later.
|
* later.
|
*/
|
*/
|
printf_filtered ("[New %s]\n", target_pid_to_str (retval));
|
printf_filtered ("[New %s]\n", target_pid_to_str (retval));
|
add_thread (retval);
|
add_thread (retval);
|
if (find_procinfo (PIDGET (retval), TIDGET (retval)) == NULL)
|
if (find_procinfo (PIDGET (retval), TIDGET (retval)) == NULL)
|
create_procinfo (PIDGET (retval), TIDGET (retval));
|
create_procinfo (PIDGET (retval), TIDGET (retval));
|
|
|
/* In addition, it's possible that this is the first
|
/* In addition, it's possible that this is the first
|
* new thread we've seen, in which case we may not
|
* new thread we've seen, in which case we may not
|
* have created entries for inferior_pid yet.
|
* have created entries for inferior_pid yet.
|
*/
|
*/
|
if (TIDGET (inferior_pid) != 0)
|
if (TIDGET (inferior_pid) != 0)
|
{
|
{
|
if (!in_thread_list (inferior_pid))
|
if (!in_thread_list (inferior_pid))
|
add_thread (inferior_pid);
|
add_thread (inferior_pid);
|
if (find_procinfo (PIDGET (inferior_pid),
|
if (find_procinfo (PIDGET (inferior_pid),
|
TIDGET (inferior_pid)) == NULL)
|
TIDGET (inferior_pid)) == NULL)
|
create_procinfo (PIDGET (inferior_pid),
|
create_procinfo (PIDGET (inferior_pid),
|
TIDGET (inferior_pid));
|
TIDGET (inferior_pid));
|
}
|
}
|
}
|
}
|
}
|
}
|
else /* flags do not indicate STOPPED */
|
else /* flags do not indicate STOPPED */
|
{
|
{
|
/* surely this can't happen... */
|
/* surely this can't happen... */
|
printf_filtered ("procfs:%d -- process not stopped.\n",
|
printf_filtered ("procfs:%d -- process not stopped.\n",
|
__LINE__);
|
__LINE__);
|
proc_prettyprint_flags (flags, 1);
|
proc_prettyprint_flags (flags, 1);
|
error ("procfs: ...giving up...");
|
error ("procfs: ...giving up...");
|
}
|
}
|
}
|
}
|
|
|
if (status)
|
if (status)
|
store_waitstatus (status, wstat);
|
store_waitstatus (status, wstat);
|
}
|
}
|
|
|
return retval;
|
return retval;
|
}
|
}
|
|
|
static int
|
static int
|
procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
|
procfs_xfer_memory (memaddr, myaddr, len, dowrite, target)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
int dowrite;
|
int dowrite;
|
struct target_ops *target; /* ignored */
|
struct target_ops *target; /* ignored */
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
int nbytes = 0;
|
int nbytes = 0;
|
|
|
/* Find procinfo for main process */
|
/* Find procinfo for main process */
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
if (pi->as_fd == 0 &&
|
if (pi->as_fd == 0 &&
|
open_procinfo_files (pi, FD_AS) == 0)
|
open_procinfo_files (pi, FD_AS) == 0)
|
{
|
{
|
proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);
|
proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
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)
|
if (dowrite)
|
{
|
{
|
#ifdef NEW_PROC_API
|
#ifdef NEW_PROC_API
|
PROCFS_NOTE ("write memory: ");
|
PROCFS_NOTE ("write memory: ");
|
#else
|
#else
|
PROCFS_NOTE ("write memory: \n");
|
PROCFS_NOTE ("write memory: \n");
|
#endif
|
#endif
|
nbytes = write (pi->as_fd, myaddr, len);
|
nbytes = write (pi->as_fd, myaddr, len);
|
}
|
}
|
else
|
else
|
{
|
{
|
PROCFS_NOTE ("read memory: \n");
|
PROCFS_NOTE ("read memory: \n");
|
nbytes = read (pi->as_fd, myaddr, len);
|
nbytes = read (pi->as_fd, myaddr, len);
|
}
|
}
|
if (nbytes < 0)
|
if (nbytes < 0)
|
{
|
{
|
nbytes = 0;
|
nbytes = 0;
|
}
|
}
|
}
|
}
|
return nbytes;
|
return nbytes;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: invalidate_cache
|
* Function: invalidate_cache
|
*
|
*
|
* Called by target_resume before making child runnable.
|
* Called by target_resume before making child runnable.
|
* Mark cached registers and status's invalid.
|
* Mark cached registers and status's invalid.
|
* If there are "dirty" caches that need to be written back
|
* If there are "dirty" caches that need to be written back
|
* to the child process, do that.
|
* to the child process, do that.
|
*
|
*
|
* File descriptors are also cached.
|
* File descriptors are also cached.
|
* As they are a limited resource, we cannot hold onto them indefinitely.
|
* As they are a limited resource, we cannot hold onto them indefinitely.
|
* However, as they are expensive to open, we don't want to throw them
|
* However, as they are expensive to open, we don't want to throw them
|
* away indescriminately either. As a compromise, we will keep the
|
* away indescriminately either. As a compromise, we will keep the
|
* file descriptors for the parent process, but discard any file
|
* file descriptors for the parent process, but discard any file
|
* descriptors we may have accumulated for the threads.
|
* descriptors we may have accumulated for the threads.
|
*
|
*
|
* Return value:
|
* Return value:
|
* As this function is called by iterate_over_threads, it always
|
* As this function is called by iterate_over_threads, it always
|
* returns zero (so that iterate_over_threads will keep iterating).
|
* returns zero (so that iterate_over_threads will keep iterating).
|
*/
|
*/
|
|
|
|
|
static int
|
static int
|
invalidate_cache (parent, pi, ptr)
|
invalidate_cache (parent, pi, ptr)
|
procinfo *parent;
|
procinfo *parent;
|
procinfo *pi;
|
procinfo *pi;
|
void *ptr;
|
void *ptr;
|
{
|
{
|
/*
|
/*
|
* About to run the child; invalidate caches and do any other cleanup.
|
* About to run the child; invalidate caches and do any other cleanup.
|
*/
|
*/
|
|
|
#if 0
|
#if 0
|
if (pi->gregs_dirty)
|
if (pi->gregs_dirty)
|
if (parent == NULL ||
|
if (parent == NULL ||
|
proc_get_current_thread (parent) != pi->tid)
|
proc_get_current_thread (parent) != pi->tid)
|
if (!proc_set_gregs (pi)) /* flush gregs cache */
|
if (!proc_set_gregs (pi)) /* flush gregs cache */
|
proc_warn (pi, "target_resume, set_gregs",
|
proc_warn (pi, "target_resume, set_gregs",
|
__LINE__);
|
__LINE__);
|
#ifdef FP0_REGNUM
|
#ifdef FP0_REGNUM
|
if (pi->fpregs_dirty)
|
if (pi->fpregs_dirty)
|
if (parent == NULL ||
|
if (parent == NULL ||
|
proc_get_current_thread (parent) != pi->tid)
|
proc_get_current_thread (parent) != pi->tid)
|
if (!proc_set_fpregs (pi)) /* flush fpregs cache */
|
if (!proc_set_fpregs (pi)) /* flush fpregs cache */
|
proc_warn (pi, "target_resume, set_fpregs",
|
proc_warn (pi, "target_resume, set_fpregs",
|
__LINE__);
|
__LINE__);
|
#endif
|
#endif
|
#endif
|
#endif
|
|
|
if (parent != NULL)
|
if (parent != NULL)
|
{
|
{
|
/* The presence of a parent indicates that this is an LWP.
|
/* The presence of a parent indicates that this is an LWP.
|
Close any file descriptors that it might have open.
|
Close any file descriptors that it might have open.
|
We don't do this to the master (parent) procinfo. */
|
We don't do this to the master (parent) procinfo. */
|
|
|
close_procinfo_files (pi);
|
close_procinfo_files (pi);
|
}
|
}
|
pi->gregs_valid = 0;
|
pi->gregs_valid = 0;
|
pi->fpregs_valid = 0;
|
pi->fpregs_valid = 0;
|
#if 0
|
#if 0
|
pi->gregs_dirty = 0;
|
pi->gregs_dirty = 0;
|
pi->fpregs_dirty = 0;
|
pi->fpregs_dirty = 0;
|
#endif
|
#endif
|
pi->status_valid = 0;
|
pi->status_valid = 0;
|
pi->threads_valid = 0;
|
pi->threads_valid = 0;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#if 0
|
#if 0
|
/*
|
/*
|
* Function: make_signal_thread_runnable
|
* Function: make_signal_thread_runnable
|
*
|
*
|
* A callback function for iterate_over_threads.
|
* A callback function for iterate_over_threads.
|
* Find the asynchronous signal thread, and make it runnable.
|
* Find the asynchronous signal thread, and make it runnable.
|
* See if that helps matters any.
|
* See if that helps matters any.
|
*/
|
*/
|
|
|
static int
|
static int
|
make_signal_thread_runnable (process, pi, ptr)
|
make_signal_thread_runnable (process, pi, ptr)
|
procinfo *process;
|
procinfo *process;
|
procinfo *pi;
|
procinfo *pi;
|
void *ptr;
|
void *ptr;
|
{
|
{
|
#ifdef PR_ASLWP
|
#ifdef PR_ASLWP
|
if (proc_flags (pi) & PR_ASLWP)
|
if (proc_flags (pi) & PR_ASLWP)
|
{
|
{
|
if (!proc_run_process (pi, 0, -1))
|
if (!proc_run_process (pi, 0, -1))
|
proc_error (pi, "make_signal_thread_runnable", __LINE__);
|
proc_error (pi, "make_signal_thread_runnable", __LINE__);
|
return 1;
|
return 1;
|
}
|
}
|
#endif
|
#endif
|
return 0;
|
return 0;
|
}
|
}
|
#endif
|
#endif
|
|
|
/*
|
/*
|
* Function: target_resume
|
* Function: target_resume
|
*
|
*
|
* Make the child process runnable. Normally we will then call
|
* Make the child process runnable. Normally we will then call
|
* procfs_wait and wait for it to stop again (unles gdb is async).
|
* procfs_wait and wait for it to stop again (unles gdb is async).
|
*
|
*
|
* Arguments:
|
* Arguments:
|
* step: if true, then arrange for the child to stop again
|
* step: if true, then arrange for the child to stop again
|
* after executing a single instruction.
|
* after executing a single instruction.
|
* signo: if zero, then cancel any pending signal.
|
* signo: if zero, then cancel any pending signal.
|
* If non-zero, then arrange for the indicated signal
|
* If non-zero, then arrange for the indicated signal
|
* to be delivered to the child when it runs.
|
* to be delivered to the child when it runs.
|
* pid: if -1, then allow any child thread to run.
|
* pid: if -1, then allow any child thread to run.
|
* if non-zero, then allow only the indicated thread to run.
|
* if non-zero, then allow only the indicated thread to run.
|
******* (not implemented yet)
|
******* (not implemented yet)
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_resume (pid, step, signo)
|
procfs_resume (pid, step, signo)
|
int pid;
|
int pid;
|
int step;
|
int step;
|
enum target_signal signo;
|
enum target_signal signo;
|
{
|
{
|
procinfo *pi, *thread;
|
procinfo *pi, *thread;
|
int native_signo;
|
int native_signo;
|
|
|
/* 2.1:
|
/* 2.1:
|
prrun.prflags |= PRSVADDR;
|
prrun.prflags |= PRSVADDR;
|
prrun.pr_vaddr = $PC; set resume address
|
prrun.pr_vaddr = $PC; set resume address
|
prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
|
prrun.prflags |= PRSTRACE; trace signals in pr_trace (all)
|
prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
|
prrun.prflags |= PRSFAULT; trace faults in pr_fault (all but PAGE)
|
prrun.prflags |= PRCFAULT; clear current fault.
|
prrun.prflags |= PRCFAULT; clear current fault.
|
|
|
PRSTRACE and PRSFAULT can be done by other means
|
PRSTRACE and PRSFAULT can be done by other means
|
(proc_trace_signals, proc_trace_faults)
|
(proc_trace_signals, proc_trace_faults)
|
PRSVADDR is unnecessary.
|
PRSVADDR is unnecessary.
|
PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
|
PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
|
This basically leaves PRSTEP and PRCSIG.
|
This basically leaves PRSTEP and PRCSIG.
|
PRCSIG is like PIOCSSIG (proc_clear_current_signal).
|
PRCSIG is like PIOCSSIG (proc_clear_current_signal).
|
So basically PR_STEP is the sole argument that must be passed
|
So basically PR_STEP is the sole argument that must be passed
|
to proc_run_process (for use in the prrun struct by ioctl). */
|
to proc_run_process (for use in the prrun struct by ioctl). */
|
|
|
/* Find procinfo for main process */
|
/* Find procinfo for main process */
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
|
|
/* First cut: ignore pid argument */
|
/* First cut: ignore pid argument */
|
errno = 0;
|
errno = 0;
|
|
|
/* Convert signal to host numbering. */
|
/* Convert signal to host numbering. */
|
if (signo == 0 ||
|
if (signo == 0 ||
|
(signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop))
|
(signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop))
|
native_signo = 0;
|
native_signo = 0;
|
else
|
else
|
native_signo = target_signal_to_host (signo);
|
native_signo = target_signal_to_host (signo);
|
|
|
pi->ignore_next_sigstop = 0;
|
pi->ignore_next_sigstop = 0;
|
|
|
/* Running the process voids all cached registers and status. */
|
/* Running the process voids all cached registers and status. */
|
/* Void the threads' caches first */
|
/* Void the threads' caches first */
|
proc_iterate_over_threads (pi, invalidate_cache, NULL);
|
proc_iterate_over_threads (pi, invalidate_cache, NULL);
|
/* Void the process procinfo's caches. */
|
/* Void the process procinfo's caches. */
|
invalidate_cache (NULL, pi, NULL);
|
invalidate_cache (NULL, pi, NULL);
|
|
|
if (pid != -1)
|
if (pid != -1)
|
{
|
{
|
/* Resume a specific thread, presumably suppressing the others. */
|
/* Resume a specific thread, presumably suppressing the others. */
|
thread = find_procinfo (PIDGET (pid), TIDGET (pid));
|
thread = find_procinfo (PIDGET (pid), TIDGET (pid));
|
if (thread == NULL)
|
if (thread == NULL)
|
warning ("procfs: resume can't find thread %d -- resuming all.",
|
warning ("procfs: resume can't find thread %d -- resuming all.",
|
TIDGET (pid));
|
TIDGET (pid));
|
else
|
else
|
{
|
{
|
if (thread->tid != 0)
|
if (thread->tid != 0)
|
{
|
{
|
/* We're to resume a specific thread, and not the others.
|
/* We're to resume a specific thread, and not the others.
|
* Set the child process's PR_ASYNC flag.
|
* Set the child process's PR_ASYNC flag.
|
*/
|
*/
|
#ifdef PR_ASYNC
|
#ifdef PR_ASYNC
|
if (!proc_set_async (pi))
|
if (!proc_set_async (pi))
|
proc_error (pi, "target_resume, set_async", __LINE__);
|
proc_error (pi, "target_resume, set_async", __LINE__);
|
#endif
|
#endif
|
#if 0
|
#if 0
|
proc_iterate_over_threads (pi,
|
proc_iterate_over_threads (pi,
|
make_signal_thread_runnable,
|
make_signal_thread_runnable,
|
NULL);
|
NULL);
|
#endif
|
#endif
|
pi = thread; /* substitute the thread's procinfo for run */
|
pi = thread; /* substitute the thread's procinfo for run */
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (!proc_run_process (pi, step, native_signo))
|
if (!proc_run_process (pi, step, native_signo))
|
{
|
{
|
if (errno == EBUSY)
|
if (errno == EBUSY)
|
warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
|
warning ("resume: target already running. Pretend to resume, and hope for the best!\n");
|
else
|
else
|
proc_error (pi, "target_resume", __LINE__);
|
proc_error (pi, "target_resume", __LINE__);
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Function: register_gdb_signals
|
* Function: register_gdb_signals
|
*
|
*
|
* Traverse the list of signals that GDB knows about
|
* Traverse the list of signals that GDB knows about
|
* (see "handle" command), and arrange for the target
|
* (see "handle" command), and arrange for the target
|
* to be stopped or not, according to these settings.
|
* to be stopped or not, according to these settings.
|
*
|
*
|
* Returns non-zero for success, zero for failure.
|
* Returns non-zero for success, zero for failure.
|
*/
|
*/
|
|
|
static int
|
static int
|
register_gdb_signals (pi, signals)
|
register_gdb_signals (pi, signals)
|
procinfo *pi;
|
procinfo *pi;
|
sigset_t *signals;
|
sigset_t *signals;
|
{
|
{
|
int signo;
|
int signo;
|
|
|
for (signo = 0; signo < NSIG; signo ++)
|
for (signo = 0; signo < NSIG; signo ++)
|
if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
|
if (signal_stop_state (target_signal_from_host (signo)) == 0 &&
|
signal_print_state (target_signal_from_host (signo)) == 0 &&
|
signal_print_state (target_signal_from_host (signo)) == 0 &&
|
signal_pass_state (target_signal_from_host (signo)) == 1)
|
signal_pass_state (target_signal_from_host (signo)) == 1)
|
prdelset (signals, signo);
|
prdelset (signals, signo);
|
else
|
else
|
praddset (signals, signo);
|
praddset (signals, signo);
|
|
|
return proc_set_traced_signals (pi, signals);
|
return proc_set_traced_signals (pi, signals);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_notice_signals
|
* Function: target_notice_signals
|
*
|
*
|
* Set up to trace signals in the child process.
|
* Set up to trace signals in the child process.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_notice_signals (pid)
|
procfs_notice_signals (pid)
|
int pid;
|
int pid;
|
{
|
{
|
sigset_t signals;
|
sigset_t signals;
|
procinfo *pi = find_procinfo_or_die (PIDGET (pid), 0);
|
procinfo *pi = find_procinfo_or_die (PIDGET (pid), 0);
|
|
|
if (proc_get_traced_signals (pi, &signals) &&
|
if (proc_get_traced_signals (pi, &signals) &&
|
register_gdb_signals (pi, &signals))
|
register_gdb_signals (pi, &signals))
|
return;
|
return;
|
else
|
else
|
proc_error (pi, "notice_signals", __LINE__);
|
proc_error (pi, "notice_signals", __LINE__);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_files_info
|
* Function: target_files_info
|
*
|
*
|
* Print status information about the child process.
|
* Print status information about the child process.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_files_info (ignore)
|
procfs_files_info (ignore)
|
struct target_ops *ignore;
|
struct target_ops *ignore;
|
{
|
{
|
printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
|
printf_filtered ("\tUsing the running image of %s %s via /proc.\n",
|
attach_flag? "attached": "child",
|
attach_flag? "attached": "child",
|
target_pid_to_str (inferior_pid));
|
target_pid_to_str (inferior_pid));
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_open
|
* Function: target_open
|
*
|
*
|
* A dummy: you don't open procfs.
|
* A dummy: you don't open procfs.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_open (args, from_tty)
|
procfs_open (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
error ("Use the \"run\" command to start a Unix child process.");
|
error ("Use the \"run\" command to start a Unix child process.");
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_can_run
|
* Function: target_can_run
|
*
|
*
|
* This tells GDB that this target vector can be invoked
|
* This tells GDB that this target vector can be invoked
|
* for "run" or "attach".
|
* for "run" or "attach".
|
*/
|
*/
|
|
|
int procfs_suppress_run = 0; /* Non-zero if procfs should pretend not to
|
int procfs_suppress_run = 0; /* Non-zero if procfs should pretend not to
|
be a runnable target. Used by targets
|
be a runnable target. Used by targets
|
that can sit atop procfs, such as solaris
|
that can sit atop procfs, such as solaris
|
thread support. */
|
thread support. */
|
|
|
|
|
static int
|
static int
|
procfs_can_run ()
|
procfs_can_run ()
|
{
|
{
|
/* This variable is controlled by modules that sit atop procfs that
|
/* This variable is controlled by modules that sit atop procfs that
|
may layer their own process structure atop that provided here.
|
may layer their own process structure atop that provided here.
|
sol-thread.c does this because of the Solaris two-level thread
|
sol-thread.c does this because of the Solaris two-level thread
|
model. */
|
model. */
|
|
|
/* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
|
/* NOTE: possibly obsolete -- use the thread_stratum approach instead. */
|
|
|
return !procfs_suppress_run;
|
return !procfs_suppress_run;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_stop
|
* Function: target_stop
|
*
|
*
|
* Stop the child process asynchronously, as when the
|
* Stop the child process asynchronously, as when the
|
* gdb user types control-c or presses a "stop" button.
|
* gdb user types control-c or presses a "stop" button.
|
*
|
*
|
* Works by sending kill(SIGINT) to the child's process group.
|
* Works by sending kill(SIGINT) to the child's process group.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_stop ()
|
procfs_stop ()
|
{
|
{
|
extern pid_t inferior_process_group;
|
extern pid_t inferior_process_group;
|
|
|
kill (-inferior_process_group, SIGINT);
|
kill (-inferior_process_group, SIGINT);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: unconditionally_kill_inferior
|
* Function: unconditionally_kill_inferior
|
*
|
*
|
* Make it die. Wait for it to die. Clean up after it.
|
* Make it die. Wait for it to die. Clean up after it.
|
* Note: this should only be applied to the real process,
|
* Note: this should only be applied to the real process,
|
* not to an LWP, because of the check for parent-process.
|
* not to an LWP, because of the check for parent-process.
|
* If we need this to work for an LWP, it needs some more logic.
|
* If we need this to work for an LWP, it needs some more logic.
|
*/
|
*/
|
|
|
static void
|
static void
|
unconditionally_kill_inferior (pi)
|
unconditionally_kill_inferior (pi)
|
procinfo *pi;
|
procinfo *pi;
|
{
|
{
|
int parent_pid;
|
int parent_pid;
|
|
|
parent_pid = proc_parent_pid (pi);
|
parent_pid = proc_parent_pid (pi);
|
#ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
|
#ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
|
/* FIXME: use access functions */
|
/* FIXME: use access functions */
|
/* Alpha OSF/1-3.x procfs needs a clear of the current signal
|
/* Alpha OSF/1-3.x procfs needs a clear of the current signal
|
before the PIOCKILL, otherwise it might generate a corrupted core
|
before the PIOCKILL, otherwise it might generate a corrupted core
|
file for the inferior. */
|
file for the inferior. */
|
if (ioctl (pi->ctl_fd, PIOCSSIG, NULL) < 0)
|
if (ioctl (pi->ctl_fd, PIOCSSIG, NULL) < 0)
|
{
|
{
|
printf_filtered ("unconditionally_kill: SSIG failed!\n");
|
printf_filtered ("unconditionally_kill: SSIG failed!\n");
|
}
|
}
|
#endif
|
#endif
|
#ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
|
#ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
|
/* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
|
/* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
|
to kill the inferior, otherwise it might remain stopped with a
|
to kill the inferior, otherwise it might remain stopped with a
|
pending SIGKILL.
|
pending SIGKILL.
|
We do not check the result of the PIOCSSIG, the inferior might have
|
We do not check the result of the PIOCSSIG, the inferior might have
|
died already. */
|
died already. */
|
{
|
{
|
struct siginfo newsiginfo;
|
struct siginfo newsiginfo;
|
|
|
memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
|
memset ((char *) &newsiginfo, 0, sizeof (newsiginfo));
|
newsiginfo.si_signo = SIGKILL;
|
newsiginfo.si_signo = SIGKILL;
|
newsiginfo.si_code = 0;
|
newsiginfo.si_code = 0;
|
newsiginfo.si_errno = 0;
|
newsiginfo.si_errno = 0;
|
newsiginfo.si_pid = getpid ();
|
newsiginfo.si_pid = getpid ();
|
newsiginfo.si_uid = getuid ();
|
newsiginfo.si_uid = getuid ();
|
/* FIXME: use proc_set_current_signal */
|
/* FIXME: use proc_set_current_signal */
|
ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo);
|
ioctl (pi->ctl_fd, PIOCSSIG, &newsiginfo);
|
}
|
}
|
#else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
|
#else /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
|
if (!proc_kill (pi, SIGKILL))
|
if (!proc_kill (pi, SIGKILL))
|
proc_warn (pi, "unconditionally_kill, proc_kill", __LINE__);
|
proc_warn (pi, "unconditionally_kill, proc_kill", __LINE__);
|
#endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
|
#endif /* PROCFS_NEED_PIOCSSIG_FOR_KILL */
|
destroy_procinfo (pi);
|
destroy_procinfo (pi);
|
|
|
/* If pi is GDB's child, wait for it to die. */
|
/* If pi is GDB's child, wait for it to die. */
|
if (parent_pid == getpid ())
|
if (parent_pid == getpid ())
|
/* FIXME: should we use waitpid to make sure we get the right event?
|
/* FIXME: should we use waitpid to make sure we get the right event?
|
Should we check the returned event? */
|
Should we check the returned event? */
|
{
|
{
|
#if 0
|
#if 0
|
int status, ret;
|
int status, ret;
|
|
|
ret = waitpid (pi->pid, &status, 0);
|
ret = waitpid (pi->pid, &status, 0);
|
#else
|
#else
|
wait (NULL);
|
wait (NULL);
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_kill_inferior
|
* Function: target_kill_inferior
|
*
|
*
|
* We're done debugging it, and we want it to go away.
|
* We're done debugging it, and we want it to go away.
|
* Then we want GDB to forget all about it.
|
* Then we want GDB to forget all about it.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_kill_inferior ()
|
procfs_kill_inferior ()
|
{
|
{
|
if (inferior_pid != 0) /* ? */
|
if (inferior_pid != 0) /* ? */
|
{
|
{
|
/* Find procinfo for main process */
|
/* Find procinfo for main process */
|
procinfo *pi = find_procinfo (PIDGET (inferior_pid), 0);
|
procinfo *pi = find_procinfo (PIDGET (inferior_pid), 0);
|
|
|
if (pi)
|
if (pi)
|
unconditionally_kill_inferior (pi);
|
unconditionally_kill_inferior (pi);
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_mourn_inferior
|
* Function: target_mourn_inferior
|
*
|
*
|
* Forget we ever debugged this thing!
|
* Forget we ever debugged this thing!
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_mourn_inferior ()
|
procfs_mourn_inferior ()
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
|
|
if (inferior_pid != 0)
|
if (inferior_pid != 0)
|
{
|
{
|
/* Find procinfo for main process */
|
/* Find procinfo for main process */
|
pi = find_procinfo (PIDGET (inferior_pid), 0);
|
pi = find_procinfo (PIDGET (inferior_pid), 0);
|
if (pi)
|
if (pi)
|
destroy_procinfo (pi);
|
destroy_procinfo (pi);
|
}
|
}
|
unpush_target (&procfs_ops);
|
unpush_target (&procfs_ops);
|
generic_mourn_inferior ();
|
generic_mourn_inferior ();
|
}
|
}
|
|
|
/*
|
/*
|
* Function: init_inferior
|
* Function: init_inferior
|
*
|
*
|
* When GDB forks to create a runnable inferior process,
|
* When GDB forks to create a runnable inferior process,
|
* this function is called on the parent side of the fork.
|
* this function is called on the parent side of the fork.
|
* It's job is to do whatever is necessary to make the child
|
* It's job is to do whatever is necessary to make the child
|
* ready to be debugged, and then wait for the child to synchronize.
|
* ready to be debugged, and then wait for the child to synchronize.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_init_inferior (pid)
|
procfs_init_inferior (pid)
|
int pid;
|
int pid;
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
sigset_t signals;
|
sigset_t signals;
|
int fail;
|
int fail;
|
|
|
/* This routine called on the parent side (GDB side)
|
/* This routine called on the parent side (GDB side)
|
after GDB forks the inferior. */
|
after GDB forks the inferior. */
|
|
|
push_target (&procfs_ops);
|
push_target (&procfs_ops);
|
|
|
if ((pi = create_procinfo (pid, 0)) == NULL)
|
if ((pi = create_procinfo (pid, 0)) == NULL)
|
perror ("procfs: out of memory in 'init_inferior'");
|
perror ("procfs: out of memory in 'init_inferior'");
|
|
|
if (!open_procinfo_files (pi, FD_CTL))
|
if (!open_procinfo_files (pi, FD_CTL))
|
proc_error (pi, "init_inferior, open_proc_files", __LINE__);
|
proc_error (pi, "init_inferior, open_proc_files", __LINE__);
|
|
|
/*
|
/*
|
xmalloc // done
|
xmalloc // done
|
open_procinfo_files // done
|
open_procinfo_files // done
|
link list // done
|
link list // done
|
prfillset (trace)
|
prfillset (trace)
|
procfs_notice_signals
|
procfs_notice_signals
|
prfillset (fault)
|
prfillset (fault)
|
prdelset (FLTPAGE)
|
prdelset (FLTPAGE)
|
PIOCWSTOP
|
PIOCWSTOP
|
PIOCSFAULT
|
PIOCSFAULT
|
*/
|
*/
|
|
|
/* If not stopped yet, wait for it to stop. */
|
/* If not stopped yet, wait for it to stop. */
|
if (!(proc_flags (pi) & PR_STOPPED) &&
|
if (!(proc_flags (pi) & PR_STOPPED) &&
|
!(proc_wait_for_stop (pi)))
|
!(proc_wait_for_stop (pi)))
|
dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL);
|
dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL);
|
|
|
/* Save some of the /proc state to be restored if we detach. */
|
/* Save some of the /proc state to be restored if we detach. */
|
/* FIXME: Why? In case another debugger was debugging it?
|
/* FIXME: Why? In case another debugger was debugging it?
|
We're it's parent, for Ghu's sake! */
|
We're it's parent, for Ghu's sake! */
|
if (!proc_get_traced_signals (pi, &pi->saved_sigset))
|
if (!proc_get_traced_signals (pi, &pi->saved_sigset))
|
proc_error (pi, "init_inferior, get_traced_signals", __LINE__);
|
proc_error (pi, "init_inferior, get_traced_signals", __LINE__);
|
if (!proc_get_held_signals (pi, &pi->saved_sighold))
|
if (!proc_get_held_signals (pi, &pi->saved_sighold))
|
proc_error (pi, "init_inferior, get_held_signals", __LINE__);
|
proc_error (pi, "init_inferior, get_held_signals", __LINE__);
|
if (!proc_get_traced_faults (pi, &pi->saved_fltset))
|
if (!proc_get_traced_faults (pi, &pi->saved_fltset))
|
proc_error (pi, "init_inferior, get_traced_faults", __LINE__);
|
proc_error (pi, "init_inferior, get_traced_faults", __LINE__);
|
if (!proc_get_traced_sysentry (pi, &pi->saved_entryset))
|
if (!proc_get_traced_sysentry (pi, &pi->saved_entryset))
|
proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__);
|
proc_error (pi, "init_inferior, get_traced_sysentry", __LINE__);
|
if (!proc_get_traced_sysexit (pi, &pi->saved_exitset))
|
if (!proc_get_traced_sysexit (pi, &pi->saved_exitset))
|
proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__);
|
proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__);
|
|
|
/* Register to trace selected signals in the child. */
|
/* Register to trace selected signals in the child. */
|
prfillset (&signals);
|
prfillset (&signals);
|
if (!register_gdb_signals (pi, &signals))
|
if (!register_gdb_signals (pi, &signals))
|
proc_error (pi, "init_inferior, register_signals", __LINE__);
|
proc_error (pi, "init_inferior, register_signals", __LINE__);
|
|
|
if ((fail = procfs_debug_inferior (pi)) != 0)
|
if ((fail = procfs_debug_inferior (pi)) != 0)
|
proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
|
proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
|
|
|
/* FIXME: logically, we should really be turning OFF run-on-last-close,
|
/* FIXME: logically, we should really be turning OFF run-on-last-close,
|
and possibly even turning ON kill-on-last-close at this point. But
|
and possibly even turning ON kill-on-last-close at this point. But
|
I can't make that change without careful testing which I don't have
|
I can't make that change without careful testing which I don't have
|
time to do right now... */
|
time to do right now... */
|
/* Turn on run-on-last-close flag so that the child
|
/* Turn on run-on-last-close flag so that the child
|
will die if GDB goes away for some reason. */
|
will die if GDB goes away for some reason. */
|
if (!proc_set_run_on_last_close (pi))
|
if (!proc_set_run_on_last_close (pi))
|
proc_error (pi, "init_inferior, set_RLC", __LINE__);
|
proc_error (pi, "init_inferior, set_RLC", __LINE__);
|
|
|
/* The 'process ID' we return to GDB is composed of
|
/* The 'process ID' we return to GDB is composed of
|
the actual process ID plus the lwp ID. */
|
the actual process ID plus the lwp ID. */
|
inferior_pid = MERGEPID (pi->pid, proc_get_current_thread (pi));
|
inferior_pid = MERGEPID (pi->pid, proc_get_current_thread (pi));
|
|
|
#ifdef START_INFERIOR_TRAPS_EXPECTED
|
#ifdef START_INFERIOR_TRAPS_EXPECTED
|
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
|
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
|
#else
|
#else
|
/* One trap to exec the shell, one to exec the program being debugged. */
|
/* One trap to exec the shell, one to exec the program being debugged. */
|
startup_inferior (2);
|
startup_inferior (2);
|
#endif /* START_INFERIOR_TRAPS_EXPECTED */
|
#endif /* START_INFERIOR_TRAPS_EXPECTED */
|
}
|
}
|
|
|
/*
|
/*
|
* Function: set_exec_trap
|
* Function: set_exec_trap
|
*
|
*
|
* When GDB forks to create a new process, this function is called
|
* When GDB forks to create a new process, this function is called
|
* on the child side of the fork before GDB exec's the user program.
|
* on the child side of the fork before GDB exec's the user program.
|
* Its job is to make the child minimally debuggable, so that the
|
* Its job is to make the child minimally debuggable, so that the
|
* parent GDB process can connect to the child and take over.
|
* parent GDB process can connect to the child and take over.
|
* This function should do only the minimum to make that possible,
|
* This function should do only the minimum to make that possible,
|
* and to synchronize with the parent process. The parent process
|
* and to synchronize with the parent process. The parent process
|
* should take care of the details.
|
* should take care of the details.
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_set_exec_trap ()
|
procfs_set_exec_trap ()
|
{
|
{
|
/* This routine called on the child side (inferior side)
|
/* This routine called on the child side (inferior side)
|
after GDB forks the inferior. It must use only local variables,
|
after GDB forks the inferior. It must use only local variables,
|
because it may be sharing data space with its parent. */
|
because it may be sharing data space with its parent. */
|
|
|
procinfo *pi;
|
procinfo *pi;
|
sysset_t exitset;
|
sysset_t exitset;
|
|
|
if ((pi = create_procinfo (getpid (), 0)) == NULL)
|
if ((pi = create_procinfo (getpid (), 0)) == NULL)
|
perror_with_name ("procfs: create_procinfo failed in child.");
|
perror_with_name ("procfs: create_procinfo failed in child.");
|
|
|
if (open_procinfo_files (pi, FD_CTL) == 0)
|
if (open_procinfo_files (pi, FD_CTL) == 0)
|
{
|
{
|
proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__);
|
proc_warn (pi, "set_exec_trap, open_proc_files", __LINE__);
|
gdb_flush (gdb_stderr);
|
gdb_flush (gdb_stderr);
|
/* no need to call "dead_procinfo", because we're going to exit. */
|
/* no need to call "dead_procinfo", because we're going to exit. */
|
_exit (127);
|
_exit (127);
|
}
|
}
|
|
|
#ifdef PRFS_STOPEXEC /* defined on OSF */
|
#ifdef PRFS_STOPEXEC /* defined on OSF */
|
/* OSF method for tracing exec syscalls. Quoting:
|
/* OSF method for tracing exec syscalls. Quoting:
|
Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
|
Under Alpha OSF/1 we have to use a PIOCSSPCACT ioctl to trace
|
exits from exec system calls because of the user level loader. */
|
exits from exec system calls because of the user level loader. */
|
/* FIXME: make nice and maybe move into an access function. */
|
/* FIXME: make nice and maybe move into an access function. */
|
{
|
{
|
int prfs_flags;
|
int prfs_flags;
|
|
|
if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
|
if (ioctl (pi->ctl_fd, PIOCGSPCACT, &prfs_flags) < 0)
|
{
|
{
|
proc_warn (pi, "set_exec_trap (PIOCGSPCACT)", __LINE__);
|
proc_warn (pi, "set_exec_trap (PIOCGSPCACT)", __LINE__);
|
gdb_flush (gdb_stderr);
|
gdb_flush (gdb_stderr);
|
_exit (127);
|
_exit (127);
|
}
|
}
|
prfs_flags |= PRFS_STOPEXEC;
|
prfs_flags |= PRFS_STOPEXEC;
|
|
|
if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
|
if (ioctl (pi->ctl_fd, PIOCSSPCACT, &prfs_flags) < 0)
|
{
|
{
|
proc_warn (pi, "set_exec_trap (PIOCSSPCACT)", __LINE__);
|
proc_warn (pi, "set_exec_trap (PIOCSSPCACT)", __LINE__);
|
gdb_flush (gdb_stderr);
|
gdb_flush (gdb_stderr);
|
_exit (127);
|
_exit (127);
|
}
|
}
|
}
|
}
|
#else /* not PRFS_STOPEXEC */
|
#else /* not PRFS_STOPEXEC */
|
/* Everyone else's (except OSF) method for tracing exec syscalls */
|
/* Everyone else's (except OSF) method for tracing exec syscalls */
|
/* GW: Rationale...
|
/* GW: Rationale...
|
Not all systems with /proc have all the exec* syscalls with the same
|
Not all systems with /proc have all the exec* syscalls with the same
|
names. On the SGI, for example, there is no SYS_exec, but there
|
names. On the SGI, for example, there is no SYS_exec, but there
|
*is* a SYS_execv. So, we try to account for that. */
|
*is* a SYS_execv. So, we try to account for that. */
|
|
|
premptyset (&exitset);
|
premptyset (&exitset);
|
#ifdef SYS_exec
|
#ifdef SYS_exec
|
praddset (&exitset, SYS_exec);
|
praddset (&exitset, SYS_exec);
|
#endif
|
#endif
|
#ifdef SYS_execve
|
#ifdef SYS_execve
|
praddset (&exitset, SYS_execve);
|
praddset (&exitset, SYS_execve);
|
#endif
|
#endif
|
#ifdef SYS_execv
|
#ifdef SYS_execv
|
praddset (&exitset, SYS_execv);
|
praddset (&exitset, SYS_execv);
|
#endif
|
#endif
|
|
|
if (!proc_set_traced_sysexit (pi, &exitset))
|
if (!proc_set_traced_sysexit (pi, &exitset))
|
{
|
{
|
proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__);
|
proc_warn (pi, "set_exec_trap, set_traced_sysexit", __LINE__);
|
gdb_flush (gdb_stderr);
|
gdb_flush (gdb_stderr);
|
_exit (127);
|
_exit (127);
|
}
|
}
|
#endif /* PRFS_STOPEXEC */
|
#endif /* PRFS_STOPEXEC */
|
|
|
/* FIXME: should this be done in the parent instead? */
|
/* FIXME: should this be done in the parent instead? */
|
/* Turn off inherit on fork flag so that all grand-children
|
/* Turn off inherit on fork flag so that all grand-children
|
of gdb start with tracing flags cleared. */
|
of gdb start with tracing flags cleared. */
|
if (!proc_unset_inherit_on_fork (pi))
|
if (!proc_unset_inherit_on_fork (pi))
|
proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__);
|
proc_warn (pi, "set_exec_trap, unset_inherit", __LINE__);
|
|
|
/* Turn off run on last close flag, so that the child process
|
/* Turn off run on last close flag, so that the child process
|
cannot run away just because we close our handle on it.
|
cannot run away just because we close our handle on it.
|
We want it to wait for the parent to attach. */
|
We want it to wait for the parent to attach. */
|
if (!proc_unset_run_on_last_close (pi))
|
if (!proc_unset_run_on_last_close (pi))
|
proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__);
|
proc_warn (pi, "set_exec_trap, unset_RLC", __LINE__);
|
|
|
/* FIXME: No need to destroy the procinfo --
|
/* FIXME: No need to destroy the procinfo --
|
we have our own address space, and we're about to do an exec! */
|
we have our own address space, and we're about to do an exec! */
|
/*destroy_procinfo (pi);*/
|
/*destroy_procinfo (pi);*/
|
}
|
}
|
|
|
/*
|
/*
|
* Function: create_inferior
|
* Function: create_inferior
|
*
|
*
|
* This function is called BEFORE gdb forks the inferior process.
|
* This function is called BEFORE gdb forks the inferior process.
|
* Its only real responsibility is to set things up for the fork,
|
* Its only real responsibility is to set things up for the fork,
|
* and tell GDB which two functions to call after the fork (one
|
* and tell GDB which two functions to call after the fork (one
|
* for the parent, and one for the child).
|
* for the parent, and one for the child).
|
*
|
*
|
* This function does a complicated search for a unix shell program,
|
* This function does a complicated search for a unix shell program,
|
* which it then uses to parse arguments and environment variables
|
* which it then uses to parse arguments and environment variables
|
* to be sent to the child. I wonder whether this code could not
|
* to be sent to the child. I wonder whether this code could not
|
* be abstracted out and shared with other unix targets such as
|
* be abstracted out and shared with other unix targets such as
|
* infptrace?
|
* infptrace?
|
*/
|
*/
|
|
|
static void
|
static void
|
procfs_create_inferior (exec_file, allargs, env)
|
procfs_create_inferior (exec_file, allargs, env)
|
char *exec_file;
|
char *exec_file;
|
char *allargs;
|
char *allargs;
|
char **env;
|
char **env;
|
{
|
{
|
char *shell_file = getenv ("SHELL");
|
char *shell_file = getenv ("SHELL");
|
char *tryname;
|
char *tryname;
|
if (shell_file != NULL && strchr (shell_file, '/') == NULL)
|
if (shell_file != NULL && strchr (shell_file, '/') == NULL)
|
{
|
{
|
|
|
/* We will be looking down the PATH to find shell_file. If we
|
/* We will be looking down the PATH to find shell_file. If we
|
just do this the normal way (via execlp, which operates by
|
just do this the normal way (via execlp, which operates by
|
attempting an exec for each element of the PATH until it
|
attempting an exec for each element of the PATH until it
|
finds one which succeeds), then there will be an exec for
|
finds one which succeeds), then there will be an exec for
|
each failed attempt, each of which will cause a PR_SYSEXIT
|
each failed attempt, each of which will cause a PR_SYSEXIT
|
stop, and we won't know how to distinguish the PR_SYSEXIT's
|
stop, and we won't know how to distinguish the PR_SYSEXIT's
|
for these failed execs with the ones for successful execs
|
for these failed execs with the ones for successful execs
|
(whether the exec has succeeded is stored at that time in the
|
(whether the exec has succeeded is stored at that time in the
|
carry bit or some such architecture-specific and
|
carry bit or some such architecture-specific and
|
non-ABI-specified place).
|
non-ABI-specified place).
|
|
|
So I can't think of anything better than to search the PATH
|
So I can't think of anything better than to search the PATH
|
now. This has several disadvantages: (1) There is a race
|
now. This has several disadvantages: (1) There is a race
|
condition; if we find a file now and it is deleted before we
|
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
|
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
|
further down in the PATH, (2) there is no way to know exactly
|
what an executable (in the sense of "capable of being
|
what an executable (in the sense of "capable of being
|
exec'd") file is. Using access() loses because it may lose
|
exec'd") file is. Using access() loses because it may lose
|
if the caller is the superuser; failing to use it loses if
|
if the caller is the superuser; failing to use it loses if
|
there are ACLs or some such. */
|
there are ACLs or some such. */
|
|
|
char *p;
|
char *p;
|
char *p1;
|
char *p1;
|
/* FIXME-maybe: might want "set path" command so user can change what
|
/* 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");
|
char *path = getenv ("PATH");
|
int len;
|
int len;
|
struct stat statbuf;
|
struct stat statbuf;
|
|
|
if (path == NULL)
|
if (path == NULL)
|
path = "/bin:/usr/bin";
|
path = "/bin:/usr/bin";
|
|
|
tryname = alloca (strlen (path) + strlen (shell_file) + 2);
|
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, ':');
|
p1 = strchr (p, ':');
|
if (p1 != NULL)
|
if (p1 != NULL)
|
len = p1 - p;
|
len = p1 - p;
|
else
|
else
|
len = strlen (p);
|
len = strlen (p);
|
strncpy (tryname, p, len);
|
strncpy (tryname, p, len);
|
tryname[len] = '\0';
|
tryname[len] = '\0';
|
strcat (tryname, "/");
|
strcat (tryname, "/");
|
strcat (tryname, shell_file);
|
strcat (tryname, shell_file);
|
if (access (tryname, X_OK) < 0)
|
if (access (tryname, X_OK) < 0)
|
continue;
|
continue;
|
if (stat (tryname, &statbuf) < 0)
|
if (stat (tryname, &statbuf) < 0)
|
continue;
|
continue;
|
if (!S_ISREG (statbuf.st_mode))
|
if (!S_ISREG (statbuf.st_mode))
|
/* We certainly need to reject directories. I'm not quite
|
/* We certainly need to reject directories. I'm not quite
|
as sure about FIFOs, sockets, etc., but I kind of doubt
|
as sure about FIFOs, sockets, etc., but I kind of doubt
|
that people want to exec() these things. */
|
that people want to exec() these things. */
|
continue;
|
continue;
|
break;
|
break;
|
}
|
}
|
if (p == NULL)
|
if (p == NULL)
|
/* Not found. This must be an error rather than merely passing
|
/* Not found. This must be an error rather than merely passing
|
the file to execlp(), because execlp() would try all the
|
the file to execlp(), because execlp() would try all the
|
exec()s, causing GDB to get confused. */
|
exec()s, causing GDB to get confused. */
|
error ("procfs:%d -- Can't find shell %s in PATH",
|
error ("procfs:%d -- Can't find shell %s in PATH",
|
__LINE__, shell_file);
|
__LINE__, shell_file);
|
|
|
shell_file = tryname;
|
shell_file = tryname;
|
}
|
}
|
|
|
fork_inferior (exec_file, allargs, env, procfs_set_exec_trap,
|
fork_inferior (exec_file, allargs, env, procfs_set_exec_trap,
|
procfs_init_inferior, NULL, shell_file);
|
procfs_init_inferior, NULL, shell_file);
|
|
|
/* We are at the first instruction we care about. */
|
/* We are at the first instruction we care about. */
|
/* Pedal to the metal... */
|
/* Pedal to the metal... */
|
|
|
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
|
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: notice_thread
|
* Function: notice_thread
|
*
|
*
|
* Callback for find_new_threads.
|
* Callback for find_new_threads.
|
* Calls "add_thread".
|
* Calls "add_thread".
|
*/
|
*/
|
|
|
static int
|
static int
|
procfs_notice_thread (pi, thread, ptr)
|
procfs_notice_thread (pi, thread, ptr)
|
procinfo *pi;
|
procinfo *pi;
|
procinfo *thread;
|
procinfo *thread;
|
void *ptr;
|
void *ptr;
|
{
|
{
|
int gdb_threadid = MERGEPID (pi->pid, thread->tid);
|
int gdb_threadid = MERGEPID (pi->pid, thread->tid);
|
|
|
if (!in_thread_list (gdb_threadid))
|
if (!in_thread_list (gdb_threadid))
|
add_thread (gdb_threadid);
|
add_thread (gdb_threadid);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_find_new_threads
|
* Function: target_find_new_threads
|
*
|
*
|
* Query all the threads that the target knows about,
|
* Query all the threads that the target knows about,
|
* and give them back to GDB to add to its list.
|
* and give them back to GDB to add to its list.
|
*/
|
*/
|
|
|
void
|
void
|
procfs_find_new_threads ()
|
procfs_find_new_threads ()
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
|
|
/* Find procinfo for main process */
|
/* Find procinfo for main process */
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
proc_update_threads (pi);
|
proc_update_threads (pi);
|
proc_iterate_over_threads (pi, procfs_notice_thread, NULL);
|
proc_iterate_over_threads (pi, procfs_notice_thread, NULL);
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_thread_alive
|
* Function: target_thread_alive
|
*
|
*
|
* Return true if the thread is still 'alive'.
|
* Return true if the thread is still 'alive'.
|
*
|
*
|
* This guy doesn't really seem to be doing his job.
|
* This guy doesn't really seem to be doing his job.
|
* Got to investigate how to tell when a thread is really gone.
|
* Got to investigate how to tell when a thread is really gone.
|
*/
|
*/
|
|
|
static int
|
static int
|
procfs_thread_alive (pid)
|
procfs_thread_alive (pid)
|
int pid;
|
int pid;
|
{
|
{
|
int proc, thread;
|
int proc, thread;
|
procinfo *pi;
|
procinfo *pi;
|
|
|
proc = PIDGET (pid);
|
proc = PIDGET (pid);
|
thread = TIDGET (pid);
|
thread = TIDGET (pid);
|
/* If I don't know it, it ain't alive! */
|
/* If I don't know it, it ain't alive! */
|
if ((pi = find_procinfo (proc, thread)) == NULL)
|
if ((pi = find_procinfo (proc, thread)) == NULL)
|
return 0;
|
return 0;
|
|
|
/* If I can't get its status, it ain't alive!
|
/* If I can't get its status, it ain't alive!
|
What's more, I need to forget about it! */
|
What's more, I need to forget about it! */
|
if (!proc_get_status (pi))
|
if (!proc_get_status (pi))
|
{
|
{
|
destroy_procinfo (pi);
|
destroy_procinfo (pi);
|
return 0;
|
return 0;
|
}
|
}
|
/* I couldn't have got its status if it weren't alive, so it's alive. */
|
/* I couldn't have got its status if it weren't alive, so it's alive. */
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: target_pid_to_str
|
* Function: target_pid_to_str
|
*
|
*
|
* Return a string to be used to identify the thread in
|
* Return a string to be used to identify the thread in
|
* the "info threads" display.
|
* the "info threads" display.
|
*/
|
*/
|
|
|
char *
|
char *
|
procfs_pid_to_str (pid)
|
procfs_pid_to_str (pid)
|
int pid;
|
int pid;
|
{
|
{
|
static char buf[80];
|
static char buf[80];
|
int proc, thread;
|
int proc, thread;
|
procinfo *pi;
|
procinfo *pi;
|
|
|
proc = PIDGET (pid);
|
proc = PIDGET (pid);
|
thread = TIDGET (pid);
|
thread = TIDGET (pid);
|
pi = find_procinfo (proc, thread);
|
pi = find_procinfo (proc, thread);
|
|
|
if (thread == 0)
|
if (thread == 0)
|
sprintf (buf, "Process %d", proc);
|
sprintf (buf, "Process %d", proc);
|
else
|
else
|
sprintf (buf, "LWP %d", thread);
|
sprintf (buf, "LWP %d", thread);
|
return &buf[0];
|
return &buf[0];
|
}
|
}
|
|
|
/*
|
/*
|
* Function: procfs_set_watchpoint
|
* Function: procfs_set_watchpoint
|
* Insert a watchpoint
|
* Insert a watchpoint
|
*/
|
*/
|
|
|
int
|
int
|
procfs_set_watchpoint (pid, addr, len, rwflag, after)
|
procfs_set_watchpoint (pid, addr, len, rwflag, after)
|
int pid;
|
int pid;
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int len;
|
int len;
|
int rwflag;
|
int rwflag;
|
int after;
|
int after;
|
{
|
{
|
#ifndef UNIXWARE
|
#ifndef UNIXWARE
|
int pflags = 0;
|
int pflags = 0;
|
procinfo *pi;
|
procinfo *pi;
|
|
|
pi = find_procinfo_or_die (pid == -1 ?
|
pi = find_procinfo_or_die (pid == -1 ?
|
PIDGET (inferior_pid) : PIDGET (pid), 0);
|
PIDGET (inferior_pid) : PIDGET (pid), 0);
|
|
|
/* Translate from GDB's flags to /proc's */
|
/* Translate from GDB's flags to /proc's */
|
if (len > 0) /* len == 0 means delete watchpoint */
|
if (len > 0) /* len == 0 means delete watchpoint */
|
{
|
{
|
switch (rwflag) { /* FIXME: need an enum! */
|
switch (rwflag) { /* FIXME: need an enum! */
|
case hw_write: /* default watchpoint (write) */
|
case hw_write: /* default watchpoint (write) */
|
pflags = WRITE_WATCHFLAG;
|
pflags = WRITE_WATCHFLAG;
|
break;
|
break;
|
case hw_read: /* read watchpoint */
|
case hw_read: /* read watchpoint */
|
pflags = READ_WATCHFLAG;
|
pflags = READ_WATCHFLAG;
|
break;
|
break;
|
case hw_access: /* access watchpoint */
|
case hw_access: /* access watchpoint */
|
pflags = READ_WATCHFLAG | WRITE_WATCHFLAG;
|
pflags = READ_WATCHFLAG | WRITE_WATCHFLAG;
|
break;
|
break;
|
case hw_execute: /* execution HW breakpoint */
|
case hw_execute: /* execution HW breakpoint */
|
pflags = EXEC_WATCHFLAG;
|
pflags = EXEC_WATCHFLAG;
|
break;
|
break;
|
default: /* Something weird. Return error. */
|
default: /* Something weird. Return error. */
|
return -1;
|
return -1;
|
}
|
}
|
if (after) /* Stop after r/w access is completed. */
|
if (after) /* Stop after r/w access is completed. */
|
pflags |= AFTER_WATCHFLAG;
|
pflags |= AFTER_WATCHFLAG;
|
}
|
}
|
|
|
if (!proc_set_watchpoint (pi, addr, len, pflags))
|
if (!proc_set_watchpoint (pi, addr, len, pflags))
|
{
|
{
|
if (errno == E2BIG) /* Typical error for no resources */
|
if (errno == E2BIG) /* Typical error for no resources */
|
return -1; /* fail */
|
return -1; /* fail */
|
/* GDB may try to remove the same watchpoint twice.
|
/* GDB may try to remove the same watchpoint twice.
|
If a remove request returns no match, don't error. */
|
If a remove request returns no match, don't error. */
|
if (errno == ESRCH && len == 0)
|
if (errno == ESRCH && len == 0)
|
return 0; /* ignore */
|
return 0; /* ignore */
|
proc_error (pi, "set_watchpoint", __LINE__);
|
proc_error (pi, "set_watchpoint", __LINE__);
|
}
|
}
|
#endif
|
#endif
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Function: stopped_by_watchpoint
|
* Function: stopped_by_watchpoint
|
*
|
*
|
* Returns non-zero if process is stopped on a hardware watchpoint fault,
|
* Returns non-zero if process is stopped on a hardware watchpoint fault,
|
* else returns zero.
|
* else returns zero.
|
*/
|
*/
|
|
|
int
|
int
|
procfs_stopped_by_watchpoint (pid)
|
procfs_stopped_by_watchpoint (pid)
|
int pid;
|
int pid;
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
|
|
pi = find_procinfo_or_die (pid == -1 ?
|
pi = find_procinfo_or_die (pid == -1 ?
|
PIDGET (inferior_pid) : PIDGET (pid), 0);
|
PIDGET (inferior_pid) : PIDGET (pid), 0);
|
if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
|
if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
|
{
|
{
|
if (proc_why (pi) == PR_FAULTED)
|
if (proc_why (pi) == PR_FAULTED)
|
{
|
{
|
#ifdef FLTWATCH
|
#ifdef FLTWATCH
|
if (proc_what (pi) == FLTWATCH)
|
if (proc_what (pi) == FLTWATCH)
|
return 1;
|
return 1;
|
#endif
|
#endif
|
#ifdef FLTKWATCH
|
#ifdef FLTKWATCH
|
if (proc_what (pi) == FLTKWATCH)
|
if (proc_what (pi) == FLTKWATCH)
|
return 1;
|
return 1;
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#ifdef TM_I386SOL2_H
|
#ifdef TM_I386SOL2_H
|
/*
|
/*
|
* Function: procfs_find_LDT_entry
|
* Function: procfs_find_LDT_entry
|
*
|
*
|
* Input:
|
* Input:
|
* int pid; // The GDB-style pid-plus-LWP.
|
* int pid; // The GDB-style pid-plus-LWP.
|
*
|
*
|
* Return:
|
* Return:
|
* pointer to the corresponding LDT entry.
|
* pointer to the corresponding LDT entry.
|
*/
|
*/
|
|
|
struct ssd *
|
struct ssd *
|
procfs_find_LDT_entry (pid)
|
procfs_find_LDT_entry (pid)
|
int pid;
|
int pid;
|
{
|
{
|
gdb_gregset_t *gregs;
|
gdb_gregset_t *gregs;
|
int key;
|
int key;
|
procinfo *pi;
|
procinfo *pi;
|
|
|
/* Find procinfo for the lwp. */
|
/* Find procinfo for the lwp. */
|
if ((pi = find_procinfo (PIDGET (pid), TIDGET (pid))) == NULL)
|
if ((pi = find_procinfo (PIDGET (pid), TIDGET (pid))) == NULL)
|
{
|
{
|
warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
|
warning ("procfs_find_LDT_entry: could not find procinfi for %d.",
|
pid);
|
pid);
|
return NULL;
|
return NULL;
|
}
|
}
|
/* get its general registers. */
|
/* get its general registers. */
|
if ((gregs = proc_get_gregs (pi)) == NULL)
|
if ((gregs = proc_get_gregs (pi)) == NULL)
|
{
|
{
|
warning ("procfs_find_LDT_entry: could not read gregs for %d.",
|
warning ("procfs_find_LDT_entry: could not read gregs for %d.",
|
pid);
|
pid);
|
return NULL;
|
return NULL;
|
}
|
}
|
/* Now extract the GS register's lower 16 bits. */
|
/* Now extract the GS register's lower 16 bits. */
|
key = (*gregs)[GS] & 0xffff;
|
key = (*gregs)[GS] & 0xffff;
|
|
|
/* Find the matching entry and return it. */
|
/* Find the matching entry and return it. */
|
return proc_get_LDT_entry (pi, key);
|
return proc_get_LDT_entry (pi, key);
|
}
|
}
|
#endif /* TM_I386SOL2_H */
|
#endif /* TM_I386SOL2_H */
|
|
|
|
|
|
|
static void
|
static void
|
info_proc_cmd (args, from_tty)
|
info_proc_cmd (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
procinfo *process = NULL;
|
procinfo *process = NULL;
|
procinfo *thread = NULL;
|
procinfo *thread = NULL;
|
char **argv = NULL;
|
char **argv = NULL;
|
char *tmp = NULL;
|
char *tmp = NULL;
|
int pid = 0;
|
int pid = 0;
|
int tid = 0;
|
int tid = 0;
|
|
|
old_chain = make_cleanup (null_cleanup, 0);
|
old_chain = make_cleanup (null_cleanup, 0);
|
if (args)
|
if (args)
|
{
|
{
|
if ((argv = buildargv (args)) == NULL)
|
if ((argv = buildargv (args)) == NULL)
|
nomem (0);
|
nomem (0);
|
else
|
else
|
make_cleanup ((make_cleanup_func) freeargv, argv);
|
make_cleanup ((make_cleanup_func) freeargv, argv);
|
}
|
}
|
while (argv != NULL && *argv != NULL)
|
while (argv != NULL && *argv != NULL)
|
{
|
{
|
if (isdigit (argv[0][0]))
|
if (isdigit (argv[0][0]))
|
{
|
{
|
pid = strtoul (argv[0], &tmp, 10);
|
pid = strtoul (argv[0], &tmp, 10);
|
if (*tmp == '/')
|
if (*tmp == '/')
|
tid = strtoul (++tmp, NULL, 10);
|
tid = strtoul (++tmp, NULL, 10);
|
}
|
}
|
else if (argv[0][0] == '/')
|
else if (argv[0][0] == '/')
|
{
|
{
|
tid = strtoul (argv[0] + 1, NULL, 10);
|
tid = strtoul (argv[0] + 1, NULL, 10);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* [...] */
|
/* [...] */
|
}
|
}
|
argv++;
|
argv++;
|
}
|
}
|
if (pid == 0)
|
if (pid == 0)
|
pid = PIDGET (inferior_pid);
|
pid = PIDGET (inferior_pid);
|
if (pid == 0)
|
if (pid == 0)
|
error ("No current process: you must name one.");
|
error ("No current process: you must name one.");
|
else
|
else
|
{
|
{
|
/* Have pid, will travel.
|
/* Have pid, will travel.
|
First see if it's a process we're already debugging. */
|
First see if it's a process we're already debugging. */
|
process = find_procinfo (pid, 0);
|
process = find_procinfo (pid, 0);
|
if (process == NULL)
|
if (process == NULL)
|
{
|
{
|
/* No. So open a procinfo for it, but
|
/* No. So open a procinfo for it, but
|
remember to close it again when finished. */
|
remember to close it again when finished. */
|
process = create_procinfo (pid, 0);
|
process = create_procinfo (pid, 0);
|
make_cleanup ((make_cleanup_func) destroy_procinfo, process);
|
make_cleanup ((make_cleanup_func) destroy_procinfo, process);
|
if (!open_procinfo_files (process, FD_CTL))
|
if (!open_procinfo_files (process, FD_CTL))
|
proc_error (process, "info proc, open_procinfo_files", __LINE__);
|
proc_error (process, "info proc, open_procinfo_files", __LINE__);
|
}
|
}
|
}
|
}
|
if (tid != 0)
|
if (tid != 0)
|
thread = create_procinfo (pid, tid);
|
thread = create_procinfo (pid, tid);
|
|
|
if (process)
|
if (process)
|
{
|
{
|
printf_filtered ("process %d flags:\n", process->pid);
|
printf_filtered ("process %d flags:\n", process->pid);
|
proc_prettyprint_flags (proc_flags (process), 1);
|
proc_prettyprint_flags (proc_flags (process), 1);
|
if (proc_flags (process) & (PR_STOPPED | PR_ISTOP))
|
if (proc_flags (process) & (PR_STOPPED | PR_ISTOP))
|
proc_prettyprint_why (proc_why (process), proc_what (process), 1);
|
proc_prettyprint_why (proc_why (process), proc_what (process), 1);
|
if (proc_get_nthreads (process) > 1)
|
if (proc_get_nthreads (process) > 1)
|
printf_filtered ("Process has %d threads.\n",
|
printf_filtered ("Process has %d threads.\n",
|
proc_get_nthreads (process));
|
proc_get_nthreads (process));
|
}
|
}
|
if (thread)
|
if (thread)
|
{
|
{
|
printf_filtered ("thread %d flags:\n", thread->tid);
|
printf_filtered ("thread %d flags:\n", thread->tid);
|
proc_prettyprint_flags (proc_flags (thread), 1);
|
proc_prettyprint_flags (proc_flags (thread), 1);
|
if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP))
|
if (proc_flags (thread) & (PR_STOPPED | PR_ISTOP))
|
proc_prettyprint_why (proc_why (thread), proc_what (thread), 1);
|
proc_prettyprint_why (proc_why (thread), proc_what (thread), 1);
|
}
|
}
|
|
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
static void
|
static void
|
proc_trace_syscalls (args, from_tty, entry_or_exit, mode)
|
proc_trace_syscalls (args, from_tty, entry_or_exit, mode)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
int entry_or_exit;
|
int entry_or_exit;
|
int mode;
|
int mode;
|
{
|
{
|
procinfo *pi;
|
procinfo *pi;
|
sysset_t *sysset;
|
sysset_t *sysset;
|
int syscallnum = 0;
|
int syscallnum = 0;
|
|
|
if (inferior_pid <= 0)
|
if (inferior_pid <= 0)
|
error ("you must be debugging a process to use this command.");
|
error ("you must be debugging a process to use this command.");
|
|
|
if (args == NULL || args[0] == 0)
|
if (args == NULL || args[0] == 0)
|
error_no_arg ("system call to trace");
|
error_no_arg ("system call to trace");
|
|
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
|
if (isdigit (args[0]))
|
if (isdigit (args[0]))
|
{
|
{
|
syscallnum = atoi (args);
|
syscallnum = atoi (args);
|
if (entry_or_exit == PR_SYSENTRY)
|
if (entry_or_exit == PR_SYSENTRY)
|
sysset = proc_get_traced_sysentry (pi, NULL);
|
sysset = proc_get_traced_sysentry (pi, NULL);
|
else
|
else
|
sysset = proc_get_traced_sysexit (pi, NULL);
|
sysset = proc_get_traced_sysexit (pi, NULL);
|
|
|
if (sysset == NULL)
|
if (sysset == NULL)
|
proc_error (pi, "proc-trace, get_traced_sysset", __LINE__);
|
proc_error (pi, "proc-trace, get_traced_sysset", __LINE__);
|
|
|
if (mode == FLAG_SET)
|
if (mode == FLAG_SET)
|
praddset (sysset, syscallnum);
|
praddset (sysset, syscallnum);
|
else
|
else
|
prdelset (sysset, syscallnum);
|
prdelset (sysset, syscallnum);
|
|
|
if (entry_or_exit == PR_SYSENTRY)
|
if (entry_or_exit == PR_SYSENTRY)
|
{
|
{
|
if (!proc_set_traced_sysentry (pi, sysset))
|
if (!proc_set_traced_sysentry (pi, sysset))
|
proc_error (pi, "proc-trace, set_traced_sysentry", __LINE__);
|
proc_error (pi, "proc-trace, set_traced_sysentry", __LINE__);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (!proc_set_traced_sysexit (pi, sysset))
|
if (!proc_set_traced_sysexit (pi, sysset))
|
proc_error (pi, "proc-trace, set_traced_sysexit", __LINE__);
|
proc_error (pi, "proc-trace, set_traced_sysexit", __LINE__);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
proc_trace_sysentry_cmd (args, from_tty)
|
proc_trace_sysentry_cmd (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_SET);
|
proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_SET);
|
}
|
}
|
|
|
static void
|
static void
|
proc_trace_sysexit_cmd (args, from_tty)
|
proc_trace_sysexit_cmd (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_SET);
|
proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_SET);
|
}
|
}
|
|
|
static void
|
static void
|
proc_untrace_sysentry_cmd (args, from_tty)
|
proc_untrace_sysentry_cmd (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET);
|
proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET);
|
}
|
}
|
|
|
static void
|
static void
|
proc_untrace_sysexit_cmd (args, from_tty)
|
proc_untrace_sysexit_cmd (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET);
|
proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET);
|
}
|
}
|
|
|
|
|
int
|
int
|
mapping_test (fd, core_addr)
|
mapping_test (fd, core_addr)
|
int fd;
|
int fd;
|
CORE_ADDR core_addr;
|
CORE_ADDR core_addr;
|
{
|
{
|
printf ("File descriptor %d, base address 0x%08x\n", fd, core_addr);
|
printf ("File descriptor %d, base address 0x%08x\n", fd, core_addr);
|
if (fd > 0)
|
if (fd > 0)
|
close (fd);
|
close (fd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
void
|
void
|
test_mapping_cmd (args, from_tty)
|
test_mapping_cmd (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
int ret;
|
int ret;
|
ret = proc_iterate_over_mappings (mapping_test);
|
ret = proc_iterate_over_mappings (mapping_test);
|
printf ("iterate_over_mappings returned %d.\n", ret);
|
printf ("iterate_over_mappings returned %d.\n", ret);
|
}
|
}
|
|
|
void
|
void
|
_initialize_procfs ()
|
_initialize_procfs ()
|
{
|
{
|
init_procfs_ops ();
|
init_procfs_ops ();
|
add_target (&procfs_ops);
|
add_target (&procfs_ops);
|
add_info ("proc", info_proc_cmd,
|
add_info ("proc", info_proc_cmd,
|
"Show /proc process information about any running process.\
|
"Show /proc process information about any running process.\
|
Default is the process being debugged.");
|
Default is the process being debugged.");
|
add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
|
add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
|
"Give a trace of entries into the syscall.");
|
"Give a trace of entries into the syscall.");
|
add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd,
|
add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd,
|
"Give a trace of exits from the syscall.");
|
"Give a trace of exits from the syscall.");
|
add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd,
|
add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd,
|
"Cancel a trace of entries into the syscall.");
|
"Cancel a trace of entries into the syscall.");
|
add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd,
|
add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd,
|
"Cancel a trace of exits from the syscall.");
|
"Cancel a trace of exits from the syscall.");
|
|
|
add_com ("test-mapping", no_class, test_mapping_cmd,
|
add_com ("test-mapping", no_class, test_mapping_cmd,
|
"test iterate-over-mappings");
|
"test iterate-over-mappings");
|
}
|
}
|
|
|
/* =================== END, GDB "MODULE" =================== */
|
/* =================== END, GDB "MODULE" =================== */
|
|
|
|
|
|
|
/* miscelaneous stubs: */
|
/* miscelaneous stubs: */
|
/* The following satisfy a few random symbols mostly created by */
|
/* The following satisfy a few random symbols mostly created by */
|
/* the solaris threads implementation, which I will chase down */
|
/* the solaris threads implementation, which I will chase down */
|
/* later. */
|
/* later. */
|
|
|
/*
|
/*
|
* Return a pid for which we guarantee
|
* Return a pid for which we guarantee
|
* we will be able to find a 'live' procinfo.
|
* we will be able to find a 'live' procinfo.
|
*/
|
*/
|
|
|
int
|
int
|
procfs_first_available ()
|
procfs_first_available ()
|
{
|
{
|
if (procinfo_list)
|
if (procinfo_list)
|
return procinfo_list->pid;
|
return procinfo_list->pid;
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
|
|
