1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001-2023 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "nat/linux-nat.h"
25 #include "nat/linux-waitpid.h"
26 #include "gdbsupport/gdb_wait.h"
28 #include <sys/syscall.h>
29 #include "nat/gdb_ptrace.h"
30 #include "linux-nat.h"
31 #include "nat/linux-ptrace.h"
32 #include "nat/linux-procfs.h"
33 #include "nat/linux-personality.h"
34 #include "linux-fork.h"
35 #include "gdbthread.h"
39 #include "inf-child.h"
40 #include "inf-ptrace.h"
42 #include <sys/procfs.h>
50 #include "gdbsupport/event-loop.h"
51 #include "event-top.h"
53 #include <sys/types.h>
55 #include "xml-support.h"
58 #include "nat/linux-osdata.h"
59 #include "linux-tdep.h"
61 #include "gdbsupport/agent.h"
62 #include "tracepoint.h"
63 #include "target-descriptions.h"
64 #include "gdbsupport/filestuff.h"
66 #include "nat/linux-namespaces.h"
67 #include "gdbsupport/block-signals.h"
68 #include "gdbsupport/fileio.h"
69 #include "gdbsupport/scope-exit.h"
70 #include "gdbsupport/gdb-sigmask.h"
71 #include "gdbsupport/common-debug.h"
72 #include <unordered_map>
74 /* This comment documents high-level logic of this file.
76 Waiting for events in sync mode
77 ===============================
79 When waiting for an event in a specific thread, we just use waitpid,
80 passing the specific pid, and not passing WNOHANG.
82 When waiting for an event in all threads, waitpid is not quite good:
84 - If the thread group leader exits while other threads in the thread
85 group still exist, waitpid(TGID, ...) hangs. That waitpid won't
86 return an exit status until the other threads in the group are
89 - When a non-leader thread execs, that thread just vanishes without
90 reporting an exit (so we'd hang if we waited for it explicitly in
91 that case). The exec event is instead reported to the TGID pid.
93 The solution is to always use -1 and WNOHANG, together with
96 First, we use non-blocking waitpid to check for events. If nothing is
97 found, we use sigsuspend to wait for SIGCHLD. When SIGCHLD arrives,
98 it means something happened to a child process. As soon as we know
99 there's an event, we get back to calling nonblocking waitpid.
101 Note that SIGCHLD should be blocked between waitpid and sigsuspend
102 calls, so that we don't miss a signal. If SIGCHLD arrives in between,
103 when it's blocked, the signal becomes pending and sigsuspend
104 immediately notices it and returns.
106 Waiting for events in async mode (TARGET_WNOHANG)
107 =================================================
109 In async mode, GDB should always be ready to handle both user input
110 and target events, so neither blocking waitpid nor sigsuspend are
111 viable options. Instead, we should asynchronously notify the GDB main
112 event loop whenever there's an unprocessed event from the target. We
113 detect asynchronous target events by handling SIGCHLD signals. To
114 notify the event loop about target events, an event pipe is used
115 --- the pipe is registered as waitable event source in the event loop,
116 the event loop select/poll's on the read end of this pipe (as well on
117 other event sources, e.g., stdin), and the SIGCHLD handler marks the
118 event pipe to raise an event. This is more portable than relying on
119 pselect/ppoll, since on kernels that lack those syscalls, libc
120 emulates them with select/poll+sigprocmask, and that is racy
121 (a.k.a. plain broken).
123 Obviously, if we fail to notify the event loop if there's a target
124 event, it's bad. OTOH, if we notify the event loop when there's no
125 event from the target, linux_nat_wait will detect that there's no real
126 event to report, and return event of type TARGET_WAITKIND_IGNORE.
127 This is mostly harmless, but it will waste time and is better avoided.
129 The main design point is that every time GDB is outside linux-nat.c,
130 we have a SIGCHLD handler installed that is called when something
131 happens to the target and notifies the GDB event loop. Whenever GDB
132 core decides to handle the event, and calls into linux-nat.c, we
133 process things as in sync mode, except that the we never block in
136 While processing an event, we may end up momentarily blocked in
137 waitpid calls. Those waitpid calls, while blocking, are guarantied to
138 return quickly. E.g., in all-stop mode, before reporting to the core
139 that an LWP hit a breakpoint, all LWPs are stopped by sending them
140 SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
141 Note that this is different from blocking indefinitely waiting for the
142 next event --- here, we're already handling an event.
147 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
148 signal is not entirely significant; we just need for a signal to be delivered,
149 so that we can intercept it. SIGSTOP's advantage is that it can not be
150 blocked. A disadvantage is that it is not a real-time signal, so it can only
151 be queued once; we do not keep track of other sources of SIGSTOP.
153 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
154 use them, because they have special behavior when the signal is generated -
155 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
156 kills the entire thread group.
158 A delivered SIGSTOP would stop the entire thread group, not just the thread we
159 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
160 cancel it (by PTRACE_CONT without passing SIGSTOP).
162 We could use a real-time signal instead. This would solve those problems; we
163 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
164 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
165 generates it, and there are races with trying to find a signal that is not
171 The case of a thread group (process) with 3 or more threads, and a
172 thread other than the leader execs is worth detailing:
174 On an exec, the Linux kernel destroys all threads except the execing
175 one in the thread group, and resets the execing thread's tid to the
176 tgid. No exit notification is sent for the execing thread -- from the
177 ptracer's perspective, it appears as though the execing thread just
178 vanishes. Until we reap all other threads except the leader and the
179 execing thread, the leader will be zombie, and the execing thread will
180 be in `D (disc sleep)' state. As soon as all other threads are
181 reaped, the execing thread changes its tid to the tgid, and the
182 previous (zombie) leader vanishes, giving place to the "new"
186 #define O_LARGEFILE 0
189 struct linux_nat_target
*linux_target
;
191 /* Does the current host support PTRACE_GETREGSET? */
192 enum tribool have_ptrace_getregset
= TRIBOOL_UNKNOWN
;
194 /* When true, print debug messages relating to the linux native target. */
196 static bool debug_linux_nat
;
198 /* Implement 'show debug linux-nat'. */
201 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
202 struct cmd_list_element
*c
, const char *value
)
204 gdb_printf (file
, _("Debugging of GNU/Linux native targets is %s.\n"),
208 /* Print a linux-nat debug statement. */
210 #define linux_nat_debug_printf(fmt, ...) \
211 debug_prefixed_printf_cond (debug_linux_nat, "linux-nat", fmt, ##__VA_ARGS__)
213 /* Print "linux-nat" enter/exit debug statements. */
215 #define LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT \
216 scoped_debug_enter_exit (debug_linux_nat, "linux-nat")
218 struct simple_pid_list
222 struct simple_pid_list
*next
;
224 static struct simple_pid_list
*stopped_pids
;
226 /* Whether target_thread_events is in effect. */
227 static int report_thread_events
;
229 static int kill_lwp (int lwpid
, int signo
);
231 static int stop_callback (struct lwp_info
*lp
);
233 static void block_child_signals (sigset_t
*prev_mask
);
234 static void restore_child_signals_mask (sigset_t
*prev_mask
);
237 static struct lwp_info
*add_lwp (ptid_t ptid
);
238 static void purge_lwp_list (int pid
);
239 static void delete_lwp (ptid_t ptid
);
240 static struct lwp_info
*find_lwp_pid (ptid_t ptid
);
242 static int lwp_status_pending_p (struct lwp_info
*lp
);
244 static void save_stop_reason (struct lwp_info
*lp
);
246 static bool proc_mem_file_is_writable ();
247 static void close_proc_mem_file (pid_t pid
);
248 static void open_proc_mem_file (ptid_t ptid
);
250 /* Return TRUE if LWP is the leader thread of the process. */
253 is_leader (lwp_info
*lp
)
255 return lp
->ptid
.pid () == lp
->ptid
.lwp ();
258 /* Convert an LWP's pending status to a std::string. */
261 pending_status_str (lwp_info
*lp
)
263 gdb_assert (lwp_status_pending_p (lp
));
265 if (lp
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
266 return lp
->waitstatus
.to_string ();
268 return status_to_str (lp
->status
);
271 /* Return true if we should report exit events for LP. */
274 report_exit_events_for (lwp_info
*lp
)
276 thread_info
*thr
= linux_target
->find_thread (lp
->ptid
);
277 gdb_assert (thr
!= nullptr);
279 return (report_thread_events
280 || (thr
->thread_options () & GDB_THREAD_OPTION_EXIT
) != 0);
286 /* See nat/linux-nat.h. */
289 ptid_of_lwp (struct lwp_info
*lwp
)
294 /* See nat/linux-nat.h. */
297 lwp_set_arch_private_info (struct lwp_info
*lwp
,
298 struct arch_lwp_info
*info
)
300 lwp
->arch_private
= info
;
303 /* See nat/linux-nat.h. */
305 struct arch_lwp_info
*
306 lwp_arch_private_info (struct lwp_info
*lwp
)
308 return lwp
->arch_private
;
311 /* See nat/linux-nat.h. */
314 lwp_is_stopped (struct lwp_info
*lwp
)
319 /* See nat/linux-nat.h. */
321 enum target_stop_reason
322 lwp_stop_reason (struct lwp_info
*lwp
)
324 return lwp
->stop_reason
;
327 /* See nat/linux-nat.h. */
330 lwp_is_stepping (struct lwp_info
*lwp
)
336 /* Trivial list manipulation functions to keep track of a list of
337 new stopped processes. */
339 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
341 struct simple_pid_list
*new_pid
= XNEW (struct simple_pid_list
);
344 new_pid
->status
= status
;
345 new_pid
->next
= *listp
;
350 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
352 struct simple_pid_list
**p
;
354 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
355 if ((*p
)->pid
== pid
)
357 struct simple_pid_list
*next
= (*p
)->next
;
359 *statusp
= (*p
)->status
;
367 /* Return the ptrace options that we want to try to enable. */
370 linux_nat_ptrace_options (int attached
)
375 options
|= PTRACE_O_EXITKILL
;
377 options
|= (PTRACE_O_TRACESYSGOOD
378 | PTRACE_O_TRACEVFORKDONE
379 | PTRACE_O_TRACEVFORK
381 | PTRACE_O_TRACEEXEC
);
386 /* Initialize ptrace and procfs warnings and check for supported
387 ptrace features given PID.
389 ATTACHED should be nonzero iff we attached to the inferior. */
392 linux_init_ptrace_procfs (pid_t pid
, int attached
)
394 int options
= linux_nat_ptrace_options (attached
);
396 linux_enable_event_reporting (pid
, options
);
397 linux_ptrace_init_warnings ();
398 linux_proc_init_warnings ();
399 proc_mem_file_is_writable ();
402 linux_nat_target::~linux_nat_target ()
406 linux_nat_target::post_attach (int pid
)
408 linux_init_ptrace_procfs (pid
, 1);
411 /* Implement the virtual inf_ptrace_target::post_startup_inferior method. */
414 linux_nat_target::post_startup_inferior (ptid_t ptid
)
416 linux_init_ptrace_procfs (ptid
.pid (), 0);
419 /* Return the number of known LWPs in the tgid given by PID. */
426 for (const lwp_info
*lp ATTRIBUTE_UNUSED
: all_lwps ())
427 if (lp
->ptid
.pid () == pid
)
433 /* Deleter for lwp_info unique_ptr specialisation. */
437 void operator() (struct lwp_info
*lwp
) const
439 delete_lwp (lwp
->ptid
);
443 /* A unique_ptr specialisation for lwp_info. */
445 typedef std::unique_ptr
<struct lwp_info
, lwp_deleter
> lwp_info_up
;
447 /* Target hook for follow_fork. */
450 linux_nat_target::follow_fork (inferior
*child_inf
, ptid_t child_ptid
,
451 target_waitkind fork_kind
, bool follow_child
,
454 inf_ptrace_target::follow_fork (child_inf
, child_ptid
, fork_kind
,
455 follow_child
, detach_fork
);
459 bool has_vforked
= fork_kind
== TARGET_WAITKIND_VFORKED
;
460 ptid_t parent_ptid
= inferior_ptid
;
461 int parent_pid
= parent_ptid
.lwp ();
462 int child_pid
= child_ptid
.lwp ();
464 /* We're already attached to the parent, by default. */
465 lwp_info
*child_lp
= add_lwp (child_ptid
);
466 child_lp
->stopped
= 1;
467 child_lp
->last_resume_kind
= resume_stop
;
469 /* Detach new forked process? */
472 int child_stop_signal
= 0;
473 bool detach_child
= true;
475 /* Move CHILD_LP into a unique_ptr and clear the source pointer
476 to prevent us doing anything stupid with it. */
477 lwp_info_up
child_lp_ptr (child_lp
);
480 linux_target
->low_prepare_to_resume (child_lp_ptr
.get ());
482 /* When debugging an inferior in an architecture that supports
483 hardware single stepping on a kernel without commit
484 6580807da14c423f0d0a708108e6df6ebc8bc83d, the vfork child
485 process starts with the TIF_SINGLESTEP/X86_EFLAGS_TF bits
486 set if the parent process had them set.
487 To work around this, single step the child process
488 once before detaching to clear the flags. */
490 /* Note that we consult the parent's architecture instead of
491 the child's because there's no inferior for the child at
493 if (!gdbarch_software_single_step_p (target_thread_architecture
498 linux_disable_event_reporting (child_pid
);
499 if (ptrace (PTRACE_SINGLESTEP
, child_pid
, 0, 0) < 0)
500 perror_with_name (_("Couldn't do single step"));
501 if (my_waitpid (child_pid
, &status
, 0) < 0)
502 perror_with_name (_("Couldn't wait vfork process"));
505 detach_child
= WIFSTOPPED (status
);
506 child_stop_signal
= WSTOPSIG (status
);
512 int signo
= child_stop_signal
;
515 && !signal_pass_state (gdb_signal_from_host (signo
)))
517 ptrace (PTRACE_DETACH
, child_pid
, 0, signo
);
519 close_proc_mem_file (child_pid
);
525 lwp_info
*parent_lp
= find_lwp_pid (parent_ptid
);
526 linux_nat_debug_printf ("waiting for VFORK_DONE on %d", parent_pid
);
527 parent_lp
->stopped
= 1;
529 /* We'll handle the VFORK_DONE event like any other
530 event, in target_wait. */
535 struct lwp_info
*child_lp
;
537 child_lp
= add_lwp (child_ptid
);
538 child_lp
->stopped
= 1;
539 child_lp
->last_resume_kind
= resume_stop
;
545 linux_nat_target::insert_fork_catchpoint (int pid
)
551 linux_nat_target::remove_fork_catchpoint (int pid
)
557 linux_nat_target::insert_vfork_catchpoint (int pid
)
563 linux_nat_target::remove_vfork_catchpoint (int pid
)
569 linux_nat_target::insert_exec_catchpoint (int pid
)
575 linux_nat_target::remove_exec_catchpoint (int pid
)
581 linux_nat_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
582 gdb::array_view
<const int> syscall_counts
)
584 /* On GNU/Linux, we ignore the arguments. It means that we only
585 enable the syscall catchpoints, but do not disable them.
587 Also, we do not use the `syscall_counts' information because we do not
588 filter system calls here. We let GDB do the logic for us. */
592 /* List of known LWPs, keyed by LWP PID. This speeds up the common
593 case of mapping a PID returned from the kernel to our corresponding
594 lwp_info data structure. */
595 static htab_t lwp_lwpid_htab
;
597 /* Calculate a hash from a lwp_info's LWP PID. */
600 lwp_info_hash (const void *ap
)
602 const struct lwp_info
*lp
= (struct lwp_info
*) ap
;
603 pid_t pid
= lp
->ptid
.lwp ();
605 return iterative_hash_object (pid
, 0);
608 /* Equality function for the lwp_info hash table. Compares the LWP's
612 lwp_lwpid_htab_eq (const void *a
, const void *b
)
614 const struct lwp_info
*entry
= (const struct lwp_info
*) a
;
615 const struct lwp_info
*element
= (const struct lwp_info
*) b
;
617 return entry
->ptid
.lwp () == element
->ptid
.lwp ();
620 /* Create the lwp_lwpid_htab hash table. */
623 lwp_lwpid_htab_create (void)
625 lwp_lwpid_htab
= htab_create (100, lwp_info_hash
, lwp_lwpid_htab_eq
, NULL
);
628 /* Add LP to the hash table. */
631 lwp_lwpid_htab_add_lwp (struct lwp_info
*lp
)
635 slot
= htab_find_slot (lwp_lwpid_htab
, lp
, INSERT
);
636 gdb_assert (slot
!= NULL
&& *slot
== NULL
);
640 /* Head of doubly-linked list of known LWPs. Sorted by reverse
641 creation order. This order is assumed in some cases. E.g.,
642 reaping status after killing alls lwps of a process: the leader LWP
643 must be reaped last. */
645 static intrusive_list
<lwp_info
> lwp_list
;
647 /* See linux-nat.h. */
652 return lwp_info_range (lwp_list
.begin ());
655 /* See linux-nat.h. */
660 return lwp_info_safe_range (lwp_list
.begin ());
663 /* Add LP to sorted-by-reverse-creation-order doubly-linked list. */
666 lwp_list_add (struct lwp_info
*lp
)
668 lwp_list
.push_front (*lp
);
671 /* Remove LP from sorted-by-reverse-creation-order doubly-linked
675 lwp_list_remove (struct lwp_info
*lp
)
677 /* Remove from sorted-by-creation-order list. */
678 lwp_list
.erase (lwp_list
.iterator_to (*lp
));
683 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
684 _initialize_linux_nat. */
685 static sigset_t suspend_mask
;
687 /* Signals to block to make that sigsuspend work. */
688 static sigset_t blocked_mask
;
690 /* SIGCHLD action. */
691 static struct sigaction sigchld_action
;
693 /* Block child signals (SIGCHLD and linux threads signals), and store
694 the previous mask in PREV_MASK. */
697 block_child_signals (sigset_t
*prev_mask
)
699 /* Make sure SIGCHLD is blocked. */
700 if (!sigismember (&blocked_mask
, SIGCHLD
))
701 sigaddset (&blocked_mask
, SIGCHLD
);
703 gdb_sigmask (SIG_BLOCK
, &blocked_mask
, prev_mask
);
706 /* Restore child signals mask, previously returned by
707 block_child_signals. */
710 restore_child_signals_mask (sigset_t
*prev_mask
)
712 gdb_sigmask (SIG_SETMASK
, prev_mask
, NULL
);
715 /* Mask of signals to pass directly to the inferior. */
716 static sigset_t pass_mask
;
718 /* Update signals to pass to the inferior. */
720 linux_nat_target::pass_signals
721 (gdb::array_view
<const unsigned char> pass_signals
)
725 sigemptyset (&pass_mask
);
727 for (signo
= 1; signo
< NSIG
; signo
++)
729 int target_signo
= gdb_signal_from_host (signo
);
730 if (target_signo
< pass_signals
.size () && pass_signals
[target_signo
])
731 sigaddset (&pass_mask
, signo
);
737 /* Prototypes for local functions. */
738 static int stop_wait_callback (struct lwp_info
*lp
);
739 static int resume_stopped_resumed_lwps (struct lwp_info
*lp
, const ptid_t wait_ptid
);
740 static int check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
);
744 /* Destroy and free LP. */
746 lwp_info::~lwp_info ()
748 /* Let the arch specific bits release arch_lwp_info. */
749 linux_target
->low_delete_thread (this->arch_private
);
752 /* Traversal function for purge_lwp_list. */
755 lwp_lwpid_htab_remove_pid (void **slot
, void *info
)
757 struct lwp_info
*lp
= (struct lwp_info
*) *slot
;
758 int pid
= *(int *) info
;
760 if (lp
->ptid
.pid () == pid
)
762 htab_clear_slot (lwp_lwpid_htab
, slot
);
763 lwp_list_remove (lp
);
770 /* Remove all LWPs belong to PID from the lwp list. */
773 purge_lwp_list (int pid
)
775 htab_traverse_noresize (lwp_lwpid_htab
, lwp_lwpid_htab_remove_pid
, &pid
);
778 /* Add the LWP specified by PTID to the list. PTID is the first LWP
779 in the process. Return a pointer to the structure describing the
782 This differs from add_lwp in that we don't let the arch specific
783 bits know about this new thread. Current clients of this callback
784 take the opportunity to install watchpoints in the new thread, and
785 we shouldn't do that for the first thread. If we're spawning a
786 child ("run"), the thread executes the shell wrapper first, and we
787 shouldn't touch it until it execs the program we want to debug.
788 For "attach", it'd be okay to call the callback, but it's not
789 necessary, because watchpoints can't yet have been inserted into
792 static struct lwp_info
*
793 add_initial_lwp (ptid_t ptid
)
795 gdb_assert (ptid
.lwp_p ());
797 lwp_info
*lp
= new lwp_info (ptid
);
800 /* Add to sorted-by-reverse-creation-order list. */
803 /* Add to keyed-by-pid htab. */
804 lwp_lwpid_htab_add_lwp (lp
);
809 /* Add the LWP specified by PID to the list. Return a pointer to the
810 structure describing the new LWP. The LWP should already be
813 static struct lwp_info
*
814 add_lwp (ptid_t ptid
)
818 lp
= add_initial_lwp (ptid
);
820 /* Let the arch specific bits know about this new thread. Current
821 clients of this callback take the opportunity to install
822 watchpoints in the new thread. We don't do this for the first
823 thread though. See add_initial_lwp. */
824 linux_target
->low_new_thread (lp
);
829 /* Remove the LWP specified by PID from the list. */
832 delete_lwp (ptid_t ptid
)
834 lwp_info
dummy (ptid
);
836 void **slot
= htab_find_slot (lwp_lwpid_htab
, &dummy
, NO_INSERT
);
840 lwp_info
*lp
= *(struct lwp_info
**) slot
;
841 gdb_assert (lp
!= NULL
);
843 htab_clear_slot (lwp_lwpid_htab
, slot
);
845 /* Remove from sorted-by-creation-order list. */
846 lwp_list_remove (lp
);
852 /* Return a pointer to the structure describing the LWP corresponding
853 to PID. If no corresponding LWP could be found, return NULL. */
855 static struct lwp_info
*
856 find_lwp_pid (ptid_t ptid
)
865 lwp_info
dummy (ptid_t (0, lwp
));
866 return (struct lwp_info
*) htab_find (lwp_lwpid_htab
, &dummy
);
869 /* See nat/linux-nat.h. */
872 iterate_over_lwps (ptid_t filter
,
873 gdb::function_view
<iterate_over_lwps_ftype
> callback
)
875 for (lwp_info
*lp
: all_lwps_safe ())
877 if (lp
->ptid
.matches (filter
))
879 if (callback (lp
) != 0)
887 /* Update our internal state when changing from one checkpoint to
888 another indicated by NEW_PTID. We can only switch single-threaded
889 applications, so we only create one new LWP, and the previous list
893 linux_nat_switch_fork (ptid_t new_ptid
)
897 purge_lwp_list (inferior_ptid
.pid ());
899 lp
= add_lwp (new_ptid
);
902 /* This changes the thread's ptid while preserving the gdb thread
903 num. Also changes the inferior pid, while preserving the
905 thread_change_ptid (linux_target
, inferior_ptid
, new_ptid
);
907 /* We've just told GDB core that the thread changed target id, but,
908 in fact, it really is a different thread, with different register
910 registers_changed ();
913 /* Handle the exit of a single thread LP. If DEL_THREAD is true,
914 delete the thread_info associated to LP, if it exists. */
917 exit_lwp (struct lwp_info
*lp
, bool del_thread
= true)
919 struct thread_info
*th
= linux_target
->find_thread (lp
->ptid
);
921 if (th
!= nullptr && del_thread
)
924 delete_lwp (lp
->ptid
);
927 /* Wait for the LWP specified by LP, which we have just attached to.
928 Returns a wait status for that LWP, to cache. */
931 linux_nat_post_attach_wait (ptid_t ptid
, int *signalled
)
933 pid_t new_pid
, pid
= ptid
.lwp ();
936 if (linux_proc_pid_is_stopped (pid
))
938 linux_nat_debug_printf ("Attaching to a stopped process");
940 /* The process is definitely stopped. It is in a job control
941 stop, unless the kernel predates the TASK_STOPPED /
942 TASK_TRACED distinction, in which case it might be in a
943 ptrace stop. Make sure it is in a ptrace stop; from there we
944 can kill it, signal it, et cetera.
946 First make sure there is a pending SIGSTOP. Since we are
947 already attached, the process can not transition from stopped
948 to running without a PTRACE_CONT; so we know this signal will
949 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
950 probably already in the queue (unless this kernel is old
951 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
952 is not an RT signal, it can only be queued once. */
953 kill_lwp (pid
, SIGSTOP
);
955 /* Finally, resume the stopped process. This will deliver the SIGSTOP
956 (or a higher priority signal, just like normal PTRACE_ATTACH). */
957 ptrace (PTRACE_CONT
, pid
, 0, 0);
960 /* Make sure the initial process is stopped. The user-level threads
961 layer might want to poke around in the inferior, and that won't
962 work if things haven't stabilized yet. */
963 new_pid
= my_waitpid (pid
, &status
, __WALL
);
964 gdb_assert (pid
== new_pid
);
966 if (!WIFSTOPPED (status
))
968 /* The pid we tried to attach has apparently just exited. */
969 linux_nat_debug_printf ("Failed to stop %d: %s", pid
,
970 status_to_str (status
).c_str ());
974 if (WSTOPSIG (status
) != SIGSTOP
)
977 linux_nat_debug_printf ("Received %s after attaching",
978 status_to_str (status
).c_str ());
985 linux_nat_target::create_inferior (const char *exec_file
,
986 const std::string
&allargs
,
987 char **env
, int from_tty
)
989 maybe_disable_address_space_randomization restore_personality
990 (disable_randomization
);
992 /* The fork_child mechanism is synchronous and calls target_wait, so
993 we have to mask the async mode. */
995 /* Make sure we report all signals during startup. */
998 inf_ptrace_target::create_inferior (exec_file
, allargs
, env
, from_tty
);
1000 open_proc_mem_file (inferior_ptid
);
1003 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1004 already attached. Returns true if a new LWP is found, false
1008 attach_proc_task_lwp_callback (ptid_t ptid
)
1010 struct lwp_info
*lp
;
1012 /* Ignore LWPs we're already attached to. */
1013 lp
= find_lwp_pid (ptid
);
1016 int lwpid
= ptid
.lwp ();
1018 if (ptrace (PTRACE_ATTACH
, lwpid
, 0, 0) < 0)
1022 /* Be quiet if we simply raced with the thread exiting.
1023 EPERM is returned if the thread's task still exists, and
1024 is marked as exited or zombie, as well as other
1025 conditions, so in that case, confirm the status in
1026 /proc/PID/status. */
1028 || (err
== EPERM
&& linux_proc_pid_is_gone (lwpid
)))
1030 linux_nat_debug_printf
1031 ("Cannot attach to lwp %d: thread is gone (%d: %s)",
1032 lwpid
, err
, safe_strerror (err
));
1038 = linux_ptrace_attach_fail_reason_string (ptid
, err
);
1040 error (_("Cannot attach to lwp %d: %s"),
1041 lwpid
, reason
.c_str ());
1046 linux_nat_debug_printf ("PTRACE_ATTACH %s, 0, 0 (OK)",
1047 ptid
.to_string ().c_str ());
1049 lp
= add_lwp (ptid
);
1051 /* The next time we wait for this LWP we'll see a SIGSTOP as
1052 PTRACE_ATTACH brings it to a halt. */
1055 /* We need to wait for a stop before being able to make the
1056 next ptrace call on this LWP. */
1057 lp
->must_set_ptrace_flags
= 1;
1059 /* So that wait collects the SIGSTOP. */
1069 linux_nat_target::attach (const char *args
, int from_tty
)
1071 struct lwp_info
*lp
;
1075 /* Make sure we report all signals during attach. */
1080 inf_ptrace_target::attach (args
, from_tty
);
1082 catch (const gdb_exception_error
&ex
)
1084 pid_t pid
= parse_pid_to_attach (args
);
1085 std::string reason
= linux_ptrace_attach_fail_reason (pid
);
1087 if (!reason
.empty ())
1088 throw_error (ex
.error
, "warning: %s\n%s", reason
.c_str (),
1091 throw_error (ex
.error
, "%s", ex
.what ());
1094 /* The ptrace base target adds the main thread with (pid,0,0)
1095 format. Decorate it with lwp info. */
1096 ptid
= ptid_t (inferior_ptid
.pid (),
1097 inferior_ptid
.pid ());
1098 thread_change_ptid (linux_target
, inferior_ptid
, ptid
);
1100 /* Add the initial process as the first LWP to the list. */
1101 lp
= add_initial_lwp (ptid
);
1103 status
= linux_nat_post_attach_wait (lp
->ptid
, &lp
->signalled
);
1104 if (!WIFSTOPPED (status
))
1106 if (WIFEXITED (status
))
1108 int exit_code
= WEXITSTATUS (status
);
1110 target_terminal::ours ();
1111 target_mourn_inferior (inferior_ptid
);
1113 error (_("Unable to attach: program exited normally."));
1115 error (_("Unable to attach: program exited with code %d."),
1118 else if (WIFSIGNALED (status
))
1120 enum gdb_signal signo
;
1122 target_terminal::ours ();
1123 target_mourn_inferior (inferior_ptid
);
1125 signo
= gdb_signal_from_host (WTERMSIG (status
));
1126 error (_("Unable to attach: program terminated with signal "
1128 gdb_signal_to_name (signo
),
1129 gdb_signal_to_string (signo
));
1132 internal_error (_("unexpected status %d for PID %ld"),
1133 status
, (long) ptid
.lwp ());
1138 open_proc_mem_file (lp
->ptid
);
1140 /* Save the wait status to report later. */
1142 linux_nat_debug_printf ("waitpid %ld, saving status %s",
1143 (long) lp
->ptid
.pid (),
1144 status_to_str (status
).c_str ());
1146 lp
->status
= status
;
1148 /* We must attach to every LWP. If /proc is mounted, use that to
1149 find them now. The inferior may be using raw clone instead of
1150 using pthreads. But even if it is using pthreads, thread_db
1151 walks structures in the inferior's address space to find the list
1152 of threads/LWPs, and those structures may well be corrupted.
1153 Note that once thread_db is loaded, we'll still use it to list
1154 threads and associate pthread info with each LWP. */
1157 linux_proc_attach_tgid_threads (lp
->ptid
.pid (),
1158 attach_proc_task_lwp_callback
);
1160 catch (const gdb_exception_error
&)
1162 /* Failed to attach to some LWP. Detach any we've already
1164 iterate_over_lwps (ptid_t (ptid
.pid ()),
1165 [] (struct lwp_info
*lwp
) -> int
1167 /* Ignore errors when detaching. */
1168 ptrace (PTRACE_DETACH
, lwp
->ptid
.lwp (), 0, 0);
1169 delete_lwp (lwp
->ptid
);
1173 target_terminal::ours ();
1174 target_mourn_inferior (inferior_ptid
);
1179 /* Add all the LWPs to gdb's thread list. */
1180 iterate_over_lwps (ptid_t (ptid
.pid ()),
1181 [] (struct lwp_info
*lwp
) -> int
1183 if (lwp
->ptid
.pid () != lwp
->ptid
.lwp ())
1185 add_thread (linux_target
, lwp
->ptid
);
1186 set_running (linux_target
, lwp
->ptid
, true);
1187 set_executing (linux_target
, lwp
->ptid
, true);
1193 /* Ptrace-detach the thread with pid PID. */
1196 detach_one_pid (int pid
, int signo
)
1198 if (ptrace (PTRACE_DETACH
, pid
, 0, signo
) < 0)
1200 int save_errno
= errno
;
1202 /* We know the thread exists, so ESRCH must mean the lwp is
1203 zombie. This can happen if one of the already-detached
1204 threads exits the whole thread group. In that case we're
1205 still attached, and must reap the lwp. */
1206 if (save_errno
== ESRCH
)
1210 ret
= my_waitpid (pid
, &status
, __WALL
);
1213 warning (_("Couldn't reap LWP %d while detaching: %s"),
1214 pid
, safe_strerror (errno
));
1216 else if (!WIFEXITED (status
) && !WIFSIGNALED (status
))
1218 warning (_("Reaping LWP %d while detaching "
1219 "returned unexpected status 0x%x"),
1224 error (_("Can't detach %d: %s"),
1225 pid
, safe_strerror (save_errno
));
1228 linux_nat_debug_printf ("PTRACE_DETACH (%d, %s, 0) (OK)",
1229 pid
, strsignal (signo
));
1232 /* Get pending signal of THREAD as a host signal number, for detaching
1233 purposes. This is the signal the thread last stopped for, which we
1234 need to deliver to the thread when detaching, otherwise, it'd be
1238 get_detach_signal (struct lwp_info
*lp
)
1240 enum gdb_signal signo
= GDB_SIGNAL_0
;
1242 /* If we paused threads momentarily, we may have stored pending
1243 events in lp->status or lp->waitstatus (see stop_wait_callback),
1244 and GDB core hasn't seen any signal for those threads.
1245 Otherwise, the last signal reported to the core is found in the
1246 thread object's stop_signal.
1248 There's a corner case that isn't handled here at present. Only
1249 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1250 stop_signal make sense as a real signal to pass to the inferior.
1251 Some catchpoint related events, like
1252 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1253 to GDB_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1254 those traps are debug API (ptrace in our case) related and
1255 induced; the inferior wouldn't see them if it wasn't being
1256 traced. Hence, we should never pass them to the inferior, even
1257 when set to pass state. Since this corner case isn't handled by
1258 infrun.c when proceeding with a signal, for consistency, neither
1259 do we handle it here (or elsewhere in the file we check for
1260 signal pass state). Normally SIGTRAP isn't set to pass state, so
1261 this is really a corner case. */
1263 if (lp
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
1264 signo
= GDB_SIGNAL_0
; /* a pending ptrace event, not a real signal. */
1265 else if (lp
->status
)
1266 signo
= gdb_signal_from_host (WSTOPSIG (lp
->status
));
1269 thread_info
*tp
= linux_target
->find_thread (lp
->ptid
);
1271 if (target_is_non_stop_p () && !tp
->executing ())
1273 if (tp
->has_pending_waitstatus ())
1275 /* If the thread has a pending event, and it was stopped with a
1276 signal, use that signal to resume it. If it has a pending
1277 event of another kind, it was not stopped with a signal, so
1278 resume it without a signal. */
1279 if (tp
->pending_waitstatus ().kind () == TARGET_WAITKIND_STOPPED
)
1280 signo
= tp
->pending_waitstatus ().sig ();
1282 signo
= GDB_SIGNAL_0
;
1285 signo
= tp
->stop_signal ();
1287 else if (!target_is_non_stop_p ())
1290 process_stratum_target
*last_target
;
1292 get_last_target_status (&last_target
, &last_ptid
, nullptr);
1294 if (last_target
== linux_target
1295 && lp
->ptid
.lwp () == last_ptid
.lwp ())
1296 signo
= tp
->stop_signal ();
1300 if (signo
== GDB_SIGNAL_0
)
1302 linux_nat_debug_printf ("lwp %s has no pending signal",
1303 lp
->ptid
.to_string ().c_str ());
1305 else if (!signal_pass_state (signo
))
1307 linux_nat_debug_printf
1308 ("lwp %s had signal %s but it is in no pass state",
1309 lp
->ptid
.to_string ().c_str (), gdb_signal_to_string (signo
));
1313 linux_nat_debug_printf ("lwp %s has pending signal %s",
1314 lp
->ptid
.to_string ().c_str (),
1315 gdb_signal_to_string (signo
));
1317 return gdb_signal_to_host (signo
);
1323 /* If LP has a pending fork/vfork/clone status, return it. */
1325 static std::optional
<target_waitstatus
>
1326 get_pending_child_status (lwp_info
*lp
)
1328 LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT
;
1330 linux_nat_debug_printf ("lwp %s (stopped = %d)",
1331 lp
->ptid
.to_string ().c_str (), lp
->stopped
);
1333 /* Check in lwp_info::status. */
1334 if (WIFSTOPPED (lp
->status
) && linux_is_extended_waitstatus (lp
->status
))
1336 int event
= linux_ptrace_get_extended_event (lp
->status
);
1338 if (event
== PTRACE_EVENT_FORK
1339 || event
== PTRACE_EVENT_VFORK
1340 || event
== PTRACE_EVENT_CLONE
)
1342 unsigned long child_pid
;
1343 int ret
= ptrace (PTRACE_GETEVENTMSG
, lp
->ptid
.lwp (), 0, &child_pid
);
1346 target_waitstatus ws
;
1348 if (event
== PTRACE_EVENT_FORK
)
1349 ws
.set_forked (ptid_t (child_pid
, child_pid
));
1350 else if (event
== PTRACE_EVENT_VFORK
)
1351 ws
.set_vforked (ptid_t (child_pid
, child_pid
));
1352 else if (event
== PTRACE_EVENT_CLONE
)
1353 ws
.set_thread_cloned (ptid_t (lp
->ptid
.pid (), child_pid
));
1355 gdb_assert_not_reached ("unhandled");
1361 perror_warning_with_name (_("Failed to retrieve event msg"));
1367 /* Check in lwp_info::waitstatus. */
1368 if (is_new_child_status (lp
->waitstatus
.kind ()))
1369 return lp
->waitstatus
;
1371 thread_info
*tp
= linux_target
->find_thread (lp
->ptid
);
1373 /* Check in thread_info::pending_waitstatus. */
1374 if (tp
->has_pending_waitstatus ()
1375 && is_new_child_status (tp
->pending_waitstatus ().kind ()))
1376 return tp
->pending_waitstatus ();
1378 /* Check in thread_info::pending_follow. */
1379 if (is_new_child_status (tp
->pending_follow
.kind ()))
1380 return tp
->pending_follow
;
1385 /* Detach from LP. If SIGNO_P is non-NULL, then it points to the
1386 signal number that should be passed to the LWP when detaching.
1387 Otherwise pass any pending signal the LWP may have, if any. */
1390 detach_one_lwp (struct lwp_info
*lp
, int *signo_p
)
1392 int lwpid
= lp
->ptid
.lwp ();
1395 /* If the lwp/thread we are about to detach has a pending fork/clone
1396 event, there is a process/thread GDB is attached to that the core
1397 of GDB doesn't know about. Detach from it. */
1399 std::optional
<target_waitstatus
> ws
= get_pending_child_status (lp
);
1400 if (ws
.has_value ())
1401 detach_one_pid (ws
->child_ptid ().lwp (), 0);
1403 /* If there is a pending SIGSTOP, get rid of it. */
1406 linux_nat_debug_printf ("Sending SIGCONT to %s",
1407 lp
->ptid
.to_string ().c_str ());
1409 kill_lwp (lwpid
, SIGCONT
);
1413 /* If the lwp has exited or was terminated due to a signal, there's
1414 nothing left to do. */
1415 if (lp
->waitstatus
.kind () == TARGET_WAITKIND_EXITED
1416 || lp
->waitstatus
.kind () == TARGET_WAITKIND_THREAD_EXITED
1417 || lp
->waitstatus
.kind () == TARGET_WAITKIND_SIGNALLED
)
1419 linux_nat_debug_printf
1420 ("Can't detach %s - it has exited or was terminated: %s.",
1421 lp
->ptid
.to_string ().c_str (),
1422 lp
->waitstatus
.to_string ().c_str ());
1423 delete_lwp (lp
->ptid
);
1427 if (signo_p
== NULL
)
1429 /* Pass on any pending signal for this LWP. */
1430 signo
= get_detach_signal (lp
);
1435 linux_nat_debug_printf ("preparing to resume lwp %s (stopped = %d)",
1436 lp
->ptid
.to_string ().c_str (),
1439 /* Preparing to resume may try to write registers, and fail if the
1440 lwp is zombie. If that happens, ignore the error. We'll handle
1441 it below, when detach fails with ESRCH. */
1444 linux_target
->low_prepare_to_resume (lp
);
1446 catch (const gdb_exception_error
&ex
)
1448 if (!check_ptrace_stopped_lwp_gone (lp
))
1452 detach_one_pid (lwpid
, signo
);
1454 delete_lwp (lp
->ptid
);
1458 detach_callback (struct lwp_info
*lp
)
1460 /* We don't actually detach from the thread group leader just yet.
1461 If the thread group exits, we must reap the zombie clone lwps
1462 before we're able to reap the leader. */
1463 if (lp
->ptid
.lwp () != lp
->ptid
.pid ())
1464 detach_one_lwp (lp
, NULL
);
1469 linux_nat_target::detach (inferior
*inf
, int from_tty
)
1471 LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT
;
1473 struct lwp_info
*main_lwp
;
1476 /* Don't unregister from the event loop, as there may be other
1477 inferiors running. */
1479 /* Stop all threads before detaching. ptrace requires that the
1480 thread is stopped to successfully detach. */
1481 iterate_over_lwps (ptid_t (pid
), stop_callback
);
1482 /* ... and wait until all of them have reported back that
1483 they're no longer running. */
1484 iterate_over_lwps (ptid_t (pid
), stop_wait_callback
);
1486 /* We can now safely remove breakpoints. We don't this in earlier
1487 in common code because this target doesn't currently support
1488 writing memory while the inferior is running. */
1489 remove_breakpoints_inf (current_inferior ());
1491 iterate_over_lwps (ptid_t (pid
), detach_callback
);
1493 /* We have detached from everything except the main thread now, so
1494 should only have one thread left. However, in non-stop mode the
1495 main thread might have exited, in which case we'll have no threads
1497 gdb_assert (num_lwps (pid
) == 1
1498 || (target_is_non_stop_p () && num_lwps (pid
) == 0));
1500 if (pid
== inferior_ptid
.pid () && forks_exist_p ())
1502 /* Multi-fork case. The current inferior_ptid is being detached
1503 from, but there are other viable forks to debug. Detach from
1504 the current fork, and context-switch to the first
1506 linux_fork_detach (from_tty
, find_lwp_pid (ptid_t (pid
)));
1510 target_announce_detach (from_tty
);
1512 /* In non-stop mode it is possible that the main thread has exited,
1513 in which case we don't try to detach. */
1514 main_lwp
= find_lwp_pid (ptid_t (pid
));
1515 if (main_lwp
!= nullptr)
1517 /* Pass on any pending signal for the last LWP. */
1518 int signo
= get_detach_signal (main_lwp
);
1520 detach_one_lwp (main_lwp
, &signo
);
1523 gdb_assert (target_is_non_stop_p ());
1525 detach_success (inf
);
1528 close_proc_mem_file (pid
);
1531 /* Resume execution of the inferior process. If STEP is nonzero,
1532 single-step it. If SIGNAL is nonzero, give it that signal. */
1535 linux_resume_one_lwp_throw (struct lwp_info
*lp
, int step
,
1536 enum gdb_signal signo
)
1540 /* stop_pc doubles as the PC the LWP had when it was last resumed.
1541 We only presently need that if the LWP is stepped though (to
1542 handle the case of stepping a breakpoint instruction). */
1545 struct regcache
*regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
1547 lp
->stop_pc
= regcache_read_pc (regcache
);
1552 linux_target
->low_prepare_to_resume (lp
);
1553 linux_target
->low_resume (lp
->ptid
, step
, signo
);
1555 /* Successfully resumed. Clear state that no longer makes sense,
1556 and mark the LWP as running. Must not do this before resuming
1557 otherwise if that fails other code will be confused. E.g., we'd
1558 later try to stop the LWP and hang forever waiting for a stop
1559 status. Note that we must not throw after this is cleared,
1560 otherwise handle_zombie_lwp_error would get confused. */
1563 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1564 registers_changed_ptid (linux_target
, lp
->ptid
);
1567 /* Called when we try to resume a stopped LWP and that errors out. If
1568 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
1569 or about to become), discard the error, clear any pending status
1570 the LWP may have, and return true (we'll collect the exit status
1571 soon enough). Otherwise, return false. */
1574 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
1576 /* If we get an error after resuming the LWP successfully, we'd
1577 confuse !T state for the LWP being gone. */
1578 gdb_assert (lp
->stopped
);
1580 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
1581 because even if ptrace failed with ESRCH, the tracee may be "not
1582 yet fully dead", but already refusing ptrace requests. In that
1583 case the tracee has 'R (Running)' state for a little bit
1584 (observed in Linux 3.18). See also the note on ESRCH in the
1585 ptrace(2) man page. Instead, check whether the LWP has any state
1586 other than ptrace-stopped. */
1588 /* Don't assume anything if /proc/PID/status can't be read. */
1589 if (linux_proc_pid_is_trace_stopped_nowarn (lp
->ptid
.lwp ()) == 0)
1591 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1593 lp
->waitstatus
.set_ignore ();
1599 /* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
1600 disappears while we try to resume it. */
1603 linux_resume_one_lwp (struct lwp_info
*lp
, int step
, enum gdb_signal signo
)
1607 linux_resume_one_lwp_throw (lp
, step
, signo
);
1609 catch (const gdb_exception_error
&ex
)
1611 if (!check_ptrace_stopped_lwp_gone (lp
))
1619 resume_lwp (struct lwp_info
*lp
, int step
, enum gdb_signal signo
)
1623 struct inferior
*inf
= find_inferior_ptid (linux_target
, lp
->ptid
);
1625 if (inf
->vfork_child
!= NULL
)
1627 linux_nat_debug_printf ("Not resuming sibling %s (vfork parent)",
1628 lp
->ptid
.to_string ().c_str ());
1630 else if (!lwp_status_pending_p (lp
))
1632 linux_nat_debug_printf ("Resuming sibling %s, %s, %s",
1633 lp
->ptid
.to_string ().c_str (),
1634 (signo
!= GDB_SIGNAL_0
1635 ? strsignal (gdb_signal_to_host (signo
))
1637 step
? "step" : "resume");
1639 linux_resume_one_lwp (lp
, step
, signo
);
1643 linux_nat_debug_printf ("Not resuming sibling %s (has pending)",
1644 lp
->ptid
.to_string ().c_str ());
1648 linux_nat_debug_printf ("Not resuming sibling %s (not stopped)",
1649 lp
->ptid
.to_string ().c_str ());
1652 /* Callback for iterate_over_lwps. If LWP is EXCEPT, do nothing.
1653 Resume LWP with the last stop signal, if it is in pass state. */
1656 linux_nat_resume_callback (struct lwp_info
*lp
, struct lwp_info
*except
)
1658 enum gdb_signal signo
= GDB_SIGNAL_0
;
1665 struct thread_info
*thread
;
1667 thread
= linux_target
->find_thread (lp
->ptid
);
1670 signo
= thread
->stop_signal ();
1671 thread
->set_stop_signal (GDB_SIGNAL_0
);
1675 resume_lwp (lp
, 0, signo
);
1680 resume_clear_callback (struct lwp_info
*lp
)
1683 lp
->last_resume_kind
= resume_stop
;
1688 resume_set_callback (struct lwp_info
*lp
)
1691 lp
->last_resume_kind
= resume_continue
;
1696 linux_nat_target::resume (ptid_t scope_ptid
, int step
, enum gdb_signal signo
)
1698 struct lwp_info
*lp
;
1700 linux_nat_debug_printf ("Preparing to %s %s, %s, inferior_ptid %s",
1701 step
? "step" : "resume",
1702 scope_ptid
.to_string ().c_str (),
1703 (signo
!= GDB_SIGNAL_0
1704 ? strsignal (gdb_signal_to_host (signo
)) : "0"),
1705 inferior_ptid
.to_string ().c_str ());
1707 /* Mark the lwps we're resuming as resumed and update their
1708 last_resume_kind to resume_continue. */
1709 iterate_over_lwps (scope_ptid
, resume_set_callback
);
1711 lp
= find_lwp_pid (inferior_ptid
);
1712 gdb_assert (lp
!= NULL
);
1714 /* Remember if we're stepping. */
1715 lp
->last_resume_kind
= step
? resume_step
: resume_continue
;
1717 /* If we have a pending wait status for this thread, there is no
1718 point in resuming the process. But first make sure that
1719 linux_nat_wait won't preemptively handle the event - we
1720 should never take this short-circuit if we are going to
1721 leave LP running, since we have skipped resuming all the
1722 other threads. This bit of code needs to be synchronized
1723 with linux_nat_wait. */
1725 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1728 && WSTOPSIG (lp
->status
)
1729 && sigismember (&pass_mask
, WSTOPSIG (lp
->status
)))
1731 linux_nat_debug_printf
1732 ("Not short circuiting for ignored status 0x%x", lp
->status
);
1734 /* FIXME: What should we do if we are supposed to continue
1735 this thread with a signal? */
1736 gdb_assert (signo
== GDB_SIGNAL_0
);
1737 signo
= gdb_signal_from_host (WSTOPSIG (lp
->status
));
1742 if (lwp_status_pending_p (lp
))
1744 /* FIXME: What should we do if we are supposed to continue
1745 this thread with a signal? */
1746 gdb_assert (signo
== GDB_SIGNAL_0
);
1748 linux_nat_debug_printf ("Short circuiting for status %s",
1749 pending_status_str (lp
).c_str ());
1751 if (target_can_async_p ())
1753 target_async (true);
1754 /* Tell the event loop we have something to process. */
1760 /* No use iterating unless we're resuming other threads. */
1761 if (scope_ptid
!= lp
->ptid
)
1762 iterate_over_lwps (scope_ptid
, [=] (struct lwp_info
*info
)
1764 return linux_nat_resume_callback (info
, lp
);
1767 linux_nat_debug_printf ("%s %s, %s (resume event thread)",
1768 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1769 lp
->ptid
.to_string ().c_str (),
1770 (signo
!= GDB_SIGNAL_0
1771 ? strsignal (gdb_signal_to_host (signo
)) : "0"));
1773 linux_resume_one_lwp (lp
, step
, signo
);
1776 /* Send a signal to an LWP. */
1779 kill_lwp (int lwpid
, int signo
)
1784 ret
= syscall (__NR_tkill
, lwpid
, signo
);
1785 if (errno
== ENOSYS
)
1787 /* If tkill fails, then we are not using nptl threads, a
1788 configuration we no longer support. */
1789 perror_with_name (("tkill"));
1794 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
1795 event, check if the core is interested in it: if not, ignore the
1796 event, and keep waiting; otherwise, we need to toggle the LWP's
1797 syscall entry/exit status, since the ptrace event itself doesn't
1798 indicate it, and report the trap to higher layers. */
1801 linux_handle_syscall_trap (struct lwp_info
*lp
, int stopping
)
1803 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1804 struct gdbarch
*gdbarch
= target_thread_architecture (lp
->ptid
);
1805 thread_info
*thread
= linux_target
->find_thread (lp
->ptid
);
1806 int syscall_number
= (int) gdbarch_get_syscall_number (gdbarch
, thread
);
1810 /* If we're stopping threads, there's a SIGSTOP pending, which
1811 makes it so that the LWP reports an immediate syscall return,
1812 followed by the SIGSTOP. Skip seeing that "return" using
1813 PTRACE_CONT directly, and let stop_wait_callback collect the
1814 SIGSTOP. Later when the thread is resumed, a new syscall
1815 entry event. If we didn't do this (and returned 0), we'd
1816 leave a syscall entry pending, and our caller, by using
1817 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1818 itself. Later, when the user re-resumes this LWP, we'd see
1819 another syscall entry event and we'd mistake it for a return.
1821 If stop_wait_callback didn't force the SIGSTOP out of the LWP
1822 (leaving immediately with LWP->signalled set, without issuing
1823 a PTRACE_CONT), it would still be problematic to leave this
1824 syscall enter pending, as later when the thread is resumed,
1825 it would then see the same syscall exit mentioned above,
1826 followed by the delayed SIGSTOP, while the syscall didn't
1827 actually get to execute. It seems it would be even more
1828 confusing to the user. */
1830 linux_nat_debug_printf
1831 ("ignoring syscall %d for LWP %ld (stopping threads), resuming with "
1832 "PTRACE_CONT for SIGSTOP", syscall_number
, lp
->ptid
.lwp ());
1834 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
1835 ptrace (PTRACE_CONT
, lp
->ptid
.lwp (), 0, 0);
1840 /* Always update the entry/return state, even if this particular
1841 syscall isn't interesting to the core now. In async mode,
1842 the user could install a new catchpoint for this syscall
1843 between syscall enter/return, and we'll need to know to
1844 report a syscall return if that happens. */
1845 lp
->syscall_state
= (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
1846 ? TARGET_WAITKIND_SYSCALL_RETURN
1847 : TARGET_WAITKIND_SYSCALL_ENTRY
);
1849 if (catch_syscall_enabled ())
1851 if (catching_syscall_number (syscall_number
))
1853 /* Alright, an event to report. */
1854 if (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
)
1855 ourstatus
->set_syscall_entry (syscall_number
);
1856 else if (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_RETURN
)
1857 ourstatus
->set_syscall_return (syscall_number
);
1859 gdb_assert_not_reached ("unexpected syscall state");
1861 linux_nat_debug_printf
1862 ("stopping for %s of syscall %d for LWP %ld",
1863 (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
1864 ? "entry" : "return"), syscall_number
, lp
->ptid
.lwp ());
1869 linux_nat_debug_printf
1870 ("ignoring %s of syscall %d for LWP %ld",
1871 (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
1872 ? "entry" : "return"), syscall_number
, lp
->ptid
.lwp ());
1876 /* If we had been syscall tracing, and hence used PT_SYSCALL
1877 before on this LWP, it could happen that the user removes all
1878 syscall catchpoints before we get to process this event.
1879 There are two noteworthy issues here:
1881 - When stopped at a syscall entry event, resuming with
1882 PT_STEP still resumes executing the syscall and reports a
1885 - Only PT_SYSCALL catches syscall enters. If we last
1886 single-stepped this thread, then this event can't be a
1887 syscall enter. If we last single-stepped this thread, this
1888 has to be a syscall exit.
1890 The points above mean that the next resume, be it PT_STEP or
1891 PT_CONTINUE, can not trigger a syscall trace event. */
1892 linux_nat_debug_printf
1893 ("caught syscall event with no syscall catchpoints. %d for LWP %ld, "
1894 "ignoring", syscall_number
, lp
->ptid
.lwp ());
1895 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
1898 /* The core isn't interested in this event. For efficiency, avoid
1899 stopping all threads only to have the core resume them all again.
1900 Since we're not stopping threads, if we're still syscall tracing
1901 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1902 subsequent syscall. Simply resume using the inf-ptrace layer,
1903 which knows when to use PT_SYSCALL or PT_CONTINUE. */
1905 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
1912 linux_nat_target::follow_clone (ptid_t child_ptid
)
1914 lwp_info
*new_lp
= add_lwp (child_ptid
);
1915 new_lp
->stopped
= 1;
1917 /* If the thread_db layer is active, let it record the user
1918 level thread id and status, and add the thread to GDB's
1920 if (!thread_db_notice_clone (inferior_ptid
, new_lp
->ptid
))
1922 /* The process is not using thread_db. Add the LWP to
1924 add_thread (linux_target
, new_lp
->ptid
);
1927 /* We just created NEW_LP so it cannot yet contain STATUS. */
1928 gdb_assert (new_lp
->status
== 0);
1930 if (!pull_pid_from_list (&stopped_pids
, child_ptid
.lwp (), &new_lp
->status
))
1931 internal_error (_("no saved status for clone lwp"));
1933 if (WSTOPSIG (new_lp
->status
) != SIGSTOP
)
1935 /* This can happen if someone starts sending signals to
1936 the new thread before it gets a chance to run, which
1937 have a lower number than SIGSTOP (e.g. SIGUSR1).
1938 This is an unlikely case, and harder to handle for
1939 fork / vfork than for clone, so we do not try - but
1940 we handle it for clone events here. */
1942 new_lp
->signalled
= 1;
1944 /* Save the wait status to report later. */
1945 linux_nat_debug_printf
1946 ("waitpid of new LWP %ld, saving status %s",
1947 (long) new_lp
->ptid
.lwp (), status_to_str (new_lp
->status
).c_str ());
1953 if (report_thread_events
)
1954 new_lp
->waitstatus
.set_thread_created ();
1958 /* Handle a GNU/Linux extended wait response. If we see a clone
1959 event, we need to add the new LWP to our list (and not report the
1960 trap to higher layers). This function returns non-zero if the
1961 event should be ignored and we should wait again. If STOPPING is
1962 true, the new LWP remains stopped, otherwise it is continued. */
1965 linux_handle_extended_wait (struct lwp_info
*lp
, int status
)
1967 int pid
= lp
->ptid
.lwp ();
1968 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1969 int event
= linux_ptrace_get_extended_event (status
);
1971 /* All extended events we currently use are mid-syscall. Only
1972 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
1973 you have to be using PTRACE_SEIZE to get that. */
1974 lp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1976 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1977 || event
== PTRACE_EVENT_CLONE
)
1979 unsigned long new_pid
;
1982 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1984 /* If we haven't already seen the new PID stop, wait for it now. */
1985 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1987 /* The new child has a pending SIGSTOP. We can't affect it until it
1988 hits the SIGSTOP, but we're already attached. */
1989 ret
= my_waitpid (new_pid
, &status
, __WALL
);
1991 perror_with_name (_("waiting for new child"));
1992 else if (ret
!= new_pid
)
1993 internal_error (_("wait returned unexpected PID %d"), ret
);
1994 else if (!WIFSTOPPED (status
))
1995 internal_error (_("wait returned unexpected status 0x%x"), status
);
1998 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
)
2000 open_proc_mem_file (ptid_t (new_pid
, new_pid
));
2002 /* The arch-specific native code may need to know about new
2003 forks even if those end up never mapped to an
2005 linux_target
->low_new_fork (lp
, new_pid
);
2007 else if (event
== PTRACE_EVENT_CLONE
)
2009 linux_target
->low_new_clone (lp
, new_pid
);
2012 if (event
== PTRACE_EVENT_FORK
2013 && linux_fork_checkpointing_p (lp
->ptid
.pid ()))
2015 /* Handle checkpointing by linux-fork.c here as a special
2016 case. We don't want the follow-fork-mode or 'catch fork'
2017 to interfere with this. */
2019 /* This won't actually modify the breakpoint list, but will
2020 physically remove the breakpoints from the child. */
2021 detach_breakpoints (ptid_t (new_pid
, new_pid
));
2023 /* Retain child fork in ptrace (stopped) state. */
2024 if (!find_fork_pid (new_pid
))
2027 /* Report as spurious, so that infrun doesn't want to follow
2028 this fork. We're actually doing an infcall in
2030 ourstatus
->set_spurious ();
2032 /* Report the stop to the core. */
2036 if (event
== PTRACE_EVENT_FORK
)
2037 ourstatus
->set_forked (ptid_t (new_pid
, new_pid
));
2038 else if (event
== PTRACE_EVENT_VFORK
)
2039 ourstatus
->set_vforked (ptid_t (new_pid
, new_pid
));
2040 else if (event
== PTRACE_EVENT_CLONE
)
2042 linux_nat_debug_printf
2043 ("Got clone event from LWP %d, new child is LWP %ld", pid
, new_pid
);
2045 /* Save the status again, we'll use it in follow_clone. */
2046 add_to_pid_list (&stopped_pids
, new_pid
, status
);
2048 ourstatus
->set_thread_cloned (ptid_t (lp
->ptid
.pid (), new_pid
));
2054 if (event
== PTRACE_EVENT_EXEC
)
2056 linux_nat_debug_printf ("Got exec event from LWP %ld", lp
->ptid
.lwp ());
2058 /* Close the previous /proc/PID/mem file for this inferior,
2059 which was using the address space which is now gone.
2060 Reading/writing from this file would return 0/EOF. */
2061 close_proc_mem_file (lp
->ptid
.pid ());
2063 /* Open a new file for the new address space. */
2064 open_proc_mem_file (lp
->ptid
);
2066 ourstatus
->set_execd
2067 (make_unique_xstrdup (linux_proc_pid_to_exec_file (pid
)));
2069 /* The thread that execed must have been resumed, but, when a
2070 thread execs, it changes its tid to the tgid, and the old
2071 tgid thread might have not been resumed. */
2074 /* All other LWPs are gone now. We'll have received a thread
2075 exit notification for all threads other the execing one.
2076 That one, if it wasn't the leader, just silently changes its
2077 tid to the tgid, and the previous leader vanishes. Since
2078 Linux 3.0, the former thread ID can be retrieved with
2079 PTRACE_GETEVENTMSG, but since we support older kernels, don't
2080 bother with it, and just walk the LWP list. Even with
2081 PTRACE_GETEVENTMSG, we'd still need to lookup the
2082 corresponding LWP object, and it would be an extra ptrace
2083 syscall, so this way may even be more efficient. */
2084 for (lwp_info
*other_lp
: all_lwps_safe ())
2085 if (other_lp
!= lp
&& other_lp
->ptid
.pid () == lp
->ptid
.pid ())
2086 exit_lwp (other_lp
);
2091 if (event
== PTRACE_EVENT_VFORK_DONE
)
2093 linux_nat_debug_printf
2094 ("Got PTRACE_EVENT_VFORK_DONE from LWP %ld",
2096 ourstatus
->set_vfork_done ();
2100 internal_error (_("unknown ptrace event %d"), event
);
2103 /* Suspend waiting for a signal. We're mostly interested in
2109 linux_nat_debug_printf ("about to sigsuspend");
2110 sigsuspend (&suspend_mask
);
2112 /* If the quit flag is set, it means that the user pressed Ctrl-C
2113 and we're debugging a process that is running on a separate
2114 terminal, so we must forward the Ctrl-C to the inferior. (If the
2115 inferior is sharing GDB's terminal, then the Ctrl-C reaches the
2116 inferior directly.) We must do this here because functions that
2117 need to block waiting for a signal loop forever until there's an
2118 event to report before returning back to the event loop. */
2119 if (!target_terminal::is_ours ())
2121 if (check_quit_flag ())
2122 target_pass_ctrlc ();
2126 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2130 wait_lwp (struct lwp_info
*lp
)
2134 int thread_dead
= 0;
2137 gdb_assert (!lp
->stopped
);
2138 gdb_assert (lp
->status
== 0);
2140 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2141 block_child_signals (&prev_mask
);
2145 pid
= my_waitpid (lp
->ptid
.lwp (), &status
, __WALL
| WNOHANG
);
2146 if (pid
== -1 && errno
== ECHILD
)
2148 /* The thread has previously exited. We need to delete it
2149 now because if this was a non-leader thread execing, we
2150 won't get an exit event. See comments on exec events at
2151 the top of the file. */
2153 linux_nat_debug_printf ("%s vanished.",
2154 lp
->ptid
.to_string ().c_str ());
2159 /* Bugs 10970, 12702.
2160 Thread group leader may have exited in which case we'll lock up in
2161 waitpid if there are other threads, even if they are all zombies too.
2162 Basically, we're not supposed to use waitpid this way.
2163 tkill(pid,0) cannot be used here as it gets ESRCH for both
2164 for zombie and running processes.
2166 As a workaround, check if we're waiting for the thread group leader and
2167 if it's a zombie, and avoid calling waitpid if it is.
2169 This is racy, what if the tgl becomes a zombie right after we check?
2170 Therefore always use WNOHANG with sigsuspend - it is equivalent to
2171 waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
2173 if (lp
->ptid
.pid () == lp
->ptid
.lwp ()
2174 && linux_proc_pid_is_zombie (lp
->ptid
.lwp ()))
2177 linux_nat_debug_printf ("Thread group leader %s vanished.",
2178 lp
->ptid
.to_string ().c_str ());
2182 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2183 get invoked despite our caller had them intentionally blocked by
2184 block_child_signals. This is sensitive only to the loop of
2185 linux_nat_wait_1 and there if we get called my_waitpid gets called
2186 again before it gets to sigsuspend so we can safely let the handlers
2187 get executed here. */
2191 restore_child_signals_mask (&prev_mask
);
2195 gdb_assert (pid
== lp
->ptid
.lwp ());
2197 linux_nat_debug_printf ("waitpid %s received %s",
2198 lp
->ptid
.to_string ().c_str (),
2199 status_to_str (status
).c_str ());
2201 /* Check if the thread has exited. */
2202 if (WIFEXITED (status
) || WIFSIGNALED (status
))
2204 if (report_exit_events_for (lp
) || is_leader (lp
))
2206 linux_nat_debug_printf ("LWP %d exited.", lp
->ptid
.pid ());
2208 /* If this is the leader exiting, it means the whole
2209 process is gone. Store the status to report to the
2210 core. Store it in lp->waitstatus, because lp->status
2211 would be ambiguous (W_EXITCODE(0,0) == 0). */
2212 lp
->waitstatus
= host_status_to_waitstatus (status
);
2217 linux_nat_debug_printf ("%s exited.",
2218 lp
->ptid
.to_string ().c_str ());
2228 gdb_assert (WIFSTOPPED (status
));
2231 if (lp
->must_set_ptrace_flags
)
2233 inferior
*inf
= find_inferior_pid (linux_target
, lp
->ptid
.pid ());
2234 int options
= linux_nat_ptrace_options (inf
->attach_flag
);
2236 linux_enable_event_reporting (lp
->ptid
.lwp (), options
);
2237 lp
->must_set_ptrace_flags
= 0;
2240 /* Handle GNU/Linux's syscall SIGTRAPs. */
2241 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
2243 /* No longer need the sysgood bit. The ptrace event ends up
2244 recorded in lp->waitstatus if we care for it. We can carry
2245 on handling the event like a regular SIGTRAP from here
2247 status
= W_STOPCODE (SIGTRAP
);
2248 if (linux_handle_syscall_trap (lp
, 1))
2249 return wait_lwp (lp
);
2253 /* Almost all other ptrace-stops are known to be outside of system
2254 calls, with further exceptions in linux_handle_extended_wait. */
2255 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2258 /* Handle GNU/Linux's extended waitstatus for trace events. */
2259 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
2260 && linux_is_extended_waitstatus (status
))
2262 linux_nat_debug_printf ("Handling extended status 0x%06x", status
);
2263 linux_handle_extended_wait (lp
, status
);
2270 /* Send a SIGSTOP to LP. */
2273 stop_callback (struct lwp_info
*lp
)
2275 if (!lp
->stopped
&& !lp
->signalled
)
2279 linux_nat_debug_printf ("kill %s **<SIGSTOP>**",
2280 lp
->ptid
.to_string ().c_str ());
2283 ret
= kill_lwp (lp
->ptid
.lwp (), SIGSTOP
);
2284 linux_nat_debug_printf ("lwp kill %d %s", ret
,
2285 errno
? safe_strerror (errno
) : "ERRNO-OK");
2288 gdb_assert (lp
->status
== 0);
2294 /* Request a stop on LWP. */
2297 linux_stop_lwp (struct lwp_info
*lwp
)
2299 stop_callback (lwp
);
2302 /* See linux-nat.h */
2305 linux_stop_and_wait_all_lwps (void)
2307 /* Stop all LWP's ... */
2308 iterate_over_lwps (minus_one_ptid
, stop_callback
);
2310 /* ... and wait until all of them have reported back that
2311 they're no longer running. */
2312 iterate_over_lwps (minus_one_ptid
, stop_wait_callback
);
2315 /* See linux-nat.h */
2318 linux_unstop_all_lwps (void)
2320 iterate_over_lwps (minus_one_ptid
,
2321 [] (struct lwp_info
*info
)
2323 return resume_stopped_resumed_lwps (info
, minus_one_ptid
);
2327 /* Return non-zero if LWP PID has a pending SIGINT. */
2330 linux_nat_has_pending_sigint (int pid
)
2332 sigset_t pending
, blocked
, ignored
;
2334 linux_proc_pending_signals (pid
, &pending
, &blocked
, &ignored
);
2336 if (sigismember (&pending
, SIGINT
)
2337 && !sigismember (&ignored
, SIGINT
))
2343 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2346 set_ignore_sigint (struct lwp_info
*lp
)
2348 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2349 flag to consume the next one. */
2350 if (lp
->stopped
&& lp
->status
!= 0 && WIFSTOPPED (lp
->status
)
2351 && WSTOPSIG (lp
->status
) == SIGINT
)
2354 lp
->ignore_sigint
= 1;
2359 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2360 This function is called after we know the LWP has stopped; if the LWP
2361 stopped before the expected SIGINT was delivered, then it will never have
2362 arrived. Also, if the signal was delivered to a shared queue and consumed
2363 by a different thread, it will never be delivered to this LWP. */
2366 maybe_clear_ignore_sigint (struct lwp_info
*lp
)
2368 if (!lp
->ignore_sigint
)
2371 if (!linux_nat_has_pending_sigint (lp
->ptid
.lwp ()))
2373 linux_nat_debug_printf ("Clearing bogus flag for %s",
2374 lp
->ptid
.to_string ().c_str ());
2375 lp
->ignore_sigint
= 0;
2379 /* Fetch the possible triggered data watchpoint info and store it in
2382 On some archs, like x86, that use debug registers to set
2383 watchpoints, it's possible that the way to know which watched
2384 address trapped, is to check the register that is used to select
2385 which address to watch. Problem is, between setting the watchpoint
2386 and reading back which data address trapped, the user may change
2387 the set of watchpoints, and, as a consequence, GDB changes the
2388 debug registers in the inferior. To avoid reading back a stale
2389 stopped-data-address when that happens, we cache in LP the fact
2390 that a watchpoint trapped, and the corresponding data address, as
2391 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2392 registers meanwhile, we have the cached data we can rely on. */
2395 check_stopped_by_watchpoint (struct lwp_info
*lp
)
2397 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
2398 inferior_ptid
= lp
->ptid
;
2400 if (linux_target
->low_stopped_by_watchpoint ())
2402 lp
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
2403 lp
->stopped_data_address_p
2404 = linux_target
->low_stopped_data_address (&lp
->stopped_data_address
);
2407 return lp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2410 /* Returns true if the LWP had stopped for a watchpoint. */
2413 linux_nat_target::stopped_by_watchpoint ()
2415 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2417 gdb_assert (lp
!= NULL
);
2419 return lp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2423 linux_nat_target::stopped_data_address (CORE_ADDR
*addr_p
)
2425 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2427 gdb_assert (lp
!= NULL
);
2429 *addr_p
= lp
->stopped_data_address
;
2431 return lp
->stopped_data_address_p
;
2434 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2437 linux_nat_target::low_status_is_event (int status
)
2439 return WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
;
2442 /* Wait until LP is stopped. */
2445 stop_wait_callback (struct lwp_info
*lp
)
2447 inferior
*inf
= find_inferior_ptid (linux_target
, lp
->ptid
);
2449 /* If this is a vfork parent, bail out, it is not going to report
2450 any SIGSTOP until the vfork is done with. */
2451 if (inf
->vfork_child
!= NULL
)
2458 status
= wait_lwp (lp
);
2462 if (lp
->ignore_sigint
&& WIFSTOPPED (status
)
2463 && WSTOPSIG (status
) == SIGINT
)
2465 lp
->ignore_sigint
= 0;
2468 ptrace (PTRACE_CONT
, lp
->ptid
.lwp (), 0, 0);
2470 linux_nat_debug_printf
2471 ("PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)",
2472 lp
->ptid
.to_string ().c_str (),
2473 errno
? safe_strerror (errno
) : "OK");
2475 return stop_wait_callback (lp
);
2478 maybe_clear_ignore_sigint (lp
);
2480 if (WSTOPSIG (status
) != SIGSTOP
)
2482 /* The thread was stopped with a signal other than SIGSTOP. */
2484 linux_nat_debug_printf ("Pending event %s in %s",
2485 status_to_str ((int) status
).c_str (),
2486 lp
->ptid
.to_string ().c_str ());
2488 /* Save the sigtrap event. */
2489 lp
->status
= status
;
2490 gdb_assert (lp
->signalled
);
2491 save_stop_reason (lp
);
2495 /* We caught the SIGSTOP that we intended to catch. */
2497 linux_nat_debug_printf ("Expected SIGSTOP caught for %s.",
2498 lp
->ptid
.to_string ().c_str ());
2502 /* If we are waiting for this stop so we can report the thread
2503 stopped then we need to record this status. Otherwise, we can
2504 now discard this stop event. */
2505 if (lp
->last_resume_kind
== resume_stop
)
2507 lp
->status
= status
;
2508 save_stop_reason (lp
);
2516 /* Get the inferior associated to LWP. Must be called with an LWP that has
2517 an associated inferior. Always return non-nullptr. */
2520 lwp_inferior (const lwp_info
*lwp
)
2522 inferior
*inf
= find_inferior_ptid (linux_target
, lwp
->ptid
);
2523 gdb_assert (inf
!= nullptr);
2527 /* Return non-zero if LP has a wait status pending. Discard the
2528 pending event and resume the LWP if the event that originally
2529 caused the stop became uninteresting. */
2532 status_callback (struct lwp_info
*lp
)
2534 /* Only report a pending wait status if we pretend that this has
2535 indeed been resumed. */
2539 if (!lwp_status_pending_p (lp
))
2542 if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
2543 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
2545 struct regcache
*regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
2549 pc
= regcache_read_pc (regcache
);
2551 if (pc
!= lp
->stop_pc
)
2553 linux_nat_debug_printf ("PC of %s changed. was=%s, now=%s",
2554 lp
->ptid
.to_string ().c_str (),
2555 paddress (current_inferior ()->arch (),
2557 paddress (current_inferior ()->arch (), pc
));
2561 #if !USE_SIGTRAP_SIGINFO
2562 else if (!breakpoint_inserted_here_p (lwp_inferior (lp
)->aspace
, pc
))
2564 linux_nat_debug_printf ("previous breakpoint of %s, at %s gone",
2565 lp
->ptid
.to_string ().c_str (),
2566 paddress (current_inferior ()->arch (),
2575 linux_nat_debug_printf ("pending event of %s cancelled.",
2576 lp
->ptid
.to_string ().c_str ());
2579 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
2587 /* Count the LWP's that have had events. */
2590 count_events_callback (struct lwp_info
*lp
, int *count
)
2592 gdb_assert (count
!= NULL
);
2594 /* Select only resumed LWPs that have an event pending. */
2595 if (lp
->resumed
&& lwp_status_pending_p (lp
))
2601 /* Select the LWP (if any) that is currently being single-stepped. */
2604 select_singlestep_lwp_callback (struct lwp_info
*lp
)
2606 if (lp
->last_resume_kind
== resume_step
2613 /* Returns true if LP has a status pending. */
2616 lwp_status_pending_p (struct lwp_info
*lp
)
2618 /* We check for lp->waitstatus in addition to lp->status, because we
2619 can have pending process exits recorded in lp->status and
2620 W_EXITCODE(0,0) happens to be 0. */
2621 return lp
->status
!= 0 || lp
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
;
2624 /* Select the Nth LWP that has had an event. */
2627 select_event_lwp_callback (struct lwp_info
*lp
, int *selector
)
2629 gdb_assert (selector
!= NULL
);
2631 /* Select only resumed LWPs that have an event pending. */
2632 if (lp
->resumed
&& lwp_status_pending_p (lp
))
2633 if ((*selector
)-- == 0)
2639 /* Called when the LWP stopped for a signal/trap. If it stopped for a
2640 trap check what caused it (breakpoint, watchpoint, trace, etc.),
2641 and save the result in the LWP's stop_reason field. If it stopped
2642 for a breakpoint, decrement the PC if necessary on the lwp's
2646 save_stop_reason (struct lwp_info
*lp
)
2648 struct regcache
*regcache
;
2649 struct gdbarch
*gdbarch
;
2652 #if USE_SIGTRAP_SIGINFO
2656 gdb_assert (lp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
);
2657 gdb_assert (lp
->status
!= 0);
2659 if (!linux_target
->low_status_is_event (lp
->status
))
2662 inferior
*inf
= lwp_inferior (lp
);
2663 if (inf
->starting_up
)
2666 regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
2667 gdbarch
= regcache
->arch ();
2669 pc
= regcache_read_pc (regcache
);
2670 sw_bp_pc
= pc
- gdbarch_decr_pc_after_break (gdbarch
);
2672 #if USE_SIGTRAP_SIGINFO
2673 if (linux_nat_get_siginfo (lp
->ptid
, &siginfo
))
2675 if (siginfo
.si_signo
== SIGTRAP
)
2677 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
)
2678 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
2680 /* The si_code is ambiguous on this arch -- check debug
2682 if (!check_stopped_by_watchpoint (lp
))
2683 lp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
2685 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
))
2687 /* If we determine the LWP stopped for a SW breakpoint,
2688 trust it. Particularly don't check watchpoint
2689 registers, because, at least on s390, we'd find
2690 stopped-by-watchpoint as long as there's a watchpoint
2692 lp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
2694 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
2696 /* This can indicate either a hardware breakpoint or
2697 hardware watchpoint. Check debug registers. */
2698 if (!check_stopped_by_watchpoint (lp
))
2699 lp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
2701 else if (siginfo
.si_code
== TRAP_TRACE
)
2703 linux_nat_debug_printf ("%s stopped by trace",
2704 lp
->ptid
.to_string ().c_str ());
2706 /* We may have single stepped an instruction that
2707 triggered a watchpoint. In that case, on some
2708 architectures (such as x86), instead of TRAP_HWBKPT,
2709 si_code indicates TRAP_TRACE, and we need to check
2710 the debug registers separately. */
2711 check_stopped_by_watchpoint (lp
);
2716 if ((!lp
->step
|| lp
->stop_pc
== sw_bp_pc
)
2717 && software_breakpoint_inserted_here_p (inf
->aspace
, sw_bp_pc
))
2719 /* The LWP was either continued, or stepped a software
2720 breakpoint instruction. */
2721 lp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
2724 if (hardware_breakpoint_inserted_here_p (inf
->aspace
, pc
))
2725 lp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
2727 if (lp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
)
2728 check_stopped_by_watchpoint (lp
);
2731 if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
)
2733 linux_nat_debug_printf ("%s stopped by software breakpoint",
2734 lp
->ptid
.to_string ().c_str ());
2736 /* Back up the PC if necessary. */
2738 regcache_write_pc (regcache
, sw_bp_pc
);
2740 /* Update this so we record the correct stop PC below. */
2743 else if (lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
2745 linux_nat_debug_printf ("%s stopped by hardware breakpoint",
2746 lp
->ptid
.to_string ().c_str ());
2748 else if (lp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
2750 linux_nat_debug_printf ("%s stopped by hardware watchpoint",
2751 lp
->ptid
.to_string ().c_str ());
2758 /* Returns true if the LWP had stopped for a software breakpoint. */
2761 linux_nat_target::stopped_by_sw_breakpoint ()
2763 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2765 gdb_assert (lp
!= NULL
);
2767 return lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
2770 /* Implement the supports_stopped_by_sw_breakpoint method. */
2773 linux_nat_target::supports_stopped_by_sw_breakpoint ()
2775 return USE_SIGTRAP_SIGINFO
;
2778 /* Returns true if the LWP had stopped for a hardware
2779 breakpoint/watchpoint. */
2782 linux_nat_target::stopped_by_hw_breakpoint ()
2784 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2786 gdb_assert (lp
!= NULL
);
2788 return lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
2791 /* Implement the supports_stopped_by_hw_breakpoint method. */
2794 linux_nat_target::supports_stopped_by_hw_breakpoint ()
2796 return USE_SIGTRAP_SIGINFO
;
2799 /* Select one LWP out of those that have events pending. */
2802 select_event_lwp (ptid_t filter
, struct lwp_info
**orig_lp
, int *status
)
2805 int random_selector
;
2806 struct lwp_info
*event_lp
= NULL
;
2808 /* Record the wait status for the original LWP. */
2809 (*orig_lp
)->status
= *status
;
2811 /* In all-stop, give preference to the LWP that is being
2812 single-stepped. There will be at most one, and it will be the
2813 LWP that the core is most interested in. If we didn't do this,
2814 then we'd have to handle pending step SIGTRAPs somehow in case
2815 the core later continues the previously-stepped thread, as
2816 otherwise we'd report the pending SIGTRAP then, and the core, not
2817 having stepped the thread, wouldn't understand what the trap was
2818 for, and therefore would report it to the user as a random
2820 if (!target_is_non_stop_p ())
2822 event_lp
= iterate_over_lwps (filter
, select_singlestep_lwp_callback
);
2823 if (event_lp
!= NULL
)
2825 linux_nat_debug_printf ("Select single-step %s",
2826 event_lp
->ptid
.to_string ().c_str ());
2830 if (event_lp
== NULL
)
2832 /* Pick one at random, out of those which have had events. */
2834 /* First see how many events we have. */
2835 iterate_over_lwps (filter
,
2836 [&] (struct lwp_info
*info
)
2838 return count_events_callback (info
, &num_events
);
2840 gdb_assert (num_events
> 0);
2842 /* Now randomly pick a LWP out of those that have had
2844 random_selector
= (int)
2845 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2848 linux_nat_debug_printf ("Found %d events, selecting #%d",
2849 num_events
, random_selector
);
2852 = (iterate_over_lwps
2854 [&] (struct lwp_info
*info
)
2856 return select_event_lwp_callback (info
,
2861 if (event_lp
!= NULL
)
2863 /* Switch the event LWP. */
2864 *orig_lp
= event_lp
;
2865 *status
= event_lp
->status
;
2868 /* Flush the wait status for the event LWP. */
2869 (*orig_lp
)->status
= 0;
2872 /* Return non-zero if LP has been resumed. */
2875 resumed_callback (struct lwp_info
*lp
)
2880 /* Check if we should go on and pass this event to common code.
2882 If so, save the status to the lwp_info structure associated to LWPID. */
2885 linux_nat_filter_event (int lwpid
, int status
)
2887 struct lwp_info
*lp
;
2888 int event
= linux_ptrace_get_extended_event (status
);
2890 lp
= find_lwp_pid (ptid_t (lwpid
));
2892 /* Check for events reported by anything not in our LWP list. */
2895 if (WIFSTOPPED (status
))
2897 if (WSTOPSIG (status
) == SIGTRAP
&& event
== PTRACE_EVENT_EXEC
)
2899 /* A non-leader thread exec'ed after we've seen the
2900 leader zombie, and removed it from our lists (in
2901 check_zombie_leaders). The non-leader thread changes
2902 its tid to the tgid. */
2903 linux_nat_debug_printf
2904 ("Re-adding thread group leader LWP %d after exec.",
2907 lp
= add_lwp (ptid_t (lwpid
, lwpid
));
2910 add_thread (linux_target
, lp
->ptid
);
2914 /* A process we are controlling has forked and the new
2915 child's stop was reported to us by the kernel. Save
2916 its PID and go back to waiting for the fork event to
2917 be reported - the stopped process might be returned
2918 from waitpid before or after the fork event is. */
2919 linux_nat_debug_printf
2920 ("Saving LWP %d status %s in stopped_pids list",
2921 lwpid
, status_to_str (status
).c_str ());
2922 add_to_pid_list (&stopped_pids
, lwpid
, status
);
2927 /* Don't report an event for the exit of an LWP not in our
2928 list, i.e. not part of any inferior we're debugging.
2929 This can happen if we detach from a program we originally
2930 forked and then it exits. However, note that we may have
2931 earlier deleted a leader of an inferior we're debugging,
2932 in check_zombie_leaders. Re-add it back here if so. */
2933 for (inferior
*inf
: all_inferiors (linux_target
))
2935 if (inf
->pid
== lwpid
)
2937 linux_nat_debug_printf
2938 ("Re-adding thread group leader LWP %d after exit.",
2941 lp
= add_lwp (ptid_t (lwpid
, lwpid
));
2943 add_thread (linux_target
, lp
->ptid
);
2953 /* This LWP is stopped now. (And if dead, this prevents it from
2954 ever being continued.) */
2957 if (WIFSTOPPED (status
) && lp
->must_set_ptrace_flags
)
2959 inferior
*inf
= find_inferior_pid (linux_target
, lp
->ptid
.pid ());
2960 int options
= linux_nat_ptrace_options (inf
->attach_flag
);
2962 linux_enable_event_reporting (lp
->ptid
.lwp (), options
);
2963 lp
->must_set_ptrace_flags
= 0;
2966 /* Handle GNU/Linux's syscall SIGTRAPs. */
2967 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
2969 /* No longer need the sysgood bit. The ptrace event ends up
2970 recorded in lp->waitstatus if we care for it. We can carry
2971 on handling the event like a regular SIGTRAP from here
2973 status
= W_STOPCODE (SIGTRAP
);
2974 if (linux_handle_syscall_trap (lp
, 0))
2979 /* Almost all other ptrace-stops are known to be outside of system
2980 calls, with further exceptions in linux_handle_extended_wait. */
2981 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2984 /* Handle GNU/Linux's extended waitstatus for trace events. */
2985 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
2986 && linux_is_extended_waitstatus (status
))
2988 linux_nat_debug_printf ("Handling extended status 0x%06x", status
);
2990 if (linux_handle_extended_wait (lp
, status
))
2994 /* Check if the thread has exited. */
2995 if (WIFEXITED (status
) || WIFSIGNALED (status
))
2997 if (!report_exit_events_for (lp
) && !is_leader (lp
))
2999 linux_nat_debug_printf ("%s exited.",
3000 lp
->ptid
.to_string ().c_str ());
3002 /* If this was not the leader exiting, then the exit signal
3003 was not the end of the debugged application and should be
3009 /* Note that even if the leader was ptrace-stopped, it can still
3010 exit, if e.g., some other thread brings down the whole
3011 process (calls `exit'). So don't assert that the lwp is
3013 linux_nat_debug_printf ("LWP %ld exited (resumed=%d)",
3014 lp
->ptid
.lwp (), lp
->resumed
);
3016 /* Dead LWP's aren't expected to reported a pending sigstop. */
3019 /* Store the pending event in the waitstatus, because
3020 W_EXITCODE(0,0) == 0. */
3021 lp
->waitstatus
= host_status_to_waitstatus (status
);
3025 /* Make sure we don't report a SIGSTOP that we sent ourselves in
3026 an attempt to stop an LWP. */
3028 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
3032 if (lp
->last_resume_kind
== resume_stop
)
3034 linux_nat_debug_printf ("resume_stop SIGSTOP caught for %s.",
3035 lp
->ptid
.to_string ().c_str ());
3039 /* This is a delayed SIGSTOP. Filter out the event. */
3041 linux_nat_debug_printf
3042 ("%s %s, 0, 0 (discard delayed SIGSTOP)",
3043 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3044 lp
->ptid
.to_string ().c_str ());
3046 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
3047 gdb_assert (lp
->resumed
);
3052 /* Make sure we don't report a SIGINT that we have already displayed
3053 for another thread. */
3054 if (lp
->ignore_sigint
3055 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGINT
)
3057 linux_nat_debug_printf ("Delayed SIGINT caught for %s.",
3058 lp
->ptid
.to_string ().c_str ());
3060 /* This is a delayed SIGINT. */
3061 lp
->ignore_sigint
= 0;
3063 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
3064 linux_nat_debug_printf ("%s %s, 0, 0 (discard SIGINT)",
3065 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3066 lp
->ptid
.to_string ().c_str ());
3067 gdb_assert (lp
->resumed
);
3069 /* Discard the event. */
3073 /* Don't report signals that GDB isn't interested in, such as
3074 signals that are neither printed nor stopped upon. Stopping all
3075 threads can be a bit time-consuming, so if we want decent
3076 performance with heavily multi-threaded programs, especially when
3077 they're using a high frequency timer, we'd better avoid it if we
3079 if (WIFSTOPPED (status
))
3081 enum gdb_signal signo
= gdb_signal_from_host (WSTOPSIG (status
));
3083 if (!target_is_non_stop_p ())
3085 /* Only do the below in all-stop, as we currently use SIGSTOP
3086 to implement target_stop (see linux_nat_stop) in
3088 if (signo
== GDB_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
3090 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3091 forwarded to the entire process group, that is, all LWPs
3092 will receive it - unless they're using CLONE_THREAD to
3093 share signals. Since we only want to report it once, we
3094 mark it as ignored for all LWPs except this one. */
3095 iterate_over_lwps (ptid_t (lp
->ptid
.pid ()), set_ignore_sigint
);
3096 lp
->ignore_sigint
= 0;
3099 maybe_clear_ignore_sigint (lp
);
3102 /* When using hardware single-step, we need to report every signal.
3103 Otherwise, signals in pass_mask may be short-circuited
3104 except signals that might be caused by a breakpoint, or SIGSTOP
3105 if we sent the SIGSTOP and are waiting for it to arrive. */
3107 && WSTOPSIG (status
) && sigismember (&pass_mask
, WSTOPSIG (status
))
3108 && (WSTOPSIG (status
) != SIGSTOP
3109 || !linux_target
->find_thread (lp
->ptid
)->stop_requested
)
3110 && !linux_wstatus_maybe_breakpoint (status
))
3112 linux_resume_one_lwp (lp
, lp
->step
, signo
);
3113 linux_nat_debug_printf
3114 ("%s %s, %s (preempt 'handle')",
3115 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3116 lp
->ptid
.to_string ().c_str (),
3117 (signo
!= GDB_SIGNAL_0
3118 ? strsignal (gdb_signal_to_host (signo
)) : "0"));
3123 /* An interesting event. */
3125 lp
->status
= status
;
3126 save_stop_reason (lp
);
3129 /* Detect zombie thread group leaders, and "exit" them. We can't reap
3130 their exits until all other threads in the group have exited. */
3133 check_zombie_leaders (void)
3135 for (inferior
*inf
: all_inferiors ())
3137 struct lwp_info
*leader_lp
;
3142 leader_lp
= find_lwp_pid (ptid_t (inf
->pid
));
3143 if (leader_lp
!= NULL
3144 /* Check if there are other threads in the group, as we may
3145 have raced with the inferior simply exiting. Note this
3146 isn't a watertight check. If the inferior is
3147 multi-threaded and is exiting, it may be we see the
3148 leader as zombie before we reap all the non-leader
3149 threads. See comments below. */
3150 && num_lwps (inf
->pid
) > 1
3151 && linux_proc_pid_is_zombie (inf
->pid
))
3153 /* A zombie leader in a multi-threaded program can mean one
3156 #1 - Only the leader exited, not the whole program, e.g.,
3157 with pthread_exit. Since we can't reap the leader's exit
3158 status until all other threads are gone and reaped too,
3159 we want to delete the zombie leader right away, as it
3160 can't be debugged, we can't read its registers, etc.
3161 This is the main reason we check for zombie leaders
3164 #2 - The whole thread-group/process exited (a group exit,
3165 via e.g. exit(3), and there is (or will be shortly) an
3166 exit reported for each thread in the process, and then
3167 finally an exit for the leader once the non-leaders are
3170 #3 - There are 3 or more threads in the group, and a
3171 thread other than the leader exec'd. See comments on
3172 exec events at the top of the file.
3174 Ideally we would never delete the leader for case #2.
3175 Instead, we want to collect the exit status of each
3176 non-leader thread, and then finally collect the exit
3177 status of the leader as normal and use its exit code as
3178 whole-process exit code. Unfortunately, there's no
3179 race-free way to distinguish cases #1 and #2. We can't
3180 assume the exit events for the non-leaders threads are
3181 already pending in the kernel, nor can we assume the
3182 non-leader threads are in zombie state already. Between
3183 the leader becoming zombie and the non-leaders exiting
3184 and becoming zombie themselves, there's a small time
3185 window, so such a check would be racy. Temporarily
3186 pausing all threads and checking to see if all threads
3187 exit or not before re-resuming them would work in the
3188 case that all threads are running right now, but it
3189 wouldn't work if some thread is currently already
3190 ptrace-stopped, e.g., due to scheduler-locking.
3192 So what we do is we delete the leader anyhow, and then
3193 later on when we see its exit status, we re-add it back.
3194 We also make sure that we only report a whole-process
3195 exit when we see the leader exiting, as opposed to when
3196 the last LWP in the LWP list exits, which can be a
3197 non-leader if we deleted the leader here. */
3198 linux_nat_debug_printf ("Thread group leader %d zombie "
3199 "(it exited, or another thread execd), "
3202 exit_lwp (leader_lp
);
3207 /* Convenience function that is called when we're about to return an
3208 event to the core. If the event is an exit or signalled event,
3209 then this decides whether to report it as process-wide event, as a
3210 thread exit event, or to suppress it. All other event kinds are
3211 passed through unmodified. */
3214 filter_exit_event (struct lwp_info
*event_child
,
3215 struct target_waitstatus
*ourstatus
)
3217 ptid_t ptid
= event_child
->ptid
;
3219 /* Note we must filter TARGET_WAITKIND_SIGNALLED as well, otherwise
3220 if a non-leader thread exits with a signal, we'd report it to the
3221 core which would interpret it as the whole-process exiting.
3222 There is no TARGET_WAITKIND_THREAD_SIGNALLED event kind. */
3223 if (ourstatus
->kind () != TARGET_WAITKIND_EXITED
3224 && ourstatus
->kind () != TARGET_WAITKIND_SIGNALLED
)
3227 if (!is_leader (event_child
))
3229 if (report_exit_events_for (event_child
))
3231 ourstatus
->set_thread_exited (0);
3232 /* Delete lwp, but not thread_info, infrun will need it to
3233 process the event. */
3234 exit_lwp (event_child
, false);
3238 ourstatus
->set_ignore ();
3239 exit_lwp (event_child
);
3247 linux_nat_wait_1 (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3248 target_wait_flags target_options
)
3250 LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT
;
3253 enum resume_kind last_resume_kind
;
3254 struct lwp_info
*lp
;
3257 /* The first time we get here after starting a new inferior, we may
3258 not have added it to the LWP list yet - this is the earliest
3259 moment at which we know its PID. */
3260 if (ptid
.is_pid () && find_lwp_pid (ptid
) == nullptr)
3262 ptid_t
lwp_ptid (ptid
.pid (), ptid
.pid ());
3264 /* Upgrade the main thread's ptid. */
3265 thread_change_ptid (linux_target
, ptid
, lwp_ptid
);
3266 lp
= add_initial_lwp (lwp_ptid
);
3270 /* Make sure SIGCHLD is blocked until the sigsuspend below. */
3271 block_child_signals (&prev_mask
);
3273 /* First check if there is a LWP with a wait status pending. */
3274 lp
= iterate_over_lwps (ptid
, status_callback
);
3277 linux_nat_debug_printf ("Using pending wait status %s for %s.",
3278 pending_status_str (lp
).c_str (),
3279 lp
->ptid
.to_string ().c_str ());
3282 /* But if we don't find a pending event, we'll have to wait. Always
3283 pull all events out of the kernel. We'll randomly select an
3284 event LWP out of all that have events, to prevent starvation. */
3290 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3293 - If the thread group leader exits while other threads in the
3294 thread group still exist, waitpid(TGID, ...) hangs. That
3295 waitpid won't return an exit status until the other threads
3296 in the group are reaped.
3298 - When a non-leader thread execs, that thread just vanishes
3299 without reporting an exit (so we'd hang if we waited for it
3300 explicitly in that case). The exec event is reported to
3304 lwpid
= my_waitpid (-1, &status
, __WALL
| WNOHANG
);
3306 linux_nat_debug_printf ("waitpid(-1, ...) returned %d, %s",
3308 errno
? safe_strerror (errno
) : "ERRNO-OK");
3312 linux_nat_debug_printf ("waitpid %ld received %s",
3314 status_to_str (status
).c_str ());
3316 linux_nat_filter_event (lwpid
, status
);
3317 /* Retry until nothing comes out of waitpid. A single
3318 SIGCHLD can indicate more than one child stopped. */
3322 /* Now that we've pulled all events out of the kernel, resume
3323 LWPs that don't have an interesting event to report. */
3324 iterate_over_lwps (minus_one_ptid
,
3325 [] (struct lwp_info
*info
)
3327 return resume_stopped_resumed_lwps (info
, minus_one_ptid
);
3330 /* ... and find an LWP with a status to report to the core, if
3332 lp
= iterate_over_lwps (ptid
, status_callback
);
3336 /* Check for zombie thread group leaders. Those can't be reaped
3337 until all other threads in the thread group are. */
3338 check_zombie_leaders ();
3340 /* If there are no resumed children left, bail. We'd be stuck
3341 forever in the sigsuspend call below otherwise. */
3342 if (iterate_over_lwps (ptid
, resumed_callback
) == NULL
)
3344 linux_nat_debug_printf ("exit (no resumed LWP)");
3346 ourstatus
->set_no_resumed ();
3348 restore_child_signals_mask (&prev_mask
);
3349 return minus_one_ptid
;
3352 /* No interesting event to report to the core. */
3354 if (target_options
& TARGET_WNOHANG
)
3356 linux_nat_debug_printf ("no interesting events found");
3358 ourstatus
->set_ignore ();
3359 restore_child_signals_mask (&prev_mask
);
3360 return minus_one_ptid
;
3363 /* We shouldn't end up here unless we want to try again. */
3364 gdb_assert (lp
== NULL
);
3366 /* Block until we get an event reported with SIGCHLD. */
3372 status
= lp
->status
;
3375 if (!target_is_non_stop_p ())
3377 /* Now stop all other LWP's ... */
3378 iterate_over_lwps (minus_one_ptid
, stop_callback
);
3380 /* ... and wait until all of them have reported back that
3381 they're no longer running. */
3382 iterate_over_lwps (minus_one_ptid
, stop_wait_callback
);
3385 /* If we're not waiting for a specific LWP, choose an event LWP from
3386 among those that have had events. Giving equal priority to all
3387 LWPs that have had events helps prevent starvation. */
3388 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
3389 select_event_lwp (ptid
, &lp
, &status
);
3391 gdb_assert (lp
!= NULL
);
3393 /* Now that we've selected our final event LWP, un-adjust its PC if
3394 it was a software breakpoint, and we can't reliably support the
3395 "stopped by software breakpoint" stop reason. */
3396 if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3397 && !USE_SIGTRAP_SIGINFO
)
3399 struct regcache
*regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
3400 struct gdbarch
*gdbarch
= regcache
->arch ();
3401 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3407 pc
= regcache_read_pc (regcache
);
3408 regcache_write_pc (regcache
, pc
+ decr_pc
);
3412 /* We'll need this to determine whether to report a SIGSTOP as
3413 GDB_SIGNAL_0. Need to take a copy because resume_clear_callback
3415 last_resume_kind
= lp
->last_resume_kind
;
3417 if (!target_is_non_stop_p ())
3419 /* In all-stop, from the core's perspective, all LWPs are now
3420 stopped until a new resume action is sent over. */
3421 iterate_over_lwps (minus_one_ptid
, resume_clear_callback
);
3425 resume_clear_callback (lp
);
3428 if (linux_target
->low_status_is_event (status
))
3430 linux_nat_debug_printf ("trap ptid is %s.",
3431 lp
->ptid
.to_string ().c_str ());
3434 if (lp
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
3436 *ourstatus
= lp
->waitstatus
;
3437 lp
->waitstatus
.set_ignore ();
3440 *ourstatus
= host_status_to_waitstatus (status
);
3442 linux_nat_debug_printf ("event found");
3444 restore_child_signals_mask (&prev_mask
);
3446 if (last_resume_kind
== resume_stop
3447 && ourstatus
->kind () == TARGET_WAITKIND_STOPPED
3448 && WSTOPSIG (status
) == SIGSTOP
)
3450 /* A thread that has been requested to stop by GDB with
3451 target_stop, and it stopped cleanly, so report as SIG0. The
3452 use of SIGSTOP is an implementation detail. */
3453 ourstatus
->set_stopped (GDB_SIGNAL_0
);
3456 if (ourstatus
->kind () == TARGET_WAITKIND_EXITED
3457 || ourstatus
->kind () == TARGET_WAITKIND_SIGNALLED
)
3460 lp
->core
= linux_common_core_of_thread (lp
->ptid
);
3462 return filter_exit_event (lp
, ourstatus
);
3465 /* Resume LWPs that are currently stopped without any pending status
3466 to report, but are resumed from the core's perspective. */
3469 resume_stopped_resumed_lwps (struct lwp_info
*lp
, const ptid_t wait_ptid
)
3471 inferior
*inf
= lwp_inferior (lp
);
3475 linux_nat_debug_printf ("NOT resuming LWP %s, not stopped",
3476 lp
->ptid
.to_string ().c_str ());
3478 else if (!lp
->resumed
)
3480 linux_nat_debug_printf ("NOT resuming LWP %s, not resumed",
3481 lp
->ptid
.to_string ().c_str ());
3483 else if (lwp_status_pending_p (lp
))
3485 linux_nat_debug_printf ("NOT resuming LWP %s, has pending status",
3486 lp
->ptid
.to_string ().c_str ());
3488 else if (inf
->vfork_child
!= nullptr)
3490 linux_nat_debug_printf ("NOT resuming LWP %s (vfork parent)",
3491 lp
->ptid
.to_string ().c_str ());
3495 struct regcache
*regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
3496 struct gdbarch
*gdbarch
= regcache
->arch ();
3500 CORE_ADDR pc
= regcache_read_pc (regcache
);
3501 int leave_stopped
= 0;
3503 /* Don't bother if there's a breakpoint at PC that we'd hit
3504 immediately, and we're not waiting for this LWP. */
3505 if (!lp
->ptid
.matches (wait_ptid
))
3507 if (breakpoint_inserted_here_p (inf
->aspace
.get (), pc
))
3513 linux_nat_debug_printf
3514 ("resuming stopped-resumed LWP %s at %s: step=%d",
3515 lp
->ptid
.to_string ().c_str (), paddress (gdbarch
, pc
),
3518 linux_resume_one_lwp_throw (lp
, lp
->step
, GDB_SIGNAL_0
);
3521 catch (const gdb_exception_error
&ex
)
3523 if (!check_ptrace_stopped_lwp_gone (lp
))
3532 linux_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3533 target_wait_flags target_options
)
3535 LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT
;
3539 linux_nat_debug_printf ("[%s], [%s]", ptid
.to_string ().c_str (),
3540 target_options_to_string (target_options
).c_str ());
3542 /* Flush the async file first. */
3543 if (target_is_async_p ())
3544 async_file_flush ();
3546 /* Resume LWPs that are currently stopped without any pending status
3547 to report, but are resumed from the core's perspective. LWPs get
3548 in this state if we find them stopping at a time we're not
3549 interested in reporting the event (target_wait on a
3550 specific_process, for example, see linux_nat_wait_1), and
3551 meanwhile the event became uninteresting. Don't bother resuming
3552 LWPs we're not going to wait for if they'd stop immediately. */
3553 if (target_is_non_stop_p ())
3554 iterate_over_lwps (minus_one_ptid
,
3555 [=] (struct lwp_info
*info
)
3557 return resume_stopped_resumed_lwps (info
, ptid
);
3560 event_ptid
= linux_nat_wait_1 (ptid
, ourstatus
, target_options
);
3562 /* If we requested any event, and something came out, assume there
3563 may be more. If we requested a specific lwp or process, also
3564 assume there may be more. */
3565 if (target_is_async_p ()
3566 && ((ourstatus
->kind () != TARGET_WAITKIND_IGNORE
3567 && ourstatus
->kind () != TARGET_WAITKIND_NO_RESUMED
)
3568 || ptid
!= minus_one_ptid
))
3577 kill_one_lwp (pid_t pid
)
3579 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
3582 kill_lwp (pid
, SIGKILL
);
3584 if (debug_linux_nat
)
3586 int save_errno
= errno
;
3588 linux_nat_debug_printf
3589 ("kill (SIGKILL) %ld, 0, 0 (%s)", (long) pid
,
3590 save_errno
!= 0 ? safe_strerror (save_errno
) : "OK");
3593 /* Some kernels ignore even SIGKILL for processes under ptrace. */
3596 ptrace (PTRACE_KILL
, pid
, 0, 0);
3597 if (debug_linux_nat
)
3599 int save_errno
= errno
;
3601 linux_nat_debug_printf
3602 ("PTRACE_KILL %ld, 0, 0 (%s)", (long) pid
,
3603 save_errno
? safe_strerror (save_errno
) : "OK");
3607 /* Wait for an LWP to die. */
3610 kill_wait_one_lwp (pid_t pid
)
3614 /* We must make sure that there are no pending events (delayed
3615 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3616 program doesn't interfere with any following debugging session. */
3620 res
= my_waitpid (pid
, NULL
, __WALL
);
3621 if (res
!= (pid_t
) -1)
3623 linux_nat_debug_printf ("wait %ld received unknown.", (long) pid
);
3625 /* The Linux kernel sometimes fails to kill a thread
3626 completely after PTRACE_KILL; that goes from the stop
3627 point in do_fork out to the one in get_signal_to_deliver
3628 and waits again. So kill it again. */
3634 gdb_assert (res
== -1 && errno
== ECHILD
);
3637 /* Callback for iterate_over_lwps. */
3640 kill_callback (struct lwp_info
*lp
)
3642 kill_one_lwp (lp
->ptid
.lwp ());
3646 /* Callback for iterate_over_lwps. */
3649 kill_wait_callback (struct lwp_info
*lp
)
3651 kill_wait_one_lwp (lp
->ptid
.lwp ());
3655 /* Kill the fork/clone child of LP if it has an unfollowed child. */
3658 kill_unfollowed_child_callback (lwp_info
*lp
)
3660 std::optional
<target_waitstatus
> ws
= get_pending_child_status (lp
);
3661 if (ws
.has_value ())
3663 ptid_t child_ptid
= ws
->child_ptid ();
3664 int child_pid
= child_ptid
.pid ();
3665 int child_lwp
= child_ptid
.lwp ();
3667 kill_one_lwp (child_lwp
);
3668 kill_wait_one_lwp (child_lwp
);
3670 /* Let the arch-specific native code know this process is
3672 if (ws
->kind () != TARGET_WAITKIND_THREAD_CLONED
)
3673 linux_target
->low_forget_process (child_pid
);
3680 linux_nat_target::kill ()
3682 ptid_t
pid_ptid (inferior_ptid
.pid ());
3684 /* If we're stopped while forking/cloning and we haven't followed
3685 yet, kill the child task. We need to do this first because the
3686 parent will be sleeping if this is a vfork. */
3687 iterate_over_lwps (pid_ptid
, kill_unfollowed_child_callback
);
3689 if (forks_exist_p ())
3690 linux_fork_killall ();
3693 /* Stop all threads before killing them, since ptrace requires
3694 that the thread is stopped to successfully PTRACE_KILL. */
3695 iterate_over_lwps (pid_ptid
, stop_callback
);
3696 /* ... and wait until all of them have reported back that
3697 they're no longer running. */
3698 iterate_over_lwps (pid_ptid
, stop_wait_callback
);
3700 /* Kill all LWP's ... */
3701 iterate_over_lwps (pid_ptid
, kill_callback
);
3703 /* ... and wait until we've flushed all events. */
3704 iterate_over_lwps (pid_ptid
, kill_wait_callback
);
3707 target_mourn_inferior (inferior_ptid
);
3711 linux_nat_target::mourn_inferior ()
3713 LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT
;
3715 int pid
= inferior_ptid
.pid ();
3717 purge_lwp_list (pid
);
3719 close_proc_mem_file (pid
);
3721 if (! forks_exist_p ())
3722 /* Normal case, no other forks available. */
3723 inf_ptrace_target::mourn_inferior ();
3725 /* Multi-fork case. The current inferior_ptid has exited, but
3726 there are other viable forks to debug. Delete the exiting
3727 one and context-switch to the first available. */
3728 linux_fork_mourn_inferior ();
3730 /* Let the arch-specific native code know this process is gone. */
3731 linux_target
->low_forget_process (pid
);
3734 /* Convert a native/host siginfo object, into/from the siginfo in the
3735 layout of the inferiors' architecture. */
3738 siginfo_fixup (siginfo_t
*siginfo
, gdb_byte
*inf_siginfo
, int direction
)
3740 /* If the low target didn't do anything, then just do a straight
3742 if (!linux_target
->low_siginfo_fixup (siginfo
, inf_siginfo
, direction
))
3745 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
3747 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
3751 static enum target_xfer_status
3752 linux_xfer_siginfo (ptid_t ptid
, enum target_object object
,
3753 const char *annex
, gdb_byte
*readbuf
,
3754 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
3755 ULONGEST
*xfered_len
)
3758 gdb_byte inf_siginfo
[sizeof (siginfo_t
)];
3760 gdb_assert (object
== TARGET_OBJECT_SIGNAL_INFO
);
3761 gdb_assert (readbuf
|| writebuf
);
3763 if (offset
> sizeof (siginfo
))
3764 return TARGET_XFER_E_IO
;
3766 if (!linux_nat_get_siginfo (ptid
, &siginfo
))
3767 return TARGET_XFER_E_IO
;
3769 /* When GDB is built as a 64-bit application, ptrace writes into
3770 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3771 inferior with a 64-bit GDB should look the same as debugging it
3772 with a 32-bit GDB, we need to convert it. GDB core always sees
3773 the converted layout, so any read/write will have to be done
3775 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
3777 if (offset
+ len
> sizeof (siginfo
))
3778 len
= sizeof (siginfo
) - offset
;
3780 if (readbuf
!= NULL
)
3781 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
3784 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
3786 /* Convert back to ptrace layout before flushing it out. */
3787 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
3789 int pid
= get_ptrace_pid (ptid
);
3791 ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
3793 return TARGET_XFER_E_IO
;
3797 return TARGET_XFER_OK
;
3800 static enum target_xfer_status
3801 linux_nat_xfer_osdata (enum target_object object
,
3802 const char *annex
, gdb_byte
*readbuf
,
3803 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
3804 ULONGEST
*xfered_len
);
3806 static enum target_xfer_status
3807 linux_proc_xfer_memory_partial (int pid
, gdb_byte
*readbuf
,
3808 const gdb_byte
*writebuf
, ULONGEST offset
,
3809 LONGEST len
, ULONGEST
*xfered_len
);
3811 enum target_xfer_status
3812 linux_nat_target::xfer_partial (enum target_object object
,
3813 const char *annex
, gdb_byte
*readbuf
,
3814 const gdb_byte
*writebuf
,
3815 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
3817 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
3818 return linux_xfer_siginfo (inferior_ptid
, object
, annex
, readbuf
, writebuf
,
3819 offset
, len
, xfered_len
);
3821 /* The target is connected but no live inferior is selected. Pass
3822 this request down to a lower stratum (e.g., the executable
3824 if (object
== TARGET_OBJECT_MEMORY
&& inferior_ptid
== null_ptid
)
3825 return TARGET_XFER_EOF
;
3827 if (object
== TARGET_OBJECT_AUXV
)
3828 return memory_xfer_auxv (this, object
, annex
, readbuf
, writebuf
,
3829 offset
, len
, xfered_len
);
3831 if (object
== TARGET_OBJECT_OSDATA
)
3832 return linux_nat_xfer_osdata (object
, annex
, readbuf
, writebuf
,
3833 offset
, len
, xfered_len
);
3835 if (object
== TARGET_OBJECT_MEMORY
)
3837 /* GDB calculates all addresses in the largest possible address
3838 width. The address width must be masked before its final use
3839 by linux_proc_xfer_partial.
3841 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
3842 int addr_bit
= gdbarch_addr_bit (current_inferior ()->arch ());
3844 if (addr_bit
< (sizeof (ULONGEST
) * HOST_CHAR_BIT
))
3845 offset
&= ((ULONGEST
) 1 << addr_bit
) - 1;
3847 /* If /proc/pid/mem is writable, don't fallback to ptrace. If
3848 the write via /proc/pid/mem fails because the inferior execed
3849 (and we haven't seen the exec event yet), a subsequent ptrace
3850 poke would incorrectly write memory to the post-exec address
3851 space, while the core was trying to write to the pre-exec
3853 if (proc_mem_file_is_writable ())
3854 return linux_proc_xfer_memory_partial (inferior_ptid
.pid (), readbuf
,
3855 writebuf
, offset
, len
,
3859 return inf_ptrace_target::xfer_partial (object
, annex
, readbuf
, writebuf
,
3860 offset
, len
, xfered_len
);
3864 linux_nat_target::thread_alive (ptid_t ptid
)
3866 /* As long as a PTID is in lwp list, consider it alive. */
3867 return find_lwp_pid (ptid
) != NULL
;
3870 /* Implement the to_update_thread_list target method for this
3874 linux_nat_target::update_thread_list ()
3876 /* We add/delete threads from the list as clone/exit events are
3877 processed, so just try deleting exited threads still in the
3879 delete_exited_threads ();
3881 /* Update the processor core that each lwp/thread was last seen
3883 for (lwp_info
*lwp
: all_lwps ())
3885 /* Avoid accessing /proc if the thread hasn't run since we last
3886 time we fetched the thread's core. Accessing /proc becomes
3887 noticeably expensive when we have thousands of LWPs. */
3888 if (lwp
->core
== -1)
3889 lwp
->core
= linux_common_core_of_thread (lwp
->ptid
);
3894 linux_nat_target::pid_to_str (ptid_t ptid
)
3897 && (ptid
.pid () != ptid
.lwp ()
3898 || num_lwps (ptid
.pid ()) > 1))
3899 return string_printf ("LWP %ld", ptid
.lwp ());
3901 return normal_pid_to_str (ptid
);
3905 linux_nat_target::thread_name (struct thread_info
*thr
)
3907 return linux_proc_tid_get_name (thr
->ptid
);
3910 /* Accepts an integer PID; Returns a string representing a file that
3911 can be opened to get the symbols for the child process. */
3914 linux_nat_target::pid_to_exec_file (int pid
)
3916 return linux_proc_pid_to_exec_file (pid
);
3919 /* Object representing an /proc/PID/mem open file. We keep one such
3920 file open per inferior.
3922 It might be tempting to think about only ever opening one file at
3923 most for all inferiors, closing/reopening the file as we access
3924 memory of different inferiors, to minimize number of file
3925 descriptors open, which can otherwise run into resource limits.
3926 However, that does not work correctly -- if the inferior execs and
3927 we haven't processed the exec event yet, and, we opened a
3928 /proc/PID/mem file, we will get a mem file accessing the post-exec
3929 address space, thinking we're opening it for the pre-exec address
3930 space. That is dangerous as we can poke memory (e.g. clearing
3931 breakpoints) in the post-exec memory by mistake, corrupting the
3932 inferior. For that reason, we open the mem file as early as
3933 possible, right after spawning, forking or attaching to the
3934 inferior, when the inferior is stopped and thus before it has a
3937 Note that after opening the file, even if the thread we opened it
3938 for subsequently exits, the open file is still usable for accessing
3939 memory. It's only when the whole process exits or execs that the
3940 file becomes invalid, at which point reads/writes return EOF. */
3945 proc_mem_file (ptid_t ptid
, int fd
)
3946 : m_ptid (ptid
), m_fd (fd
)
3948 gdb_assert (m_fd
!= -1);
3953 linux_nat_debug_printf ("closing fd %d for /proc/%d/task/%ld/mem",
3954 m_fd
, m_ptid
.pid (), m_ptid
.lwp ());
3958 DISABLE_COPY_AND_ASSIGN (proc_mem_file
);
3966 /* The LWP this file was opened for. Just for debugging
3970 /* The file descriptor. */
3974 /* The map between an inferior process id, and the open /proc/PID/mem
3975 file. This is stored in a map instead of in a per-inferior
3976 structure because we need to be able to access memory of processes
3977 which don't have a corresponding struct inferior object. E.g.,
3978 with "detach-on-fork on" (the default), and "follow-fork parent"
3979 (also default), we don't create an inferior for the fork child, but
3980 we still need to remove breakpoints from the fork child's
3982 static std::unordered_map
<int, proc_mem_file
> proc_mem_file_map
;
3984 /* Close the /proc/PID/mem file for PID. */
3987 close_proc_mem_file (pid_t pid
)
3989 proc_mem_file_map
.erase (pid
);
3992 /* Open the /proc/PID/mem file for the process (thread group) of PTID.
3993 We actually open /proc/PID/task/LWP/mem, as that's the LWP we know
3994 exists and is stopped right now. We prefer the
3995 /proc/PID/task/LWP/mem form over /proc/LWP/mem to avoid tid-reuse
3996 races, just in case this is ever called on an already-waited
4000 open_proc_mem_file (ptid_t ptid
)
4002 auto iter
= proc_mem_file_map
.find (ptid
.pid ());
4003 gdb_assert (iter
== proc_mem_file_map
.end ());
4006 xsnprintf (filename
, sizeof filename
,
4007 "/proc/%d/task/%ld/mem", ptid
.pid (), ptid
.lwp ());
4009 int fd
= gdb_open_cloexec (filename
, O_RDWR
| O_LARGEFILE
, 0).release ();
4013 warning (_("opening /proc/PID/mem file for lwp %d.%ld failed: %s (%d)"),
4014 ptid
.pid (), ptid
.lwp (),
4015 safe_strerror (errno
), errno
);
4019 proc_mem_file_map
.emplace (std::piecewise_construct
,
4020 std::forward_as_tuple (ptid
.pid ()),
4021 std::forward_as_tuple (ptid
, fd
));
4023 linux_nat_debug_printf ("opened fd %d for lwp %d.%ld",
4024 fd
, ptid
.pid (), ptid
.lwp ());
4027 /* Helper for linux_proc_xfer_memory_partial and
4028 proc_mem_file_is_writable. FD is the already opened /proc/pid/mem
4029 file, and PID is the pid of the corresponding process. The rest of
4030 the arguments are like linux_proc_xfer_memory_partial's. */
4032 static enum target_xfer_status
4033 linux_proc_xfer_memory_partial_fd (int fd
, int pid
,
4034 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
4035 ULONGEST offset
, LONGEST len
,
4036 ULONGEST
*xfered_len
)
4040 gdb_assert (fd
!= -1);
4042 /* Use pread64/pwrite64 if available, since they save a syscall and
4043 can handle 64-bit offsets even on 32-bit platforms (for instance,
4044 SPARC debugging a SPARC64 application). But only use them if the
4045 offset isn't so high that when cast to off_t it'd be negative, as
4046 seen on SPARC64. pread64/pwrite64 outright reject such offsets.
4049 if ((off_t
) offset
>= 0)
4050 ret
= (readbuf
!= nullptr
4051 ? pread64 (fd
, readbuf
, len
, offset
)
4052 : pwrite64 (fd
, writebuf
, len
, offset
));
4056 ret
= lseek (fd
, offset
, SEEK_SET
);
4058 ret
= (readbuf
!= nullptr
4059 ? read (fd
, readbuf
, len
)
4060 : write (fd
, writebuf
, len
));
4065 linux_nat_debug_printf ("accessing fd %d for pid %d failed: %s (%d)",
4066 fd
, pid
, safe_strerror (errno
), errno
);
4067 return TARGET_XFER_E_IO
;
4071 /* EOF means the address space is gone, the whole process exited
4073 linux_nat_debug_printf ("accessing fd %d for pid %d got EOF",
4075 return TARGET_XFER_EOF
;
4080 return TARGET_XFER_OK
;
4084 /* Implement the to_xfer_partial target method using /proc/PID/mem.
4085 Because we can use a single read/write call, this can be much more
4086 efficient than banging away at PTRACE_PEEKTEXT. Also, unlike
4087 PTRACE_PEEKTEXT/PTRACE_POKETEXT, this works with running
4090 static enum target_xfer_status
4091 linux_proc_xfer_memory_partial (int pid
, gdb_byte
*readbuf
,
4092 const gdb_byte
*writebuf
, ULONGEST offset
,
4093 LONGEST len
, ULONGEST
*xfered_len
)
4095 auto iter
= proc_mem_file_map
.find (pid
);
4096 if (iter
== proc_mem_file_map
.end ())
4097 return TARGET_XFER_EOF
;
4099 int fd
= iter
->second
.fd ();
4101 return linux_proc_xfer_memory_partial_fd (fd
, pid
, readbuf
, writebuf
, offset
,
4105 /* Check whether /proc/pid/mem is writable in the current kernel, and
4106 return true if so. It wasn't writable before Linux 2.6.39, but
4107 there's no way to know whether the feature was backported to older
4108 kernels. So we check to see if it works. The result is cached,
4109 and this is guaranteed to be called once early during inferior
4110 startup, so that any warning is printed out consistently between
4111 GDB invocations. Note we don't call it during GDB startup instead
4112 though, because then we might warn with e.g. just "gdb --version"
4113 on sandboxed systems. See PR gdb/29907. */
4116 proc_mem_file_is_writable ()
4118 static std::optional
<bool> writable
;
4120 if (writable
.has_value ())
4123 writable
.emplace (false);
4125 /* We check whether /proc/pid/mem is writable by trying to write to
4126 one of our variables via /proc/self/mem. */
4128 int fd
= gdb_open_cloexec ("/proc/self/mem", O_RDWR
| O_LARGEFILE
, 0).release ();
4132 warning (_("opening /proc/self/mem file failed: %s (%d)"),
4133 safe_strerror (errno
), errno
);
4137 SCOPE_EXIT
{ close (fd
); };
4139 /* This is the variable we try to write to. Note OFFSET below. */
4140 volatile gdb_byte test_var
= 0;
4142 gdb_byte writebuf
[] = {0x55};
4143 ULONGEST offset
= (uintptr_t) &test_var
;
4144 ULONGEST xfered_len
;
4146 enum target_xfer_status res
4147 = linux_proc_xfer_memory_partial_fd (fd
, getpid (), nullptr, writebuf
,
4148 offset
, 1, &xfered_len
);
4150 if (res
== TARGET_XFER_OK
)
4152 gdb_assert (xfered_len
== 1);
4153 gdb_assert (test_var
== 0x55);
4161 /* Parse LINE as a signal set and add its set bits to SIGS. */
4164 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
4166 int len
= strlen (line
) - 1;
4170 if (line
[len
] != '\n')
4171 error (_("Could not parse signal set: %s"), line
);
4179 if (*p
>= '0' && *p
<= '9')
4181 else if (*p
>= 'a' && *p
<= 'f')
4182 digit
= *p
- 'a' + 10;
4184 error (_("Could not parse signal set: %s"), line
);
4189 sigaddset (sigs
, signum
+ 1);
4191 sigaddset (sigs
, signum
+ 2);
4193 sigaddset (sigs
, signum
+ 3);
4195 sigaddset (sigs
, signum
+ 4);
4201 /* Find process PID's pending signals from /proc/pid/status and set
4205 linux_proc_pending_signals (int pid
, sigset_t
*pending
,
4206 sigset_t
*blocked
, sigset_t
*ignored
)
4208 char buffer
[PATH_MAX
], fname
[PATH_MAX
];
4210 sigemptyset (pending
);
4211 sigemptyset (blocked
);
4212 sigemptyset (ignored
);
4213 xsnprintf (fname
, sizeof fname
, "/proc/%d/status", pid
);
4214 gdb_file_up procfile
= gdb_fopen_cloexec (fname
, "r");
4215 if (procfile
== NULL
)
4216 error (_("Could not open %s"), fname
);
4218 while (fgets (buffer
, PATH_MAX
, procfile
.get ()) != NULL
)
4220 /* Normal queued signals are on the SigPnd line in the status
4221 file. However, 2.6 kernels also have a "shared" pending
4222 queue for delivering signals to a thread group, so check for
4225 Unfortunately some Red Hat kernels include the shared pending
4226 queue but not the ShdPnd status field. */
4228 if (startswith (buffer
, "SigPnd:\t"))
4229 add_line_to_sigset (buffer
+ 8, pending
);
4230 else if (startswith (buffer
, "ShdPnd:\t"))
4231 add_line_to_sigset (buffer
+ 8, pending
);
4232 else if (startswith (buffer
, "SigBlk:\t"))
4233 add_line_to_sigset (buffer
+ 8, blocked
);
4234 else if (startswith (buffer
, "SigIgn:\t"))
4235 add_line_to_sigset (buffer
+ 8, ignored
);
4239 static enum target_xfer_status
4240 linux_nat_xfer_osdata (enum target_object object
,
4241 const char *annex
, gdb_byte
*readbuf
,
4242 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
4243 ULONGEST
*xfered_len
)
4245 gdb_assert (object
== TARGET_OBJECT_OSDATA
);
4247 *xfered_len
= linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
4248 if (*xfered_len
== 0)
4249 return TARGET_XFER_EOF
;
4251 return TARGET_XFER_OK
;
4254 std::vector
<static_tracepoint_marker
>
4255 linux_nat_target::static_tracepoint_markers_by_strid (const char *strid
)
4257 char s
[IPA_CMD_BUF_SIZE
];
4258 int pid
= inferior_ptid
.pid ();
4259 std::vector
<static_tracepoint_marker
> markers
;
4261 ptid_t ptid
= ptid_t (pid
, 0);
4262 static_tracepoint_marker marker
;
4267 strcpy (s
, "qTfSTM");
4268 agent_run_command (pid
, s
, strlen (s
) + 1);
4271 SCOPE_EXIT
{ target_continue_no_signal (ptid
); };
4277 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4279 if (strid
== NULL
|| marker
.str_id
== strid
)
4280 markers
.push_back (std::move (marker
));
4282 while (*p
++ == ','); /* comma-separated list */
4284 strcpy (s
, "qTsSTM");
4285 agent_run_command (pid
, s
, strlen (s
) + 1);
4292 /* target_can_async_p implementation. */
4295 linux_nat_target::can_async_p ()
4297 /* This flag should be checked in the common target.c code. */
4298 gdb_assert (target_async_permitted
);
4300 /* Otherwise, this targets is always able to support async mode. */
4305 linux_nat_target::supports_non_stop ()
4310 /* to_always_non_stop_p implementation. */
4313 linux_nat_target::always_non_stop_p ()
4319 linux_nat_target::supports_multi_process ()
4325 linux_nat_target::supports_disable_randomization ()
4330 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4331 so we notice when any child changes state, and notify the
4332 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4333 above to wait for the arrival of a SIGCHLD. */
4336 sigchld_handler (int signo
)
4338 int old_errno
= errno
;
4340 if (debug_linux_nat
)
4341 gdb_stdlog
->write_async_safe ("sigchld\n", sizeof ("sigchld\n") - 1);
4343 if (signo
== SIGCHLD
)
4345 /* Let the event loop know that there are events to handle. */
4346 linux_nat_target::async_file_mark_if_open ();
4352 /* Callback registered with the target events file descriptor. */
4355 handle_target_event (int error
, gdb_client_data client_data
)
4357 inferior_event_handler (INF_REG_EVENT
);
4360 /* target_async implementation. */
4363 linux_nat_target::async (bool enable
)
4365 if (enable
== is_async_p ())
4368 /* Block child signals while we create/destroy the pipe, as their
4369 handler writes to it. */
4370 gdb::block_signals blocker
;
4374 if (!async_file_open ())
4375 internal_error ("creating event pipe failed.");
4377 add_file_handler (async_wait_fd (), handle_target_event
, NULL
,
4380 /* There may be pending events to handle. Tell the event loop
4386 delete_file_handler (async_wait_fd ());
4387 async_file_close ();
4391 /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4395 linux_nat_stop_lwp (struct lwp_info
*lwp
)
4399 linux_nat_debug_printf ("running -> suspending %s",
4400 lwp
->ptid
.to_string ().c_str ());
4403 if (lwp
->last_resume_kind
== resume_stop
)
4405 linux_nat_debug_printf ("already stopping LWP %ld at GDB's request",
4410 stop_callback (lwp
);
4411 lwp
->last_resume_kind
= resume_stop
;
4415 /* Already known to be stopped; do nothing. */
4417 if (debug_linux_nat
)
4419 if (linux_target
->find_thread (lwp
->ptid
)->stop_requested
)
4420 linux_nat_debug_printf ("already stopped/stop_requested %s",
4421 lwp
->ptid
.to_string ().c_str ());
4423 linux_nat_debug_printf ("already stopped/no stop_requested yet %s",
4424 lwp
->ptid
.to_string ().c_str ());
4431 linux_nat_target::stop (ptid_t ptid
)
4433 LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT
;
4434 iterate_over_lwps (ptid
, linux_nat_stop_lwp
);
4437 /* Return the cached value of the processor core for thread PTID. */
4440 linux_nat_target::core_of_thread (ptid_t ptid
)
4442 struct lwp_info
*info
= find_lwp_pid (ptid
);
4449 /* Implementation of to_filesystem_is_local. */
4452 linux_nat_target::filesystem_is_local ()
4454 struct inferior
*inf
= current_inferior ();
4456 if (inf
->fake_pid_p
|| inf
->pid
== 0)
4459 return linux_ns_same (inf
->pid
, LINUX_NS_MNT
);
4462 /* Convert the INF argument passed to a to_fileio_* method
4463 to a process ID suitable for passing to its corresponding
4464 linux_mntns_* function. If INF is non-NULL then the
4465 caller is requesting the filesystem seen by INF. If INF
4466 is NULL then the caller is requesting the filesystem seen
4467 by the GDB. We fall back to GDB's filesystem in the case
4468 that INF is non-NULL but its PID is unknown. */
4471 linux_nat_fileio_pid_of (struct inferior
*inf
)
4473 if (inf
== NULL
|| inf
->fake_pid_p
|| inf
->pid
== 0)
4479 /* Implementation of to_fileio_open. */
4482 linux_nat_target::fileio_open (struct inferior
*inf
, const char *filename
,
4483 int flags
, int mode
, int warn_if_slow
,
4484 fileio_error
*target_errno
)
4490 if (fileio_to_host_openflags (flags
, &nat_flags
) == -1
4491 || fileio_to_host_mode (mode
, &nat_mode
) == -1)
4493 *target_errno
= FILEIO_EINVAL
;
4497 fd
= linux_mntns_open_cloexec (linux_nat_fileio_pid_of (inf
),
4498 filename
, nat_flags
, nat_mode
);
4500 *target_errno
= host_to_fileio_error (errno
);
4505 /* Implementation of to_fileio_readlink. */
4507 std::optional
<std::string
>
4508 linux_nat_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
4509 fileio_error
*target_errno
)
4514 len
= linux_mntns_readlink (linux_nat_fileio_pid_of (inf
),
4515 filename
, buf
, sizeof (buf
));
4518 *target_errno
= host_to_fileio_error (errno
);
4522 return std::string (buf
, len
);
4525 /* Implementation of to_fileio_unlink. */
4528 linux_nat_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
4529 fileio_error
*target_errno
)
4533 ret
= linux_mntns_unlink (linux_nat_fileio_pid_of (inf
),
4536 *target_errno
= host_to_fileio_error (errno
);
4541 /* Implementation of the to_thread_events method. */
4544 linux_nat_target::thread_events (int enable
)
4546 report_thread_events
= enable
;
4550 linux_nat_target::supports_set_thread_options (gdb_thread_options options
)
4552 constexpr gdb_thread_options supported_options
4553 = GDB_THREAD_OPTION_CLONE
| GDB_THREAD_OPTION_EXIT
;
4554 return ((options
& supported_options
) == options
);
4557 linux_nat_target::linux_nat_target ()
4559 /* We don't change the stratum; this target will sit at
4560 process_stratum and thread_db will set at thread_stratum. This
4561 is a little strange, since this is a multi-threaded-capable
4562 target, but we want to be on the stack below thread_db, and we
4563 also want to be used for single-threaded processes. */
4566 /* See linux-nat.h. */
4569 linux_nat_get_siginfo (ptid_t ptid
, siginfo_t
*siginfo
)
4571 int pid
= get_ptrace_pid (ptid
);
4572 return ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, siginfo
) == 0;
4575 /* See nat/linux-nat.h. */
4578 current_lwp_ptid (void)
4580 gdb_assert (inferior_ptid
.lwp_p ());
4581 return inferior_ptid
;
4584 /* Implement 'maintenance info linux-lwps'. Displays some basic
4585 information about all the current lwp_info objects. */
4588 maintenance_info_lwps (const char *arg
, int from_tty
)
4590 if (all_lwps ().size () == 0)
4592 gdb_printf ("No Linux LWPs\n");
4596 /* Start the width at 8 to match the column heading below, then
4597 figure out the widest ptid string. We'll use this to build our
4598 output table below. */
4599 size_t ptid_width
= 8;
4600 for (lwp_info
*lp
: all_lwps ())
4601 ptid_width
= std::max (ptid_width
, lp
->ptid
.to_string ().size ());
4603 /* Setup the table headers. */
4604 struct ui_out
*uiout
= current_uiout
;
4605 ui_out_emit_table
table_emitter (uiout
, 2, -1, "linux-lwps");
4606 uiout
->table_header (ptid_width
, ui_left
, "lwp-ptid", _("LWP Ptid"));
4607 uiout
->table_header (9, ui_left
, "thread-info", _("Thread ID"));
4608 uiout
->table_body ();
4610 /* Display one table row for each lwp_info. */
4611 for (lwp_info
*lp
: all_lwps ())
4613 ui_out_emit_tuple
tuple_emitter (uiout
, "lwp-entry");
4615 thread_info
*th
= linux_target
->find_thread (lp
->ptid
);
4617 uiout
->field_string ("lwp-ptid", lp
->ptid
.to_string ().c_str ());
4619 uiout
->field_string ("thread-info", "None");
4621 uiout
->field_string ("thread-info", print_full_thread_id (th
));
4623 uiout
->message ("\n");
4627 void _initialize_linux_nat ();
4629 _initialize_linux_nat ()
4631 add_setshow_boolean_cmd ("linux-nat", class_maintenance
,
4632 &debug_linux_nat
, _("\
4633 Set debugging of GNU/Linux native target."), _(" \
4634 Show debugging of GNU/Linux native target."), _(" \
4635 When on, print debug messages relating to the GNU/Linux native target."),
4637 show_debug_linux_nat
,
4638 &setdebuglist
, &showdebuglist
);
4640 add_setshow_boolean_cmd ("linux-namespaces", class_maintenance
,
4641 &debug_linux_namespaces
, _("\
4642 Set debugging of GNU/Linux namespaces module."), _("\
4643 Show debugging of GNU/Linux namespaces module."), _("\
4644 Enables printf debugging output."),
4647 &setdebuglist
, &showdebuglist
);
4649 /* Install a SIGCHLD handler. */
4650 sigchld_action
.sa_handler
= sigchld_handler
;
4651 sigemptyset (&sigchld_action
.sa_mask
);
4652 sigchld_action
.sa_flags
= SA_RESTART
;
4654 /* Make it the default. */
4655 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
4657 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4658 gdb_sigmask (SIG_SETMASK
, NULL
, &suspend_mask
);
4659 sigdelset (&suspend_mask
, SIGCHLD
);
4661 sigemptyset (&blocked_mask
);
4663 lwp_lwpid_htab_create ();
4665 add_cmd ("linux-lwps", class_maintenance
, maintenance_info_lwps
,
4666 _("List the Linux LWPS."), &maintenanceinfolist
);
4670 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4671 the GNU/Linux Threads library and therefore doesn't really belong
4674 /* NPTL reserves the first two RT signals, but does not provide any
4675 way for the debugger to query the signal numbers - fortunately
4676 they don't change. */
4677 static int lin_thread_signals
[] = { __SIGRTMIN
, __SIGRTMIN
+ 1 };
4679 /* See linux-nat.h. */
4682 lin_thread_get_thread_signal_num (void)
4684 return sizeof (lin_thread_signals
) / sizeof (lin_thread_signals
[0]);
4687 /* See linux-nat.h. */
4690 lin_thread_get_thread_signal (unsigned int i
)
4692 gdb_assert (i
< lin_thread_get_thread_signal_num ());
4693 return lin_thread_signals
[i
];