1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001-2021 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> /* for elf_gregset etc. */
43 #include "elf-bfd.h" /* for elfcore_write_* */
44 #include "gregset.h" /* for gregset */
45 #include "gdbcore.h" /* for get_exec_file */
46 #include <ctype.h> /* for isdigit */
47 #include <sys/stat.h> /* for struct stat */
48 #include <fcntl.h> /* for O_RDONLY */
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 "gdbsupport/buffer.h"
64 #include "target-descriptions.h"
65 #include "gdbsupport/filestuff.h"
67 #include "nat/linux-namespaces.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, the self-pipe trick is used
115 --- a 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 writes a
118 byte to this pipe. 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 static unsigned int debug_linux_nat
;
196 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
197 struct cmd_list_element
*c
, const char *value
)
199 fprintf_filtered (file
, _("Debugging of GNU/Linux lwp module is %s.\n"),
203 /* Print a linux-nat debug statement. */
205 #define linux_nat_debug_printf(fmt, ...) \
206 debug_prefixed_printf_cond (debug_linux_nat, "linux-nat", fmt, ##__VA_ARGS__)
208 struct simple_pid_list
212 struct simple_pid_list
*next
;
214 static struct simple_pid_list
*stopped_pids
;
216 /* Whether target_thread_events is in effect. */
217 static int report_thread_events
;
219 /* Async mode support. */
221 /* The read/write ends of the pipe registered as waitable file in the
223 static int linux_nat_event_pipe
[2] = { -1, -1 };
225 /* True if we're currently in async mode. */
226 #define linux_is_async_p() (linux_nat_event_pipe[0] != -1)
228 /* Flush the event pipe. */
231 async_file_flush (void)
238 ret
= read (linux_nat_event_pipe
[0], &buf
, 1);
240 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
243 /* Put something (anything, doesn't matter what, or how much) in event
244 pipe, so that the select/poll in the event-loop realizes we have
245 something to process. */
248 async_file_mark (void)
252 /* It doesn't really matter what the pipe contains, as long we end
253 up with something in it. Might as well flush the previous
259 ret
= write (linux_nat_event_pipe
[1], "+", 1);
261 while (ret
== -1 && errno
== EINTR
);
263 /* Ignore EAGAIN. If the pipe is full, the event loop will already
264 be awakened anyway. */
267 static int kill_lwp (int lwpid
, int signo
);
269 static int stop_callback (struct lwp_info
*lp
);
271 static void block_child_signals (sigset_t
*prev_mask
);
272 static void restore_child_signals_mask (sigset_t
*prev_mask
);
275 static struct lwp_info
*add_lwp (ptid_t ptid
);
276 static void purge_lwp_list (int pid
);
277 static void delete_lwp (ptid_t ptid
);
278 static struct lwp_info
*find_lwp_pid (ptid_t ptid
);
280 static int lwp_status_pending_p (struct lwp_info
*lp
);
282 static void save_stop_reason (struct lwp_info
*lp
);
284 static void close_proc_mem_file (pid_t pid
);
285 static void open_proc_mem_file (ptid_t ptid
);
290 /* See nat/linux-nat.h. */
293 ptid_of_lwp (struct lwp_info
*lwp
)
298 /* See nat/linux-nat.h. */
301 lwp_set_arch_private_info (struct lwp_info
*lwp
,
302 struct arch_lwp_info
*info
)
304 lwp
->arch_private
= info
;
307 /* See nat/linux-nat.h. */
309 struct arch_lwp_info
*
310 lwp_arch_private_info (struct lwp_info
*lwp
)
312 return lwp
->arch_private
;
315 /* See nat/linux-nat.h. */
318 lwp_is_stopped (struct lwp_info
*lwp
)
323 /* See nat/linux-nat.h. */
325 enum target_stop_reason
326 lwp_stop_reason (struct lwp_info
*lwp
)
328 return lwp
->stop_reason
;
331 /* See nat/linux-nat.h. */
334 lwp_is_stepping (struct lwp_info
*lwp
)
340 /* Trivial list manipulation functions to keep track of a list of
341 new stopped processes. */
343 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
345 struct simple_pid_list
*new_pid
= XNEW (struct simple_pid_list
);
348 new_pid
->status
= status
;
349 new_pid
->next
= *listp
;
354 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
356 struct simple_pid_list
**p
;
358 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
359 if ((*p
)->pid
== pid
)
361 struct simple_pid_list
*next
= (*p
)->next
;
363 *statusp
= (*p
)->status
;
371 /* Return the ptrace options that we want to try to enable. */
374 linux_nat_ptrace_options (int attached
)
379 options
|= PTRACE_O_EXITKILL
;
381 options
|= (PTRACE_O_TRACESYSGOOD
382 | PTRACE_O_TRACEVFORKDONE
383 | PTRACE_O_TRACEVFORK
385 | PTRACE_O_TRACEEXEC
);
390 /* Initialize ptrace and procfs warnings and check for supported
391 ptrace features given PID.
393 ATTACHED should be nonzero iff we attached to the inferior. */
396 linux_init_ptrace_procfs (pid_t pid
, int attached
)
398 int options
= linux_nat_ptrace_options (attached
);
400 linux_enable_event_reporting (pid
, options
);
401 linux_ptrace_init_warnings ();
402 linux_proc_init_warnings ();
405 linux_nat_target::~linux_nat_target ()
409 linux_nat_target::post_attach (int pid
)
411 linux_init_ptrace_procfs (pid
, 1);
415 linux_nat_target::post_startup_inferior (ptid_t ptid
)
417 linux_init_ptrace_procfs (ptid
.pid (), 0);
420 /* Return the number of known LWPs in the tgid given by PID. */
427 for (const lwp_info
*lp ATTRIBUTE_UNUSED
: all_lwps ())
428 if (lp
->ptid
.pid () == pid
)
434 /* Deleter for lwp_info unique_ptr specialisation. */
438 void operator() (struct lwp_info
*lwp
) const
440 delete_lwp (lwp
->ptid
);
444 /* A unique_ptr specialisation for lwp_info. */
446 typedef std::unique_ptr
<struct lwp_info
, lwp_deleter
> lwp_info_up
;
448 /* Target hook for follow_fork. */
451 linux_nat_target::follow_fork (inferior
*child_inf
, ptid_t child_ptid
,
452 target_waitkind fork_kind
, bool follow_child
,
455 inf_ptrace_target::follow_fork (child_inf
, child_ptid
, fork_kind
,
456 follow_child
, detach_fork
);
460 bool has_vforked
= fork_kind
== TARGET_WAITKIND_VFORKED
;
461 ptid_t parent_ptid
= inferior_ptid
;
462 int parent_pid
= parent_ptid
.lwp ();
463 int child_pid
= child_ptid
.lwp ();
465 /* We're already attached to the parent, by default. */
466 lwp_info
*child_lp
= add_lwp (child_ptid
);
467 child_lp
->stopped
= 1;
468 child_lp
->last_resume_kind
= resume_stop
;
470 /* Detach new forked process? */
473 int child_stop_signal
= 0;
474 bool detach_child
= true;
476 /* Move CHILD_LP into a unique_ptr and clear the source pointer
477 to prevent us doing anything stupid with it. */
478 lwp_info_up
child_lp_ptr (child_lp
);
481 linux_target
->low_prepare_to_resume (child_lp_ptr
.get ());
483 /* When debugging an inferior in an architecture that supports
484 hardware single stepping on a kernel without commit
485 6580807da14c423f0d0a708108e6df6ebc8bc83d, the vfork child
486 process starts with the TIF_SINGLESTEP/X86_EFLAGS_TF bits
487 set if the parent process had them set.
488 To work around this, single step the child process
489 once before detaching to clear the flags. */
491 /* Note that we consult the parent's architecture instead of
492 the child's because there's no inferior for the child at
494 if (!gdbarch_software_single_step_p (target_thread_architecture
499 linux_disable_event_reporting (child_pid
);
500 if (ptrace (PTRACE_SINGLESTEP
, child_pid
, 0, 0) < 0)
501 perror_with_name (_("Couldn't do single step"));
502 if (my_waitpid (child_pid
, &status
, 0) < 0)
503 perror_with_name (_("Couldn't wait vfork process"));
506 detach_child
= WIFSTOPPED (status
);
507 child_stop_signal
= WSTOPSIG (status
);
513 int signo
= child_stop_signal
;
516 && !signal_pass_state (gdb_signal_from_host (signo
)))
518 ptrace (PTRACE_DETACH
, child_pid
, 0, signo
);
520 close_proc_mem_file (child_pid
);
526 struct lwp_info
*parent_lp
;
528 parent_lp
= find_lwp_pid (parent_ptid
);
529 gdb_assert (linux_supports_tracefork () >= 0);
531 if (linux_supports_tracevforkdone ())
533 linux_nat_debug_printf ("waiting for VFORK_DONE on %d",
535 parent_lp
->stopped
= 1;
537 /* We'll handle the VFORK_DONE event like any other
538 event, in target_wait. */
542 /* We can't insert breakpoints until the child has
543 finished with the shared memory region. We need to
544 wait until that happens. Ideal would be to just
546 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
547 - waitpid (parent_pid, &status, __WALL);
548 However, most architectures can't handle a syscall
549 being traced on the way out if it wasn't traced on
552 We might also think to loop, continuing the child
553 until it exits or gets a SIGTRAP. One problem is
554 that the child might call ptrace with PTRACE_TRACEME.
556 There's no simple and reliable way to figure out when
557 the vforked child will be done with its copy of the
558 shared memory. We could step it out of the syscall,
559 two instructions, let it go, and then single-step the
560 parent once. When we have hardware single-step, this
561 would work; with software single-step it could still
562 be made to work but we'd have to be able to insert
563 single-step breakpoints in the child, and we'd have
564 to insert -just- the single-step breakpoint in the
565 parent. Very awkward.
567 In the end, the best we can do is to make sure it
568 runs for a little while. Hopefully it will be out of
569 range of any breakpoints we reinsert. Usually this
570 is only the single-step breakpoint at vfork's return
573 linux_nat_debug_printf ("no VFORK_DONE support, sleeping a bit");
577 /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
578 and leave it pending. The next linux_nat_resume call
579 will notice a pending event, and bypasses actually
580 resuming the inferior. */
581 parent_lp
->status
= 0;
582 parent_lp
->waitstatus
.set_vfork_done ();
583 parent_lp
->stopped
= 1;
585 /* If we're in async mode, need to tell the event loop
586 there's something here to process. */
587 if (target_is_async_p ())
594 struct lwp_info
*child_lp
;
596 child_lp
= add_lwp (child_ptid
);
597 child_lp
->stopped
= 1;
598 child_lp
->last_resume_kind
= resume_stop
;
604 linux_nat_target::insert_fork_catchpoint (int pid
)
606 return !linux_supports_tracefork ();
610 linux_nat_target::remove_fork_catchpoint (int pid
)
616 linux_nat_target::insert_vfork_catchpoint (int pid
)
618 return !linux_supports_tracefork ();
622 linux_nat_target::remove_vfork_catchpoint (int pid
)
628 linux_nat_target::insert_exec_catchpoint (int pid
)
630 return !linux_supports_tracefork ();
634 linux_nat_target::remove_exec_catchpoint (int pid
)
640 linux_nat_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
641 gdb::array_view
<const int> syscall_counts
)
643 if (!linux_supports_tracesysgood ())
646 /* On GNU/Linux, we ignore the arguments. It means that we only
647 enable the syscall catchpoints, but do not disable them.
649 Also, we do not use the `syscall_counts' information because we do not
650 filter system calls here. We let GDB do the logic for us. */
654 /* List of known LWPs, keyed by LWP PID. This speeds up the common
655 case of mapping a PID returned from the kernel to our corresponding
656 lwp_info data structure. */
657 static htab_t lwp_lwpid_htab
;
659 /* Calculate a hash from a lwp_info's LWP PID. */
662 lwp_info_hash (const void *ap
)
664 const struct lwp_info
*lp
= (struct lwp_info
*) ap
;
665 pid_t pid
= lp
->ptid
.lwp ();
667 return iterative_hash_object (pid
, 0);
670 /* Equality function for the lwp_info hash table. Compares the LWP's
674 lwp_lwpid_htab_eq (const void *a
, const void *b
)
676 const struct lwp_info
*entry
= (const struct lwp_info
*) a
;
677 const struct lwp_info
*element
= (const struct lwp_info
*) b
;
679 return entry
->ptid
.lwp () == element
->ptid
.lwp ();
682 /* Create the lwp_lwpid_htab hash table. */
685 lwp_lwpid_htab_create (void)
687 lwp_lwpid_htab
= htab_create (100, lwp_info_hash
, lwp_lwpid_htab_eq
, NULL
);
690 /* Add LP to the hash table. */
693 lwp_lwpid_htab_add_lwp (struct lwp_info
*lp
)
697 slot
= htab_find_slot (lwp_lwpid_htab
, lp
, INSERT
);
698 gdb_assert (slot
!= NULL
&& *slot
== NULL
);
702 /* Head of doubly-linked list of known LWPs. Sorted by reverse
703 creation order. This order is assumed in some cases. E.g.,
704 reaping status after killing alls lwps of a process: the leader LWP
705 must be reaped last. */
707 static intrusive_list
<lwp_info
> lwp_list
;
709 /* See linux-nat.h. */
714 return lwp_info_range (lwp_list
.begin ());
717 /* See linux-nat.h. */
722 return lwp_info_safe_range (lwp_list
.begin ());
725 /* Add LP to sorted-by-reverse-creation-order doubly-linked list. */
728 lwp_list_add (struct lwp_info
*lp
)
730 lwp_list
.push_front (*lp
);
733 /* Remove LP from sorted-by-reverse-creation-order doubly-linked
737 lwp_list_remove (struct lwp_info
*lp
)
739 /* Remove from sorted-by-creation-order list. */
740 lwp_list
.erase (lwp_list
.iterator_to (*lp
));
745 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
746 _initialize_linux_nat. */
747 static sigset_t suspend_mask
;
749 /* Signals to block to make that sigsuspend work. */
750 static sigset_t blocked_mask
;
752 /* SIGCHLD action. */
753 static struct sigaction sigchld_action
;
755 /* Block child signals (SIGCHLD and linux threads signals), and store
756 the previous mask in PREV_MASK. */
759 block_child_signals (sigset_t
*prev_mask
)
761 /* Make sure SIGCHLD is blocked. */
762 if (!sigismember (&blocked_mask
, SIGCHLD
))
763 sigaddset (&blocked_mask
, SIGCHLD
);
765 gdb_sigmask (SIG_BLOCK
, &blocked_mask
, prev_mask
);
768 /* Restore child signals mask, previously returned by
769 block_child_signals. */
772 restore_child_signals_mask (sigset_t
*prev_mask
)
774 gdb_sigmask (SIG_SETMASK
, prev_mask
, NULL
);
777 /* Mask of signals to pass directly to the inferior. */
778 static sigset_t pass_mask
;
780 /* Update signals to pass to the inferior. */
782 linux_nat_target::pass_signals
783 (gdb::array_view
<const unsigned char> pass_signals
)
787 sigemptyset (&pass_mask
);
789 for (signo
= 1; signo
< NSIG
; signo
++)
791 int target_signo
= gdb_signal_from_host (signo
);
792 if (target_signo
< pass_signals
.size () && pass_signals
[target_signo
])
793 sigaddset (&pass_mask
, signo
);
799 /* Prototypes for local functions. */
800 static int stop_wait_callback (struct lwp_info
*lp
);
801 static int resume_stopped_resumed_lwps (struct lwp_info
*lp
, const ptid_t wait_ptid
);
802 static int check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
);
806 /* Destroy and free LP. */
808 lwp_info::~lwp_info ()
810 /* Let the arch specific bits release arch_lwp_info. */
811 linux_target
->low_delete_thread (this->arch_private
);
814 /* Traversal function for purge_lwp_list. */
817 lwp_lwpid_htab_remove_pid (void **slot
, void *info
)
819 struct lwp_info
*lp
= (struct lwp_info
*) *slot
;
820 int pid
= *(int *) info
;
822 if (lp
->ptid
.pid () == pid
)
824 htab_clear_slot (lwp_lwpid_htab
, slot
);
825 lwp_list_remove (lp
);
832 /* Remove all LWPs belong to PID from the lwp list. */
835 purge_lwp_list (int pid
)
837 htab_traverse_noresize (lwp_lwpid_htab
, lwp_lwpid_htab_remove_pid
, &pid
);
840 /* Add the LWP specified by PTID to the list. PTID is the first LWP
841 in the process. Return a pointer to the structure describing the
844 This differs from add_lwp in that we don't let the arch specific
845 bits know about this new thread. Current clients of this callback
846 take the opportunity to install watchpoints in the new thread, and
847 we shouldn't do that for the first thread. If we're spawning a
848 child ("run"), the thread executes the shell wrapper first, and we
849 shouldn't touch it until it execs the program we want to debug.
850 For "attach", it'd be okay to call the callback, but it's not
851 necessary, because watchpoints can't yet have been inserted into
854 static struct lwp_info
*
855 add_initial_lwp (ptid_t ptid
)
857 gdb_assert (ptid
.lwp_p ());
859 lwp_info
*lp
= new lwp_info (ptid
);
862 /* Add to sorted-by-reverse-creation-order list. */
865 /* Add to keyed-by-pid htab. */
866 lwp_lwpid_htab_add_lwp (lp
);
871 /* Add the LWP specified by PID to the list. Return a pointer to the
872 structure describing the new LWP. The LWP should already be
875 static struct lwp_info
*
876 add_lwp (ptid_t ptid
)
880 lp
= add_initial_lwp (ptid
);
882 /* Let the arch specific bits know about this new thread. Current
883 clients of this callback take the opportunity to install
884 watchpoints in the new thread. We don't do this for the first
885 thread though. See add_initial_lwp. */
886 linux_target
->low_new_thread (lp
);
891 /* Remove the LWP specified by PID from the list. */
894 delete_lwp (ptid_t ptid
)
896 lwp_info
dummy (ptid
);
898 void **slot
= htab_find_slot (lwp_lwpid_htab
, &dummy
, NO_INSERT
);
902 lwp_info
*lp
= *(struct lwp_info
**) slot
;
903 gdb_assert (lp
!= NULL
);
905 htab_clear_slot (lwp_lwpid_htab
, slot
);
907 /* Remove from sorted-by-creation-order list. */
908 lwp_list_remove (lp
);
914 /* Return a pointer to the structure describing the LWP corresponding
915 to PID. If no corresponding LWP could be found, return NULL. */
917 static struct lwp_info
*
918 find_lwp_pid (ptid_t ptid
)
927 lwp_info
dummy (ptid_t (0, lwp
));
928 return (struct lwp_info
*) htab_find (lwp_lwpid_htab
, &dummy
);
931 /* See nat/linux-nat.h. */
934 iterate_over_lwps (ptid_t filter
,
935 gdb::function_view
<iterate_over_lwps_ftype
> callback
)
937 for (lwp_info
*lp
: all_lwps_safe ())
939 if (lp
->ptid
.matches (filter
))
941 if (callback (lp
) != 0)
949 /* Update our internal state when changing from one checkpoint to
950 another indicated by NEW_PTID. We can only switch single-threaded
951 applications, so we only create one new LWP, and the previous list
955 linux_nat_switch_fork (ptid_t new_ptid
)
959 purge_lwp_list (inferior_ptid
.pid ());
961 lp
= add_lwp (new_ptid
);
964 /* This changes the thread's ptid while preserving the gdb thread
965 num. Also changes the inferior pid, while preserving the
967 thread_change_ptid (linux_target
, inferior_ptid
, new_ptid
);
969 /* We've just told GDB core that the thread changed target id, but,
970 in fact, it really is a different thread, with different register
972 registers_changed ();
975 /* Handle the exit of a single thread LP. */
978 exit_lwp (struct lwp_info
*lp
)
980 struct thread_info
*th
= find_thread_ptid (linux_target
, lp
->ptid
);
984 if (print_thread_events
)
985 printf_unfiltered (_("[%s exited]\n"),
986 target_pid_to_str (lp
->ptid
).c_str ());
991 delete_lwp (lp
->ptid
);
994 /* Wait for the LWP specified by LP, which we have just attached to.
995 Returns a wait status for that LWP, to cache. */
998 linux_nat_post_attach_wait (ptid_t ptid
, int *signalled
)
1000 pid_t new_pid
, pid
= ptid
.lwp ();
1003 if (linux_proc_pid_is_stopped (pid
))
1005 linux_nat_debug_printf ("Attaching to a stopped process");
1007 /* The process is definitely stopped. It is in a job control
1008 stop, unless the kernel predates the TASK_STOPPED /
1009 TASK_TRACED distinction, in which case it might be in a
1010 ptrace stop. Make sure it is in a ptrace stop; from there we
1011 can kill it, signal it, et cetera.
1013 First make sure there is a pending SIGSTOP. Since we are
1014 already attached, the process can not transition from stopped
1015 to running without a PTRACE_CONT; so we know this signal will
1016 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1017 probably already in the queue (unless this kernel is old
1018 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1019 is not an RT signal, it can only be queued once. */
1020 kill_lwp (pid
, SIGSTOP
);
1022 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1023 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1024 ptrace (PTRACE_CONT
, pid
, 0, 0);
1027 /* Make sure the initial process is stopped. The user-level threads
1028 layer might want to poke around in the inferior, and that won't
1029 work if things haven't stabilized yet. */
1030 new_pid
= my_waitpid (pid
, &status
, __WALL
);
1031 gdb_assert (pid
== new_pid
);
1033 if (!WIFSTOPPED (status
))
1035 /* The pid we tried to attach has apparently just exited. */
1036 linux_nat_debug_printf ("Failed to stop %d: %s", pid
,
1037 status_to_str (status
).c_str ());
1041 if (WSTOPSIG (status
) != SIGSTOP
)
1044 linux_nat_debug_printf ("Received %s after attaching",
1045 status_to_str (status
).c_str ());
1052 linux_nat_target::create_inferior (const char *exec_file
,
1053 const std::string
&allargs
,
1054 char **env
, int from_tty
)
1056 maybe_disable_address_space_randomization restore_personality
1057 (disable_randomization
);
1059 /* The fork_child mechanism is synchronous and calls target_wait, so
1060 we have to mask the async mode. */
1062 /* Make sure we report all signals during startup. */
1065 inf_ptrace_target::create_inferior (exec_file
, allargs
, env
, from_tty
);
1067 open_proc_mem_file (inferior_ptid
);
1070 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1071 already attached. Returns true if a new LWP is found, false
1075 attach_proc_task_lwp_callback (ptid_t ptid
)
1077 struct lwp_info
*lp
;
1079 /* Ignore LWPs we're already attached to. */
1080 lp
= find_lwp_pid (ptid
);
1083 int lwpid
= ptid
.lwp ();
1085 if (ptrace (PTRACE_ATTACH
, lwpid
, 0, 0) < 0)
1089 /* Be quiet if we simply raced with the thread exiting.
1090 EPERM is returned if the thread's task still exists, and
1091 is marked as exited or zombie, as well as other
1092 conditions, so in that case, confirm the status in
1093 /proc/PID/status. */
1095 || (err
== EPERM
&& linux_proc_pid_is_gone (lwpid
)))
1097 linux_nat_debug_printf
1098 ("Cannot attach to lwp %d: thread is gone (%d: %s)",
1099 lwpid
, err
, safe_strerror (err
));
1105 = linux_ptrace_attach_fail_reason_string (ptid
, err
);
1107 warning (_("Cannot attach to lwp %d: %s"),
1108 lwpid
, reason
.c_str ());
1113 linux_nat_debug_printf ("PTRACE_ATTACH %s, 0, 0 (OK)",
1114 target_pid_to_str (ptid
).c_str ());
1116 lp
= add_lwp (ptid
);
1118 /* The next time we wait for this LWP we'll see a SIGSTOP as
1119 PTRACE_ATTACH brings it to a halt. */
1122 /* We need to wait for a stop before being able to make the
1123 next ptrace call on this LWP. */
1124 lp
->must_set_ptrace_flags
= 1;
1126 /* So that wait collects the SIGSTOP. */
1129 /* Also add the LWP to gdb's thread list, in case a
1130 matching libthread_db is not found (or the process uses
1132 add_thread (linux_target
, lp
->ptid
);
1133 set_running (linux_target
, lp
->ptid
, true);
1134 set_executing (linux_target
, lp
->ptid
, true);
1143 linux_nat_target::attach (const char *args
, int from_tty
)
1145 struct lwp_info
*lp
;
1149 /* Make sure we report all signals during attach. */
1154 inf_ptrace_target::attach (args
, from_tty
);
1156 catch (const gdb_exception_error
&ex
)
1158 pid_t pid
= parse_pid_to_attach (args
);
1159 std::string reason
= linux_ptrace_attach_fail_reason (pid
);
1161 if (!reason
.empty ())
1162 throw_error (ex
.error
, "warning: %s\n%s", reason
.c_str (),
1165 throw_error (ex
.error
, "%s", ex
.what ());
1168 /* The ptrace base target adds the main thread with (pid,0,0)
1169 format. Decorate it with lwp info. */
1170 ptid
= ptid_t (inferior_ptid
.pid (),
1171 inferior_ptid
.pid ());
1172 thread_change_ptid (linux_target
, inferior_ptid
, ptid
);
1174 /* Add the initial process as the first LWP to the list. */
1175 lp
= add_initial_lwp (ptid
);
1177 status
= linux_nat_post_attach_wait (lp
->ptid
, &lp
->signalled
);
1178 if (!WIFSTOPPED (status
))
1180 if (WIFEXITED (status
))
1182 int exit_code
= WEXITSTATUS (status
);
1184 target_terminal::ours ();
1185 target_mourn_inferior (inferior_ptid
);
1187 error (_("Unable to attach: program exited normally."));
1189 error (_("Unable to attach: program exited with code %d."),
1192 else if (WIFSIGNALED (status
))
1194 enum gdb_signal signo
;
1196 target_terminal::ours ();
1197 target_mourn_inferior (inferior_ptid
);
1199 signo
= gdb_signal_from_host (WTERMSIG (status
));
1200 error (_("Unable to attach: program terminated with signal "
1202 gdb_signal_to_name (signo
),
1203 gdb_signal_to_string (signo
));
1206 internal_error (__FILE__
, __LINE__
,
1207 _("unexpected status %d for PID %ld"),
1208 status
, (long) ptid
.lwp ());
1213 open_proc_mem_file (lp
->ptid
);
1215 /* Save the wait status to report later. */
1217 linux_nat_debug_printf ("waitpid %ld, saving status %s",
1218 (long) lp
->ptid
.pid (),
1219 status_to_str (status
).c_str ());
1221 lp
->status
= status
;
1223 /* We must attach to every LWP. If /proc is mounted, use that to
1224 find them now. The inferior may be using raw clone instead of
1225 using pthreads. But even if it is using pthreads, thread_db
1226 walks structures in the inferior's address space to find the list
1227 of threads/LWPs, and those structures may well be corrupted.
1228 Note that once thread_db is loaded, we'll still use it to list
1229 threads and associate pthread info with each LWP. */
1230 linux_proc_attach_tgid_threads (lp
->ptid
.pid (),
1231 attach_proc_task_lwp_callback
);
1233 if (target_can_async_p ())
1237 /* Get pending signal of THREAD as a host signal number, for detaching
1238 purposes. This is the signal the thread last stopped for, which we
1239 need to deliver to the thread when detaching, otherwise, it'd be
1243 get_detach_signal (struct lwp_info
*lp
)
1245 enum gdb_signal signo
= GDB_SIGNAL_0
;
1247 /* If we paused threads momentarily, we may have stored pending
1248 events in lp->status or lp->waitstatus (see stop_wait_callback),
1249 and GDB core hasn't seen any signal for those threads.
1250 Otherwise, the last signal reported to the core is found in the
1251 thread object's stop_signal.
1253 There's a corner case that isn't handled here at present. Only
1254 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1255 stop_signal make sense as a real signal to pass to the inferior.
1256 Some catchpoint related events, like
1257 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1258 to GDB_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1259 those traps are debug API (ptrace in our case) related and
1260 induced; the inferior wouldn't see them if it wasn't being
1261 traced. Hence, we should never pass them to the inferior, even
1262 when set to pass state. Since this corner case isn't handled by
1263 infrun.c when proceeding with a signal, for consistency, neither
1264 do we handle it here (or elsewhere in the file we check for
1265 signal pass state). Normally SIGTRAP isn't set to pass state, so
1266 this is really a corner case. */
1268 if (lp
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
1269 signo
= GDB_SIGNAL_0
; /* a pending ptrace event, not a real signal. */
1270 else if (lp
->status
)
1271 signo
= gdb_signal_from_host (WSTOPSIG (lp
->status
));
1274 struct thread_info
*tp
= find_thread_ptid (linux_target
, lp
->ptid
);
1276 if (target_is_non_stop_p () && !tp
->executing ())
1278 if (tp
->has_pending_waitstatus ())
1279 signo
= tp
->pending_waitstatus ().sig ();
1281 signo
= tp
->stop_signal ();
1283 else if (!target_is_non_stop_p ())
1286 process_stratum_target
*last_target
;
1288 get_last_target_status (&last_target
, &last_ptid
, nullptr);
1290 if (last_target
== linux_target
1291 && lp
->ptid
.lwp () == last_ptid
.lwp ())
1292 signo
= tp
->stop_signal ();
1296 if (signo
== GDB_SIGNAL_0
)
1298 linux_nat_debug_printf ("lwp %s has no pending signal",
1299 target_pid_to_str (lp
->ptid
).c_str ());
1301 else if (!signal_pass_state (signo
))
1303 linux_nat_debug_printf
1304 ("lwp %s had signal %s but it is in no pass state",
1305 target_pid_to_str (lp
->ptid
).c_str (), gdb_signal_to_string (signo
));
1309 linux_nat_debug_printf ("lwp %s has pending signal %s",
1310 target_pid_to_str (lp
->ptid
).c_str (),
1311 gdb_signal_to_string (signo
));
1313 return gdb_signal_to_host (signo
);
1319 /* Detach from LP. If SIGNO_P is non-NULL, then it points to the
1320 signal number that should be passed to the LWP when detaching.
1321 Otherwise pass any pending signal the LWP may have, if any. */
1324 detach_one_lwp (struct lwp_info
*lp
, int *signo_p
)
1326 int lwpid
= lp
->ptid
.lwp ();
1329 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1331 if (lp
->status
!= 0)
1332 linux_nat_debug_printf ("Pending %s for %s on detach.",
1333 strsignal (WSTOPSIG (lp
->status
)),
1334 target_pid_to_str (lp
->ptid
).c_str ());
1336 /* If there is a pending SIGSTOP, get rid of it. */
1339 linux_nat_debug_printf ("Sending SIGCONT to %s",
1340 target_pid_to_str (lp
->ptid
).c_str ());
1342 kill_lwp (lwpid
, SIGCONT
);
1346 if (signo_p
== NULL
)
1348 /* Pass on any pending signal for this LWP. */
1349 signo
= get_detach_signal (lp
);
1354 /* Preparing to resume may try to write registers, and fail if the
1355 lwp is zombie. If that happens, ignore the error. We'll handle
1356 it below, when detach fails with ESRCH. */
1359 linux_target
->low_prepare_to_resume (lp
);
1361 catch (const gdb_exception_error
&ex
)
1363 if (!check_ptrace_stopped_lwp_gone (lp
))
1367 if (ptrace (PTRACE_DETACH
, lwpid
, 0, signo
) < 0)
1369 int save_errno
= errno
;
1371 /* We know the thread exists, so ESRCH must mean the lwp is
1372 zombie. This can happen if one of the already-detached
1373 threads exits the whole thread group. In that case we're
1374 still attached, and must reap the lwp. */
1375 if (save_errno
== ESRCH
)
1379 ret
= my_waitpid (lwpid
, &status
, __WALL
);
1382 warning (_("Couldn't reap LWP %d while detaching: %s"),
1383 lwpid
, safe_strerror (errno
));
1385 else if (!WIFEXITED (status
) && !WIFSIGNALED (status
))
1387 warning (_("Reaping LWP %d while detaching "
1388 "returned unexpected status 0x%x"),
1394 error (_("Can't detach %s: %s"),
1395 target_pid_to_str (lp
->ptid
).c_str (),
1396 safe_strerror (save_errno
));
1400 linux_nat_debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)",
1401 target_pid_to_str (lp
->ptid
).c_str (),
1404 delete_lwp (lp
->ptid
);
1408 detach_callback (struct lwp_info
*lp
)
1410 /* We don't actually detach from the thread group leader just yet.
1411 If the thread group exits, we must reap the zombie clone lwps
1412 before we're able to reap the leader. */
1413 if (lp
->ptid
.lwp () != lp
->ptid
.pid ())
1414 detach_one_lwp (lp
, NULL
);
1419 linux_nat_target::detach (inferior
*inf
, int from_tty
)
1421 struct lwp_info
*main_lwp
;
1424 /* Don't unregister from the event loop, as there may be other
1425 inferiors running. */
1427 /* Stop all threads before detaching. ptrace requires that the
1428 thread is stopped to successfully detach. */
1429 iterate_over_lwps (ptid_t (pid
), stop_callback
);
1430 /* ... and wait until all of them have reported back that
1431 they're no longer running. */
1432 iterate_over_lwps (ptid_t (pid
), stop_wait_callback
);
1434 /* We can now safely remove breakpoints. We don't this in earlier
1435 in common code because this target doesn't currently support
1436 writing memory while the inferior is running. */
1437 remove_breakpoints_inf (current_inferior ());
1439 iterate_over_lwps (ptid_t (pid
), detach_callback
);
1441 /* Only the initial process should be left right now. */
1442 gdb_assert (num_lwps (pid
) == 1);
1444 main_lwp
= find_lwp_pid (ptid_t (pid
));
1446 if (forks_exist_p ())
1448 /* Multi-fork case. The current inferior_ptid is being detached
1449 from, but there are other viable forks to debug. Detach from
1450 the current fork, and context-switch to the first
1452 linux_fork_detach (from_tty
);
1456 target_announce_detach (from_tty
);
1458 /* Pass on any pending signal for the last LWP. */
1459 int signo
= get_detach_signal (main_lwp
);
1461 detach_one_lwp (main_lwp
, &signo
);
1463 detach_success (inf
);
1466 close_proc_mem_file (pid
);
1469 /* Resume execution of the inferior process. If STEP is nonzero,
1470 single-step it. If SIGNAL is nonzero, give it that signal. */
1473 linux_resume_one_lwp_throw (struct lwp_info
*lp
, int step
,
1474 enum gdb_signal signo
)
1478 /* stop_pc doubles as the PC the LWP had when it was last resumed.
1479 We only presently need that if the LWP is stepped though (to
1480 handle the case of stepping a breakpoint instruction). */
1483 struct regcache
*regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
1485 lp
->stop_pc
= regcache_read_pc (regcache
);
1490 linux_target
->low_prepare_to_resume (lp
);
1491 linux_target
->low_resume (lp
->ptid
, step
, signo
);
1493 /* Successfully resumed. Clear state that no longer makes sense,
1494 and mark the LWP as running. Must not do this before resuming
1495 otherwise if that fails other code will be confused. E.g., we'd
1496 later try to stop the LWP and hang forever waiting for a stop
1497 status. Note that we must not throw after this is cleared,
1498 otherwise handle_zombie_lwp_error would get confused. */
1501 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1502 registers_changed_ptid (linux_target
, lp
->ptid
);
1505 /* Called when we try to resume a stopped LWP and that errors out. If
1506 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
1507 or about to become), discard the error, clear any pending status
1508 the LWP may have, and return true (we'll collect the exit status
1509 soon enough). Otherwise, return false. */
1512 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
1514 /* If we get an error after resuming the LWP successfully, we'd
1515 confuse !T state for the LWP being gone. */
1516 gdb_assert (lp
->stopped
);
1518 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
1519 because even if ptrace failed with ESRCH, the tracee may be "not
1520 yet fully dead", but already refusing ptrace requests. In that
1521 case the tracee has 'R (Running)' state for a little bit
1522 (observed in Linux 3.18). See also the note on ESRCH in the
1523 ptrace(2) man page. Instead, check whether the LWP has any state
1524 other than ptrace-stopped. */
1526 /* Don't assume anything if /proc/PID/status can't be read. */
1527 if (linux_proc_pid_is_trace_stopped_nowarn (lp
->ptid
.lwp ()) == 0)
1529 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1531 lp
->waitstatus
.set_ignore ();
1537 /* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
1538 disappears while we try to resume it. */
1541 linux_resume_one_lwp (struct lwp_info
*lp
, int step
, enum gdb_signal signo
)
1545 linux_resume_one_lwp_throw (lp
, step
, signo
);
1547 catch (const gdb_exception_error
&ex
)
1549 if (!check_ptrace_stopped_lwp_gone (lp
))
1557 resume_lwp (struct lwp_info
*lp
, int step
, enum gdb_signal signo
)
1561 struct inferior
*inf
= find_inferior_ptid (linux_target
, lp
->ptid
);
1563 if (inf
->vfork_child
!= NULL
)
1565 linux_nat_debug_printf ("Not resuming %s (vfork parent)",
1566 target_pid_to_str (lp
->ptid
).c_str ());
1568 else if (!lwp_status_pending_p (lp
))
1570 linux_nat_debug_printf ("Resuming sibling %s, %s, %s",
1571 target_pid_to_str (lp
->ptid
).c_str (),
1572 (signo
!= GDB_SIGNAL_0
1573 ? strsignal (gdb_signal_to_host (signo
))
1575 step
? "step" : "resume");
1577 linux_resume_one_lwp (lp
, step
, signo
);
1581 linux_nat_debug_printf ("Not resuming sibling %s (has pending)",
1582 target_pid_to_str (lp
->ptid
).c_str ());
1586 linux_nat_debug_printf ("Not resuming sibling %s (not stopped)",
1587 target_pid_to_str (lp
->ptid
).c_str ());
1590 /* Callback for iterate_over_lwps. If LWP is EXCEPT, do nothing.
1591 Resume LWP with the last stop signal, if it is in pass state. */
1594 linux_nat_resume_callback (struct lwp_info
*lp
, struct lwp_info
*except
)
1596 enum gdb_signal signo
= GDB_SIGNAL_0
;
1603 struct thread_info
*thread
;
1605 thread
= find_thread_ptid (linux_target
, lp
->ptid
);
1608 signo
= thread
->stop_signal ();
1609 thread
->set_stop_signal (GDB_SIGNAL_0
);
1613 resume_lwp (lp
, 0, signo
);
1618 resume_clear_callback (struct lwp_info
*lp
)
1621 lp
->last_resume_kind
= resume_stop
;
1626 resume_set_callback (struct lwp_info
*lp
)
1629 lp
->last_resume_kind
= resume_continue
;
1634 linux_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1636 struct lwp_info
*lp
;
1639 linux_nat_debug_printf ("Preparing to %s %s, %s, inferior_ptid %s",
1640 step
? "step" : "resume",
1641 target_pid_to_str (ptid
).c_str (),
1642 (signo
!= GDB_SIGNAL_0
1643 ? strsignal (gdb_signal_to_host (signo
)) : "0"),
1644 target_pid_to_str (inferior_ptid
).c_str ());
1646 /* A specific PTID means `step only this process id'. */
1647 resume_many
= (minus_one_ptid
== ptid
1650 /* Mark the lwps we're resuming as resumed and update their
1651 last_resume_kind to resume_continue. */
1652 iterate_over_lwps (ptid
, resume_set_callback
);
1654 /* See if it's the current inferior that should be handled
1657 lp
= find_lwp_pid (inferior_ptid
);
1659 lp
= find_lwp_pid (ptid
);
1660 gdb_assert (lp
!= NULL
);
1662 /* Remember if we're stepping. */
1663 lp
->last_resume_kind
= step
? resume_step
: resume_continue
;
1665 /* If we have a pending wait status for this thread, there is no
1666 point in resuming the process. But first make sure that
1667 linux_nat_wait won't preemptively handle the event - we
1668 should never take this short-circuit if we are going to
1669 leave LP running, since we have skipped resuming all the
1670 other threads. This bit of code needs to be synchronized
1671 with linux_nat_wait. */
1673 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1676 && WSTOPSIG (lp
->status
)
1677 && sigismember (&pass_mask
, WSTOPSIG (lp
->status
)))
1679 linux_nat_debug_printf
1680 ("Not short circuiting for ignored status 0x%x", lp
->status
);
1682 /* FIXME: What should we do if we are supposed to continue
1683 this thread with a signal? */
1684 gdb_assert (signo
== GDB_SIGNAL_0
);
1685 signo
= gdb_signal_from_host (WSTOPSIG (lp
->status
));
1690 if (lwp_status_pending_p (lp
))
1692 /* FIXME: What should we do if we are supposed to continue
1693 this thread with a signal? */
1694 gdb_assert (signo
== GDB_SIGNAL_0
);
1696 linux_nat_debug_printf ("Short circuiting for status 0x%x",
1699 if (target_can_async_p ())
1702 /* Tell the event loop we have something to process. */
1709 iterate_over_lwps (ptid
, [=] (struct lwp_info
*info
)
1711 return linux_nat_resume_callback (info
, lp
);
1714 linux_nat_debug_printf ("%s %s, %s (resume event thread)",
1715 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1716 target_pid_to_str (lp
->ptid
).c_str (),
1717 (signo
!= GDB_SIGNAL_0
1718 ? strsignal (gdb_signal_to_host (signo
)) : "0"));
1720 linux_resume_one_lwp (lp
, step
, signo
);
1722 if (target_can_async_p ())
1726 /* Send a signal to an LWP. */
1729 kill_lwp (int lwpid
, int signo
)
1734 ret
= syscall (__NR_tkill
, lwpid
, signo
);
1735 if (errno
== ENOSYS
)
1737 /* If tkill fails, then we are not using nptl threads, a
1738 configuration we no longer support. */
1739 perror_with_name (("tkill"));
1744 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
1745 event, check if the core is interested in it: if not, ignore the
1746 event, and keep waiting; otherwise, we need to toggle the LWP's
1747 syscall entry/exit status, since the ptrace event itself doesn't
1748 indicate it, and report the trap to higher layers. */
1751 linux_handle_syscall_trap (struct lwp_info
*lp
, int stopping
)
1753 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1754 struct gdbarch
*gdbarch
= target_thread_architecture (lp
->ptid
);
1755 thread_info
*thread
= find_thread_ptid (linux_target
, lp
->ptid
);
1756 int syscall_number
= (int) gdbarch_get_syscall_number (gdbarch
, thread
);
1760 /* If we're stopping threads, there's a SIGSTOP pending, which
1761 makes it so that the LWP reports an immediate syscall return,
1762 followed by the SIGSTOP. Skip seeing that "return" using
1763 PTRACE_CONT directly, and let stop_wait_callback collect the
1764 SIGSTOP. Later when the thread is resumed, a new syscall
1765 entry event. If we didn't do this (and returned 0), we'd
1766 leave a syscall entry pending, and our caller, by using
1767 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1768 itself. Later, when the user re-resumes this LWP, we'd see
1769 another syscall entry event and we'd mistake it for a return.
1771 If stop_wait_callback didn't force the SIGSTOP out of the LWP
1772 (leaving immediately with LWP->signalled set, without issuing
1773 a PTRACE_CONT), it would still be problematic to leave this
1774 syscall enter pending, as later when the thread is resumed,
1775 it would then see the same syscall exit mentioned above,
1776 followed by the delayed SIGSTOP, while the syscall didn't
1777 actually get to execute. It seems it would be even more
1778 confusing to the user. */
1780 linux_nat_debug_printf
1781 ("ignoring syscall %d for LWP %ld (stopping threads), resuming with "
1782 "PTRACE_CONT for SIGSTOP", syscall_number
, lp
->ptid
.lwp ());
1784 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
1785 ptrace (PTRACE_CONT
, lp
->ptid
.lwp (), 0, 0);
1790 /* Always update the entry/return state, even if this particular
1791 syscall isn't interesting to the core now. In async mode,
1792 the user could install a new catchpoint for this syscall
1793 between syscall enter/return, and we'll need to know to
1794 report a syscall return if that happens. */
1795 lp
->syscall_state
= (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
1796 ? TARGET_WAITKIND_SYSCALL_RETURN
1797 : TARGET_WAITKIND_SYSCALL_ENTRY
);
1799 if (catch_syscall_enabled ())
1801 if (catching_syscall_number (syscall_number
))
1803 /* Alright, an event to report. */
1804 if (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
)
1805 ourstatus
->set_syscall_entry (syscall_number
);
1806 else if (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_RETURN
)
1807 ourstatus
->set_syscall_return (syscall_number
);
1809 gdb_assert_not_reached ("unexpected syscall state");
1811 linux_nat_debug_printf
1812 ("stopping for %s of syscall %d for LWP %ld",
1813 (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
1814 ? "entry" : "return"), syscall_number
, lp
->ptid
.lwp ());
1819 linux_nat_debug_printf
1820 ("ignoring %s of syscall %d for LWP %ld",
1821 (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
1822 ? "entry" : "return"), syscall_number
, lp
->ptid
.lwp ());
1826 /* If we had been syscall tracing, and hence used PT_SYSCALL
1827 before on this LWP, it could happen that the user removes all
1828 syscall catchpoints before we get to process this event.
1829 There are two noteworthy issues here:
1831 - When stopped at a syscall entry event, resuming with
1832 PT_STEP still resumes executing the syscall and reports a
1835 - Only PT_SYSCALL catches syscall enters. If we last
1836 single-stepped this thread, then this event can't be a
1837 syscall enter. If we last single-stepped this thread, this
1838 has to be a syscall exit.
1840 The points above mean that the next resume, be it PT_STEP or
1841 PT_CONTINUE, can not trigger a syscall trace event. */
1842 linux_nat_debug_printf
1843 ("caught syscall event with no syscall catchpoints. %d for LWP %ld, "
1844 "ignoring", syscall_number
, lp
->ptid
.lwp ());
1845 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
1848 /* The core isn't interested in this event. For efficiency, avoid
1849 stopping all threads only to have the core resume them all again.
1850 Since we're not stopping threads, if we're still syscall tracing
1851 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1852 subsequent syscall. Simply resume using the inf-ptrace layer,
1853 which knows when to use PT_SYSCALL or PT_CONTINUE. */
1855 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
1859 /* Handle a GNU/Linux extended wait response. If we see a clone
1860 event, we need to add the new LWP to our list (and not report the
1861 trap to higher layers). This function returns non-zero if the
1862 event should be ignored and we should wait again. If STOPPING is
1863 true, the new LWP remains stopped, otherwise it is continued. */
1866 linux_handle_extended_wait (struct lwp_info
*lp
, int status
)
1868 int pid
= lp
->ptid
.lwp ();
1869 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1870 int event
= linux_ptrace_get_extended_event (status
);
1872 /* All extended events we currently use are mid-syscall. Only
1873 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
1874 you have to be using PTRACE_SEIZE to get that. */
1875 lp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
1877 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1878 || event
== PTRACE_EVENT_CLONE
)
1880 unsigned long new_pid
;
1883 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1885 /* If we haven't already seen the new PID stop, wait for it now. */
1886 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1888 /* The new child has a pending SIGSTOP. We can't affect it until it
1889 hits the SIGSTOP, but we're already attached. */
1890 ret
= my_waitpid (new_pid
, &status
, __WALL
);
1892 perror_with_name (_("waiting for new child"));
1893 else if (ret
!= new_pid
)
1894 internal_error (__FILE__
, __LINE__
,
1895 _("wait returned unexpected PID %d"), ret
);
1896 else if (!WIFSTOPPED (status
))
1897 internal_error (__FILE__
, __LINE__
,
1898 _("wait returned unexpected status 0x%x"), status
);
1901 ptid_t
child_ptid (new_pid
, new_pid
);
1903 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
)
1905 open_proc_mem_file (child_ptid
);
1907 /* The arch-specific native code may need to know about new
1908 forks even if those end up never mapped to an
1910 linux_target
->low_new_fork (lp
, new_pid
);
1912 else if (event
== PTRACE_EVENT_CLONE
)
1914 linux_target
->low_new_clone (lp
, new_pid
);
1917 if (event
== PTRACE_EVENT_FORK
1918 && linux_fork_checkpointing_p (lp
->ptid
.pid ()))
1920 /* Handle checkpointing by linux-fork.c here as a special
1921 case. We don't want the follow-fork-mode or 'catch fork'
1922 to interfere with this. */
1924 /* This won't actually modify the breakpoint list, but will
1925 physically remove the breakpoints from the child. */
1926 detach_breakpoints (ptid_t (new_pid
, new_pid
));
1928 /* Retain child fork in ptrace (stopped) state. */
1929 if (!find_fork_pid (new_pid
))
1932 /* Report as spurious, so that infrun doesn't want to follow
1933 this fork. We're actually doing an infcall in
1935 ourstatus
->set_spurious ();
1937 /* Report the stop to the core. */
1941 if (event
== PTRACE_EVENT_FORK
)
1942 ourstatus
->set_forked (child_ptid
);
1943 else if (event
== PTRACE_EVENT_VFORK
)
1944 ourstatus
->set_vforked (child_ptid
);
1945 else if (event
== PTRACE_EVENT_CLONE
)
1947 struct lwp_info
*new_lp
;
1949 ourstatus
->set_ignore ();
1951 linux_nat_debug_printf
1952 ("Got clone event from LWP %d, new child is LWP %ld", pid
, new_pid
);
1954 new_lp
= add_lwp (ptid_t (lp
->ptid
.pid (), new_pid
));
1955 new_lp
->stopped
= 1;
1956 new_lp
->resumed
= 1;
1958 /* If the thread_db layer is active, let it record the user
1959 level thread id and status, and add the thread to GDB's
1961 if (!thread_db_notice_clone (lp
->ptid
, new_lp
->ptid
))
1963 /* The process is not using thread_db. Add the LWP to
1965 target_post_attach (new_lp
->ptid
.lwp ());
1966 add_thread (linux_target
, new_lp
->ptid
);
1969 /* Even if we're stopping the thread for some reason
1970 internal to this module, from the perspective of infrun
1971 and the user/frontend, this new thread is running until
1972 it next reports a stop. */
1973 set_running (linux_target
, new_lp
->ptid
, true);
1974 set_executing (linux_target
, new_lp
->ptid
, true);
1976 if (WSTOPSIG (status
) != SIGSTOP
)
1978 /* This can happen if someone starts sending signals to
1979 the new thread before it gets a chance to run, which
1980 have a lower number than SIGSTOP (e.g. SIGUSR1).
1981 This is an unlikely case, and harder to handle for
1982 fork / vfork than for clone, so we do not try - but
1983 we handle it for clone events here. */
1985 new_lp
->signalled
= 1;
1987 /* We created NEW_LP so it cannot yet contain STATUS. */
1988 gdb_assert (new_lp
->status
== 0);
1990 /* Save the wait status to report later. */
1991 linux_nat_debug_printf
1992 ("waitpid of new LWP %ld, saving status %s",
1993 (long) new_lp
->ptid
.lwp (), status_to_str (status
).c_str ());
1994 new_lp
->status
= status
;
1996 else if (report_thread_events
)
1998 new_lp
->waitstatus
.set_thread_created ();
1999 new_lp
->status
= status
;
2008 if (event
== PTRACE_EVENT_EXEC
)
2010 linux_nat_debug_printf ("Got exec event from LWP %ld", lp
->ptid
.lwp ());
2012 /* Close the previous /proc/PID/mem file for this inferior,
2013 which was using the address space which is now gone.
2014 Reading/writing from this file would return 0/EOF. */
2015 close_proc_mem_file (lp
->ptid
.pid ());
2017 /* Open a new file for the new address space. */
2018 open_proc_mem_file (lp
->ptid
);
2020 ourstatus
->set_execd
2021 (make_unique_xstrdup (linux_proc_pid_to_exec_file (pid
)));
2023 /* The thread that execed must have been resumed, but, when a
2024 thread execs, it changes its tid to the tgid, and the old
2025 tgid thread might have not been resumed. */
2030 if (event
== PTRACE_EVENT_VFORK_DONE
)
2032 if (current_inferior ()->waiting_for_vfork_done
)
2034 linux_nat_debug_printf
2035 ("Got expected PTRACE_EVENT_VFORK_DONE from LWP %ld: stopping",
2038 ourstatus
->set_vfork_done ();
2042 linux_nat_debug_printf
2043 ("Got PTRACE_EVENT_VFORK_DONE from LWP %ld: ignoring", lp
->ptid
.lwp ());
2048 internal_error (__FILE__
, __LINE__
,
2049 _("unknown ptrace event %d"), event
);
2052 /* Suspend waiting for a signal. We're mostly interested in
2058 linux_nat_debug_printf ("about to sigsuspend");
2059 sigsuspend (&suspend_mask
);
2061 /* If the quit flag is set, it means that the user pressed Ctrl-C
2062 and we're debugging a process that is running on a separate
2063 terminal, so we must forward the Ctrl-C to the inferior. (If the
2064 inferior is sharing GDB's terminal, then the Ctrl-C reaches the
2065 inferior directly.) We must do this here because functions that
2066 need to block waiting for a signal loop forever until there's an
2067 event to report before returning back to the event loop. */
2068 if (!target_terminal::is_ours ())
2070 if (check_quit_flag ())
2071 target_pass_ctrlc ();
2075 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2079 wait_lwp (struct lwp_info
*lp
)
2083 int thread_dead
= 0;
2086 gdb_assert (!lp
->stopped
);
2087 gdb_assert (lp
->status
== 0);
2089 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2090 block_child_signals (&prev_mask
);
2094 pid
= my_waitpid (lp
->ptid
.lwp (), &status
, __WALL
| WNOHANG
);
2095 if (pid
== -1 && errno
== ECHILD
)
2097 /* The thread has previously exited. We need to delete it
2098 now because if this was a non-leader thread execing, we
2099 won't get an exit event. See comments on exec events at
2100 the top of the file. */
2102 linux_nat_debug_printf ("%s vanished.",
2103 target_pid_to_str (lp
->ptid
).c_str ());
2108 /* Bugs 10970, 12702.
2109 Thread group leader may have exited in which case we'll lock up in
2110 waitpid if there are other threads, even if they are all zombies too.
2111 Basically, we're not supposed to use waitpid this way.
2112 tkill(pid,0) cannot be used here as it gets ESRCH for both
2113 for zombie and running processes.
2115 As a workaround, check if we're waiting for the thread group leader and
2116 if it's a zombie, and avoid calling waitpid if it is.
2118 This is racy, what if the tgl becomes a zombie right after we check?
2119 Therefore always use WNOHANG with sigsuspend - it is equivalent to
2120 waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
2122 if (lp
->ptid
.pid () == lp
->ptid
.lwp ()
2123 && linux_proc_pid_is_zombie (lp
->ptid
.lwp ()))
2126 linux_nat_debug_printf ("Thread group leader %s vanished.",
2127 target_pid_to_str (lp
->ptid
).c_str ());
2131 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2132 get invoked despite our caller had them intentionally blocked by
2133 block_child_signals. This is sensitive only to the loop of
2134 linux_nat_wait_1 and there if we get called my_waitpid gets called
2135 again before it gets to sigsuspend so we can safely let the handlers
2136 get executed here. */
2140 restore_child_signals_mask (&prev_mask
);
2144 gdb_assert (pid
== lp
->ptid
.lwp ());
2146 linux_nat_debug_printf ("waitpid %s received %s",
2147 target_pid_to_str (lp
->ptid
).c_str (),
2148 status_to_str (status
).c_str ());
2150 /* Check if the thread has exited. */
2151 if (WIFEXITED (status
) || WIFSIGNALED (status
))
2153 if (report_thread_events
2154 || lp
->ptid
.pid () == lp
->ptid
.lwp ())
2156 linux_nat_debug_printf ("LWP %d exited.", lp
->ptid
.pid ());
2158 /* If this is the leader exiting, it means the whole
2159 process is gone. Store the status to report to the
2160 core. Store it in lp->waitstatus, because lp->status
2161 would be ambiguous (W_EXITCODE(0,0) == 0). */
2162 store_waitstatus (&lp
->waitstatus
, status
);
2167 linux_nat_debug_printf ("%s exited.",
2168 target_pid_to_str (lp
->ptid
).c_str ());
2178 gdb_assert (WIFSTOPPED (status
));
2181 if (lp
->must_set_ptrace_flags
)
2183 inferior
*inf
= find_inferior_pid (linux_target
, lp
->ptid
.pid ());
2184 int options
= linux_nat_ptrace_options (inf
->attach_flag
);
2186 linux_enable_event_reporting (lp
->ptid
.lwp (), options
);
2187 lp
->must_set_ptrace_flags
= 0;
2190 /* Handle GNU/Linux's syscall SIGTRAPs. */
2191 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
2193 /* No longer need the sysgood bit. The ptrace event ends up
2194 recorded in lp->waitstatus if we care for it. We can carry
2195 on handling the event like a regular SIGTRAP from here
2197 status
= W_STOPCODE (SIGTRAP
);
2198 if (linux_handle_syscall_trap (lp
, 1))
2199 return wait_lwp (lp
);
2203 /* Almost all other ptrace-stops are known to be outside of system
2204 calls, with further exceptions in linux_handle_extended_wait. */
2205 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2208 /* Handle GNU/Linux's extended waitstatus for trace events. */
2209 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
2210 && linux_is_extended_waitstatus (status
))
2212 linux_nat_debug_printf ("Handling extended status 0x%06x", status
);
2213 linux_handle_extended_wait (lp
, status
);
2220 /* Send a SIGSTOP to LP. */
2223 stop_callback (struct lwp_info
*lp
)
2225 if (!lp
->stopped
&& !lp
->signalled
)
2229 linux_nat_debug_printf ("kill %s **<SIGSTOP>**",
2230 target_pid_to_str (lp
->ptid
).c_str ());
2233 ret
= kill_lwp (lp
->ptid
.lwp (), SIGSTOP
);
2234 linux_nat_debug_printf ("lwp kill %d %s", ret
,
2235 errno
? safe_strerror (errno
) : "ERRNO-OK");
2238 gdb_assert (lp
->status
== 0);
2244 /* Request a stop on LWP. */
2247 linux_stop_lwp (struct lwp_info
*lwp
)
2249 stop_callback (lwp
);
2252 /* See linux-nat.h */
2255 linux_stop_and_wait_all_lwps (void)
2257 /* Stop all LWP's ... */
2258 iterate_over_lwps (minus_one_ptid
, stop_callback
);
2260 /* ... and wait until all of them have reported back that
2261 they're no longer running. */
2262 iterate_over_lwps (minus_one_ptid
, stop_wait_callback
);
2265 /* See linux-nat.h */
2268 linux_unstop_all_lwps (void)
2270 iterate_over_lwps (minus_one_ptid
,
2271 [] (struct lwp_info
*info
)
2273 return resume_stopped_resumed_lwps (info
, minus_one_ptid
);
2277 /* Return non-zero if LWP PID has a pending SIGINT. */
2280 linux_nat_has_pending_sigint (int pid
)
2282 sigset_t pending
, blocked
, ignored
;
2284 linux_proc_pending_signals (pid
, &pending
, &blocked
, &ignored
);
2286 if (sigismember (&pending
, SIGINT
)
2287 && !sigismember (&ignored
, SIGINT
))
2293 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2296 set_ignore_sigint (struct lwp_info
*lp
)
2298 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2299 flag to consume the next one. */
2300 if (lp
->stopped
&& lp
->status
!= 0 && WIFSTOPPED (lp
->status
)
2301 && WSTOPSIG (lp
->status
) == SIGINT
)
2304 lp
->ignore_sigint
= 1;
2309 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2310 This function is called after we know the LWP has stopped; if the LWP
2311 stopped before the expected SIGINT was delivered, then it will never have
2312 arrived. Also, if the signal was delivered to a shared queue and consumed
2313 by a different thread, it will never be delivered to this LWP. */
2316 maybe_clear_ignore_sigint (struct lwp_info
*lp
)
2318 if (!lp
->ignore_sigint
)
2321 if (!linux_nat_has_pending_sigint (lp
->ptid
.lwp ()))
2323 linux_nat_debug_printf ("Clearing bogus flag for %s",
2324 target_pid_to_str (lp
->ptid
).c_str ());
2325 lp
->ignore_sigint
= 0;
2329 /* Fetch the possible triggered data watchpoint info and store it in
2332 On some archs, like x86, that use debug registers to set
2333 watchpoints, it's possible that the way to know which watched
2334 address trapped, is to check the register that is used to select
2335 which address to watch. Problem is, between setting the watchpoint
2336 and reading back which data address trapped, the user may change
2337 the set of watchpoints, and, as a consequence, GDB changes the
2338 debug registers in the inferior. To avoid reading back a stale
2339 stopped-data-address when that happens, we cache in LP the fact
2340 that a watchpoint trapped, and the corresponding data address, as
2341 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2342 registers meanwhile, we have the cached data we can rely on. */
2345 check_stopped_by_watchpoint (struct lwp_info
*lp
)
2347 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
2348 inferior_ptid
= lp
->ptid
;
2350 if (linux_target
->low_stopped_by_watchpoint ())
2352 lp
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
2353 lp
->stopped_data_address_p
2354 = linux_target
->low_stopped_data_address (&lp
->stopped_data_address
);
2357 return lp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2360 /* Returns true if the LWP had stopped for a watchpoint. */
2363 linux_nat_target::stopped_by_watchpoint ()
2365 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2367 gdb_assert (lp
!= NULL
);
2369 return lp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2373 linux_nat_target::stopped_data_address (CORE_ADDR
*addr_p
)
2375 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2377 gdb_assert (lp
!= NULL
);
2379 *addr_p
= lp
->stopped_data_address
;
2381 return lp
->stopped_data_address_p
;
2384 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2387 linux_nat_target::low_status_is_event (int status
)
2389 return WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
;
2392 /* Wait until LP is stopped. */
2395 stop_wait_callback (struct lwp_info
*lp
)
2397 inferior
*inf
= find_inferior_ptid (linux_target
, lp
->ptid
);
2399 /* If this is a vfork parent, bail out, it is not going to report
2400 any SIGSTOP until the vfork is done with. */
2401 if (inf
->vfork_child
!= NULL
)
2408 status
= wait_lwp (lp
);
2412 if (lp
->ignore_sigint
&& WIFSTOPPED (status
)
2413 && WSTOPSIG (status
) == SIGINT
)
2415 lp
->ignore_sigint
= 0;
2418 ptrace (PTRACE_CONT
, lp
->ptid
.lwp (), 0, 0);
2420 linux_nat_debug_printf
2421 ("PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)",
2422 target_pid_to_str (lp
->ptid
).c_str (),
2423 errno
? safe_strerror (errno
) : "OK");
2425 return stop_wait_callback (lp
);
2428 maybe_clear_ignore_sigint (lp
);
2430 if (WSTOPSIG (status
) != SIGSTOP
)
2432 /* The thread was stopped with a signal other than SIGSTOP. */
2434 linux_nat_debug_printf ("Pending event %s in %s",
2435 status_to_str ((int) status
).c_str (),
2436 target_pid_to_str (lp
->ptid
).c_str ());
2438 /* Save the sigtrap event. */
2439 lp
->status
= status
;
2440 gdb_assert (lp
->signalled
);
2441 save_stop_reason (lp
);
2445 /* We caught the SIGSTOP that we intended to catch. */
2447 linux_nat_debug_printf ("Expected SIGSTOP caught for %s.",
2448 target_pid_to_str (lp
->ptid
).c_str ());
2452 /* If we are waiting for this stop so we can report the thread
2453 stopped then we need to record this status. Otherwise, we can
2454 now discard this stop event. */
2455 if (lp
->last_resume_kind
== resume_stop
)
2457 lp
->status
= status
;
2458 save_stop_reason (lp
);
2466 /* Return non-zero if LP has a wait status pending. Discard the
2467 pending event and resume the LWP if the event that originally
2468 caused the stop became uninteresting. */
2471 status_callback (struct lwp_info
*lp
)
2473 /* Only report a pending wait status if we pretend that this has
2474 indeed been resumed. */
2478 if (!lwp_status_pending_p (lp
))
2481 if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
2482 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
2484 struct regcache
*regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
2488 pc
= regcache_read_pc (regcache
);
2490 if (pc
!= lp
->stop_pc
)
2492 linux_nat_debug_printf ("PC of %s changed. was=%s, now=%s",
2493 target_pid_to_str (lp
->ptid
).c_str (),
2494 paddress (target_gdbarch (), lp
->stop_pc
),
2495 paddress (target_gdbarch (), pc
));
2499 #if !USE_SIGTRAP_SIGINFO
2500 else if (!breakpoint_inserted_here_p (regcache
->aspace (), pc
))
2502 linux_nat_debug_printf ("previous breakpoint of %s, at %s gone",
2503 target_pid_to_str (lp
->ptid
).c_str (),
2504 paddress (target_gdbarch (), lp
->stop_pc
));
2512 linux_nat_debug_printf ("pending event of %s cancelled.",
2513 target_pid_to_str (lp
->ptid
).c_str ());
2516 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
2524 /* Count the LWP's that have had events. */
2527 count_events_callback (struct lwp_info
*lp
, int *count
)
2529 gdb_assert (count
!= NULL
);
2531 /* Select only resumed LWPs that have an event pending. */
2532 if (lp
->resumed
&& lwp_status_pending_p (lp
))
2538 /* Select the LWP (if any) that is currently being single-stepped. */
2541 select_singlestep_lwp_callback (struct lwp_info
*lp
)
2543 if (lp
->last_resume_kind
== resume_step
2550 /* Returns true if LP has a status pending. */
2553 lwp_status_pending_p (struct lwp_info
*lp
)
2555 /* We check for lp->waitstatus in addition to lp->status, because we
2556 can have pending process exits recorded in lp->status and
2557 W_EXITCODE(0,0) happens to be 0. */
2558 return lp
->status
!= 0 || lp
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
;
2561 /* Select the Nth LWP that has had an event. */
2564 select_event_lwp_callback (struct lwp_info
*lp
, int *selector
)
2566 gdb_assert (selector
!= NULL
);
2568 /* Select only resumed LWPs that have an event pending. */
2569 if (lp
->resumed
&& lwp_status_pending_p (lp
))
2570 if ((*selector
)-- == 0)
2576 /* Called when the LWP stopped for a signal/trap. If it stopped for a
2577 trap check what caused it (breakpoint, watchpoint, trace, etc.),
2578 and save the result in the LWP's stop_reason field. If it stopped
2579 for a breakpoint, decrement the PC if necessary on the lwp's
2583 save_stop_reason (struct lwp_info
*lp
)
2585 struct regcache
*regcache
;
2586 struct gdbarch
*gdbarch
;
2589 #if USE_SIGTRAP_SIGINFO
2593 gdb_assert (lp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
);
2594 gdb_assert (lp
->status
!= 0);
2596 if (!linux_target
->low_status_is_event (lp
->status
))
2599 regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
2600 gdbarch
= regcache
->arch ();
2602 pc
= regcache_read_pc (regcache
);
2603 sw_bp_pc
= pc
- gdbarch_decr_pc_after_break (gdbarch
);
2605 #if USE_SIGTRAP_SIGINFO
2606 if (linux_nat_get_siginfo (lp
->ptid
, &siginfo
))
2608 if (siginfo
.si_signo
== SIGTRAP
)
2610 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
)
2611 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
2613 /* The si_code is ambiguous on this arch -- check debug
2615 if (!check_stopped_by_watchpoint (lp
))
2616 lp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
2618 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
))
2620 /* If we determine the LWP stopped for a SW breakpoint,
2621 trust it. Particularly don't check watchpoint
2622 registers, because, at least on s390, we'd find
2623 stopped-by-watchpoint as long as there's a watchpoint
2625 lp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
2627 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
2629 /* This can indicate either a hardware breakpoint or
2630 hardware watchpoint. Check debug registers. */
2631 if (!check_stopped_by_watchpoint (lp
))
2632 lp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
2634 else if (siginfo
.si_code
== TRAP_TRACE
)
2636 linux_nat_debug_printf ("%s stopped by trace",
2637 target_pid_to_str (lp
->ptid
).c_str ());
2639 /* We may have single stepped an instruction that
2640 triggered a watchpoint. In that case, on some
2641 architectures (such as x86), instead of TRAP_HWBKPT,
2642 si_code indicates TRAP_TRACE, and we need to check
2643 the debug registers separately. */
2644 check_stopped_by_watchpoint (lp
);
2649 if ((!lp
->step
|| lp
->stop_pc
== sw_bp_pc
)
2650 && software_breakpoint_inserted_here_p (regcache
->aspace (),
2653 /* The LWP was either continued, or stepped a software
2654 breakpoint instruction. */
2655 lp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
2658 if (hardware_breakpoint_inserted_here_p (regcache
->aspace (), pc
))
2659 lp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
2661 if (lp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
)
2662 check_stopped_by_watchpoint (lp
);
2665 if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
)
2667 linux_nat_debug_printf ("%s stopped by software breakpoint",
2668 target_pid_to_str (lp
->ptid
).c_str ());
2670 /* Back up the PC if necessary. */
2672 regcache_write_pc (regcache
, sw_bp_pc
);
2674 /* Update this so we record the correct stop PC below. */
2677 else if (lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
2679 linux_nat_debug_printf ("%s stopped by hardware breakpoint",
2680 target_pid_to_str (lp
->ptid
).c_str ());
2682 else if (lp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
2684 linux_nat_debug_printf ("%s stopped by hardware watchpoint",
2685 target_pid_to_str (lp
->ptid
).c_str ());
2692 /* Returns true if the LWP had stopped for a software breakpoint. */
2695 linux_nat_target::stopped_by_sw_breakpoint ()
2697 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2699 gdb_assert (lp
!= NULL
);
2701 return lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
2704 /* Implement the supports_stopped_by_sw_breakpoint method. */
2707 linux_nat_target::supports_stopped_by_sw_breakpoint ()
2709 return USE_SIGTRAP_SIGINFO
;
2712 /* Returns true if the LWP had stopped for a hardware
2713 breakpoint/watchpoint. */
2716 linux_nat_target::stopped_by_hw_breakpoint ()
2718 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2720 gdb_assert (lp
!= NULL
);
2722 return lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
2725 /* Implement the supports_stopped_by_hw_breakpoint method. */
2728 linux_nat_target::supports_stopped_by_hw_breakpoint ()
2730 return USE_SIGTRAP_SIGINFO
;
2733 /* Select one LWP out of those that have events pending. */
2736 select_event_lwp (ptid_t filter
, struct lwp_info
**orig_lp
, int *status
)
2739 int random_selector
;
2740 struct lwp_info
*event_lp
= NULL
;
2742 /* Record the wait status for the original LWP. */
2743 (*orig_lp
)->status
= *status
;
2745 /* In all-stop, give preference to the LWP that is being
2746 single-stepped. There will be at most one, and it will be the
2747 LWP that the core is most interested in. If we didn't do this,
2748 then we'd have to handle pending step SIGTRAPs somehow in case
2749 the core later continues the previously-stepped thread, as
2750 otherwise we'd report the pending SIGTRAP then, and the core, not
2751 having stepped the thread, wouldn't understand what the trap was
2752 for, and therefore would report it to the user as a random
2754 if (!target_is_non_stop_p ())
2756 event_lp
= iterate_over_lwps (filter
, select_singlestep_lwp_callback
);
2757 if (event_lp
!= NULL
)
2759 linux_nat_debug_printf ("Select single-step %s",
2760 target_pid_to_str (event_lp
->ptid
).c_str ());
2764 if (event_lp
== NULL
)
2766 /* Pick one at random, out of those which have had events. */
2768 /* First see how many events we have. */
2769 iterate_over_lwps (filter
,
2770 [&] (struct lwp_info
*info
)
2772 return count_events_callback (info
, &num_events
);
2774 gdb_assert (num_events
> 0);
2776 /* Now randomly pick a LWP out of those that have had
2778 random_selector
= (int)
2779 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2782 linux_nat_debug_printf ("Found %d events, selecting #%d",
2783 num_events
, random_selector
);
2786 = (iterate_over_lwps
2788 [&] (struct lwp_info
*info
)
2790 return select_event_lwp_callback (info
,
2795 if (event_lp
!= NULL
)
2797 /* Switch the event LWP. */
2798 *orig_lp
= event_lp
;
2799 *status
= event_lp
->status
;
2802 /* Flush the wait status for the event LWP. */
2803 (*orig_lp
)->status
= 0;
2806 /* Return non-zero if LP has been resumed. */
2809 resumed_callback (struct lwp_info
*lp
)
2814 /* Check if we should go on and pass this event to common code.
2816 If so, save the status to the lwp_info structure associated to LWPID. */
2819 linux_nat_filter_event (int lwpid
, int status
)
2821 struct lwp_info
*lp
;
2822 int event
= linux_ptrace_get_extended_event (status
);
2824 lp
= find_lwp_pid (ptid_t (lwpid
));
2826 /* Check for stop events reported by a process we didn't already
2827 know about - anything not already in our LWP list.
2829 If we're expecting to receive stopped processes after
2830 fork, vfork, and clone events, then we'll just add the
2831 new one to our list and go back to waiting for the event
2832 to be reported - the stopped process might be returned
2833 from waitpid before or after the event is.
2835 But note the case of a non-leader thread exec'ing after the
2836 leader having exited, and gone from our lists. The non-leader
2837 thread changes its tid to the tgid. */
2839 if (WIFSTOPPED (status
) && lp
== NULL
2840 && (WSTOPSIG (status
) == SIGTRAP
&& event
== PTRACE_EVENT_EXEC
))
2842 /* A multi-thread exec after we had seen the leader exiting. */
2843 linux_nat_debug_printf ("Re-adding thread group leader LWP %d.", lwpid
);
2845 lp
= add_lwp (ptid_t (lwpid
, lwpid
));
2848 add_thread (linux_target
, lp
->ptid
);
2851 if (WIFSTOPPED (status
) && !lp
)
2853 linux_nat_debug_printf ("saving LWP %ld status %s in stopped_pids list",
2854 (long) lwpid
, status_to_str (status
).c_str ());
2855 add_to_pid_list (&stopped_pids
, lwpid
, status
);
2859 /* Make sure we don't report an event for the exit of an LWP not in
2860 our list, i.e. not part of the current process. This can happen
2861 if we detach from a program we originally forked and then it
2863 if (!WIFSTOPPED (status
) && !lp
)
2866 /* This LWP is stopped now. (And if dead, this prevents it from
2867 ever being continued.) */
2870 if (WIFSTOPPED (status
) && lp
->must_set_ptrace_flags
)
2872 inferior
*inf
= find_inferior_pid (linux_target
, lp
->ptid
.pid ());
2873 int options
= linux_nat_ptrace_options (inf
->attach_flag
);
2875 linux_enable_event_reporting (lp
->ptid
.lwp (), options
);
2876 lp
->must_set_ptrace_flags
= 0;
2879 /* Handle GNU/Linux's syscall SIGTRAPs. */
2880 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
2882 /* No longer need the sysgood bit. The ptrace event ends up
2883 recorded in lp->waitstatus if we care for it. We can carry
2884 on handling the event like a regular SIGTRAP from here
2886 status
= W_STOPCODE (SIGTRAP
);
2887 if (linux_handle_syscall_trap (lp
, 0))
2892 /* Almost all other ptrace-stops are known to be outside of system
2893 calls, with further exceptions in linux_handle_extended_wait. */
2894 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2897 /* Handle GNU/Linux's extended waitstatus for trace events. */
2898 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
2899 && linux_is_extended_waitstatus (status
))
2901 linux_nat_debug_printf ("Handling extended status 0x%06x", status
);
2903 if (linux_handle_extended_wait (lp
, status
))
2907 /* Check if the thread has exited. */
2908 if (WIFEXITED (status
) || WIFSIGNALED (status
))
2910 if (!report_thread_events
2911 && num_lwps (lp
->ptid
.pid ()) > 1)
2913 linux_nat_debug_printf ("%s exited.",
2914 target_pid_to_str (lp
->ptid
).c_str ());
2916 /* If there is at least one more LWP, then the exit signal
2917 was not the end of the debugged application and should be
2923 /* Note that even if the leader was ptrace-stopped, it can still
2924 exit, if e.g., some other thread brings down the whole
2925 process (calls `exit'). So don't assert that the lwp is
2927 linux_nat_debug_printf ("LWP %ld exited (resumed=%d)",
2928 lp
->ptid
.lwp (), lp
->resumed
);
2930 /* Dead LWP's aren't expected to reported a pending sigstop. */
2933 /* Store the pending event in the waitstatus, because
2934 W_EXITCODE(0,0) == 0. */
2935 store_waitstatus (&lp
->waitstatus
, status
);
2939 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2940 an attempt to stop an LWP. */
2942 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
2946 if (lp
->last_resume_kind
== resume_stop
)
2948 linux_nat_debug_printf ("resume_stop SIGSTOP caught for %s.",
2949 target_pid_to_str (lp
->ptid
).c_str ());
2953 /* This is a delayed SIGSTOP. Filter out the event. */
2955 linux_nat_debug_printf
2956 ("%s %s, 0, 0 (discard delayed SIGSTOP)",
2957 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2958 target_pid_to_str (lp
->ptid
).c_str ());
2960 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
2961 gdb_assert (lp
->resumed
);
2966 /* Make sure we don't report a SIGINT that we have already displayed
2967 for another thread. */
2968 if (lp
->ignore_sigint
2969 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGINT
)
2971 linux_nat_debug_printf ("Delayed SIGINT caught for %s.",
2972 target_pid_to_str (lp
->ptid
).c_str ());
2974 /* This is a delayed SIGINT. */
2975 lp
->ignore_sigint
= 0;
2977 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
2978 linux_nat_debug_printf ("%s %s, 0, 0 (discard SIGINT)",
2979 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2980 target_pid_to_str (lp
->ptid
).c_str ());
2981 gdb_assert (lp
->resumed
);
2983 /* Discard the event. */
2987 /* Don't report signals that GDB isn't interested in, such as
2988 signals that are neither printed nor stopped upon. Stopping all
2989 threads can be a bit time-consuming, so if we want decent
2990 performance with heavily multi-threaded programs, especially when
2991 they're using a high frequency timer, we'd better avoid it if we
2993 if (WIFSTOPPED (status
))
2995 enum gdb_signal signo
= gdb_signal_from_host (WSTOPSIG (status
));
2997 if (!target_is_non_stop_p ())
2999 /* Only do the below in all-stop, as we currently use SIGSTOP
3000 to implement target_stop (see linux_nat_stop) in
3002 if (signo
== GDB_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
3004 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3005 forwarded to the entire process group, that is, all LWPs
3006 will receive it - unless they're using CLONE_THREAD to
3007 share signals. Since we only want to report it once, we
3008 mark it as ignored for all LWPs except this one. */
3009 iterate_over_lwps (ptid_t (lp
->ptid
.pid ()), set_ignore_sigint
);
3010 lp
->ignore_sigint
= 0;
3013 maybe_clear_ignore_sigint (lp
);
3016 /* When using hardware single-step, we need to report every signal.
3017 Otherwise, signals in pass_mask may be short-circuited
3018 except signals that might be caused by a breakpoint, or SIGSTOP
3019 if we sent the SIGSTOP and are waiting for it to arrive. */
3021 && WSTOPSIG (status
) && sigismember (&pass_mask
, WSTOPSIG (status
))
3022 && (WSTOPSIG (status
) != SIGSTOP
3023 || !find_thread_ptid (linux_target
, lp
->ptid
)->stop_requested
)
3024 && !linux_wstatus_maybe_breakpoint (status
))
3026 linux_resume_one_lwp (lp
, lp
->step
, signo
);
3027 linux_nat_debug_printf
3028 ("%s %s, %s (preempt 'handle')",
3029 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3030 target_pid_to_str (lp
->ptid
).c_str (),
3031 (signo
!= GDB_SIGNAL_0
3032 ? strsignal (gdb_signal_to_host (signo
)) : "0"));
3037 /* An interesting event. */
3039 lp
->status
= status
;
3040 save_stop_reason (lp
);
3043 /* Detect zombie thread group leaders, and "exit" them. We can't reap
3044 their exits until all other threads in the group have exited. */
3047 check_zombie_leaders (void)
3049 for (inferior
*inf
: all_inferiors ())
3051 struct lwp_info
*leader_lp
;
3056 leader_lp
= find_lwp_pid (ptid_t (inf
->pid
));
3057 if (leader_lp
!= NULL
3058 /* Check if there are other threads in the group, as we may
3059 have raced with the inferior simply exiting. */
3060 && num_lwps (inf
->pid
) > 1
3061 && linux_proc_pid_is_zombie (inf
->pid
))
3063 linux_nat_debug_printf ("Thread group leader %d zombie "
3064 "(it exited, or another thread execd).",
3067 /* A leader zombie can mean one of two things:
3069 - It exited, and there's an exit status pending
3070 available, or only the leader exited (not the whole
3071 program). In the latter case, we can't waitpid the
3072 leader's exit status until all other threads are gone.
3074 - There are 3 or more threads in the group, and a thread
3075 other than the leader exec'd. See comments on exec
3076 events at the top of the file. We could try
3077 distinguishing the exit and exec cases, by waiting once
3078 more, and seeing if something comes out, but it doesn't
3079 sound useful. The previous leader _does_ go away, and
3080 we'll re-add the new one once we see the exec event
3081 (which is just the same as what would happen if the
3082 previous leader did exit voluntarily before some other
3085 linux_nat_debug_printf ("Thread group leader %d vanished.", inf
->pid
);
3086 exit_lwp (leader_lp
);
3091 /* Convenience function that is called when the kernel reports an exit
3092 event. This decides whether to report the event to GDB as a
3093 process exit event, a thread exit event, or to suppress the
3097 filter_exit_event (struct lwp_info
*event_child
,
3098 struct target_waitstatus
*ourstatus
)
3100 ptid_t ptid
= event_child
->ptid
;
3102 if (num_lwps (ptid
.pid ()) > 1)
3104 if (report_thread_events
)
3105 ourstatus
->set_thread_exited (0);
3107 ourstatus
->set_ignore ();
3109 exit_lwp (event_child
);
3116 linux_nat_wait_1 (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3117 target_wait_flags target_options
)
3120 enum resume_kind last_resume_kind
;
3121 struct lwp_info
*lp
;
3124 linux_nat_debug_printf ("enter");
3126 /* The first time we get here after starting a new inferior, we may
3127 not have added it to the LWP list yet - this is the earliest
3128 moment at which we know its PID. */
3129 if (ptid
.is_pid () && find_lwp_pid (ptid
) == nullptr)
3131 ptid_t
lwp_ptid (ptid
.pid (), ptid
.pid ());
3133 /* Upgrade the main thread's ptid. */
3134 thread_change_ptid (linux_target
, ptid
, lwp_ptid
);
3135 lp
= add_initial_lwp (lwp_ptid
);
3139 /* Make sure SIGCHLD is blocked until the sigsuspend below. */
3140 block_child_signals (&prev_mask
);
3142 /* First check if there is a LWP with a wait status pending. */
3143 lp
= iterate_over_lwps (ptid
, status_callback
);
3146 linux_nat_debug_printf ("Using pending wait status %s for %s.",
3147 status_to_str (lp
->status
).c_str (),
3148 target_pid_to_str (lp
->ptid
).c_str ());
3151 /* But if we don't find a pending event, we'll have to wait. Always
3152 pull all events out of the kernel. We'll randomly select an
3153 event LWP out of all that have events, to prevent starvation. */
3159 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3162 - If the thread group leader exits while other threads in the
3163 thread group still exist, waitpid(TGID, ...) hangs. That
3164 waitpid won't return an exit status until the other threads
3165 in the group are reaped.
3167 - When a non-leader thread execs, that thread just vanishes
3168 without reporting an exit (so we'd hang if we waited for it
3169 explicitly in that case). The exec event is reported to
3173 lwpid
= my_waitpid (-1, &status
, __WALL
| WNOHANG
);
3175 linux_nat_debug_printf ("waitpid(-1, ...) returned %d, %s",
3177 errno
? safe_strerror (errno
) : "ERRNO-OK");
3181 linux_nat_debug_printf ("waitpid %ld received %s",
3183 status_to_str (status
).c_str ());
3185 linux_nat_filter_event (lwpid
, status
);
3186 /* Retry until nothing comes out of waitpid. A single
3187 SIGCHLD can indicate more than one child stopped. */
3191 /* Now that we've pulled all events out of the kernel, resume
3192 LWPs that don't have an interesting event to report. */
3193 iterate_over_lwps (minus_one_ptid
,
3194 [] (struct lwp_info
*info
)
3196 return resume_stopped_resumed_lwps (info
, minus_one_ptid
);
3199 /* ... and find an LWP with a status to report to the core, if
3201 lp
= iterate_over_lwps (ptid
, status_callback
);
3205 /* Check for zombie thread group leaders. Those can't be reaped
3206 until all other threads in the thread group are. */
3207 check_zombie_leaders ();
3209 /* If there are no resumed children left, bail. We'd be stuck
3210 forever in the sigsuspend call below otherwise. */
3211 if (iterate_over_lwps (ptid
, resumed_callback
) == NULL
)
3213 linux_nat_debug_printf ("exit (no resumed LWP)");
3215 ourstatus
->set_no_resumed ();
3217 restore_child_signals_mask (&prev_mask
);
3218 return minus_one_ptid
;
3221 /* No interesting event to report to the core. */
3223 if (target_options
& TARGET_WNOHANG
)
3225 linux_nat_debug_printf ("exit (ignore)");
3227 ourstatus
->set_ignore ();
3228 restore_child_signals_mask (&prev_mask
);
3229 return minus_one_ptid
;
3232 /* We shouldn't end up here unless we want to try again. */
3233 gdb_assert (lp
== NULL
);
3235 /* Block until we get an event reported with SIGCHLD. */
3241 status
= lp
->status
;
3244 if (!target_is_non_stop_p ())
3246 /* Now stop all other LWP's ... */
3247 iterate_over_lwps (minus_one_ptid
, stop_callback
);
3249 /* ... and wait until all of them have reported back that
3250 they're no longer running. */
3251 iterate_over_lwps (minus_one_ptid
, stop_wait_callback
);
3254 /* If we're not waiting for a specific LWP, choose an event LWP from
3255 among those that have had events. Giving equal priority to all
3256 LWPs that have had events helps prevent starvation. */
3257 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
3258 select_event_lwp (ptid
, &lp
, &status
);
3260 gdb_assert (lp
!= NULL
);
3262 /* Now that we've selected our final event LWP, un-adjust its PC if
3263 it was a software breakpoint, and we can't reliably support the
3264 "stopped by software breakpoint" stop reason. */
3265 if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3266 && !USE_SIGTRAP_SIGINFO
)
3268 struct regcache
*regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
3269 struct gdbarch
*gdbarch
= regcache
->arch ();
3270 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3276 pc
= regcache_read_pc (regcache
);
3277 regcache_write_pc (regcache
, pc
+ decr_pc
);
3281 /* We'll need this to determine whether to report a SIGSTOP as
3282 GDB_SIGNAL_0. Need to take a copy because resume_clear_callback
3284 last_resume_kind
= lp
->last_resume_kind
;
3286 if (!target_is_non_stop_p ())
3288 /* In all-stop, from the core's perspective, all LWPs are now
3289 stopped until a new resume action is sent over. */
3290 iterate_over_lwps (minus_one_ptid
, resume_clear_callback
);
3294 resume_clear_callback (lp
);
3297 if (linux_target
->low_status_is_event (status
))
3299 linux_nat_debug_printf ("trap ptid is %s.",
3300 target_pid_to_str (lp
->ptid
).c_str ());
3303 if (lp
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
3305 *ourstatus
= lp
->waitstatus
;
3306 lp
->waitstatus
.set_ignore ();
3309 store_waitstatus (ourstatus
, status
);
3311 linux_nat_debug_printf ("exit");
3313 restore_child_signals_mask (&prev_mask
);
3315 if (last_resume_kind
== resume_stop
3316 && ourstatus
->kind () == TARGET_WAITKIND_STOPPED
3317 && WSTOPSIG (status
) == SIGSTOP
)
3319 /* A thread that has been requested to stop by GDB with
3320 target_stop, and it stopped cleanly, so report as SIG0. The
3321 use of SIGSTOP is an implementation detail. */
3322 ourstatus
->set_stopped (GDB_SIGNAL_0
);
3325 if (ourstatus
->kind () == TARGET_WAITKIND_EXITED
3326 || ourstatus
->kind () == TARGET_WAITKIND_SIGNALLED
)
3329 lp
->core
= linux_common_core_of_thread (lp
->ptid
);
3331 if (ourstatus
->kind () == TARGET_WAITKIND_EXITED
)
3332 return filter_exit_event (lp
, ourstatus
);
3337 /* Resume LWPs that are currently stopped without any pending status
3338 to report, but are resumed from the core's perspective. */
3341 resume_stopped_resumed_lwps (struct lwp_info
*lp
, const ptid_t wait_ptid
)
3345 linux_nat_debug_printf ("NOT resuming LWP %s, not stopped",
3346 target_pid_to_str (lp
->ptid
).c_str ());
3348 else if (!lp
->resumed
)
3350 linux_nat_debug_printf ("NOT resuming LWP %s, not resumed",
3351 target_pid_to_str (lp
->ptid
).c_str ());
3353 else if (lwp_status_pending_p (lp
))
3355 linux_nat_debug_printf ("NOT resuming LWP %s, has pending status",
3356 target_pid_to_str (lp
->ptid
).c_str ());
3360 struct regcache
*regcache
= get_thread_regcache (linux_target
, lp
->ptid
);
3361 struct gdbarch
*gdbarch
= regcache
->arch ();
3365 CORE_ADDR pc
= regcache_read_pc (regcache
);
3366 int leave_stopped
= 0;
3368 /* Don't bother if there's a breakpoint at PC that we'd hit
3369 immediately, and we're not waiting for this LWP. */
3370 if (!lp
->ptid
.matches (wait_ptid
))
3372 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
3378 linux_nat_debug_printf
3379 ("resuming stopped-resumed LWP %s at %s: step=%d",
3380 target_pid_to_str (lp
->ptid
).c_str (), paddress (gdbarch
, pc
),
3383 linux_resume_one_lwp_throw (lp
, lp
->step
, GDB_SIGNAL_0
);
3386 catch (const gdb_exception_error
&ex
)
3388 if (!check_ptrace_stopped_lwp_gone (lp
))
3397 linux_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3398 target_wait_flags target_options
)
3402 linux_nat_debug_printf ("[%s], [%s]", target_pid_to_str (ptid
).c_str (),
3403 target_options_to_string (target_options
).c_str ());
3405 /* Flush the async file first. */
3406 if (target_is_async_p ())
3407 async_file_flush ();
3409 /* Resume LWPs that are currently stopped without any pending status
3410 to report, but are resumed from the core's perspective. LWPs get
3411 in this state if we find them stopping at a time we're not
3412 interested in reporting the event (target_wait on a
3413 specific_process, for example, see linux_nat_wait_1), and
3414 meanwhile the event became uninteresting. Don't bother resuming
3415 LWPs we're not going to wait for if they'd stop immediately. */
3416 if (target_is_non_stop_p ())
3417 iterate_over_lwps (minus_one_ptid
,
3418 [=] (struct lwp_info
*info
)
3420 return resume_stopped_resumed_lwps (info
, ptid
);
3423 event_ptid
= linux_nat_wait_1 (ptid
, ourstatus
, target_options
);
3425 /* If we requested any event, and something came out, assume there
3426 may be more. If we requested a specific lwp or process, also
3427 assume there may be more. */
3428 if (target_is_async_p ()
3429 && ((ourstatus
->kind () != TARGET_WAITKIND_IGNORE
3430 && ourstatus
->kind () != TARGET_WAITKIND_NO_RESUMED
)
3431 || ptid
!= minus_one_ptid
))
3440 kill_one_lwp (pid_t pid
)
3442 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
3445 kill_lwp (pid
, SIGKILL
);
3447 if (debug_linux_nat
)
3449 int save_errno
= errno
;
3451 linux_nat_debug_printf
3452 ("kill (SIGKILL) %ld, 0, 0 (%s)", (long) pid
,
3453 save_errno
!= 0 ? safe_strerror (save_errno
) : "OK");
3456 /* Some kernels ignore even SIGKILL for processes under ptrace. */
3459 ptrace (PTRACE_KILL
, pid
, 0, 0);
3460 if (debug_linux_nat
)
3462 int save_errno
= errno
;
3464 linux_nat_debug_printf
3465 ("PTRACE_KILL %ld, 0, 0 (%s)", (long) pid
,
3466 save_errno
? safe_strerror (save_errno
) : "OK");
3470 /* Wait for an LWP to die. */
3473 kill_wait_one_lwp (pid_t pid
)
3477 /* We must make sure that there are no pending events (delayed
3478 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3479 program doesn't interfere with any following debugging session. */
3483 res
= my_waitpid (pid
, NULL
, __WALL
);
3484 if (res
!= (pid_t
) -1)
3486 linux_nat_debug_printf ("wait %ld received unknown.", (long) pid
);
3488 /* The Linux kernel sometimes fails to kill a thread
3489 completely after PTRACE_KILL; that goes from the stop
3490 point in do_fork out to the one in get_signal_to_deliver
3491 and waits again. So kill it again. */
3497 gdb_assert (res
== -1 && errno
== ECHILD
);
3500 /* Callback for iterate_over_lwps. */
3503 kill_callback (struct lwp_info
*lp
)
3505 kill_one_lwp (lp
->ptid
.lwp ());
3509 /* Callback for iterate_over_lwps. */
3512 kill_wait_callback (struct lwp_info
*lp
)
3514 kill_wait_one_lwp (lp
->ptid
.lwp ());
3518 /* Kill the fork children of any threads of inferior INF that are
3519 stopped at a fork event. */
3522 kill_unfollowed_fork_children (struct inferior
*inf
)
3524 for (thread_info
*thread
: inf
->non_exited_threads ())
3526 struct target_waitstatus
*ws
= &thread
->pending_follow
;
3528 if (ws
->kind () == TARGET_WAITKIND_FORKED
3529 || ws
->kind () == TARGET_WAITKIND_VFORKED
)
3531 ptid_t child_ptid
= ws
->child_ptid ();
3532 int child_pid
= child_ptid
.pid ();
3533 int child_lwp
= child_ptid
.lwp ();
3535 kill_one_lwp (child_lwp
);
3536 kill_wait_one_lwp (child_lwp
);
3538 /* Let the arch-specific native code know this process is
3540 linux_target
->low_forget_process (child_pid
);
3546 linux_nat_target::kill ()
3548 /* If we're stopped while forking and we haven't followed yet,
3549 kill the other task. We need to do this first because the
3550 parent will be sleeping if this is a vfork. */
3551 kill_unfollowed_fork_children (current_inferior ());
3553 if (forks_exist_p ())
3554 linux_fork_killall ();
3557 ptid_t ptid
= ptid_t (inferior_ptid
.pid ());
3559 /* Stop all threads before killing them, since ptrace requires
3560 that the thread is stopped to successfully PTRACE_KILL. */
3561 iterate_over_lwps (ptid
, stop_callback
);
3562 /* ... and wait until all of them have reported back that
3563 they're no longer running. */
3564 iterate_over_lwps (ptid
, stop_wait_callback
);
3566 /* Kill all LWP's ... */
3567 iterate_over_lwps (ptid
, kill_callback
);
3569 /* ... and wait until we've flushed all events. */
3570 iterate_over_lwps (ptid
, kill_wait_callback
);
3573 target_mourn_inferior (inferior_ptid
);
3577 linux_nat_target::mourn_inferior ()
3579 int pid
= inferior_ptid
.pid ();
3581 purge_lwp_list (pid
);
3583 close_proc_mem_file (pid
);
3585 if (! forks_exist_p ())
3586 /* Normal case, no other forks available. */
3587 inf_ptrace_target::mourn_inferior ();
3589 /* Multi-fork case. The current inferior_ptid has exited, but
3590 there are other viable forks to debug. Delete the exiting
3591 one and context-switch to the first available. */
3592 linux_fork_mourn_inferior ();
3594 /* Let the arch-specific native code know this process is gone. */
3595 linux_target
->low_forget_process (pid
);
3598 /* Convert a native/host siginfo object, into/from the siginfo in the
3599 layout of the inferiors' architecture. */
3602 siginfo_fixup (siginfo_t
*siginfo
, gdb_byte
*inf_siginfo
, int direction
)
3604 /* If the low target didn't do anything, then just do a straight
3606 if (!linux_target
->low_siginfo_fixup (siginfo
, inf_siginfo
, direction
))
3609 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
3611 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
3615 static enum target_xfer_status
3616 linux_xfer_siginfo (enum target_object object
,
3617 const char *annex
, gdb_byte
*readbuf
,
3618 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
3619 ULONGEST
*xfered_len
)
3623 gdb_byte inf_siginfo
[sizeof (siginfo_t
)];
3625 gdb_assert (object
== TARGET_OBJECT_SIGNAL_INFO
);
3626 gdb_assert (readbuf
|| writebuf
);
3628 pid
= inferior_ptid
.lwp ();
3630 pid
= inferior_ptid
.pid ();
3632 if (offset
> sizeof (siginfo
))
3633 return TARGET_XFER_E_IO
;
3636 ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
3638 return TARGET_XFER_E_IO
;
3640 /* When GDB is built as a 64-bit application, ptrace writes into
3641 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3642 inferior with a 64-bit GDB should look the same as debugging it
3643 with a 32-bit GDB, we need to convert it. GDB core always sees
3644 the converted layout, so any read/write will have to be done
3646 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
3648 if (offset
+ len
> sizeof (siginfo
))
3649 len
= sizeof (siginfo
) - offset
;
3651 if (readbuf
!= NULL
)
3652 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
3655 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
3657 /* Convert back to ptrace layout before flushing it out. */
3658 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
3661 ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
3663 return TARGET_XFER_E_IO
;
3667 return TARGET_XFER_OK
;
3670 static enum target_xfer_status
3671 linux_nat_xfer_osdata (enum target_object object
,
3672 const char *annex
, gdb_byte
*readbuf
,
3673 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
3674 ULONGEST
*xfered_len
);
3676 static enum target_xfer_status
3677 linux_proc_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3678 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
);
3680 enum target_xfer_status
3681 linux_nat_target::xfer_partial (enum target_object object
,
3682 const char *annex
, gdb_byte
*readbuf
,
3683 const gdb_byte
*writebuf
,
3684 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
3686 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
3687 return linux_xfer_siginfo (object
, annex
, readbuf
, writebuf
,
3688 offset
, len
, xfered_len
);
3690 /* The target is connected but no live inferior is selected. Pass
3691 this request down to a lower stratum (e.g., the executable
3693 if (object
== TARGET_OBJECT_MEMORY
&& inferior_ptid
== null_ptid
)
3694 return TARGET_XFER_EOF
;
3696 if (object
== TARGET_OBJECT_AUXV
)
3697 return memory_xfer_auxv (this, object
, annex
, readbuf
, writebuf
,
3698 offset
, len
, xfered_len
);
3700 if (object
== TARGET_OBJECT_OSDATA
)
3701 return linux_nat_xfer_osdata (object
, annex
, readbuf
, writebuf
,
3702 offset
, len
, xfered_len
);
3704 if (object
== TARGET_OBJECT_MEMORY
)
3706 /* GDB calculates all addresses in the largest possible address
3707 width. The address width must be masked before its final use
3708 by linux_proc_xfer_partial.
3710 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
3711 int addr_bit
= gdbarch_addr_bit (target_gdbarch ());
3713 if (addr_bit
< (sizeof (ULONGEST
) * HOST_CHAR_BIT
))
3714 offset
&= ((ULONGEST
) 1 << addr_bit
) - 1;
3716 return linux_proc_xfer_memory_partial (readbuf
, writebuf
,
3717 offset
, len
, xfered_len
);
3720 return inf_ptrace_target::xfer_partial (object
, annex
, readbuf
, writebuf
,
3721 offset
, len
, xfered_len
);
3725 linux_nat_target::thread_alive (ptid_t ptid
)
3727 /* As long as a PTID is in lwp list, consider it alive. */
3728 return find_lwp_pid (ptid
) != NULL
;
3731 /* Implement the to_update_thread_list target method for this
3735 linux_nat_target::update_thread_list ()
3737 /* We add/delete threads from the list as clone/exit events are
3738 processed, so just try deleting exited threads still in the
3740 delete_exited_threads ();
3742 /* Update the processor core that each lwp/thread was last seen
3744 for (lwp_info
*lwp
: all_lwps ())
3746 /* Avoid accessing /proc if the thread hasn't run since we last
3747 time we fetched the thread's core. Accessing /proc becomes
3748 noticeably expensive when we have thousands of LWPs. */
3749 if (lwp
->core
== -1)
3750 lwp
->core
= linux_common_core_of_thread (lwp
->ptid
);
3755 linux_nat_target::pid_to_str (ptid_t ptid
)
3758 && (ptid
.pid () != ptid
.lwp ()
3759 || num_lwps (ptid
.pid ()) > 1))
3760 return string_printf ("LWP %ld", ptid
.lwp ());
3762 return normal_pid_to_str (ptid
);
3766 linux_nat_target::thread_name (struct thread_info
*thr
)
3768 return linux_proc_tid_get_name (thr
->ptid
);
3771 /* Accepts an integer PID; Returns a string representing a file that
3772 can be opened to get the symbols for the child process. */
3775 linux_nat_target::pid_to_exec_file (int pid
)
3777 return linux_proc_pid_to_exec_file (pid
);
3780 /* Object representing an /proc/PID/mem open file. We keep one such
3781 file open per inferior.
3783 It might be tempting to think about only ever opening one file at
3784 most for all inferiors, closing/reopening the file as we access
3785 memory of different inferiors, to minimize number of file
3786 descriptors open, which can otherwise run into resource limits.
3787 However, that does not work correctly -- if the inferior execs and
3788 we haven't processed the exec event yet, and, we opened a
3789 /proc/PID/mem file, we will get a mem file accessing the post-exec
3790 address space, thinking we're opening it for the pre-exec address
3791 space. That is dangerous as we can poke memory (e.g. clearing
3792 breakpoints) in the post-exec memory by mistake, corrupting the
3793 inferior. For that reason, we open the mem file as early as
3794 possible, right after spawning, forking or attaching to the
3795 inferior, when the inferior is stopped and thus before it has a
3798 Note that after opening the file, even if the thread we opened it
3799 for subsequently exits, the open file is still usable for accessing
3800 memory. It's only when the whole process exits or execs that the
3801 file becomes invalid, at which point reads/writes return EOF. */
3806 proc_mem_file (ptid_t ptid
, int fd
)
3807 : m_ptid (ptid
), m_fd (fd
)
3809 gdb_assert (m_fd
!= -1);
3814 linux_nat_debug_printf ("closing fd %d for /proc/%d/task/%ld/mem",
3815 m_fd
, m_ptid
.pid (), m_ptid
.lwp ());
3819 DISABLE_COPY_AND_ASSIGN (proc_mem_file
);
3827 /* The LWP this file was opened for. Just for debugging
3831 /* The file descriptor. */
3835 /* The map between an inferior process id, and the open /proc/PID/mem
3836 file. This is stored in a map instead of in a per-inferior
3837 structure because we need to be able to access memory of processes
3838 which don't have a corresponding struct inferior object. E.g.,
3839 with "detach-on-fork on" (the default), and "follow-fork parent"
3840 (also default), we don't create an inferior for the fork child, but
3841 we still need to remove breakpoints from the fork child's
3843 static std::unordered_map
<int, proc_mem_file
> proc_mem_file_map
;
3845 /* Close the /proc/PID/mem file for PID. */
3848 close_proc_mem_file (pid_t pid
)
3850 proc_mem_file_map
.erase (pid
);
3853 /* Open the /proc/PID/mem file for the process (thread group) of PTID.
3854 We actually open /proc/PID/task/LWP/mem, as that's the LWP we know
3855 exists and is stopped right now. We prefer the
3856 /proc/PID/task/LWP/mem form over /proc/LWP/mem to avoid tid-reuse
3857 races, just in case this is ever called on an already-waited
3861 open_proc_mem_file (ptid_t ptid
)
3863 auto iter
= proc_mem_file_map
.find (ptid
.pid ());
3864 gdb_assert (iter
== proc_mem_file_map
.end ());
3867 xsnprintf (filename
, sizeof filename
,
3868 "/proc/%d/task/%ld/mem", ptid
.pid (), ptid
.lwp ());
3870 int fd
= gdb_open_cloexec (filename
, O_RDWR
| O_LARGEFILE
, 0).release ();
3874 warning (_("opening /proc/PID/mem file for lwp %d.%ld failed: %s (%d)"),
3875 ptid
.pid (), ptid
.lwp (),
3876 safe_strerror (errno
), errno
);
3880 proc_mem_file_map
.emplace (std::piecewise_construct
,
3881 std::forward_as_tuple (ptid
.pid ()),
3882 std::forward_as_tuple (ptid
, fd
));
3884 linux_nat_debug_printf ("opened fd %d for lwp %d.%ld\n",
3885 fd
, ptid
.pid (), ptid
.lwp ());
3888 /* Implement the to_xfer_partial target method using /proc/PID/mem.
3889 Because we can use a single read/write call, this can be much more
3890 efficient than banging away at PTRACE_PEEKTEXT. Also, unlike
3891 PTRACE_PEEKTEXT/PTRACE_POKETEXT, this works with running
3894 static enum target_xfer_status
3895 linux_proc_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
3896 ULONGEST offset
, LONGEST len
,
3897 ULONGEST
*xfered_len
)
3901 auto iter
= proc_mem_file_map
.find (inferior_ptid
.pid ());
3902 if (iter
== proc_mem_file_map
.end ())
3903 return TARGET_XFER_EOF
;
3905 int fd
= iter
->second
.fd ();
3907 gdb_assert (fd
!= -1);
3909 /* Use pread64/pwrite64 if available, since they save a syscall and can
3910 handle 64-bit offsets even on 32-bit platforms (for instance, SPARC
3911 debugging a SPARC64 application). */
3913 ret
= (readbuf
? pread64 (fd
, readbuf
, len
, offset
)
3914 : pwrite64 (fd
, writebuf
, len
, offset
));
3916 ret
= lseek (fd
, offset
, SEEK_SET
);
3918 ret
= (readbuf
? read (fd
, readbuf
, len
)
3919 : write (fd
, writebuf
, len
));
3924 linux_nat_debug_printf ("accessing fd %d for pid %d failed: %s (%d)\n",
3925 fd
, inferior_ptid
.pid (),
3926 safe_strerror (errno
), errno
);
3927 return TARGET_XFER_EOF
;
3931 /* EOF means the address space is gone, the whole process exited
3933 linux_nat_debug_printf ("accessing fd %d for pid %d got EOF\n",
3934 fd
, inferior_ptid
.pid ());
3935 return TARGET_XFER_EOF
;
3940 return TARGET_XFER_OK
;
3944 /* Parse LINE as a signal set and add its set bits to SIGS. */
3947 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
3949 int len
= strlen (line
) - 1;
3953 if (line
[len
] != '\n')
3954 error (_("Could not parse signal set: %s"), line
);
3962 if (*p
>= '0' && *p
<= '9')
3964 else if (*p
>= 'a' && *p
<= 'f')
3965 digit
= *p
- 'a' + 10;
3967 error (_("Could not parse signal set: %s"), line
);
3972 sigaddset (sigs
, signum
+ 1);
3974 sigaddset (sigs
, signum
+ 2);
3976 sigaddset (sigs
, signum
+ 3);
3978 sigaddset (sigs
, signum
+ 4);
3984 /* Find process PID's pending signals from /proc/pid/status and set
3988 linux_proc_pending_signals (int pid
, sigset_t
*pending
,
3989 sigset_t
*blocked
, sigset_t
*ignored
)
3991 char buffer
[PATH_MAX
], fname
[PATH_MAX
];
3993 sigemptyset (pending
);
3994 sigemptyset (blocked
);
3995 sigemptyset (ignored
);
3996 xsnprintf (fname
, sizeof fname
, "/proc/%d/status", pid
);
3997 gdb_file_up procfile
= gdb_fopen_cloexec (fname
, "r");
3998 if (procfile
== NULL
)
3999 error (_("Could not open %s"), fname
);
4001 while (fgets (buffer
, PATH_MAX
, procfile
.get ()) != NULL
)
4003 /* Normal queued signals are on the SigPnd line in the status
4004 file. However, 2.6 kernels also have a "shared" pending
4005 queue for delivering signals to a thread group, so check for
4008 Unfortunately some Red Hat kernels include the shared pending
4009 queue but not the ShdPnd status field. */
4011 if (startswith (buffer
, "SigPnd:\t"))
4012 add_line_to_sigset (buffer
+ 8, pending
);
4013 else if (startswith (buffer
, "ShdPnd:\t"))
4014 add_line_to_sigset (buffer
+ 8, pending
);
4015 else if (startswith (buffer
, "SigBlk:\t"))
4016 add_line_to_sigset (buffer
+ 8, blocked
);
4017 else if (startswith (buffer
, "SigIgn:\t"))
4018 add_line_to_sigset (buffer
+ 8, ignored
);
4022 static enum target_xfer_status
4023 linux_nat_xfer_osdata (enum target_object object
,
4024 const char *annex
, gdb_byte
*readbuf
,
4025 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
4026 ULONGEST
*xfered_len
)
4028 gdb_assert (object
== TARGET_OBJECT_OSDATA
);
4030 *xfered_len
= linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
4031 if (*xfered_len
== 0)
4032 return TARGET_XFER_EOF
;
4034 return TARGET_XFER_OK
;
4037 std::vector
<static_tracepoint_marker
>
4038 linux_nat_target::static_tracepoint_markers_by_strid (const char *strid
)
4040 char s
[IPA_CMD_BUF_SIZE
];
4041 int pid
= inferior_ptid
.pid ();
4042 std::vector
<static_tracepoint_marker
> markers
;
4044 ptid_t ptid
= ptid_t (pid
, 0);
4045 static_tracepoint_marker marker
;
4050 memcpy (s
, "qTfSTM", sizeof ("qTfSTM"));
4051 s
[sizeof ("qTfSTM")] = 0;
4053 agent_run_command (pid
, s
, strlen (s
) + 1);
4056 SCOPE_EXIT
{ target_continue_no_signal (ptid
); };
4062 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
4064 if (strid
== NULL
|| marker
.str_id
== strid
)
4065 markers
.push_back (std::move (marker
));
4067 while (*p
++ == ','); /* comma-separated list */
4069 memcpy (s
, "qTsSTM", sizeof ("qTsSTM"));
4070 s
[sizeof ("qTsSTM")] = 0;
4071 agent_run_command (pid
, s
, strlen (s
) + 1);
4078 /* target_is_async_p implementation. */
4081 linux_nat_target::is_async_p ()
4083 return linux_is_async_p ();
4086 /* target_can_async_p implementation. */
4089 linux_nat_target::can_async_p ()
4091 /* This flag should be checked in the common target.c code. */
4092 gdb_assert (target_async_permitted
);
4094 /* Otherwise, this targets is always able to support async mode. */
4099 linux_nat_target::supports_non_stop ()
4104 /* to_always_non_stop_p implementation. */
4107 linux_nat_target::always_non_stop_p ()
4113 linux_nat_target::supports_multi_process ()
4119 linux_nat_target::supports_disable_randomization ()
4124 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4125 so we notice when any child changes state, and notify the
4126 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4127 above to wait for the arrival of a SIGCHLD. */
4130 sigchld_handler (int signo
)
4132 int old_errno
= errno
;
4134 if (debug_linux_nat
)
4135 gdb_stdlog
->write_async_safe ("sigchld\n", sizeof ("sigchld\n") - 1);
4137 if (signo
== SIGCHLD
4138 && linux_nat_event_pipe
[0] != -1)
4139 async_file_mark (); /* Let the event loop know that there are
4140 events to handle. */
4145 /* Callback registered with the target events file descriptor. */
4148 handle_target_event (int error
, gdb_client_data client_data
)
4150 inferior_event_handler (INF_REG_EVENT
);
4153 /* Create/destroy the target events pipe. Returns previous state. */
4156 linux_async_pipe (int enable
)
4158 int previous
= linux_is_async_p ();
4160 if (previous
!= enable
)
4164 /* Block child signals while we create/destroy the pipe, as
4165 their handler writes to it. */
4166 block_child_signals (&prev_mask
);
4170 if (gdb_pipe_cloexec (linux_nat_event_pipe
) == -1)
4171 internal_error (__FILE__
, __LINE__
,
4172 "creating event pipe failed.");
4174 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
4175 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
4179 close (linux_nat_event_pipe
[0]);
4180 close (linux_nat_event_pipe
[1]);
4181 linux_nat_event_pipe
[0] = -1;
4182 linux_nat_event_pipe
[1] = -1;
4185 restore_child_signals_mask (&prev_mask
);
4192 linux_nat_target::async_wait_fd ()
4194 return linux_nat_event_pipe
[0];
4197 /* target_async implementation. */
4200 linux_nat_target::async (int enable
)
4204 if (!linux_async_pipe (1))
4206 add_file_handler (linux_nat_event_pipe
[0],
4207 handle_target_event
, NULL
,
4209 /* There may be pending events to handle. Tell the event loop
4216 delete_file_handler (linux_nat_event_pipe
[0]);
4217 linux_async_pipe (0);
4222 /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4226 linux_nat_stop_lwp (struct lwp_info
*lwp
)
4230 linux_nat_debug_printf ("running -> suspending %s",
4231 target_pid_to_str (lwp
->ptid
).c_str ());
4234 if (lwp
->last_resume_kind
== resume_stop
)
4236 linux_nat_debug_printf ("already stopping LWP %ld at GDB's request",
4241 stop_callback (lwp
);
4242 lwp
->last_resume_kind
= resume_stop
;
4246 /* Already known to be stopped; do nothing. */
4248 if (debug_linux_nat
)
4250 if (find_thread_ptid (linux_target
, lwp
->ptid
)->stop_requested
)
4251 linux_nat_debug_printf ("already stopped/stop_requested %s",
4252 target_pid_to_str (lwp
->ptid
).c_str ());
4254 linux_nat_debug_printf ("already stopped/no stop_requested yet %s",
4255 target_pid_to_str (lwp
->ptid
).c_str ());
4262 linux_nat_target::stop (ptid_t ptid
)
4264 iterate_over_lwps (ptid
, linux_nat_stop_lwp
);
4268 linux_nat_target::close ()
4270 /* Unregister from the event loop. */
4274 inf_ptrace_target::close ();
4277 /* When requests are passed down from the linux-nat layer to the
4278 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4279 used. The address space pointer is stored in the inferior object,
4280 but the common code that is passed such ptid can't tell whether
4281 lwpid is a "main" process id or not (it assumes so). We reverse
4282 look up the "main" process id from the lwp here. */
4284 struct address_space
*
4285 linux_nat_target::thread_address_space (ptid_t ptid
)
4287 struct lwp_info
*lwp
;
4288 struct inferior
*inf
;
4291 if (ptid
.lwp () == 0)
4293 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
4295 lwp
= find_lwp_pid (ptid
);
4296 pid
= lwp
->ptid
.pid ();
4300 /* A (pid,lwpid,0) ptid. */
4304 inf
= find_inferior_pid (this, pid
);
4305 gdb_assert (inf
!= NULL
);
4309 /* Return the cached value of the processor core for thread PTID. */
4312 linux_nat_target::core_of_thread (ptid_t ptid
)
4314 struct lwp_info
*info
= find_lwp_pid (ptid
);
4321 /* Implementation of to_filesystem_is_local. */
4324 linux_nat_target::filesystem_is_local ()
4326 struct inferior
*inf
= current_inferior ();
4328 if (inf
->fake_pid_p
|| inf
->pid
== 0)
4331 return linux_ns_same (inf
->pid
, LINUX_NS_MNT
);
4334 /* Convert the INF argument passed to a to_fileio_* method
4335 to a process ID suitable for passing to its corresponding
4336 linux_mntns_* function. If INF is non-NULL then the
4337 caller is requesting the filesystem seen by INF. If INF
4338 is NULL then the caller is requesting the filesystem seen
4339 by the GDB. We fall back to GDB's filesystem in the case
4340 that INF is non-NULL but its PID is unknown. */
4343 linux_nat_fileio_pid_of (struct inferior
*inf
)
4345 if (inf
== NULL
|| inf
->fake_pid_p
|| inf
->pid
== 0)
4351 /* Implementation of to_fileio_open. */
4354 linux_nat_target::fileio_open (struct inferior
*inf
, const char *filename
,
4355 int flags
, int mode
, int warn_if_slow
,
4362 if (fileio_to_host_openflags (flags
, &nat_flags
) == -1
4363 || fileio_to_host_mode (mode
, &nat_mode
) == -1)
4365 *target_errno
= FILEIO_EINVAL
;
4369 fd
= linux_mntns_open_cloexec (linux_nat_fileio_pid_of (inf
),
4370 filename
, nat_flags
, nat_mode
);
4372 *target_errno
= host_to_fileio_error (errno
);
4377 /* Implementation of to_fileio_readlink. */
4379 gdb::optional
<std::string
>
4380 linux_nat_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
4386 len
= linux_mntns_readlink (linux_nat_fileio_pid_of (inf
),
4387 filename
, buf
, sizeof (buf
));
4390 *target_errno
= host_to_fileio_error (errno
);
4394 return std::string (buf
, len
);
4397 /* Implementation of to_fileio_unlink. */
4400 linux_nat_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
4405 ret
= linux_mntns_unlink (linux_nat_fileio_pid_of (inf
),
4408 *target_errno
= host_to_fileio_error (errno
);
4413 /* Implementation of the to_thread_events method. */
4416 linux_nat_target::thread_events (int enable
)
4418 report_thread_events
= enable
;
4421 linux_nat_target::linux_nat_target ()
4423 /* We don't change the stratum; this target will sit at
4424 process_stratum and thread_db will set at thread_stratum. This
4425 is a little strange, since this is a multi-threaded-capable
4426 target, but we want to be on the stack below thread_db, and we
4427 also want to be used for single-threaded processes. */
4430 /* See linux-nat.h. */
4433 linux_nat_get_siginfo (ptid_t ptid
, siginfo_t
*siginfo
)
4442 ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, siginfo
);
4445 memset (siginfo
, 0, sizeof (*siginfo
));
4451 /* See nat/linux-nat.h. */
4454 current_lwp_ptid (void)
4456 gdb_assert (inferior_ptid
.lwp_p ());
4457 return inferior_ptid
;
4460 void _initialize_linux_nat ();
4462 _initialize_linux_nat ()
4464 add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance
,
4465 &debug_linux_nat
, _("\
4466 Set debugging of GNU/Linux lwp module."), _("\
4467 Show debugging of GNU/Linux lwp module."), _("\
4468 Enables printf debugging output."),
4470 show_debug_linux_nat
,
4471 &setdebuglist
, &showdebuglist
);
4473 add_setshow_boolean_cmd ("linux-namespaces", class_maintenance
,
4474 &debug_linux_namespaces
, _("\
4475 Set debugging of GNU/Linux namespaces module."), _("\
4476 Show debugging of GNU/Linux namespaces module."), _("\
4477 Enables printf debugging output."),
4480 &setdebuglist
, &showdebuglist
);
4482 /* Install a SIGCHLD handler. */
4483 sigchld_action
.sa_handler
= sigchld_handler
;
4484 sigemptyset (&sigchld_action
.sa_mask
);
4485 sigchld_action
.sa_flags
= SA_RESTART
;
4487 /* Make it the default. */
4488 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
4490 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4491 gdb_sigmask (SIG_SETMASK
, NULL
, &suspend_mask
);
4492 sigdelset (&suspend_mask
, SIGCHLD
);
4494 sigemptyset (&blocked_mask
);
4496 lwp_lwpid_htab_create ();
4500 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4501 the GNU/Linux Threads library and therefore doesn't really belong
4504 /* NPTL reserves the first two RT signals, but does not provide any
4505 way for the debugger to query the signal numbers - fortunately
4506 they don't change. */
4507 static int lin_thread_signals
[] = { __SIGRTMIN
, __SIGRTMIN
+ 1 };
4509 /* See linux-nat.h. */
4512 lin_thread_get_thread_signal_num (void)
4514 return sizeof (lin_thread_signals
) / sizeof (lin_thread_signals
[0]);
4517 /* See linux-nat.h. */
4520 lin_thread_get_thread_signal (unsigned int i
)
4522 gdb_assert (i
< lin_thread_get_thread_signal_num ());
4523 return lin_thread_signals
[i
];