/* Machine independent support for SVR4 /proc (process file system) for GDB.
- Copyright (C) 1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010,
- 2011 Free Software Foundation, Inc.
+ Copyright (C) 1999-2003, 2006-2012 Free Software Foundation, Inc.
Written by Michael Snyder at Cygnus Solutions.
Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
static void procfs_attach (struct target_ops *, char *, int);
static void procfs_detach (struct target_ops *, char *, int);
static void procfs_resume (struct target_ops *,
- ptid_t, int, enum target_signal);
+ ptid_t, int, enum gdb_signal);
static void procfs_stop (ptid_t);
static void procfs_files_info (struct target_ops *);
static void procfs_fetch_registers (struct target_ops *,
struct regcache *, int);
static void procfs_store_registers (struct target_ops *,
struct regcache *, int);
-static void procfs_notice_signals (ptid_t);
+static void procfs_pass_signals (int, unsigned char *);
static void procfs_kill_inferior (struct target_ops *ops);
static void procfs_mourn_inferior (struct target_ops *ops);
static void procfs_create_inferior (struct target_ops *, char *,
static int procfs_thread_alive (struct target_ops *ops, ptid_t);
-void procfs_find_new_threads (struct target_ops *ops);
-char *procfs_pid_to_str (struct target_ops *, ptid_t);
+static void procfs_find_new_threads (struct target_ops *ops);
+static char *procfs_pid_to_str (struct target_ops *, ptid_t);
static int proc_find_memory_regions (int (*) (CORE_ADDR,
unsigned long,
static int procfs_can_use_hw_breakpoint (int, int, int);
+static void procfs_info_proc (struct target_ops *, char *,
+ enum info_proc_what);
+
#if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
/* When GDB is built as 64-bit application on Solaris, the auxv data
is presented in 64-bit format. We need to provide a custom parser
t->to_store_registers = procfs_store_registers;
t->to_xfer_partial = procfs_xfer_partial;
t->deprecated_xfer_memory = procfs_xfer_memory;
- t->to_notice_signals = procfs_notice_signals;
+ t->to_pass_signals = procfs_pass_signals;
t->to_files_info = procfs_files_info;
t->to_stop = procfs_stop;
t->to_has_thread_control = tc_schedlock;
t->to_find_memory_regions = proc_find_memory_regions;
t->to_make_corefile_notes = procfs_make_note_section;
+ t->to_info_proc = procfs_info_proc;
#if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
t->to_auxv_parse = procfs_auxv_parse;
#ifdef HAVE_PR_SIGINFO64_T
typedef pr_siginfo64_t gdb_siginfo_t;
#else
-typedef struct siginfo gdb_siginfo_t;
+typedef siginfo_t gdb_siginfo_t;
#endif
/* On mips-irix, praddset and prdelset are defined in such a way that
else
strcat (tmp, "/ctl");
fd = open_with_retry (tmp, O_WRONLY);
- if (fd <= 0)
+ if (fd < 0)
return 0; /* fail */
pi->ctl_fd = fd;
break;
return 0; /* There is no 'as' file descriptor for an lwp. */
strcat (tmp, "/as");
fd = open_with_retry (tmp, O_RDWR);
- if (fd <= 0)
+ if (fd < 0)
return 0; /* fail */
pi->as_fd = fd;
break;
else
strcat (tmp, "/status");
fd = open_with_retry (tmp, O_RDONLY);
- if (fd <= 0)
+ if (fd < 0)
return 0; /* fail */
pi->status_fd = fd;
break;
#ifdef PIOCTSTATUS /* OSF */
/* Only one FD; just open it. */
- if ((fd = open_with_retry (pi->pathname, O_RDWR)) == 0)
+ if ((fd = open_with_retry (pi->pathname, O_RDWR)) < 0)
return 0;
#else /* Sol 2.5, Irix, other? */
if (pi->tid == 0) /* Master procinfo for the process */
{
fd = open_with_retry (pi->pathname, O_RDWR);
- if (fd <= 0)
+ if (fd < 0)
return 0; /* fail */
}
else /* LWP thread procinfo */
return 0; /* fail */
/* 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 */
#else /* Irix, other? */
return 0; /* Don't know how to open threads. */
prsysent_t header;
prsyscall_t *syscalls;
int i, size, maxcall;
+ struct cleanup *cleanups;
pi->num_syscalls = 0;
pi->syscall_names = 0;
{
error (_("load_syscalls: Can't open /proc/%d/sysent"), pi->pid);
}
+ cleanups = make_cleanup_close (sysent_fd);
size = sizeof header - sizeof (prsyscall_t);
if (read (sysent_fd, &header, size) != size)
size = header.pr_nsyscalls * sizeof (prsyscall_t);
syscalls = xmalloc (size);
+ make_cleanup (free_current_contents, &syscalls);
if (read (sysent_fd, syscalls, size) != size)
- {
- xfree (syscalls);
- error (_("load_syscalls: Error reading /proc/%d/sysent"), pi->pid);
- }
+ error (_("load_syscalls: Error reading /proc/%d/sysent"), pi->pid);
/* Find maximum syscall number. This may not be the same as
pr_nsyscalls since that value refers to the number of entries
pi->syscall_names[callnum][size-1] = '\0';
}
- close (sysent_fd);
- xfree (syscalls);
+ do_cleanups (cleanups);
}
/* Free the space allocated for the syscall names from the procinfo
than have a bunch of #ifdefs all thru the gdb target vector
functions, we do our best to hide them all in here. */
-int proc_get_status (procinfo * pi);
-long proc_flags (procinfo * pi);
-int proc_why (procinfo * pi);
-int proc_what (procinfo * pi);
-int proc_set_run_on_last_close (procinfo * pi);
-int proc_unset_run_on_last_close (procinfo * pi);
-int proc_set_inherit_on_fork (procinfo * pi);
-int proc_unset_inherit_on_fork (procinfo * pi);
-int proc_set_async (procinfo * pi);
-int proc_unset_async (procinfo * pi);
-int proc_stop_process (procinfo * pi);
-int proc_trace_signal (procinfo * pi, int signo);
-int proc_ignore_signal (procinfo * pi, int signo);
-int proc_clear_current_fault (procinfo * pi);
-int proc_set_current_signal (procinfo * pi, int signo);
-int proc_clear_current_signal (procinfo * pi);
-int proc_set_gregs (procinfo * pi);
-int proc_set_fpregs (procinfo * pi);
-int proc_wait_for_stop (procinfo * pi);
-int proc_run_process (procinfo * pi, int step, int signo);
-int proc_kill (procinfo * pi, int signo);
-int proc_parent_pid (procinfo * pi);
-int proc_get_nthreads (procinfo * pi);
-int proc_get_current_thread (procinfo * pi);
-int proc_set_held_signals (procinfo * pi, gdb_sigset_t * sighold);
-int proc_set_traced_sysexit (procinfo * pi, sysset_t * sysset);
-int proc_set_traced_sysentry (procinfo * pi, sysset_t * sysset);
-int proc_set_traced_faults (procinfo * pi, fltset_t * fltset);
-int proc_set_traced_signals (procinfo * pi, gdb_sigset_t * sigset);
-
-int proc_update_threads (procinfo * pi);
-int proc_iterate_over_threads (procinfo * pi,
- int (*func) (procinfo *, procinfo *, void *),
- void *ptr);
-
-gdb_gregset_t *proc_get_gregs (procinfo * pi);
-gdb_fpregset_t *proc_get_fpregs (procinfo * pi);
-sysset_t *proc_get_traced_sysexit (procinfo * pi, sysset_t * save);
-sysset_t *proc_get_traced_sysentry (procinfo * pi, sysset_t * save);
-fltset_t *proc_get_traced_faults (procinfo * pi, fltset_t * save);
-gdb_sigset_t *proc_get_traced_signals (procinfo * pi, gdb_sigset_t * save);
-gdb_sigset_t *proc_get_held_signals (procinfo * pi, gdb_sigset_t * save);
-gdb_sigset_t *proc_get_pending_signals (procinfo * pi, gdb_sigset_t * save);
-gdb_sigaction_t *proc_get_signal_actions (procinfo * pi,
- gdb_sigaction_t *save);
-
-void proc_warn (procinfo * pi, char *func, int line);
-void proc_error (procinfo * pi, char *func, int line);
+static long proc_flags (procinfo * pi);
+static int proc_why (procinfo * pi);
+static int proc_what (procinfo * pi);
+static int proc_set_current_signal (procinfo * pi, int signo);
+static int proc_get_current_thread (procinfo * pi);
+static int proc_iterate_over_threads
+ (procinfo * pi,
+ int (*func) (procinfo *, procinfo *, void *),
+ void *ptr);
-void
+static void
proc_warn (procinfo *pi, char *func, int line)
{
sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
print_sys_errmsg (errmsg, errno);
}
-void
+static void
proc_error (procinfo *pi, char *func, int line)
{
sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
file descriptor is also only opened when it is needed. Returns
non-zero for success, zero for failure. */
-int
+static int
proc_get_status (procinfo *pi)
{
/* Status file descriptor is opened "lazily". */
/* Returns the process flags (pr_flags field). */
-long
+static long
proc_flags (procinfo *pi)
{
if (!pi->status_valid)
/* Returns the pr_why field (why the process stopped). */
-int
+static int
proc_why (procinfo *pi)
{
if (!pi->status_valid)
/* Returns the pr_what field (details of why the process stopped). */
-int
+static int
proc_what (procinfo *pi)
{
if (!pi->status_valid)
/* Returns the pr_nsysarg field (number of args to the current
syscall). */
-int
+static int
proc_nsysarg (procinfo *pi)
{
if (!pi->status_valid)
/* Returns the pr_sysarg field (pointer to the arguments of current
syscall). */
-long *
+static long *
proc_sysargs (procinfo *pi)
{
if (!pi->status_valid)
return (long *) &pi->prstatus.pr_sysarg;
#endif
}
-
-/* Returns the pr_syscall field (id of current syscall if we are in
- one). */
-
-int
-proc_syscall (procinfo *pi)
-{
- if (!pi->status_valid)
- if (!proc_get_status (pi))
- return 0;
-
-#ifdef NEW_PROC_API
- return pi->prstatus.pr_lwp.pr_syscall;
-#else
- return pi->prstatus.pr_syscall;
-#endif
-}
#endif /* PIOCSSPCACT */
+#ifdef PROCFS_DONT_PIOCSSIG_CURSIG
/* Returns the pr_cursig field (current signal). */
-long
+static long
proc_cursig (struct procinfo *pi)
{
if (!pi->status_valid)
return pi->prstatus.pr_cursig;
#endif
}
+#endif /* PROCFS_DONT_PIOCSSIG_CURSIG */
/* === I appologize for the messiness of this function.
=== This is an area where the different versions of
become runnable when debugger closes all /proc fds. Returns
non-zero for success, zero for failure. */
-int
+static int
proc_set_run_on_last_close (procinfo *pi)
{
return proc_modify_flag (pi, PR_RLC, FLAG_SET);
runnable when debugger closes its file handles. Returns non-zero
for success, zero for failure. */
-int
+static int
proc_unset_run_on_last_close (procinfo *pi)
{
return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
}
-#ifdef PR_KLC
-/* Set the kill_on_last_close flag. Process with all threads will be
- killed when debugger closes all /proc fds (or debugger exits or
- dies). Returns non-zero for success, zero for failure. */
-
-int
-proc_set_kill_on_last_close (procinfo *pi)
-{
- return proc_modify_flag (pi, PR_KLC, FLAG_SET);
-}
-
-/* Reset the kill_on_last_close flag. Process will NOT be killed when
- debugger closes its file handles (or exits or dies). Returns
- non-zero for success, zero for failure. */
-
-int
-proc_unset_kill_on_last_close (procinfo *pi)
-{
- return proc_modify_flag (pi, PR_KLC, FLAG_RESET);
-}
-#endif /* PR_KLC */
-
-/* Set inherit_on_fork flag. If the process forks a child while we
- are registered for events in the parent, then we will also recieve
- events from the child. Returns non-zero for success, zero for
- failure. */
-
-int
-proc_set_inherit_on_fork (procinfo *pi)
-{
- return proc_modify_flag (pi, PR_FORK, FLAG_SET);
-}
-
/* Reset inherit_on_fork flag. If the process forks a child while we
are registered for events in the parent, then we will NOT recieve
events from the child. Returns non-zero for success, zero for
failure. */
-int
+static int
proc_unset_inherit_on_fork (procinfo *pi)
{
return proc_modify_flag (pi, PR_FORK, FLAG_RESET);
(signal etc.), the remaining LWPs will continue to run. Returns
non-zero for success, zero for failure. */
-int
+static int
proc_set_async (procinfo *pi)
{
return proc_modify_flag (pi, PR_ASYNC, FLAG_SET);
(signal etc.), then all other LWPs will stop as well. Returns
non-zero for success, zero for failure. */
-int
+static int
proc_unset_async (procinfo *pi)
{
return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET);
/* Request the process/LWP to stop. Does not wait. Returns non-zero
for success, zero for failure. */
-int
+static int
proc_stop_process (procinfo *pi)
{
int win;
/* Wait for the process or LWP to stop (block until it does). Returns
non-zero for success, zero for failure. */
-int
+static int
proc_wait_for_stop (procinfo *pi)
{
int win;
any; if non-zero, set the current signal to this one. Returns
non-zero for success, zero for failure. */
-int
+static int
proc_run_process (procinfo *pi, int step, int signo)
{
int win;
/* Register to trace signals in the process or LWP. Returns non-zero
for success, zero for failure. */
-int
+static int
proc_set_traced_signals (procinfo *pi, gdb_sigset_t *sigset)
{
int win;
/* Register to trace hardware faults in the process or LWP. Returns
non-zero for success, zero for failure. */
-int
+static int
proc_set_traced_faults (procinfo *pi, fltset_t *fltset)
{
int win;
/* Register to trace entry to system calls in the process or LWP.
Returns non-zero for success, zero for failure. */
-int
+static int
proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset)
{
int win;
/* Register to trace exit from system calls in the process or LWP.
Returns non-zero for success, zero for failure. */
-int
+static int
proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset)
{
int win;
/* Specify the set of blocked / held signals in the process or LWP.
Returns non-zero for success, zero for failure. */
-int
+static int
proc_set_held_signals (procinfo *pi, gdb_sigset_t *sighold)
{
int win;
return win;
}
-/* Returns the set of signals that are pending in the process or LWP.
- Will also copy the sigset if SAVE is non-zero. */
-
-gdb_sigset_t *
-proc_get_pending_signals (procinfo *pi, gdb_sigset_t *save)
-{
- gdb_sigset_t *ret = NULL;
-
- /* We should never have to apply this operation to any procinfo
- except the one for the main process. If that ever changes for
- any reason, then take out the following clause and replace it
- with one that makes sure the ctl_fd is open. */
-
- if (pi->tid != 0)
- pi = find_procinfo_or_die (pi->pid, 0);
-
- if (!pi->status_valid)
- if (!proc_get_status (pi))
- return NULL;
-
-#ifdef NEW_PROC_API
- ret = &pi->prstatus.pr_lwp.pr_lwppend;
-#else
- ret = &pi->prstatus.pr_sigpend;
-#endif
- if (save && ret)
- memcpy (save, ret, sizeof (gdb_sigset_t));
-
- return ret;
-}
-
-/* Returns the set of signal actions. Will also copy the sigactionset
- if SAVE is non-zero. */
-
-gdb_sigaction_t *
-proc_get_signal_actions (procinfo *pi, gdb_sigaction_t *save)
-{
- gdb_sigaction_t *ret = NULL;
-
- /* We should never have to apply this operation to any procinfo
- except the one for the main process. If that ever changes for
- any reason, then take out the following clause and replace it
- with one that makes sure the ctl_fd is open. */
-
- if (pi->tid != 0)
- pi = find_procinfo_or_die (pi->pid, 0);
-
- if (!pi->status_valid)
- if (!proc_get_status (pi))
- return NULL;
-
-#ifdef NEW_PROC_API
- ret = &pi->prstatus.pr_lwp.pr_action;
-#else
- ret = &pi->prstatus.pr_action;
-#endif
- if (save && ret)
- memcpy (save, ret, sizeof (gdb_sigaction_t));
-
- return ret;
-}
-
/* Returns the set of signals that are held / blocked. Will also copy
the sigset if SAVE is non-zero. */
-gdb_sigset_t *
+static gdb_sigset_t *
proc_get_held_signals (procinfo *pi, gdb_sigset_t *save)
{
gdb_sigset_t *ret = NULL;
/* Returns the set of signals that are traced / debugged. Will also
copy the sigset if SAVE is non-zero. */
-gdb_sigset_t *
+static gdb_sigset_t *
proc_get_traced_signals (procinfo *pi, gdb_sigset_t *save)
{
gdb_sigset_t *ret = NULL;
return ret;
}
-/* Add SIGNO to the set of signals that are traced. Returns non-zero
- for success, zero for failure. */
-
-int
-proc_trace_signal (procinfo *pi, int signo)
-{
- gdb_sigset_t temp;
-
- /* We should never have to apply this operation to any procinfo
- except the one for the main process. If that ever changes for
- any reason, then take out the following clause and replace it
- with one that makes sure the ctl_fd is open. */
-
- if (pi->tid != 0)
- pi = find_procinfo_or_die (pi->pid, 0);
-
- if (pi)
- {
- if (proc_get_traced_signals (pi, &temp))
- {
- gdb_praddset (&temp, signo);
- return proc_set_traced_signals (pi, &temp);
- }
- }
-
- return 0; /* failure */
-}
-
-/* Remove SIGNO from the set of signals that are traced. Returns
- non-zero for success, zero for failure. */
-
-int
-proc_ignore_signal (procinfo *pi, int signo)
-{
- gdb_sigset_t temp;
-
- /* We should never have to apply this operation to any procinfo
- except the one for the main process. If that ever changes for
- any reason, then take out the following clause and replace it
- with one that makes sure the ctl_fd is open. */
-
- if (pi->tid != 0)
- pi = find_procinfo_or_die (pi->pid, 0);
-
- if (pi)
- {
- if (proc_get_traced_signals (pi, &temp))
- {
- gdb_prdelset (&temp, signo);
- return proc_set_traced_signals (pi, &temp);
- }
- }
-
- return 0; /* failure */
-}
-
/* Returns the set of hardware faults that are traced /debugged. Will
also copy the faultset if SAVE is non-zero. */
-fltset_t *
+static fltset_t *
proc_get_traced_faults (procinfo *pi, fltset_t *save)
{
fltset_t *ret = NULL;
/* Returns the set of syscalls that are traced /debugged on entry.
Will also copy the syscall set if SAVE is non-zero. */
-sysset_t *
+static sysset_t *
proc_get_traced_sysentry (procinfo *pi, sysset_t *save)
{
sysset_t *ret = NULL;
/* Returns the set of syscalls that are traced /debugged on exit.
Will also copy the syscall set if SAVE is non-zero. */
-sysset_t *
+static sysset_t *
proc_get_traced_sysexit (procinfo *pi, sysset_t *save)
{
sysset_t * ret = NULL;
not be sent to the process or LWP when it resumes. Returns
non-zero for success, zero for failure. */
-int
+static int
proc_clear_current_fault (procinfo *pi)
{
int win;
trap back to the debugger. Returns non-zero for success, zero for
failure. */
-int
+static int
proc_set_current_signal (procinfo *pi, int signo)
{
int win;
get_last_target_status (&wait_ptid, &wait_status);
if (ptid_equal (wait_ptid, inferior_ptid)
&& wait_status.kind == TARGET_WAITKIND_STOPPED
- && wait_status.value.sig == target_signal_from_host (signo)
+ && wait_status.value.sig == gdb_signal_from_host (signo)
&& proc_get_status (pi)
#ifdef NEW_PROC_API
&& pi->prstatus.pr_lwp.pr_info.si_signo == signo
process or LWP when it resumes. Returns non-zero for success, zero
for failure. */
-int
+static int
proc_clear_current_signal (procinfo *pi)
{
int win;
/* Return the general-purpose registers for the process or LWP
corresponding to PI. Upon failure, return NULL. */
-gdb_gregset_t *
+static gdb_gregset_t *
proc_get_gregs (procinfo *pi)
{
if (!pi->status_valid || !pi->gregs_valid)
/* Return the general-purpose registers for the process or LWP
corresponding to PI. Upon failure, return NULL. */
-gdb_fpregset_t *
+static gdb_fpregset_t *
proc_get_fpregs (procinfo *pi)
{
#ifdef NEW_PROC_API
corresponding to PI. Return non-zero for success, zero for
failure. */
-int
+static int
proc_set_gregs (procinfo *pi)
{
gdb_gregset_t *gregs;
corresponding to PI. Return non-zero for success, zero for
failure. */
-int
+static int
proc_set_fpregs (procinfo *pi)
{
gdb_fpregset_t *fpregs;
/* Send a signal to the proc or lwp with the semantics of "kill()".
Returns non-zero for success, zero for failure. */
-int
+static int
proc_kill (procinfo *pi, int signo)
{
int win;
/* Find the pid of the process that started this one. Returns the
parent process pid, or zero. */
-int
+static int
proc_parent_pid (procinfo *pi)
{
/* We should never have to apply this operation to any procinfo
}
#endif
-int
+static int
proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags)
{
#if !defined (PCWATCH) && !defined (PIOCSWATCH)
#if defined (PIOCNTHR) && defined (PIOCTLIST)
/* OSF version */
-int
+static int
proc_get_nthreads (procinfo *pi)
{
int nthreads = 0;
#else
#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
/* Solaris and Unixware version */
-int
+static int
proc_get_nthreads (procinfo *pi)
{
if (!pi->status_valid)
#else
/* Default version */
-int
+static int
proc_get_nthreads (procinfo *pi)
{
return 0;
#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
/* Solaris and Unixware version */
-int
+static int
proc_get_current_thread (procinfo *pi)
{
/* Note: this should be applied to the root procinfo for the
#else
#if defined (PIOCNTHR) && defined (PIOCTLIST)
/* OSF version */
-int
+static int
proc_get_current_thread (procinfo *pi)
{
#if 0 /* FIXME: not ready for prime time? */
#else
/* Default version */
-int
+static int
proc_get_current_thread (procinfo *pi)
{
return 0;
unfortunately requires a different method on every OS. Returns
non-zero for success, zero for failure. */
-int
+static int
proc_delete_dead_threads (procinfo *parent, procinfo *thread, void *ignore)
{
if (thread && parent) /* sanity */
#if defined (PIOCLSTATUS)
/* Solaris 2.5 (ioctl) version */
-int
+static int
proc_update_threads (procinfo *pi)
{
gdb_prstatus_t *prstatus;
closedir (dir);
}
-int
+static int
proc_update_threads (procinfo *pi)
{
char pathname[MAX_PROC_NAME_SIZE + 16];
#else
#ifdef PIOCTLIST
/* OSF version */
-int
+static int
proc_update_threads (procinfo *pi)
{
int nthreads, i;
}
#else
/* Default version */
-int
+static int
proc_update_threads (procinfo *pi)
{
return 0;
function. PTR is an opaque parameter for function. Returns the
first non-zero return value from the callee, or zero. */
-int
+static int
proc_iterate_over_threads (procinfo *pi,
int (*func) (procinfo *, procinfo *, void *),
void *ptr)
static ptid_t do_attach (ptid_t ptid);
static void do_detach (int signo);
-static int register_gdb_signals (procinfo *, gdb_sigset_t *);
static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum,
int entry_or_exit, int mode, int from_tty);
if (!proc_set_traced_faults (pi, &traced_faults))
return __LINE__;
- /* Register to trace selected signals in the child. */
- premptyset (&traced_signals);
- if (!register_gdb_signals (pi, &traced_signals))
+ /* Initially, register to trace all signals in the child. */
+ prfillset (&traced_signals);
+ if (!proc_set_traced_signals (pi, &traced_signals))
return __LINE__;
long storage_needed;
CORE_ADDR sym_addr;
- abfd = bfd_fdopenr ("unamed", 0, fd);
+ abfd = gdb_bfd_fdopenr ("unamed", 0, fd);
if (abfd == NULL)
{
warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
{
/* Not the correct format, so we can not possibly find the dbx_link
symbol in it. */
- bfd_close (abfd);
+ gdb_bfd_unref (abfd);
return 0;
}
if (dbx_link_bpt == NULL)
{
warning (_("Failed to insert dbx_link breakpoint."));
- bfd_close (abfd);
+ gdb_bfd_unref (abfd);
return 0;
}
- bfd_close (abfd);
+ gdb_bfd_unref (abfd);
return 1;
}
- bfd_close (abfd);
+ gdb_bfd_unref (abfd);
return 0;
}
else
{
/* How to keep going without returning to wfi: */
- target_resume (ptid, 0, TARGET_SIGNAL_0);
+ target_resume (ptid, 0, GDB_SIGNAL_0);
goto wait_again;
}
}
/* This is an internal event and should be transparent
to wfi, so resume the execution and wait again. See
comment in procfs_init_inferior() for more details. */
- target_resume (ptid, 0, TARGET_SIGNAL_0);
+ target_resume (ptid, 0, GDB_SIGNAL_0);
goto wait_again;
}
#endif
static void
procfs_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum target_signal signo)
+ ptid_t ptid, int step, enum gdb_signal signo)
{
procinfo *pi, *thread;
int native_signo;
/* Convert signal to host numbering. */
if (signo == 0 ||
- (signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop))
+ (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop))
native_signo = 0;
else
- native_signo = target_signal_to_host (signo);
+ native_signo = gdb_signal_to_host (signo);
pi->ignore_next_sigstop = 0;
}
}
-/* Traverse the list of signals that GDB knows about (see "handle"
- command), and arrange for the target to be stopped or not,
- according to these settings. Returns non-zero for success, zero
- for failure. */
-
-static int
-register_gdb_signals (procinfo *pi, gdb_sigset_t *signals)
-{
- int signo;
-
- for (signo = 0; signo < NSIG; signo ++)
- if (signal_stop_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)
- gdb_prdelset (signals, signo);
- else
- gdb_praddset (signals, signo);
-
- return proc_set_traced_signals (pi, signals);
-}
-
/* Set up to trace signals in the child process. */
static void
-procfs_notice_signals (ptid_t ptid)
+procfs_pass_signals (int numsigs, unsigned char *pass_signals)
{
gdb_sigset_t signals;
- procinfo *pi = find_procinfo_or_die (PIDGET (ptid), 0);
+ procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
+ int signo;
- if (proc_get_traced_signals (pi, &signals) &&
- register_gdb_signals (pi, &signals))
- return;
- else
- proc_error (pi, "notice_signals", __LINE__);
+ prfillset (&signals);
+
+ for (signo = 0; signo < NSIG; signo++)
+ {
+ int target_signo = gdb_signal_from_host (signo);
+ if (target_signo < numsigs && pass_signals[target_signo])
+ gdb_prdelset (&signals, signo);
+ }
+
+ if (!proc_set_traced_signals (pi, &signals))
+ proc_error (pi, "pass_signals", __LINE__);
}
/* Print status information about the child process. */
push_target (ops);
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))
proc_error (pi, "init_inferior, open_proc_files", __LINE__);
if (!proc_get_traced_sysexit (pi, pi->saved_exitset))
proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__);
- /* Register to trace selected signals in the child. */
- prfillset (&signals);
- if (!register_gdb_signals (pi, &signals))
- proc_error (pi, "init_inferior, register_signals", __LINE__);
-
if ((fail = procfs_debug_inferior (pi)) != 0)
proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
}
pid = fork_inferior (exec_file, allargs, env, procfs_set_exec_trap,
- NULL, NULL, shell_file);
+ NULL, NULL, shell_file, NULL);
procfs_init_inferior (ops, pid);
}
/* Query all the threads that the target knows about, and give them
back to GDB to add to its list. */
-void
+static void
procfs_find_new_threads (struct target_ops *ops)
{
procinfo *pi;
/* Convert PTID to a string. Returns the string in a static
buffer. */
-char *
+static char *
procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[80];
/* Insert a watchpoint. */
-int
+static int
procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag,
int after)
{
int funcstat;
int map_fd;
int nmap;
+ struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
#ifdef NEW_PROC_API
struct stat sbuf;
#endif
for (prmap = prmaps; nmap > 0; prmap++, nmap--)
if ((funcstat = (*func) (prmap, child_func, data)) != 0)
- return funcstat;
+ {
+ do_cleanups (cleanups);
+ return funcstat;
+ }
+ do_cleanups (cleanups);
return 0;
}
/* Implement the "info proc" command. */
static void
-info_proc_cmd (char *args, int from_tty)
+procfs_info_proc (struct target_ops *ops, char *args,
+ enum info_proc_what what)
{
struct cleanup *old_chain;
procinfo *process = NULL;
int tid = 0;
int mappings = 0;
+ switch (what)
+ {
+ case IP_MINIMAL:
+ break;
+
+ case IP_MAPPINGS:
+ case IP_ALL:
+ mappings = 1;
+ break;
+
+ default:
+ error (_("Not supported on this target."));
+ }
+
old_chain = make_cleanup (null_cleanup, 0);
if (args)
{
{
tid = strtoul (argv[0] + 1, NULL, 10);
}
- else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
- {
- mappings = 1;
- }
- else
- {
- /* [...] */
- }
argv++;
}
if (pid == 0)
}
+/* Provide a prototype to silence -Wmissing-prototypes. */
+extern void _initialize_procfs (void);
+
void
_initialize_procfs (void)
{
observer_attach_inferior_created (procfs_inferior_created);
- add_info ("proc", info_proc_cmd, _("\
-Show /proc process information about any running process.\n\
-Specify process id, or use the program being debugged by default.\n\
-Specify keyword 'mappings' for detailed info on memory mappings."));
add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
_("Give a trace of entries into the syscall."));
add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd,
static char *
procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
char *note_data, int *note_size,
- enum target_signal stop_signal)
+ enum gdb_signal stop_signal)
{
struct regcache *regcache = get_thread_regcache (ptid);
gdb_gregset_t gregs;
bfd *obfd;
char *note_data;
int *note_size;
- enum target_signal stop_signal;
+ enum gdb_signal stop_signal;
};
static int
static int
find_signalled_thread (struct thread_info *info, void *data)
{
- if (info->suspend.stop_signal != TARGET_SIGNAL_0
+ if (info->suspend.stop_signal != GDB_SIGNAL_0
&& ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
return 1;
return 0;
}
-static enum target_signal
+static enum gdb_signal
find_stop_signal (void)
{
struct thread_info *info =
if (info)
return info->suspend.stop_signal;
else
- return TARGET_SIGNAL_0;
+ return GDB_SIGNAL_0;
}
static char *
struct procfs_corefile_thread_data thread_args;
gdb_byte *auxv;
int auxv_len;
- enum target_signal stop_signal;
+ enum gdb_signal stop_signal;
if (get_exec_file (0))
{
- strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
- strncpy (psargs, get_exec_file (0),
- sizeof (psargs));
+ strncpy (fname, lbasename (get_exec_file (0)), sizeof (fname));
+ fname[sizeof (fname) - 1] = 0;
+ strncpy (psargs, get_exec_file (0), sizeof (psargs));
+ psargs[sizeof (psargs) - 1] = 0;
inf_args = get_inferior_args ();
if (inf_args && *inf_args &&
projects / deliverable / binutils-gdb.git / blobdiff