mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
d90e17a74d
is the first inferior. (startup_inferior): If the target support multi-process, tell it to resume only the new process. * linux-nat.c (num_lwps): Delete global. (purge_lwp_list): New function. (num_lwps): New function. (add_lwp, delete_lwp): Adjust. (ptid_match): New. (iterate_over_lwps): Add filter argument. Handle it. (linux_nat_attach): Remove FIXME note. (linux_nat_detach): Adjust to iterate over threads of the inferior we're detaching from. Adjust to num_lwps being a function. Don't assume the head of the lwp list is the main thread of the process we're detaching from. Don't destroy the LWP list. (resume_callback): Add debug output. (linux_nat_resume): Handle resuming a single inferior. Allow a wildcard resume in non-stop mode. (linux_handle_extended_wait): Don't assume inferior_ptid is the correct inferior of the parent LWP. (status_callback): Also check lp->waitstatus. (select_event_lwp): Add new filter parameter. Handle it. (linux_nat_filter_event): Adjust to num_lwps being a function. (linux_nat_wait_1): When adding the first lwp of the inferior, use an is_lwp check instead of checking for the number of lwps. (linux_nat_wait_1): Handle waiting for a specific tgid. Handle pending process exit statuses. (linux_nat_mourn_inferior): Don't destroy all the LWP info. Instead delete LWPs of the inferior that we're mourning. Don't unregister from the event loop here. (linux_nat_pid_to_str): Use `num_lwps'. (linux_nat_make_corefile_notes): Adjust to walk over lwps of a single inferior. (linux_nat_is_async_p): Check if async was masked out. (linux_multi_process): New global. (linux_nat_supports_multi_process): New. (linux_nat_stop_lwp): Remove LWP filtering. It is done by the caller. (linux_nat_stop): Adjust to make iterate_over_lwps itself do the LWP filtering. (linux_nat_close): New. (linux_nat_add_target): Register linux_nat_close and linux_nat_supports_multi_process. * linux-nat.h (iterate_over_lwps): Add filter argument. * linux-thread-db.c (thread_db_handle): Delete. (proc_handle, thread_agent, td_init_p, td_ta_new_p) (td_ta_map_id2thr_p, td_ta_map_lwp2thr_p, td_ta_thr_iter_p) (td_ta_event_addr_p, td_ta_set_event_p, td_ta_event_getmsg_p) (td_thr_validate_p, td_thr_get_info_p, td_thr_event_enable_p) (td_thr_tls_get_addr_p, td_create_bp_addr, td_death_bp_addr): No longer globals, moved to... (struct thread_db_info): ... this new structure. (thread_db_list): New. (add_thread_db_info, get_thread_db_info, delete_thread_db_info): New. (have_threads_callback): Filter out threads of all inferiors but the one specified by the ARGS argument. (have_threads): Add ptid argument specifying the inferior we're interested in. Handle it. (struct thread_get_info_inout): New. (thread_get_info_callback, thread_from_lwp): Adjust to use it. (thread_db_attach_lwp): Check that inferior of the passed in thread is using thread-db. Adjust. (enable_thread_event): Remove thread_agent parameter. Instead, get it from the per-inferior thread-db info. (dladdr_to_soname): Move higher up. (enable_thread_event_reporting): Adjust to use per-inferior thread-db info. (try_thread_db_load_1): Replace `handle' parameter by a thread_db_info parameter. Adjust to use per-inferior thread-db info. (try_thread_db_load): Adjust to use per-inferior thread-db info. (thread_db_load, disable_thread_event_reporting): Ditto. (check_for_thread_db): Remove conditional reporting of which libthread_db is in use. (thread_db_new_objfile): Add comment about inferior_ptid. (attach_thread): Adjust to use per-inferior thread-db info. (thread_db_detach): Adjust to use per-inferior thread-db info. Remove thread event breakpoints of the current inferior. Only unpush the thread-db target if there are no more processes using it. (check_event): Adjust to use per-inferior thread-db info. (thread_db_wait): Adjust to use per-inferior thread-db info. Only unpush the thread-db target if there are no more processes using it. (thread_db_mourn_inferior): Adjust to use per-inferior thread-db info. Mark breakpoints of the current inferior out before deleting them. Only unpush the thread-db target if there are no more processes using it. (find_new_threads_callback): Adjust to use per-inferior thread_db info. (thread_db_find_new_threads_1): Add new ptid argument. Adjust to use per-inferior thread-db info. (thread_db_find_new_threads): Adjust to use per-inferior thread-db info. (thread_db_get_thread_local_address): Adjust. (thread_db_get_ada_task_ptid): Adjust. * inf-ptrace.c (inf_ptrace_mourn_inferior): Only unpush the target if there no more processes left to debug. * thread.c (set_running, set_executing): Handle resuming all threads of a single inferior. * mi/mi-interp.c (mi_output_running_pid): New. (mi_inferior_count): New. (mi_on_resume): For backwards compatibility, if resuming all threads of an inferior, and there is only one inferior, output "all".
143 lines
4.9 KiB
C
143 lines
4.9 KiB
C
/* Native debugging support for GNU/Linux (LWP layer).
|
|
|
|
Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
|
Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "target.h"
|
|
|
|
#include <signal.h>
|
|
|
|
/* Structure describing an LWP. This is public only for the purposes
|
|
of ALL_LWPS; target-specific code should generally not access it
|
|
directly. */
|
|
|
|
struct lwp_info
|
|
{
|
|
/* The process id of the LWP. This is a combination of the LWP id
|
|
and overall process id. */
|
|
ptid_t ptid;
|
|
|
|
/* Non-zero if this LWP is cloned. In this context "cloned" means
|
|
that the LWP is reporting to its parent using a signal other than
|
|
SIGCHLD. */
|
|
int cloned;
|
|
|
|
/* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
|
|
it back yet). */
|
|
int signalled;
|
|
|
|
/* Non-zero if this LWP is stopped. */
|
|
int stopped;
|
|
|
|
/* Non-zero if this LWP will be/has been resumed. Note that an LWP
|
|
can be marked both as stopped and resumed at the same time. This
|
|
happens if we try to resume an LWP that has a wait status
|
|
pending. We shouldn't let the LWP run until that wait status has
|
|
been processed, but we should not report that wait status if GDB
|
|
didn't try to let the LWP run. */
|
|
int resumed;
|
|
|
|
/* If non-zero, a pending wait status. */
|
|
int status;
|
|
|
|
/* Non-zero if we were stepping this LWP. */
|
|
int step;
|
|
|
|
/* Non-zero si_signo if this LWP stopped with a trap. si_addr may
|
|
be the address of a hardware watchpoint. */
|
|
struct siginfo siginfo;
|
|
|
|
/* Non-zero if we expect a duplicated SIGINT. */
|
|
int ignore_sigint;
|
|
|
|
/* If WAITSTATUS->KIND != TARGET_WAITKIND_SPURIOUS, the waitstatus
|
|
for this LWP's last event. This may correspond to STATUS above,
|
|
or to a local variable in lin_lwp_wait. */
|
|
struct target_waitstatus waitstatus;
|
|
|
|
/* Next LWP in list. */
|
|
struct lwp_info *next;
|
|
};
|
|
|
|
/* The global list of LWPs, for ALL_LWPS. Unlike the threads list,
|
|
there is always at least one LWP on the list while the GNU/Linux
|
|
native target is active. */
|
|
extern struct lwp_info *lwp_list;
|
|
|
|
/* Iterate over the PTID each active thread (light-weight process). There
|
|
must be at least one. */
|
|
#define ALL_LWPS(LP, PTID) \
|
|
for ((LP) = lwp_list, (PTID) = (LP)->ptid; \
|
|
(LP) != NULL; \
|
|
(LP) = (LP)->next, (PTID) = (LP) ? (LP)->ptid : (PTID))
|
|
|
|
#define GET_LWP(ptid) ptid_get_lwp (ptid)
|
|
#define GET_PID(ptid) ptid_get_pid (ptid)
|
|
#define is_lwp(ptid) (GET_LWP (ptid) != 0)
|
|
#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
|
|
|
|
/* Attempt to initialize libthread_db. */
|
|
void check_for_thread_db (void);
|
|
|
|
int thread_db_attach_lwp (ptid_t ptid);
|
|
|
|
/* Find process PID's pending signal set from /proc/pid/status. */
|
|
void linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored);
|
|
|
|
/* linux-nat functions for handling fork events. */
|
|
extern void linux_enable_event_reporting (ptid_t ptid);
|
|
|
|
extern int lin_lwp_attach_lwp (ptid_t ptid);
|
|
|
|
/* Iterator function for lin-lwp's lwp list. */
|
|
struct lwp_info *iterate_over_lwps (ptid_t filter,
|
|
int (*callback) (struct lwp_info *,
|
|
void *),
|
|
void *data);
|
|
|
|
/* Create a prototype generic GNU/Linux target. The client can
|
|
override it with local methods. */
|
|
struct target_ops * linux_target (void);
|
|
|
|
/* Create a generic GNU/Linux target using traditional
|
|
ptrace register access. */
|
|
struct target_ops *
|
|
linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int));
|
|
|
|
/* Register the customized GNU/Linux target. This should be used
|
|
instead of calling add_target directly. */
|
|
void linux_nat_add_target (struct target_ops *);
|
|
|
|
/* Register a method to call whenever a new thread is attached. */
|
|
void linux_nat_set_new_thread (struct target_ops *, void (*) (ptid_t));
|
|
|
|
/* Register a method that converts a siginfo object between the layout
|
|
that ptrace returns, and the layout in the architecture of the
|
|
inferior. */
|
|
void linux_nat_set_siginfo_fixup (struct target_ops *,
|
|
int (*) (struct siginfo *,
|
|
gdb_byte *,
|
|
int));
|
|
|
|
/* Update linux-nat internal state when changing from one fork
|
|
to another. */
|
|
void linux_nat_switch_fork (ptid_t new_ptid);
|
|
|
|
/* Return the saved siginfo associated with PTID. */
|
|
struct siginfo *linux_nat_get_siginfo (ptid_t ptid);
|