GDB (xrefs)
Loading...
Searching...
No Matches
linux-nat.c
Go to the documentation of this file.
1/* GNU/Linux native-dependent code common to multiple platforms.
2
3 Copyright (C) 2001-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "inferior.h"
22#include "infrun.h"
23#include "target.h"
24#include "nat/linux-nat.h"
25#include "nat/linux-waitpid.h"
26#include "gdbsupport/gdb_wait.h"
27#include <unistd.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"
34#include "linux-fork.h"
35#include "gdbthread.h"
36#include "gdbcmd.h"
37#include "regcache.h"
38#include "regset.h"
39#include "inf-child.h"
40#include "inf-ptrace.h"
41#include "auxv.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 */
49#include "inf-loop.h"
50#include "gdbsupport/event-loop.h"
51#include "event-top.h"
52#include <pwd.h>
53#include <sys/types.h>
54#include <dirent.h>
55#include "xml-support.h"
56#include <sys/vfs.h>
57#include "solib.h"
58#include "nat/linux-osdata.h"
59#include "linux-tdep.h"
60#include "symfile.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"
66#include "objfiles.h"
68#include "gdbsupport/block-signals.h"
69#include "gdbsupport/fileio.h"
70#include "gdbsupport/scope-exit.h"
71#include "gdbsupport/gdb-sigmask.h"
72#include "gdbsupport/common-debug.h"
73#include <unordered_map>
74
75/* This comment documents high-level logic of this file.
76
77Waiting for events in sync mode
78===============================
79
80When waiting for an event in a specific thread, we just use waitpid,
81passing the specific pid, and not passing WNOHANG.
82
83When waiting for an event in all threads, waitpid is not quite good:
84
85- If the thread group leader exits while other threads in the thread
86 group still exist, waitpid(TGID, ...) hangs. That waitpid won't
87 return an exit status until the other threads in the group are
88 reaped.
89
90- When a non-leader thread execs, that thread just vanishes without
91 reporting an exit (so we'd hang if we waited for it explicitly in
92 that case). The exec event is instead reported to the TGID pid.
93
94The solution is to always use -1 and WNOHANG, together with
95sigsuspend.
96
97First, we use non-blocking waitpid to check for events. If nothing is
98found, we use sigsuspend to wait for SIGCHLD. When SIGCHLD arrives,
99it means something happened to a child process. As soon as we know
100there's an event, we get back to calling nonblocking waitpid.
101
102Note that SIGCHLD should be blocked between waitpid and sigsuspend
103calls, so that we don't miss a signal. If SIGCHLD arrives in between,
104when it's blocked, the signal becomes pending and sigsuspend
105immediately notices it and returns.
106
107Waiting for events in async mode (TARGET_WNOHANG)
108=================================================
109
110In async mode, GDB should always be ready to handle both user input
111and target events, so neither blocking waitpid nor sigsuspend are
112viable options. Instead, we should asynchronously notify the GDB main
113event loop whenever there's an unprocessed event from the target. We
114detect asynchronous target events by handling SIGCHLD signals. To
115notify the event loop about target events, an event pipe is used
116--- the pipe is registered as waitable event source in the event loop,
117the event loop select/poll's on the read end of this pipe (as well on
118other event sources, e.g., stdin), and the SIGCHLD handler marks the
119event pipe to raise an event. This is more portable than relying on
120pselect/ppoll, since on kernels that lack those syscalls, libc
121emulates them with select/poll+sigprocmask, and that is racy
122(a.k.a. plain broken).
123
124Obviously, if we fail to notify the event loop if there's a target
125event, it's bad. OTOH, if we notify the event loop when there's no
126event from the target, linux_nat_wait will detect that there's no real
127event to report, and return event of type TARGET_WAITKIND_IGNORE.
128This is mostly harmless, but it will waste time and is better avoided.
129
130The main design point is that every time GDB is outside linux-nat.c,
131we have a SIGCHLD handler installed that is called when something
132happens to the target and notifies the GDB event loop. Whenever GDB
133core decides to handle the event, and calls into linux-nat.c, we
134process things as in sync mode, except that the we never block in
135sigsuspend.
136
137While processing an event, we may end up momentarily blocked in
138waitpid calls. Those waitpid calls, while blocking, are guarantied to
139return quickly. E.g., in all-stop mode, before reporting to the core
140that an LWP hit a breakpoint, all LWPs are stopped by sending them
141SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
142Note that this is different from blocking indefinitely waiting for the
143next event --- here, we're already handling an event.
144
145Use of signals
146==============
147
148We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
149signal is not entirely significant; we just need for a signal to be delivered,
150so that we can intercept it. SIGSTOP's advantage is that it can not be
151blocked. A disadvantage is that it is not a real-time signal, so it can only
152be queued once; we do not keep track of other sources of SIGSTOP.
153
154Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
155use them, because they have special behavior when the signal is generated -
156not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
157kills the entire thread group.
158
159A delivered SIGSTOP would stop the entire thread group, not just the thread we
160tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
161cancel it (by PTRACE_CONT without passing SIGSTOP).
162
163We could use a real-time signal instead. This would solve those problems; we
164could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
165But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
166generates it, and there are races with trying to find a signal that is not
167blocked.
168
169Exec events
170===========
171
172The case of a thread group (process) with 3 or more threads, and a
173thread other than the leader execs is worth detailing:
174
175On an exec, the Linux kernel destroys all threads except the execing
176one in the thread group, and resets the execing thread's tid to the
177tgid. No exit notification is sent for the execing thread -- from the
178ptracer's perspective, it appears as though the execing thread just
179vanishes. Until we reap all other threads except the leader and the
180execing thread, the leader will be zombie, and the execing thread will
181be in `D (disc sleep)' state. As soon as all other threads are
182reaped, the execing thread changes its tid to the tgid, and the
183previous (zombie) leader vanishes, giving place to the "new"
184leader. */
185
186#ifndef O_LARGEFILE
187#define O_LARGEFILE 0
188#endif
189
191
192/* Does the current host support PTRACE_GETREGSET? */
193enum tribool have_ptrace_getregset = TRIBOOL_UNKNOWN;
194
195/* When true, print debug messages relating to the linux native target. */
196
197static bool debug_linux_nat;
198
199/* Implement 'show debug linux-nat'. */
200
201static void
202show_debug_linux_nat (struct ui_file *file, int from_tty,
203 struct cmd_list_element *c, const char *value)
204{
205 gdb_printf (file, _("Debugging of GNU/Linux native targets is %s.\n"),
206 value);
207}
208
209/* Print a linux-nat debug statement. */
210
211#define linux_nat_debug_printf(fmt, ...) \
212 debug_prefixed_printf_cond (debug_linux_nat, "linux-nat", fmt, ##__VA_ARGS__)
213
214/* Print "linux-nat" enter/exit debug statements. */
215
216#define LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT \
217 scoped_debug_enter_exit (debug_linux_nat, "linux-nat")
218
220{
221 int pid;
224};
226
227/* Whether target_thread_events is in effect. */
229
230static int kill_lwp (int lwpid, int signo);
231
232static int stop_callback (struct lwp_info *lp);
233
234static void block_child_signals (sigset_t *prev_mask);
235static void restore_child_signals_mask (sigset_t *prev_mask);
236
237struct lwp_info;
238static struct lwp_info *add_lwp (ptid_t ptid);
239static void purge_lwp_list (int pid);
240static void delete_lwp (ptid_t ptid);
241static struct lwp_info *find_lwp_pid (ptid_t ptid);
242
243static int lwp_status_pending_p (struct lwp_info *lp);
244
245static void save_stop_reason (struct lwp_info *lp);
246
247static bool proc_mem_file_is_writable ();
248static void close_proc_mem_file (pid_t pid);
249static void open_proc_mem_file (ptid_t ptid);
250
251/* Return TRUE if LWP is the leader thread of the process. */
252
253static bool
255{
256 return lp->ptid.pid () == lp->ptid.lwp ();
257}
258
259
260/* LWP accessors. */
261
262/* See nat/linux-nat.h. */
263
264ptid_t
266{
267 return lwp->ptid;
268}
269
270/* See nat/linux-nat.h. */
271
272void
274 struct arch_lwp_info *info)
275{
276 lwp->arch_private = info;
277}
278
279/* See nat/linux-nat.h. */
280
281struct arch_lwp_info *
283{
284 return lwp->arch_private;
285}
286
287/* See nat/linux-nat.h. */
288
289int
291{
292 return lwp->stopped;
293}
294
295/* See nat/linux-nat.h. */
296
299{
300 return lwp->stop_reason;
301}
302
303/* See nat/linux-nat.h. */
304
305int
307{
308 return lwp->step;
309}
310
311
312/* Trivial list manipulation functions to keep track of a list of
313 new stopped processes. */
314static void
315add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
316{
317 struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
318
319 new_pid->pid = pid;
320 new_pid->status = status;
321 new_pid->next = *listp;
322 *listp = new_pid;
323}
324
325static int
326pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
327{
328 struct simple_pid_list **p;
329
330 for (p = listp; *p != NULL; p = &(*p)->next)
331 if ((*p)->pid == pid)
332 {
333 struct simple_pid_list *next = (*p)->next;
334
335 *statusp = (*p)->status;
336 xfree (*p);
337 *p = next;
338 return 1;
339 }
340 return 0;
341}
342
343/* Return the ptrace options that we want to try to enable. */
344
345static int
347{
348 int options = 0;
349
350 if (!attached)
351 options |= PTRACE_O_EXITKILL;
352
353 options |= (PTRACE_O_TRACESYSGOOD
358
359 return options;
360}
361
362/* Initialize ptrace and procfs warnings and check for supported
363 ptrace features given PID.
364
365 ATTACHED should be nonzero iff we attached to the inferior. */
366
367static void
368linux_init_ptrace_procfs (pid_t pid, int attached)
369{
370 int options = linux_nat_ptrace_options (attached);
371
376}
377
379{}
380
381void
383{
385}
386
387/* Implement the virtual inf_ptrace_target::post_startup_inferior method. */
388
389void
391{
392 linux_init_ptrace_procfs (ptid.pid (), 0);
393}
394
395/* Return the number of known LWPs in the tgid given by PID. */
396
397static int
399{
400 int count = 0;
401
402 for (const lwp_info *lp ATTRIBUTE_UNUSED : all_lwps ())
403 if (lp->ptid.pid () == pid)
404 count++;
405
406 return count;
407}
408
409/* Deleter for lwp_info unique_ptr specialisation. */
410
412{
413 void operator() (struct lwp_info *lwp) const
414 {
415 delete_lwp (lwp->ptid);
416 }
417};
418
419/* A unique_ptr specialisation for lwp_info. */
420
421typedef std::unique_ptr<struct lwp_info, lwp_deleter> lwp_info_up;
422
423/* Target hook for follow_fork. */
424
425void
426linux_nat_target::follow_fork (inferior *child_inf, ptid_t child_ptid,
427 target_waitkind fork_kind, bool follow_child,
428 bool detach_fork)
429{
430 inf_ptrace_target::follow_fork (child_inf, child_ptid, fork_kind,
431 follow_child, detach_fork);
432
433 if (!follow_child)
434 {
435 bool has_vforked = fork_kind == TARGET_WAITKIND_VFORKED;
436 ptid_t parent_ptid = inferior_ptid;
437 int parent_pid = parent_ptid.lwp ();
438 int child_pid = child_ptid.lwp ();
439
440 /* We're already attached to the parent, by default. */
441 lwp_info *child_lp = add_lwp (child_ptid);
442 child_lp->stopped = 1;
443 child_lp->last_resume_kind = resume_stop;
444
445 /* Detach new forked process? */
446 if (detach_fork)
447 {
448 int child_stop_signal = 0;
449 bool detach_child = true;
450
451 /* Move CHILD_LP into a unique_ptr and clear the source pointer
452 to prevent us doing anything stupid with it. */
453 lwp_info_up child_lp_ptr (child_lp);
454 child_lp = nullptr;
455
456 linux_target->low_prepare_to_resume (child_lp_ptr.get ());
457
458 /* When debugging an inferior in an architecture that supports
459 hardware single stepping on a kernel without commit
460 6580807da14c423f0d0a708108e6df6ebc8bc83d, the vfork child
461 process starts with the TIF_SINGLESTEP/X86_EFLAGS_TF bits
462 set if the parent process had them set.
463 To work around this, single step the child process
464 once before detaching to clear the flags. */
465
466 /* Note that we consult the parent's architecture instead of
467 the child's because there's no inferior for the child at
468 this point. */
470 (parent_ptid)))
471 {
472 int status;
473
475 if (ptrace (PTRACE_SINGLESTEP, child_pid, 0, 0) < 0)
476 perror_with_name (_("Couldn't do single step"));
477 if (my_waitpid (child_pid, &status, 0) < 0)
478 perror_with_name (_("Couldn't wait vfork process"));
479 else
480 {
481 detach_child = WIFSTOPPED (status);
482 child_stop_signal = WSTOPSIG (status);
483 }
484 }
485
486 if (detach_child)
487 {
488 int signo = child_stop_signal;
489
490 if (signo != 0
491 && !signal_pass_state (gdb_signal_from_host (signo)))
492 signo = 0;
493 ptrace (PTRACE_DETACH, child_pid, 0, signo);
494
495 close_proc_mem_file (child_pid);
496 }
497 }
498
499 if (has_vforked)
500 {
501 lwp_info *parent_lp = find_lwp_pid (parent_ptid);
502 linux_nat_debug_printf ("waiting for VFORK_DONE on %d", parent_pid);
503 parent_lp->stopped = 1;
504
505 /* We'll handle the VFORK_DONE event like any other
506 event, in target_wait. */
507 }
508 }
509 else
510 {
511 struct lwp_info *child_lp;
512
513 child_lp = add_lwp (child_ptid);
514 child_lp->stopped = 1;
515 child_lp->last_resume_kind = resume_stop;
516 }
517}
518
519
520int
522{
523 return 0;
524}
525
526int
528{
529 return 0;
530}
531
532int
534{
535 return 0;
536}
537
538int
540{
541 return 0;
542}
543
544int
546{
547 return 0;
548}
549
550int
552{
553 return 0;
554}
555
556int
557linux_nat_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
558 gdb::array_view<const int> syscall_counts)
559{
560 /* On GNU/Linux, we ignore the arguments. It means that we only
561 enable the syscall catchpoints, but do not disable them.
562
563 Also, we do not use the `syscall_counts' information because we do not
564 filter system calls here. We let GDB do the logic for us. */
565 return 0;
566}
567
568/* List of known LWPs, keyed by LWP PID. This speeds up the common
569 case of mapping a PID returned from the kernel to our corresponding
570 lwp_info data structure. */
571static htab_t lwp_lwpid_htab;
572
573/* Calculate a hash from a lwp_info's LWP PID. */
574
575static hashval_t
576lwp_info_hash (const void *ap)
577{
578 const struct lwp_info *lp = (struct lwp_info *) ap;
579 pid_t pid = lp->ptid.lwp ();
580
581 return iterative_hash_object (pid, 0);
582}
583
584/* Equality function for the lwp_info hash table. Compares the LWP's
585 PID. */
586
587static int
588lwp_lwpid_htab_eq (const void *a, const void *b)
589{
590 const struct lwp_info *entry = (const struct lwp_info *) a;
591 const struct lwp_info *element = (const struct lwp_info *) b;
592
593 return entry->ptid.lwp () == element->ptid.lwp ();
594}
595
596/* Create the lwp_lwpid_htab hash table. */
597
598static void
600{
601 lwp_lwpid_htab = htab_create (100, lwp_info_hash, lwp_lwpid_htab_eq, NULL);
602}
603
604/* Add LP to the hash table. */
605
606static void
608{
609 void **slot;
610
611 slot = htab_find_slot (lwp_lwpid_htab, lp, INSERT);
612 gdb_assert (slot != NULL && *slot == NULL);
613 *slot = lp;
614}
615
616/* Head of doubly-linked list of known LWPs. Sorted by reverse
617 creation order. This order is assumed in some cases. E.g.,
618 reaping status after killing alls lwps of a process: the leader LWP
619 must be reaped last. */
620
621static intrusive_list<lwp_info> lwp_list;
622
623/* See linux-nat.h. */
624
627{
628 return lwp_info_range (lwp_list.begin ());
629}
630
631/* See linux-nat.h. */
632
635{
636 return lwp_info_safe_range (lwp_list.begin ());
637}
638
639/* Add LP to sorted-by-reverse-creation-order doubly-linked list. */
640
641static void
643{
644 lwp_list.push_front (*lp);
645}
646
647/* Remove LP from sorted-by-reverse-creation-order doubly-linked
648 list. */
649
650static void
652{
653 /* Remove from sorted-by-creation-order list. */
654 lwp_list.erase (lwp_list.iterator_to (*lp));
655}
656
657
658
659/* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
660 _initialize_linux_nat. */
661static sigset_t suspend_mask;
662
663/* Signals to block to make that sigsuspend work. */
664static sigset_t blocked_mask;
665
666/* SIGCHLD action. */
667static struct sigaction sigchld_action;
668
669/* Block child signals (SIGCHLD and linux threads signals), and store
670 the previous mask in PREV_MASK. */
671
672static void
673block_child_signals (sigset_t *prev_mask)
674{
675 /* Make sure SIGCHLD is blocked. */
676 if (!sigismember (&blocked_mask, SIGCHLD))
677 sigaddset (&blocked_mask, SIGCHLD);
678
679 gdb_sigmask (SIG_BLOCK, &blocked_mask, prev_mask);
680}
681
682/* Restore child signals mask, previously returned by
683 block_child_signals. */
684
685static void
686restore_child_signals_mask (sigset_t *prev_mask)
687{
688 gdb_sigmask (SIG_SETMASK, prev_mask, NULL);
689}
690
691/* Mask of signals to pass directly to the inferior. */
692static sigset_t pass_mask;
693
694/* Update signals to pass to the inferior. */
695void
697 (gdb::array_view<const unsigned char> pass_signals)
698{
699 int signo;
700
701 sigemptyset (&pass_mask);
702
703 for (signo = 1; signo < NSIG; signo++)
704 {
705 int target_signo = gdb_signal_from_host (signo);
706 if (target_signo < pass_signals.size () && pass_signals[target_signo])
707 sigaddset (&pass_mask, signo);
708 }
709}
710
711
712
713/* Prototypes for local functions. */
714static int stop_wait_callback (struct lwp_info *lp);
715static int resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid);
716static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp);
717
718
719
720/* Destroy and free LP. */
721
723{
724 /* Let the arch specific bits release arch_lwp_info. */
726}
727
728/* Traversal function for purge_lwp_list. */
729
730static int
731lwp_lwpid_htab_remove_pid (void **slot, void *info)
732{
733 struct lwp_info *lp = (struct lwp_info *) *slot;
734 int pid = *(int *) info;
735
736 if (lp->ptid.pid () == pid)
737 {
738 htab_clear_slot (lwp_lwpid_htab, slot);
739 lwp_list_remove (lp);
740 delete lp;
741 }
742
743 return 1;
744}
745
746/* Remove all LWPs belong to PID from the lwp list. */
747
748static void
750{
751 htab_traverse_noresize (lwp_lwpid_htab, lwp_lwpid_htab_remove_pid, &pid);
752}
753
754/* Add the LWP specified by PTID to the list. PTID is the first LWP
755 in the process. Return a pointer to the structure describing the
756 new LWP.
757
758 This differs from add_lwp in that we don't let the arch specific
759 bits know about this new thread. Current clients of this callback
760 take the opportunity to install watchpoints in the new thread, and
761 we shouldn't do that for the first thread. If we're spawning a
762 child ("run"), the thread executes the shell wrapper first, and we
763 shouldn't touch it until it execs the program we want to debug.
764 For "attach", it'd be okay to call the callback, but it's not
765 necessary, because watchpoints can't yet have been inserted into
766 the inferior. */
767
768static struct lwp_info *
770{
771 gdb_assert (ptid.lwp_p ());
772
773 lwp_info *lp = new lwp_info (ptid);
774
775
776 /* Add to sorted-by-reverse-creation-order list. */
777 lwp_list_add (lp);
778
779 /* Add to keyed-by-pid htab. */
781
782 return lp;
783}
784
785/* Add the LWP specified by PID to the list. Return a pointer to the
786 structure describing the new LWP. The LWP should already be
787 stopped. */
788
789static struct lwp_info *
790add_lwp (ptid_t ptid)
791{
792 struct lwp_info *lp;
793
794 lp = add_initial_lwp (ptid);
795
796 /* Let the arch specific bits know about this new thread. Current
797 clients of this callback take the opportunity to install
798 watchpoints in the new thread. We don't do this for the first
799 thread though. See add_initial_lwp. */
801
802 return lp;
803}
804
805/* Remove the LWP specified by PID from the list. */
806
807static void
809{
811
812 void **slot = htab_find_slot (lwp_lwpid_htab, &dummy, NO_INSERT);
813 if (slot == NULL)
814 return;
815
816 lwp_info *lp = *(struct lwp_info **) slot;
817 gdb_assert (lp != NULL);
818
819 htab_clear_slot (lwp_lwpid_htab, slot);
820
821 /* Remove from sorted-by-creation-order list. */
822 lwp_list_remove (lp);
823
824 /* Release. */
825 delete lp;
826}
827
828/* Return a pointer to the structure describing the LWP corresponding
829 to PID. If no corresponding LWP could be found, return NULL. */
830
831static struct lwp_info *
833{
834 int lwp;
835
836 if (ptid.lwp_p ())
837 lwp = ptid.lwp ();
838 else
839 lwp = ptid.pid ();
840
841 lwp_info dummy (ptid_t (0, lwp));
842 return (struct lwp_info *) htab_find (lwp_lwpid_htab, &dummy);
843}
844
845/* See nat/linux-nat.h. */
846
847struct lwp_info *
848iterate_over_lwps (ptid_t filter,
849 gdb::function_view<iterate_over_lwps_ftype> callback)
850{
851 for (lwp_info *lp : all_lwps_safe ())
852 {
853 if (lp->ptid.matches (filter))
854 {
855 if (callback (lp) != 0)
856 return lp;
857 }
858 }
859
860 return NULL;
861}
862
863/* Update our internal state when changing from one checkpoint to
864 another indicated by NEW_PTID. We can only switch single-threaded
865 applications, so we only create one new LWP, and the previous list
866 is discarded. */
867
868void
869linux_nat_switch_fork (ptid_t new_ptid)
870{
871 struct lwp_info *lp;
872
874
875 lp = add_lwp (new_ptid);
876 lp->stopped = 1;
877
878 /* This changes the thread's ptid while preserving the gdb thread
879 num. Also changes the inferior pid, while preserving the
880 inferior num. */
882
883 /* We've just told GDB core that the thread changed target id, but,
884 in fact, it really is a different thread, with different register
885 contents. */
887}
888
889/* Handle the exit of a single thread LP. */
890
891static void
892exit_lwp (struct lwp_info *lp)
893{
894 struct thread_info *th = find_thread_ptid (linux_target, lp->ptid);
895
896 if (th)
897 {
899 gdb_printf (_("[%s exited]\n"),
900 target_pid_to_str (lp->ptid).c_str ());
901
902 delete_thread (th);
903 }
904
905 delete_lwp (lp->ptid);
906}
907
908/* Wait for the LWP specified by LP, which we have just attached to.
909 Returns a wait status for that LWP, to cache. */
910
911static int
912linux_nat_post_attach_wait (ptid_t ptid, int *signalled)
913{
914 pid_t new_pid, pid = ptid.lwp ();
915 int status;
916
918 {
919 linux_nat_debug_printf ("Attaching to a stopped process");
920
921 /* The process is definitely stopped. It is in a job control
922 stop, unless the kernel predates the TASK_STOPPED /
923 TASK_TRACED distinction, in which case it might be in a
924 ptrace stop. Make sure it is in a ptrace stop; from there we
925 can kill it, signal it, et cetera.
926
927 First make sure there is a pending SIGSTOP. Since we are
928 already attached, the process can not transition from stopped
929 to running without a PTRACE_CONT; so we know this signal will
930 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
931 probably already in the queue (unless this kernel is old
932 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
933 is not an RT signal, it can only be queued once. */
934 kill_lwp (pid, SIGSTOP);
935
936 /* Finally, resume the stopped process. This will deliver the SIGSTOP
937 (or a higher priority signal, just like normal PTRACE_ATTACH). */
938 ptrace (PTRACE_CONT, pid, 0, 0);
939 }
940
941 /* Make sure the initial process is stopped. The user-level threads
942 layer might want to poke around in the inferior, and that won't
943 work if things haven't stabilized yet. */
944 new_pid = my_waitpid (pid, &status, __WALL);
945 gdb_assert (pid == new_pid);
946
947 if (!WIFSTOPPED (status))
948 {
949 /* The pid we tried to attach has apparently just exited. */
950 linux_nat_debug_printf ("Failed to stop %d: %s", pid,
951 status_to_str (status).c_str ());
952 return status;
953 }
954
955 if (WSTOPSIG (status) != SIGSTOP)
956 {
957 *signalled = 1;
958 linux_nat_debug_printf ("Received %s after attaching",
959 status_to_str (status).c_str ());
960 }
961
962 return status;
963}
964
965void
967 const std::string &allargs,
968 char **env, int from_tty)
969{
972
973 /* The fork_child mechanism is synchronous and calls target_wait, so
974 we have to mask the async mode. */
975
976 /* Make sure we report all signals during startup. */
977 pass_signals ({});
978
979 inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty);
980
982}
983
984/* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
985 already attached. Returns true if a new LWP is found, false
986 otherwise. */
987
988static int
990{
991 struct lwp_info *lp;
992
993 /* Ignore LWPs we're already attached to. */
994 lp = find_lwp_pid (ptid);
995 if (lp == NULL)
996 {
997 int lwpid = ptid.lwp ();
998
999 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1000 {
1001 int err = errno;
1002
1003 /* Be quiet if we simply raced with the thread exiting.
1004 EPERM is returned if the thread's task still exists, and
1005 is marked as exited or zombie, as well as other
1006 conditions, so in that case, confirm the status in
1007 /proc/PID/status. */
1008 if (err == ESRCH
1009 || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
1010 {
1012 ("Cannot attach to lwp %d: thread is gone (%d: %s)",
1013 lwpid, err, safe_strerror (err));
1014
1015 }
1016 else
1017 {
1018 std::string reason
1020
1021 warning (_("Cannot attach to lwp %d: %s"),
1022 lwpid, reason.c_str ());
1023 }
1024 }
1025 else
1026 {
1027 linux_nat_debug_printf ("PTRACE_ATTACH %s, 0, 0 (OK)",
1028 ptid.to_string ().c_str ());
1029
1030 lp = add_lwp (ptid);
1031
1032 /* The next time we wait for this LWP we'll see a SIGSTOP as
1033 PTRACE_ATTACH brings it to a halt. */
1034 lp->signalled = 1;
1035
1036 /* We need to wait for a stop before being able to make the
1037 next ptrace call on this LWP. */
1038 lp->must_set_ptrace_flags = 1;
1039
1040 /* So that wait collects the SIGSTOP. */
1041 lp->resumed = 1;
1042
1043 /* Also add the LWP to gdb's thread list, in case a
1044 matching libthread_db is not found (or the process uses
1045 raw clone). */
1047 set_running (linux_target, lp->ptid, true);
1048 set_executing (linux_target, lp->ptid, true);
1049 }
1050
1051 return 1;
1052 }
1053 return 0;
1054}
1055
1056void
1057linux_nat_target::attach (const char *args, int from_tty)
1058{
1059 struct lwp_info *lp;
1060 int status;
1061 ptid_t ptid;
1062
1063 /* Make sure we report all signals during attach. */
1064 pass_signals ({});
1065
1066 try
1067 {
1068 inf_ptrace_target::attach (args, from_tty);
1069 }
1070 catch (const gdb_exception_error &ex)
1071 {
1072 pid_t pid = parse_pid_to_attach (args);
1073 std::string reason = linux_ptrace_attach_fail_reason (pid);
1074
1075 if (!reason.empty ())
1076 throw_error (ex.error, "warning: %s\n%s", reason.c_str (),
1077 ex.what ());
1078 else
1079 throw_error (ex.error, "%s", ex.what ());
1080 }
1081
1082 /* The ptrace base target adds the main thread with (pid,0,0)
1083 format. Decorate it with lwp info. */
1084 ptid = ptid_t (inferior_ptid.pid (),
1085 inferior_ptid.pid ());
1087
1088 /* Add the initial process as the first LWP to the list. */
1089 lp = add_initial_lwp (ptid);
1090
1092 if (!WIFSTOPPED (status))
1093 {
1094 if (WIFEXITED (status))
1095 {
1096 int exit_code = WEXITSTATUS (status);
1097
1100 if (exit_code == 0)
1101 error (_("Unable to attach: program exited normally."));
1102 else
1103 error (_("Unable to attach: program exited with code %d."),
1104 exit_code);
1105 }
1106 else if (WIFSIGNALED (status))
1107 {
1108 enum gdb_signal signo;
1109
1112
1113 signo = gdb_signal_from_host (WTERMSIG (status));
1114 error (_("Unable to attach: program terminated with signal "
1115 "%s, %s."),
1116 gdb_signal_to_name (signo),
1117 gdb_signal_to_string (signo));
1118 }
1119
1120 internal_error (_("unexpected status %d for PID %ld"),
1121 status, (long) ptid.lwp ());
1122 }
1123
1124 lp->stopped = 1;
1125
1127
1128 /* Save the wait status to report later. */
1129 lp->resumed = 1;
1130 linux_nat_debug_printf ("waitpid %ld, saving status %s",
1131 (long) lp->ptid.pid (),
1132 status_to_str (status).c_str ());
1133
1134 lp->status = status;
1135
1136 /* We must attach to every LWP. If /proc is mounted, use that to
1137 find them now. The inferior may be using raw clone instead of
1138 using pthreads. But even if it is using pthreads, thread_db
1139 walks structures in the inferior's address space to find the list
1140 of threads/LWPs, and those structures may well be corrupted.
1141 Note that once thread_db is loaded, we'll still use it to list
1142 threads and associate pthread info with each LWP. */
1145}
1146
1147/* Ptrace-detach the thread with pid PID. */
1148
1149static void
1150detach_one_pid (int pid, int signo)
1151{
1152 if (ptrace (PTRACE_DETACH, pid, 0, signo) < 0)
1153 {
1154 int save_errno = errno;
1155
1156 /* We know the thread exists, so ESRCH must mean the lwp is
1157 zombie. This can happen if one of the already-detached
1158 threads exits the whole thread group. In that case we're
1159 still attached, and must reap the lwp. */
1160 if (save_errno == ESRCH)
1161 {
1162 int ret, status;
1163
1164 ret = my_waitpid (pid, &status, __WALL);
1165 if (ret == -1)
1166 {
1167 warning (_("Couldn't reap LWP %d while detaching: %s"),
1168 pid, safe_strerror (errno));
1169 }
1170 else if (!WIFEXITED (status) && !WIFSIGNALED (status))
1171 {
1172 warning (_("Reaping LWP %d while detaching "
1173 "returned unexpected status 0x%x"),
1174 pid, status);
1175 }
1176 }
1177 else
1178 error (_("Can't detach %d: %s"),
1179 pid, safe_strerror (save_errno));
1180 }
1181 else
1182 linux_nat_debug_printf ("PTRACE_DETACH (%d, %s, 0) (OK)",
1183 pid, strsignal (signo));
1184}
1185
1186/* Get pending signal of THREAD as a host signal number, for detaching
1187 purposes. This is the signal the thread last stopped for, which we
1188 need to deliver to the thread when detaching, otherwise, it'd be
1189 suppressed/lost. */
1190
1191static int
1193{
1194 enum gdb_signal signo = GDB_SIGNAL_0;
1195
1196 /* If we paused threads momentarily, we may have stored pending
1197 events in lp->status or lp->waitstatus (see stop_wait_callback),
1198 and GDB core hasn't seen any signal for those threads.
1199 Otherwise, the last signal reported to the core is found in the
1200 thread object's stop_signal.
1201
1202 There's a corner case that isn't handled here at present. Only
1203 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1204 stop_signal make sense as a real signal to pass to the inferior.
1205 Some catchpoint related events, like
1206 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1207 to GDB_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1208 those traps are debug API (ptrace in our case) related and
1209 induced; the inferior wouldn't see them if it wasn't being
1210 traced. Hence, we should never pass them to the inferior, even
1211 when set to pass state. Since this corner case isn't handled by
1212 infrun.c when proceeding with a signal, for consistency, neither
1213 do we handle it here (or elsewhere in the file we check for
1214 signal pass state). Normally SIGTRAP isn't set to pass state, so
1215 this is really a corner case. */
1216
1218 signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal. */
1219 else if (lp->status)
1220 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1221 else
1222 {
1223 struct thread_info *tp = find_thread_ptid (linux_target, lp->ptid);
1224
1225 if (target_is_non_stop_p () && !tp->executing ())
1226 {
1227 if (tp->has_pending_waitstatus ())
1228 {
1229 /* If the thread has a pending event, and it was stopped with a
1230 signal, use that signal to resume it. If it has a pending
1231 event of another kind, it was not stopped with a signal, so
1232 resume it without a signal. */
1234 signo = tp->pending_waitstatus ().sig ();
1235 else
1236 signo = GDB_SIGNAL_0;
1237 }
1238 else
1239 signo = tp->stop_signal ();
1240 }
1241 else if (!target_is_non_stop_p ())
1242 {
1243 ptid_t last_ptid;
1244 process_stratum_target *last_target;
1245
1246 get_last_target_status (&last_target, &last_ptid, nullptr);
1247
1248 if (last_target == linux_target
1249 && lp->ptid.lwp () == last_ptid.lwp ())
1250 signo = tp->stop_signal ();
1251 }
1252 }
1253
1254 if (signo == GDB_SIGNAL_0)
1255 {
1256 linux_nat_debug_printf ("lwp %s has no pending signal",
1257 lp->ptid.to_string ().c_str ());
1258 }
1259 else if (!signal_pass_state (signo))
1260 {
1262 ("lwp %s had signal %s but it is in no pass state",
1263 lp->ptid.to_string ().c_str (), gdb_signal_to_string (signo));
1264 }
1265 else
1266 {
1267 linux_nat_debug_printf ("lwp %s has pending signal %s",
1268 lp->ptid.to_string ().c_str (),
1269 gdb_signal_to_string (signo));
1270
1271 return gdb_signal_to_host (signo);
1272 }
1273
1274 return 0;
1275}
1276
1277/* Detach from LP. If SIGNO_P is non-NULL, then it points to the
1278 signal number that should be passed to the LWP when detaching.
1279 Otherwise pass any pending signal the LWP may have, if any. */
1280
1281static void
1282detach_one_lwp (struct lwp_info *lp, int *signo_p)
1283{
1284 int lwpid = lp->ptid.lwp ();
1285 int signo;
1286
1287 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1288
1289 /* If the lwp/thread we are about to detach has a pending fork event,
1290 there is a process GDB is attached to that the core of GDB doesn't know
1291 about. Detach from it. */
1292
1293 /* Check in lwp_info::status. */
1294 if (WIFSTOPPED (lp->status) && linux_is_extended_waitstatus (lp->status))
1295 {
1296 int event = linux_ptrace_get_extended_event (lp->status);
1297
1298 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
1299 {
1300 unsigned long child_pid;
1301 int ret = ptrace (PTRACE_GETEVENTMSG, lp->ptid.lwp (), 0, &child_pid);
1302 if (ret == 0)
1303 detach_one_pid (child_pid, 0);
1304 else
1305 perror_warning_with_name (_("Failed to detach fork child"));
1306 }
1307 }
1308
1309 /* Check in lwp_info::waitstatus. */
1312 detach_one_pid (lp->waitstatus.child_ptid ().pid (), 0);
1313
1314
1315 /* Check in thread_info::pending_waitstatus. */
1317 if (tp->has_pending_waitstatus ())
1318 {
1319 const target_waitstatus &ws = tp->pending_waitstatus ();
1320
1321 if (ws.kind () == TARGET_WAITKIND_VFORKED
1322 || ws.kind () == TARGET_WAITKIND_FORKED)
1323 detach_one_pid (ws.child_ptid ().pid (), 0);
1324 }
1325
1326 /* Check in thread_info::pending_follow. */
1329 detach_one_pid (tp->pending_follow.child_ptid ().pid (), 0);
1330
1331 if (lp->status != 0)
1332 linux_nat_debug_printf ("Pending %s for %s on detach.",
1333 strsignal (WSTOPSIG (lp->status)),
1334 lp->ptid.to_string ().c_str ());
1335
1336 /* If there is a pending SIGSTOP, get rid of it. */
1337 if (lp->signalled)
1338 {
1339 linux_nat_debug_printf ("Sending SIGCONT to %s",
1340 lp->ptid.to_string ().c_str ());
1341
1342 kill_lwp (lwpid, SIGCONT);
1343 lp->signalled = 0;
1344 }
1345
1346 if (signo_p == NULL)
1347 {
1348 /* Pass on any pending signal for this LWP. */
1349 signo = get_detach_signal (lp);
1350 }
1351 else
1352 signo = *signo_p;
1353
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. */
1357 try
1358 {
1360 }
1361 catch (const gdb_exception_error &ex)
1362 {
1364 throw;
1365 }
1366
1367 detach_one_pid (lwpid, signo);
1368
1369 delete_lwp (lp->ptid);
1370}
1371
1372static int
1374{
1375 /* We don't actually detach from the thread group leader just yet.
1376 If the thread group exits, we must reap the zombie clone lwps
1377 before we're able to reap the leader. */
1378 if (lp->ptid.lwp () != lp->ptid.pid ())
1379 detach_one_lwp (lp, NULL);
1380 return 0;
1381}
1382
1383void
1385{
1386 struct lwp_info *main_lwp;
1387 int pid = inf->pid;
1388
1389 /* Don't unregister from the event loop, as there may be other
1390 inferiors running. */
1391
1392 /* Stop all threads before detaching. ptrace requires that the
1393 thread is stopped to successfully detach. */
1395 /* ... and wait until all of them have reported back that
1396 they're no longer running. */
1398
1399 /* We can now safely remove breakpoints. We don't this in earlier
1400 in common code because this target doesn't currently support
1401 writing memory while the inferior is running. */
1403
1405
1406 /* Only the initial process should be left right now. */
1407 gdb_assert (num_lwps (pid) == 1);
1408
1409 main_lwp = find_lwp_pid (ptid_t (pid));
1410
1411 if (forks_exist_p ())
1412 {
1413 /* Multi-fork case. The current inferior_ptid is being detached
1414 from, but there are other viable forks to debug. Detach from
1415 the current fork, and context-switch to the first
1416 available. */
1417 linux_fork_detach (from_tty);
1418 }
1419 else
1420 {
1421 target_announce_detach (from_tty);
1422
1423 /* Pass on any pending signal for the last LWP. */
1424 int signo = get_detach_signal (main_lwp);
1425
1426 detach_one_lwp (main_lwp, &signo);
1427
1429 }
1430
1432}
1433
1434/* Resume execution of the inferior process. If STEP is nonzero,
1435 single-step it. If SIGNAL is nonzero, give it that signal. */
1436
1437static void
1439 enum gdb_signal signo)
1440{
1441 lp->step = step;
1442
1443 /* stop_pc doubles as the PC the LWP had when it was last resumed.
1444 We only presently need that if the LWP is stepped though (to
1445 handle the case of stepping a breakpoint instruction). */
1446 if (step)
1447 {
1449
1451 }
1452 else
1453 lp->stop_pc = 0;
1454
1456 linux_target->low_resume (lp->ptid, step, signo);
1457
1458 /* Successfully resumed. Clear state that no longer makes sense,
1459 and mark the LWP as running. Must not do this before resuming
1460 otherwise if that fails other code will be confused. E.g., we'd
1461 later try to stop the LWP and hang forever waiting for a stop
1462 status. Note that we must not throw after this is cleared,
1463 otherwise handle_zombie_lwp_error would get confused. */
1464 lp->stopped = 0;
1465 lp->core = -1;
1468}
1469
1470/* Called when we try to resume a stopped LWP and that errors out. If
1471 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
1472 or about to become), discard the error, clear any pending status
1473 the LWP may have, and return true (we'll collect the exit status
1474 soon enough). Otherwise, return false. */
1475
1476static int
1478{
1479 /* If we get an error after resuming the LWP successfully, we'd
1480 confuse !T state for the LWP being gone. */
1481 gdb_assert (lp->stopped);
1482
1483 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
1484 because even if ptrace failed with ESRCH, the tracee may be "not
1485 yet fully dead", but already refusing ptrace requests. In that
1486 case the tracee has 'R (Running)' state for a little bit
1487 (observed in Linux 3.18). See also the note on ESRCH in the
1488 ptrace(2) man page. Instead, check whether the LWP has any state
1489 other than ptrace-stopped. */
1490
1491 /* Don't assume anything if /proc/PID/status can't be read. */
1492 if (linux_proc_pid_is_trace_stopped_nowarn (lp->ptid.lwp ()) == 0)
1493 {
1495 lp->status = 0;
1496 lp->waitstatus.set_ignore ();
1497 return 1;
1498 }
1499 return 0;
1500}
1501
1502/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
1503 disappears while we try to resume it. */
1504
1505static void
1506linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1507{
1508 try
1509 {
1510 linux_resume_one_lwp_throw (lp, step, signo);
1511 }
1512 catch (const gdb_exception_error &ex)
1513 {
1515 throw;
1516 }
1517}
1518
1519/* Resume LP. */
1520
1521static void
1522resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1523{
1524 if (lp->stopped)
1525 {
1527
1528 if (inf->vfork_child != NULL)
1529 {
1530 linux_nat_debug_printf ("Not resuming %s (vfork parent)",
1531 lp->ptid.to_string ().c_str ());
1532 }
1533 else if (!lwp_status_pending_p (lp))
1534 {
1535 linux_nat_debug_printf ("Resuming sibling %s, %s, %s",
1536 lp->ptid.to_string ().c_str (),
1537 (signo != GDB_SIGNAL_0
1538 ? strsignal (gdb_signal_to_host (signo))
1539 : "0"),
1540 step ? "step" : "resume");
1541
1542 linux_resume_one_lwp (lp, step, signo);
1543 }
1544 else
1545 {
1546 linux_nat_debug_printf ("Not resuming sibling %s (has pending)",
1547 lp->ptid.to_string ().c_str ());
1548 }
1549 }
1550 else
1551 linux_nat_debug_printf ("Not resuming sibling %s (not stopped)",
1552 lp->ptid.to_string ().c_str ());
1553}
1554
1555/* Callback for iterate_over_lwps. If LWP is EXCEPT, do nothing.
1556 Resume LWP with the last stop signal, if it is in pass state. */
1557
1558static int
1559linux_nat_resume_callback (struct lwp_info *lp, struct lwp_info *except)
1560{
1561 enum gdb_signal signo = GDB_SIGNAL_0;
1562
1563 if (lp == except)
1564 return 0;
1565
1566 if (lp->stopped)
1567 {
1568 struct thread_info *thread;
1569
1570 thread = find_thread_ptid (linux_target, lp->ptid);
1571 if (thread != NULL)
1572 {
1573 signo = thread->stop_signal ();
1574 thread->set_stop_signal (GDB_SIGNAL_0);
1575 }
1576 }
1577
1578 resume_lwp (lp, 0, signo);
1579 return 0;
1580}
1581
1582static int
1584{
1585 lp->resumed = 0;
1587 return 0;
1588}
1589
1590static int
1592{
1593 lp->resumed = 1;
1595 return 0;
1596}
1597
1598void
1599linux_nat_target::resume (ptid_t scope_ptid, int step, enum gdb_signal signo)
1600{
1601 struct lwp_info *lp;
1602
1603 linux_nat_debug_printf ("Preparing to %s %s, %s, inferior_ptid %s",
1604 step ? "step" : "resume",
1605 scope_ptid.to_string ().c_str (),
1606 (signo != GDB_SIGNAL_0
1607 ? strsignal (gdb_signal_to_host (signo)) : "0"),
1608 inferior_ptid.to_string ().c_str ());
1609
1610 /* Mark the lwps we're resuming as resumed and update their
1611 last_resume_kind to resume_continue. */
1613
1615 gdb_assert (lp != NULL);
1616
1617 /* Remember if we're stepping. */
1619
1620 /* If we have a pending wait status for this thread, there is no
1621 point in resuming the process. But first make sure that
1622 linux_nat_wait won't preemptively handle the event - we
1623 should never take this short-circuit if we are going to
1624 leave LP running, since we have skipped resuming all the
1625 other threads. This bit of code needs to be synchronized
1626 with linux_nat_wait. */
1627
1628 if (lp->status && WIFSTOPPED (lp->status))
1629 {
1630 if (!lp->step
1631 && WSTOPSIG (lp->status)
1632 && sigismember (&pass_mask, WSTOPSIG (lp->status)))
1633 {
1635 ("Not short circuiting for ignored status 0x%x", lp->status);
1636
1637 /* FIXME: What should we do if we are supposed to continue
1638 this thread with a signal? */
1639 gdb_assert (signo == GDB_SIGNAL_0);
1640 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1641 lp->status = 0;
1642 }
1643 }
1644
1645 if (lwp_status_pending_p (lp))
1646 {
1647 /* FIXME: What should we do if we are supposed to continue
1648 this thread with a signal? */
1649 gdb_assert (signo == GDB_SIGNAL_0);
1650
1651 linux_nat_debug_printf ("Short circuiting for status 0x%x",
1652 lp->status);
1653
1654 if (target_can_async_p ())
1655 {
1656 target_async (true);
1657 /* Tell the event loop we have something to process. */
1658 async_file_mark ();
1659 }
1660 return;
1661 }
1662
1663 /* No use iterating unless we're resuming other threads. */
1664 if (scope_ptid != lp->ptid)
1665 iterate_over_lwps (scope_ptid, [=] (struct lwp_info *info)
1666 {
1667 return linux_nat_resume_callback (info, lp);
1668 });
1669
1670 linux_nat_debug_printf ("%s %s, %s (resume event thread)",
1671 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1672 lp->ptid.to_string ().c_str (),
1673 (signo != GDB_SIGNAL_0
1674 ? strsignal (gdb_signal_to_host (signo)) : "0"));
1675
1676 linux_resume_one_lwp (lp, step, signo);
1677}
1678
1679/* Send a signal to an LWP. */
1680
1681static int
1682kill_lwp (int lwpid, int signo)
1683{
1684 int ret;
1685
1686 errno = 0;
1687 ret = syscall (__NR_tkill, lwpid, signo);
1688 if (errno == ENOSYS)
1689 {
1690 /* If tkill fails, then we are not using nptl threads, a
1691 configuration we no longer support. */
1692 perror_with_name (("tkill"));
1693 }
1694 return ret;
1695}
1696
1697/* Handle a GNU/Linux syscall trap wait response. If we see a syscall
1698 event, check if the core is interested in it: if not, ignore the
1699 event, and keep waiting; otherwise, we need to toggle the LWP's
1700 syscall entry/exit status, since the ptrace event itself doesn't
1701 indicate it, and report the trap to higher layers. */
1702
1703static int
1704linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
1705{
1706 struct target_waitstatus *ourstatus = &lp->waitstatus;
1709 int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, thread);
1710
1711 if (stopping)
1712 {
1713 /* If we're stopping threads, there's a SIGSTOP pending, which
1714 makes it so that the LWP reports an immediate syscall return,
1715 followed by the SIGSTOP. Skip seeing that "return" using
1716 PTRACE_CONT directly, and let stop_wait_callback collect the
1717 SIGSTOP. Later when the thread is resumed, a new syscall
1718 entry event. If we didn't do this (and returned 0), we'd
1719 leave a syscall entry pending, and our caller, by using
1720 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1721 itself. Later, when the user re-resumes this LWP, we'd see
1722 another syscall entry event and we'd mistake it for a return.
1723
1724 If stop_wait_callback didn't force the SIGSTOP out of the LWP
1725 (leaving immediately with LWP->signalled set, without issuing
1726 a PTRACE_CONT), it would still be problematic to leave this
1727 syscall enter pending, as later when the thread is resumed,
1728 it would then see the same syscall exit mentioned above,
1729 followed by the delayed SIGSTOP, while the syscall didn't
1730 actually get to execute. It seems it would be even more
1731 confusing to the user. */
1732
1734 ("ignoring syscall %d for LWP %ld (stopping threads), resuming with "
1735 "PTRACE_CONT for SIGSTOP", syscall_number, lp->ptid.lwp ());
1736
1738 ptrace (PTRACE_CONT, lp->ptid.lwp (), 0, 0);
1739 lp->stopped = 0;
1740 return 1;
1741 }
1742
1743 /* Always update the entry/return state, even if this particular
1744 syscall isn't interesting to the core now. In async mode,
1745 the user could install a new catchpoint for this syscall
1746 between syscall enter/return, and we'll need to know to
1747 report a syscall return if that happens. */
1751
1752 if (catch_syscall_enabled ())
1753 {
1754 if (catching_syscall_number (syscall_number))
1755 {
1756 /* Alright, an event to report. */
1758 ourstatus->set_syscall_entry (syscall_number);
1760 ourstatus->set_syscall_return (syscall_number);
1761 else
1762 gdb_assert_not_reached ("unexpected syscall state");
1763
1765 ("stopping for %s of syscall %d for LWP %ld",
1767 ? "entry" : "return"), syscall_number, lp->ptid.lwp ());
1768
1769 return 0;
1770 }
1771
1773 ("ignoring %s of syscall %d for LWP %ld",
1775 ? "entry" : "return"), syscall_number, lp->ptid.lwp ());
1776 }
1777 else
1778 {
1779 /* If we had been syscall tracing, and hence used PT_SYSCALL
1780 before on this LWP, it could happen that the user removes all
1781 syscall catchpoints before we get to process this event.
1782 There are two noteworthy issues here:
1783
1784 - When stopped at a syscall entry event, resuming with
1785 PT_STEP still resumes executing the syscall and reports a
1786 syscall return.
1787
1788 - Only PT_SYSCALL catches syscall enters. If we last
1789 single-stepped this thread, then this event can't be a
1790 syscall enter. If we last single-stepped this thread, this
1791 has to be a syscall exit.
1792
1793 The points above mean that the next resume, be it PT_STEP or
1794 PT_CONTINUE, can not trigger a syscall trace event. */
1796 ("caught syscall event with no syscall catchpoints. %d for LWP %ld, "
1797 "ignoring", syscall_number, lp->ptid.lwp ());
1799 }
1800
1801 /* The core isn't interested in this event. For efficiency, avoid
1802 stopping all threads only to have the core resume them all again.
1803 Since we're not stopping threads, if we're still syscall tracing
1804 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1805 subsequent syscall. Simply resume using the inf-ptrace layer,
1806 which knows when to use PT_SYSCALL or PT_CONTINUE. */
1807
1808 linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
1809 return 1;
1810}
1811
1812/* Handle a GNU/Linux extended wait response. If we see a clone
1813 event, we need to add the new LWP to our list (and not report the
1814 trap to higher layers). This function returns non-zero if the
1815 event should be ignored and we should wait again. If STOPPING is
1816 true, the new LWP remains stopped, otherwise it is continued. */
1817
1818static int
1820{
1821 int pid = lp->ptid.lwp ();
1822 struct target_waitstatus *ourstatus = &lp->waitstatus;
1824
1825 /* All extended events we currently use are mid-syscall. Only
1826 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
1827 you have to be using PTRACE_SEIZE to get that. */
1829
1830 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1831 || event == PTRACE_EVENT_CLONE)
1832 {
1833 unsigned long new_pid;
1834 int ret;
1835
1836 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
1837
1838 /* If we haven't already seen the new PID stop, wait for it now. */
1839 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1840 {
1841 /* The new child has a pending SIGSTOP. We can't affect it until it
1842 hits the SIGSTOP, but we're already attached. */
1843 ret = my_waitpid (new_pid, &status, __WALL);
1844 if (ret == -1)
1845 perror_with_name (_("waiting for new child"));
1846 else if (ret != new_pid)
1847 internal_error (_("wait returned unexpected PID %d"), ret);
1848 else if (!WIFSTOPPED (status))
1849 internal_error (_("wait returned unexpected status 0x%x"), status);
1850 }
1851
1852 ptid_t child_ptid (new_pid, new_pid);
1853
1854 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
1855 {
1857
1858 /* The arch-specific native code may need to know about new
1859 forks even if those end up never mapped to an
1860 inferior. */
1861 linux_target->low_new_fork (lp, new_pid);
1862 }
1863 else if (event == PTRACE_EVENT_CLONE)
1864 {
1865 linux_target->low_new_clone (lp, new_pid);
1866 }
1867
1868 if (event == PTRACE_EVENT_FORK
1869 && linux_fork_checkpointing_p (lp->ptid.pid ()))
1870 {
1871 /* Handle checkpointing by linux-fork.c here as a special
1872 case. We don't want the follow-fork-mode or 'catch fork'
1873 to interfere with this. */
1874
1875 /* This won't actually modify the breakpoint list, but will
1876 physically remove the breakpoints from the child. */
1877 detach_breakpoints (ptid_t (new_pid, new_pid));
1878
1879 /* Retain child fork in ptrace (stopped) state. */
1880 if (!find_fork_pid (new_pid))
1881 add_fork (new_pid);
1882
1883 /* Report as spurious, so that infrun doesn't want to follow
1884 this fork. We're actually doing an infcall in
1885 linux-fork.c. */
1886 ourstatus->set_spurious ();
1887
1888 /* Report the stop to the core. */
1889 return 0;
1890 }
1891
1892 if (event == PTRACE_EVENT_FORK)
1893 ourstatus->set_forked (child_ptid);
1894 else if (event == PTRACE_EVENT_VFORK)
1895 ourstatus->set_vforked (child_ptid);
1896 else if (event == PTRACE_EVENT_CLONE)
1897 {
1898 struct lwp_info *new_lp;
1899
1900 ourstatus->set_ignore ();
1901
1903 ("Got clone event from LWP %d, new child is LWP %ld", pid, new_pid);
1904
1905 new_lp = add_lwp (ptid_t (lp->ptid.pid (), new_pid));
1906 new_lp->stopped = 1;
1907 new_lp->resumed = 1;
1908
1909 /* If the thread_db layer is active, let it record the user
1910 level thread id and status, and add the thread to GDB's
1911 list. */
1912 if (!thread_db_notice_clone (lp->ptid, new_lp->ptid))
1913 {
1914 /* The process is not using thread_db. Add the LWP to
1915 GDB's list. */
1916 add_thread (linux_target, new_lp->ptid);
1917 }
1918
1919 /* Even if we're stopping the thread for some reason
1920 internal to this module, from the perspective of infrun
1921 and the user/frontend, this new thread is running until
1922 it next reports a stop. */
1923 set_running (linux_target, new_lp->ptid, true);
1924 set_executing (linux_target, new_lp->ptid, true);
1925
1926 if (WSTOPSIG (status) != SIGSTOP)
1927 {
1928 /* This can happen if someone starts sending signals to
1929 the new thread before it gets a chance to run, which
1930 have a lower number than SIGSTOP (e.g. SIGUSR1).
1931 This is an unlikely case, and harder to handle for
1932 fork / vfork than for clone, so we do not try - but
1933 we handle it for clone events here. */
1934
1935 new_lp->signalled = 1;
1936
1937 /* We created NEW_LP so it cannot yet contain STATUS. */
1938 gdb_assert (new_lp->status == 0);
1939
1940 /* Save the wait status to report later. */
1942 ("waitpid of new LWP %ld, saving status %s",
1943 (long) new_lp->ptid.lwp (), status_to_str (status).c_str ());
1944 new_lp->status = status;
1945 }
1946 else if (report_thread_events)
1947 {
1948 new_lp->waitstatus.set_thread_created ();
1949 new_lp->status = status;
1950 }
1951
1952 return 1;
1953 }
1954
1955 return 0;
1956 }
1957
1958 if (event == PTRACE_EVENT_EXEC)
1959 {
1960 linux_nat_debug_printf ("Got exec event from LWP %ld", lp->ptid.lwp ());
1961
1962 /* Close the previous /proc/PID/mem file for this inferior,
1963 which was using the address space which is now gone.
1964 Reading/writing from this file would return 0/EOF. */
1965 close_proc_mem_file (lp->ptid.pid ());
1966
1967 /* Open a new file for the new address space. */
1969
1970 ourstatus->set_execd
1971 (make_unique_xstrdup (linux_proc_pid_to_exec_file (pid)));
1972
1973 /* The thread that execed must have been resumed, but, when a
1974 thread execs, it changes its tid to the tgid, and the old
1975 tgid thread might have not been resumed. */
1976 lp->resumed = 1;
1977 return 0;
1978 }
1979
1980 if (event == PTRACE_EVENT_VFORK_DONE)
1981 {
1983 ("Got PTRACE_EVENT_VFORK_DONE from LWP %ld",
1984 lp->ptid.lwp ());
1985 ourstatus->set_vfork_done ();
1986 return 0;
1987 }
1988
1989 internal_error (_("unknown ptrace event %d"), event);
1990}
1991
1992/* Suspend waiting for a signal. We're mostly interested in
1993 SIGCHLD/SIGINT. */
1994
1995static void
1997{
1998 linux_nat_debug_printf ("about to sigsuspend");
1999 sigsuspend (&suspend_mask);
2000
2001 /* If the quit flag is set, it means that the user pressed Ctrl-C
2002 and we're debugging a process that is running on a separate
2003 terminal, so we must forward the Ctrl-C to the inferior. (If the
2004 inferior is sharing GDB's terminal, then the Ctrl-C reaches the
2005 inferior directly.) We must do this here because functions that
2006 need to block waiting for a signal loop forever until there's an
2007 event to report before returning back to the event loop. */
2009 {
2010 if (check_quit_flag ())
2012 }
2013}
2014
2015/* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2016 exited. */
2017
2018static int
2019wait_lwp (struct lwp_info *lp)
2020{
2021 pid_t pid;
2022 int status = 0;
2023 int thread_dead = 0;
2024 sigset_t prev_mask;
2025
2026 gdb_assert (!lp->stopped);
2027 gdb_assert (lp->status == 0);
2028
2029 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2030 block_child_signals (&prev_mask);
2031
2032 for (;;)
2033 {
2034 pid = my_waitpid (lp->ptid.lwp (), &status, __WALL | WNOHANG);
2035 if (pid == -1 && errno == ECHILD)
2036 {
2037 /* The thread has previously exited. We need to delete it
2038 now because if this was a non-leader thread execing, we
2039 won't get an exit event. See comments on exec events at
2040 the top of the file. */
2041 thread_dead = 1;
2042 linux_nat_debug_printf ("%s vanished.",
2043 lp->ptid.to_string ().c_str ());
2044 }
2045 if (pid != 0)
2046 break;
2047
2048 /* Bugs 10970, 12702.
2049 Thread group leader may have exited in which case we'll lock up in
2050 waitpid if there are other threads, even if they are all zombies too.
2051 Basically, we're not supposed to use waitpid this way.
2052 tkill(pid,0) cannot be used here as it gets ESRCH for both
2053 for zombie and running processes.
2054
2055 As a workaround, check if we're waiting for the thread group leader and
2056 if it's a zombie, and avoid calling waitpid if it is.
2057
2058 This is racy, what if the tgl becomes a zombie right after we check?
2059 Therefore always use WNOHANG with sigsuspend - it is equivalent to
2060 waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
2061
2062 if (lp->ptid.pid () == lp->ptid.lwp ()
2063 && linux_proc_pid_is_zombie (lp->ptid.lwp ()))
2064 {
2065 thread_dead = 1;
2066 linux_nat_debug_printf ("Thread group leader %s vanished.",
2067 lp->ptid.to_string ().c_str ());
2068 break;
2069 }
2070
2071 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2072 get invoked despite our caller had them intentionally blocked by
2073 block_child_signals. This is sensitive only to the loop of
2074 linux_nat_wait_1 and there if we get called my_waitpid gets called
2075 again before it gets to sigsuspend so we can safely let the handlers
2076 get executed here. */
2077 wait_for_signal ();
2078 }
2079
2080 restore_child_signals_mask (&prev_mask);
2081
2082 if (!thread_dead)
2083 {
2084 gdb_assert (pid == lp->ptid.lwp ());
2085
2086 linux_nat_debug_printf ("waitpid %s received %s",
2087 lp->ptid.to_string ().c_str (),
2088 status_to_str (status).c_str ());
2089
2090 /* Check if the thread has exited. */
2091 if (WIFEXITED (status) || WIFSIGNALED (status))
2092 {
2094 || lp->ptid.pid () == lp->ptid.lwp ())
2095 {
2096 linux_nat_debug_printf ("LWP %d exited.", lp->ptid.pid ());
2097
2098 /* If this is the leader exiting, it means the whole
2099 process is gone. Store the status to report to the
2100 core. Store it in lp->waitstatus, because lp->status
2101 would be ambiguous (W_EXITCODE(0,0) == 0). */
2103 return 0;
2104 }
2105
2106 thread_dead = 1;
2107 linux_nat_debug_printf ("%s exited.",
2108 lp->ptid.to_string ().c_str ());
2109 }
2110 }
2111
2112 if (thread_dead)
2113 {
2114 exit_lwp (lp);
2115 return 0;
2116 }
2117
2118 gdb_assert (WIFSTOPPED (status));
2119 lp->stopped = 1;
2120
2121 if (lp->must_set_ptrace_flags)
2122 {
2124 int options = linux_nat_ptrace_options (inf->attach_flag);
2125
2126 linux_enable_event_reporting (lp->ptid.lwp (), options);
2127 lp->must_set_ptrace_flags = 0;
2128 }
2129
2130 /* Handle GNU/Linux's syscall SIGTRAPs. */
2131 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2132 {
2133 /* No longer need the sysgood bit. The ptrace event ends up
2134 recorded in lp->waitstatus if we care for it. We can carry
2135 on handling the event like a regular SIGTRAP from here
2136 on. */
2137 status = W_STOPCODE (SIGTRAP);
2138 if (linux_handle_syscall_trap (lp, 1))
2139 return wait_lwp (lp);
2140 }
2141 else
2142 {
2143 /* Almost all other ptrace-stops are known to be outside of system
2144 calls, with further exceptions in linux_handle_extended_wait. */
2146 }
2147
2148 /* Handle GNU/Linux's extended waitstatus for trace events. */
2149 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
2151 {
2152 linux_nat_debug_printf ("Handling extended status 0x%06x", status);
2154 return 0;
2155 }
2156
2157 return status;
2158}
2159
2160/* Send a SIGSTOP to LP. */
2161
2162static int
2164{
2165 if (!lp->stopped && !lp->signalled)
2166 {
2167 int ret;
2168
2169 linux_nat_debug_printf ("kill %s **<SIGSTOP>**",
2170 lp->ptid.to_string ().c_str ());
2171
2172 errno = 0;
2173 ret = kill_lwp (lp->ptid.lwp (), SIGSTOP);
2174 linux_nat_debug_printf ("lwp kill %d %s", ret,
2175 errno ? safe_strerror (errno) : "ERRNO-OK");
2176
2177 lp->signalled = 1;
2178 gdb_assert (lp->status == 0);
2179 }
2180
2181 return 0;
2182}
2183
2184/* Request a stop on LWP. */
2185
2186void
2188{
2189 stop_callback (lwp);
2190}
2191
2192/* See linux-nat.h */
2193
2194void
2196{
2197 /* Stop all LWP's ... */
2198 iterate_over_lwps (minus_one_ptid, stop_callback);
2199
2200 /* ... and wait until all of them have reported back that
2201 they're no longer running. */
2202 iterate_over_lwps (minus_one_ptid, stop_wait_callback);
2203}
2204
2205/* See linux-nat.h */
2206
2207void
2209{
2210 iterate_over_lwps (minus_one_ptid,
2211 [] (struct lwp_info *info)
2212 {
2213 return resume_stopped_resumed_lwps (info, minus_one_ptid);
2214 });
2215}
2216
2217/* Return non-zero if LWP PID has a pending SIGINT. */
2218
2219static int
2221{
2222 sigset_t pending, blocked, ignored;
2223
2224 linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2225
2226 if (sigismember (&pending, SIGINT)
2227 && !sigismember (&ignored, SIGINT))
2228 return 1;
2229
2230 return 0;
2231}
2232
2233/* Set a flag in LP indicating that we should ignore its next SIGINT. */
2234
2235static int
2237{
2238 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2239 flag to consume the next one. */
2240 if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2241 && WSTOPSIG (lp->status) == SIGINT)
2242 lp->status = 0;
2243 else
2244 lp->ignore_sigint = 1;
2245
2246 return 0;
2247}
2248
2249/* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2250 This function is called after we know the LWP has stopped; if the LWP
2251 stopped before the expected SIGINT was delivered, then it will never have
2252 arrived. Also, if the signal was delivered to a shared queue and consumed
2253 by a different thread, it will never be delivered to this LWP. */
2254
2255static void
2257{
2258 if (!lp->ignore_sigint)
2259 return;
2260
2261 if (!linux_nat_has_pending_sigint (lp->ptid.lwp ()))
2262 {
2263 linux_nat_debug_printf ("Clearing bogus flag for %s",
2264 lp->ptid.to_string ().c_str ());
2265 lp->ignore_sigint = 0;
2266 }
2267}
2268
2269/* Fetch the possible triggered data watchpoint info and store it in
2270 LP.
2271
2272 On some archs, like x86, that use debug registers to set
2273 watchpoints, it's possible that the way to know which watched
2274 address trapped, is to check the register that is used to select
2275 which address to watch. Problem is, between setting the watchpoint
2276 and reading back which data address trapped, the user may change
2277 the set of watchpoints, and, as a consequence, GDB changes the
2278 debug registers in the inferior. To avoid reading back a stale
2279 stopped-data-address when that happens, we cache in LP the fact
2280 that a watchpoint trapped, and the corresponding data address, as
2281 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2282 registers meanwhile, we have the cached data we can rely on. */
2283
2284static int
2286{
2287 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
2288 inferior_ptid = lp->ptid;
2289
2291 {
2295 }
2296
2298}
2299
2300/* Returns true if the LWP had stopped for a watchpoint. */
2301
2302bool
2304{
2305 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2306
2307 gdb_assert (lp != NULL);
2308
2310}
2311
2312bool
2314{
2315 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2316
2317 gdb_assert (lp != NULL);
2318
2319 *addr_p = lp->stopped_data_address;
2320
2321 return lp->stopped_data_address_p;
2322}
2323
2324/* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2325
2326bool
2328{
2329 return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2330}
2331
2332/* Wait until LP is stopped. */
2333
2334static int
2336{
2338
2339 /* If this is a vfork parent, bail out, it is not going to report
2340 any SIGSTOP until the vfork is done with. */
2341 if (inf->vfork_child != NULL)
2342 return 0;
2343
2344 if (!lp->stopped)
2345 {
2346 int status;
2347
2348 status = wait_lwp (lp);
2349 if (status == 0)
2350 return 0;
2351
2352 if (lp->ignore_sigint && WIFSTOPPED (status)
2353 && WSTOPSIG (status) == SIGINT)
2354 {
2355 lp->ignore_sigint = 0;
2356
2357 errno = 0;
2358 ptrace (PTRACE_CONT, lp->ptid.lwp (), 0, 0);
2359 lp->stopped = 0;
2361 ("PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)",
2362 lp->ptid.to_string ().c_str (),
2363 errno ? safe_strerror (errno) : "OK");
2364
2365 return stop_wait_callback (lp);
2366 }
2367
2369
2370 if (WSTOPSIG (status) != SIGSTOP)
2371 {
2372 /* The thread was stopped with a signal other than SIGSTOP. */
2373
2374 linux_nat_debug_printf ("Pending event %s in %s",
2375 status_to_str ((int) status).c_str (),
2376 lp->ptid.to_string ().c_str ());
2377
2378 /* Save the sigtrap event. */
2379 lp->status = status;
2380 gdb_assert (lp->signalled);
2381 save_stop_reason (lp);
2382 }
2383 else
2384 {
2385 /* We caught the SIGSTOP that we intended to catch. */
2386
2387 linux_nat_debug_printf ("Expected SIGSTOP caught for %s.",
2388 lp->ptid.to_string ().c_str ());
2389
2390 lp->signalled = 0;
2391
2392 /* If we are waiting for this stop so we can report the thread
2393 stopped then we need to record this status. Otherwise, we can
2394 now discard this stop event. */
2395 if (lp->last_resume_kind == resume_stop)
2396 {
2397 lp->status = status;
2398 save_stop_reason (lp);
2399 }
2400 }
2401 }
2402
2403 return 0;
2404}
2405
2406/* Return non-zero if LP has a wait status pending. Discard the
2407 pending event and resume the LWP if the event that originally
2408 caused the stop became uninteresting. */
2409
2410static int
2412{
2413 /* Only report a pending wait status if we pretend that this has
2414 indeed been resumed. */
2415 if (!lp->resumed)
2416 return 0;
2417
2418 if (!lwp_status_pending_p (lp))
2419 return 0;
2420
2423 {
2425 CORE_ADDR pc;
2426 int discard = 0;
2427
2429
2430 if (pc != lp->stop_pc)
2431 {
2432 linux_nat_debug_printf ("PC of %s changed. was=%s, now=%s",
2433 lp->ptid.to_string ().c_str (),
2435 paddress (target_gdbarch (), pc));
2436 discard = 1;
2437 }
2438
2439#if !USE_SIGTRAP_SIGINFO
2440 else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
2441 {
2442 linux_nat_debug_printf ("previous breakpoint of %s, at %s gone",
2443 lp->ptid.to_string ().c_str (),
2444 paddress (target_gdbarch (), lp->stop_pc));
2445
2446 discard = 1;
2447 }
2448#endif
2449
2450 if (discard)
2451 {
2452 linux_nat_debug_printf ("pending event of %s cancelled.",
2453 lp->ptid.to_string ().c_str ());
2454
2455 lp->status = 0;
2456 linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
2457 return 0;
2458 }
2459 }
2460
2461 return 1;
2462}
2463
2464/* Count the LWP's that have had events. */
2465
2466static int
2467count_events_callback (struct lwp_info *lp, int *count)
2468{
2469 gdb_assert (count != NULL);
2470
2471 /* Select only resumed LWPs that have an event pending. */
2472 if (lp->resumed && lwp_status_pending_p (lp))
2473 (*count)++;
2474
2475 return 0;
2476}
2477
2478/* Select the LWP (if any) that is currently being single-stepped. */
2479
2480static int
2482{
2483 if (lp->last_resume_kind == resume_step
2484 && lp->status != 0)
2485 return 1;
2486 else
2487 return 0;
2488}
2489
2490/* Returns true if LP has a status pending. */
2491
2492static int
2494{
2495 /* We check for lp->waitstatus in addition to lp->status, because we
2496 can have pending process exits recorded in lp->status and
2497 W_EXITCODE(0,0) happens to be 0. */
2498 return lp->status != 0 || lp->waitstatus.kind () != TARGET_WAITKIND_IGNORE;
2499}
2500
2501/* Select the Nth LWP that has had an event. */
2502
2503static int
2505{
2506 gdb_assert (selector != NULL);
2507
2508 /* Select only resumed LWPs that have an event pending. */
2509 if (lp->resumed && lwp_status_pending_p (lp))
2510 if ((*selector)-- == 0)
2511 return 1;
2512
2513 return 0;
2514}
2515
2516/* Called when the LWP stopped for a signal/trap. If it stopped for a
2517 trap check what caused it (breakpoint, watchpoint, trace, etc.),
2518 and save the result in the LWP's stop_reason field. If it stopped
2519 for a breakpoint, decrement the PC if necessary on the lwp's
2520 architecture. */
2521
2522static void
2524{
2525 struct regcache *regcache;
2526 struct gdbarch *gdbarch;
2527 CORE_ADDR pc;
2528 CORE_ADDR sw_bp_pc;
2529#if USE_SIGTRAP_SIGINFO
2530 siginfo_t siginfo;
2531#endif
2532
2533 gdb_assert (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON);
2534 gdb_assert (lp->status != 0);
2535
2537 return;
2538
2540 if (inf->starting_up)
2541 return;
2542
2544 gdbarch = regcache->arch ();
2545
2547 sw_bp_pc = pc - gdbarch_decr_pc_after_break (gdbarch);
2548
2549#if USE_SIGTRAP_SIGINFO
2550 if (linux_nat_get_siginfo (lp->ptid, &siginfo))
2551 {
2552 if (siginfo.si_signo == SIGTRAP)
2553 {
2554 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code)
2555 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
2556 {
2557 /* The si_code is ambiguous on this arch -- check debug
2558 registers. */
2561 }
2562 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code))
2563 {
2564 /* If we determine the LWP stopped for a SW breakpoint,
2565 trust it. Particularly don't check watchpoint
2566 registers, because, at least on s390, we'd find
2567 stopped-by-watchpoint as long as there's a watchpoint
2568 set. */
2570 }
2571 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
2572 {
2573 /* This can indicate either a hardware breakpoint or
2574 hardware watchpoint. Check debug registers. */
2577 }
2578 else if (siginfo.si_code == TRAP_TRACE)
2579 {
2580 linux_nat_debug_printf ("%s stopped by trace",
2581 lp->ptid.to_string ().c_str ());
2582
2583 /* We may have single stepped an instruction that
2584 triggered a watchpoint. In that case, on some
2585 architectures (such as x86), instead of TRAP_HWBKPT,
2586 si_code indicates TRAP_TRACE, and we need to check
2587 the debug registers separately. */
2589 }
2590 }
2591 }
2592#else
2593 if ((!lp->step || lp->stop_pc == sw_bp_pc)
2595 sw_bp_pc))
2596 {
2597 /* The LWP was either continued, or stepped a software
2598 breakpoint instruction. */
2600 }
2601
2604
2607#endif
2608
2610 {
2611 linux_nat_debug_printf ("%s stopped by software breakpoint",
2612 lp->ptid.to_string ().c_str ());
2613
2614 /* Back up the PC if necessary. */
2615 if (pc != sw_bp_pc)
2616 regcache_write_pc (regcache, sw_bp_pc);
2617
2618 /* Update this so we record the correct stop PC below. */
2619 pc = sw_bp_pc;
2620 }
2622 {
2623 linux_nat_debug_printf ("%s stopped by hardware breakpoint",
2624 lp->ptid.to_string ().c_str ());
2625 }
2627 {
2628 linux_nat_debug_printf ("%s stopped by hardware watchpoint",
2629 lp->ptid.to_string ().c_str ());
2630 }
2631
2632 lp->stop_pc = pc;
2633}
2634
2635
2636/* Returns true if the LWP had stopped for a software breakpoint. */
2637
2638bool
2640{
2641 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2642
2643 gdb_assert (lp != NULL);
2644
2646}
2647
2648/* Implement the supports_stopped_by_sw_breakpoint method. */
2649
2650bool
2652{
2653 return USE_SIGTRAP_SIGINFO;
2654}
2655
2656/* Returns true if the LWP had stopped for a hardware
2657 breakpoint/watchpoint. */
2658
2659bool
2661{
2662 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2663
2664 gdb_assert (lp != NULL);
2665
2667}
2668
2669/* Implement the supports_stopped_by_hw_breakpoint method. */
2670
2671bool
2673{
2674 return USE_SIGTRAP_SIGINFO;
2675}
2676
2677/* Select one LWP out of those that have events pending. */
2678
2679static void
2680select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
2681{
2682 int num_events = 0;
2683 int random_selector;
2684 struct lwp_info *event_lp = NULL;
2685
2686 /* Record the wait status for the original LWP. */
2687 (*orig_lp)->status = *status;
2688
2689 /* In all-stop, give preference to the LWP that is being
2690 single-stepped. There will be at most one, and it will be the
2691 LWP that the core is most interested in. If we didn't do this,
2692 then we'd have to handle pending step SIGTRAPs somehow in case
2693 the core later continues the previously-stepped thread, as
2694 otherwise we'd report the pending SIGTRAP then, and the core, not
2695 having stepped the thread, wouldn't understand what the trap was
2696 for, and therefore would report it to the user as a random
2697 signal. */
2698 if (!target_is_non_stop_p ())
2699 {
2701 if (event_lp != NULL)
2702 {
2703 linux_nat_debug_printf ("Select single-step %s",
2704 event_lp->ptid.to_string ().c_str ());
2705 }
2706 }
2707
2708 if (event_lp == NULL)
2709 {
2710 /* Pick one at random, out of those which have had events. */
2711
2712 /* First see how many events we have. */
2713 iterate_over_lwps (filter,
2714 [&] (struct lwp_info *info)
2715 {
2716 return count_events_callback (info, &num_events);
2717 });
2718 gdb_assert (num_events > 0);
2719
2720 /* Now randomly pick a LWP out of those that have had
2721 events. */
2722 random_selector = (int)
2723 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2724
2725 if (num_events > 1)
2726 linux_nat_debug_printf ("Found %d events, selecting #%d",
2727 num_events, random_selector);
2728
2729 event_lp
2731 (filter,
2732 [&] (struct lwp_info *info)
2733 {
2734 return select_event_lwp_callback (info,
2735 &random_selector);
2736 }));
2737 }
2738
2739 if (event_lp != NULL)
2740 {
2741 /* Switch the event LWP. */
2742 *orig_lp = event_lp;
2743 *status = event_lp->status;
2744 }
2745
2746 /* Flush the wait status for the event LWP. */
2747 (*orig_lp)->status = 0;
2748}
2749
2750/* Return non-zero if LP has been resumed. */
2751
2752static int
2754{
2755 return lp->resumed;
2756}
2757
2758/* Check if we should go on and pass this event to common code.
2759
2760 If so, save the status to the lwp_info structure associated to LWPID. */
2761
2762static void
2764{
2765 struct lwp_info *lp;
2767
2768 lp = find_lwp_pid (ptid_t (lwpid));
2769
2770 /* Check for events reported by anything not in our LWP list. */
2771 if (lp == nullptr)
2772 {
2773 if (WIFSTOPPED (status))
2774 {
2775 if (WSTOPSIG (status) == SIGTRAP && event == PTRACE_EVENT_EXEC)
2776 {
2777 /* A non-leader thread exec'ed after we've seen the
2778 leader zombie, and removed it from our lists (in
2779 check_zombie_leaders). The non-leader thread changes
2780 its tid to the tgid. */
2782 ("Re-adding thread group leader LWP %d after exec.",
2783 lwpid);
2784
2785 lp = add_lwp (ptid_t (lwpid, lwpid));
2786 lp->stopped = 1;
2787 lp->resumed = 1;
2789 }
2790 else
2791 {
2792 /* A process we are controlling has forked and the new
2793 child's stop was reported to us by the kernel. Save
2794 its PID and go back to waiting for the fork event to
2795 be reported - the stopped process might be returned
2796 from waitpid before or after the fork event is. */
2798 ("Saving LWP %d status %s in stopped_pids list",
2799 lwpid, status_to_str (status).c_str ());
2801 }
2802 }
2803 else
2804 {
2805 /* Don't report an event for the exit of an LWP not in our
2806 list, i.e. not part of any inferior we're debugging.
2807 This can happen if we detach from a program we originally
2808 forked and then it exits. However, note that we may have
2809 earlier deleted a leader of an inferior we're debugging,
2810 in check_zombie_leaders. Re-add it back here if so. */
2812 {
2813 if (inf->pid == lwpid)
2814 {
2816 ("Re-adding thread group leader LWP %d after exit.",
2817 lwpid);
2818
2819 lp = add_lwp (ptid_t (lwpid, lwpid));
2820 lp->resumed = 1;
2822 break;
2823 }
2824 }
2825 }
2826
2827 if (lp == nullptr)
2828 return;
2829 }
2830
2831 /* This LWP is stopped now. (And if dead, this prevents it from
2832 ever being continued.) */
2833 lp->stopped = 1;
2834
2835 if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
2836 {
2838 int options = linux_nat_ptrace_options (inf->attach_flag);
2839
2840 linux_enable_event_reporting (lp->ptid.lwp (), options);
2841 lp->must_set_ptrace_flags = 0;
2842 }
2843
2844 /* Handle GNU/Linux's syscall SIGTRAPs. */
2845 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2846 {
2847 /* No longer need the sysgood bit. The ptrace event ends up
2848 recorded in lp->waitstatus if we care for it. We can carry
2849 on handling the event like a regular SIGTRAP from here
2850 on. */
2851 status = W_STOPCODE (SIGTRAP);
2852 if (linux_handle_syscall_trap (lp, 0))
2853 return;
2854 }
2855 else
2856 {
2857 /* Almost all other ptrace-stops are known to be outside of system
2858 calls, with further exceptions in linux_handle_extended_wait. */
2860 }
2861
2862 /* Handle GNU/Linux's extended waitstatus for trace events. */
2863 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
2865 {
2866 linux_nat_debug_printf ("Handling extended status 0x%06x", status);
2867
2869 return;
2870 }
2871
2872 /* Check if the thread has exited. */
2873 if (WIFEXITED (status) || WIFSIGNALED (status))
2874 {
2875 if (!report_thread_events && !is_leader (lp))
2876 {
2877 linux_nat_debug_printf ("%s exited.",
2878 lp->ptid.to_string ().c_str ());
2879
2880 /* If this was not the leader exiting, then the exit signal
2881 was not the end of the debugged application and should be
2882 ignored. */
2883 exit_lwp (lp);
2884 return;
2885 }
2886
2887 /* Note that even if the leader was ptrace-stopped, it can still
2888 exit, if e.g., some other thread brings down the whole
2889 process (calls `exit'). So don't assert that the lwp is
2890 resumed. */
2891 linux_nat_debug_printf ("LWP %ld exited (resumed=%d)",
2892 lp->ptid.lwp (), lp->resumed);
2893
2894 /* Dead LWP's aren't expected to reported a pending sigstop. */
2895 lp->signalled = 0;
2896
2897 /* Store the pending event in the waitstatus, because
2898 W_EXITCODE(0,0) == 0. */
2900 return;
2901 }
2902
2903 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2904 an attempt to stop an LWP. */
2905 if (lp->signalled
2906 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
2907 {
2908 lp->signalled = 0;
2909
2910 if (lp->last_resume_kind == resume_stop)
2911 {
2912 linux_nat_debug_printf ("resume_stop SIGSTOP caught for %s.",
2913 lp->ptid.to_string ().c_str ());
2914 }
2915 else
2916 {
2917 /* This is a delayed SIGSTOP. Filter out the event. */
2918
2920 ("%s %s, 0, 0 (discard delayed SIGSTOP)",
2921 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2922 lp->ptid.to_string ().c_str ());
2923
2924 linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
2925 gdb_assert (lp->resumed);
2926 return;
2927 }
2928 }
2929
2930 /* Make sure we don't report a SIGINT that we have already displayed
2931 for another thread. */
2932 if (lp->ignore_sigint
2933 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
2934 {
2935 linux_nat_debug_printf ("Delayed SIGINT caught for %s.",
2936 lp->ptid.to_string ().c_str ());
2937
2938 /* This is a delayed SIGINT. */
2939 lp->ignore_sigint = 0;
2940
2941 linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
2942 linux_nat_debug_printf ("%s %s, 0, 0 (discard SIGINT)",
2943 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2944 lp->ptid.to_string ().c_str ());
2945 gdb_assert (lp->resumed);
2946
2947 /* Discard the event. */
2948 return;
2949 }
2950
2951 /* Don't report signals that GDB isn't interested in, such as
2952 signals that are neither printed nor stopped upon. Stopping all
2953 threads can be a bit time-consuming, so if we want decent
2954 performance with heavily multi-threaded programs, especially when
2955 they're using a high frequency timer, we'd better avoid it if we
2956 can. */
2957 if (WIFSTOPPED (status))
2958 {
2959 enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
2960
2961 if (!target_is_non_stop_p ())
2962 {
2963 /* Only do the below in all-stop, as we currently use SIGSTOP
2964 to implement target_stop (see linux_nat_stop) in
2965 non-stop. */
2966 if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
2967 {
2968 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2969 forwarded to the entire process group, that is, all LWPs
2970 will receive it - unless they're using CLONE_THREAD to
2971 share signals. Since we only want to report it once, we
2972 mark it as ignored for all LWPs except this one. */
2973 iterate_over_lwps (ptid_t (lp->ptid.pid ()), set_ignore_sigint);
2974 lp->ignore_sigint = 0;
2975 }
2976 else
2978 }
2979
2980 /* When using hardware single-step, we need to report every signal.
2981 Otherwise, signals in pass_mask may be short-circuited
2982 except signals that might be caused by a breakpoint, or SIGSTOP
2983 if we sent the SIGSTOP and are waiting for it to arrive. */
2984 if (!lp->step
2985 && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status))
2986 && (WSTOPSIG (status) != SIGSTOP
2989 {
2990 linux_resume_one_lwp (lp, lp->step, signo);
2992 ("%s %s, %s (preempt 'handle')",
2993 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2994 lp->ptid.to_string ().c_str (),
2995 (signo != GDB_SIGNAL_0
2996 ? strsignal (gdb_signal_to_host (signo)) : "0"));
2997 return;
2998 }
2999 }
3000
3001 /* An interesting event. */
3002 gdb_assert (lp);
3003 lp->status = status;
3004 save_stop_reason (lp);
3005}
3006
3007/* Detect zombie thread group leaders, and "exit" them. We can't reap
3008 their exits until all other threads in the group have exited. */
3009
3010static void
3012{
3013 for (inferior *inf : all_inferiors ())
3014 {
3015 struct lwp_info *leader_lp;
3016
3017 if (inf->pid == 0)
3018 continue;
3019
3020 leader_lp = find_lwp_pid (ptid_t (inf->pid));
3021 if (leader_lp != NULL
3022 /* Check if there are other threads in the group, as we may
3023 have raced with the inferior simply exiting. Note this
3024 isn't a watertight check. If the inferior is
3025 multi-threaded and is exiting, it may be we see the
3026 leader as zombie before we reap all the non-leader
3027 threads. See comments below. */
3028 && num_lwps (inf->pid) > 1
3030 {
3031 /* A zombie leader in a multi-threaded program can mean one
3032 of three things:
3033
3034 #1 - Only the leader exited, not the whole program, e.g.,
3035 with pthread_exit. Since we can't reap the leader's exit
3036 status until all other threads are gone and reaped too,
3037 we want to delete the zombie leader right away, as it
3038 can't be debugged, we can't read its registers, etc.
3039 This is the main reason we check for zombie leaders
3040 disappearing.
3041
3042 #2 - The whole thread-group/process exited (a group exit,
3043 via e.g. exit(3), and there is (or will be shortly) an
3044 exit reported for each thread in the process, and then
3045 finally an exit for the leader once the non-leaders are
3046 reaped.
3047
3048 #3 - There are 3 or more threads in the group, and a
3049 thread other than the leader exec'd. See comments on
3050 exec events at the top of the file.
3051
3052 Ideally we would never delete the leader for case #2.
3053 Instead, we want to collect the exit status of each
3054 non-leader thread, and then finally collect the exit
3055 status of the leader as normal and use its exit code as
3056 whole-process exit code. Unfortunately, there's no
3057 race-free way to distinguish cases #1 and #2. We can't
3058 assume the exit events for the non-leaders threads are
3059 already pending in the kernel, nor can we assume the
3060 non-leader threads are in zombie state already. Between
3061 the leader becoming zombie and the non-leaders exiting
3062 and becoming zombie themselves, there's a small time
3063 window, so such a check would be racy. Temporarily
3064 pausing all threads and checking to see if all threads
3065 exit or not before re-resuming them would work in the
3066 case that all threads are running right now, but it
3067 wouldn't work if some thread is currently already
3068 ptrace-stopped, e.g., due to scheduler-locking.
3069
3070 So what we do is we delete the leader anyhow, and then
3071 later on when we see its exit status, we re-add it back.
3072 We also make sure that we only report a whole-process
3073 exit when we see the leader exiting, as opposed to when
3074 the last LWP in the LWP list exits, which can be a
3075 non-leader if we deleted the leader here. */
3076 linux_nat_debug_printf ("Thread group leader %d zombie "
3077 "(it exited, or another thread execd), "
3078 "deleting it.",
3079 inf->pid);
3080 exit_lwp (leader_lp);
3081 }
3082 }
3083}
3084
3085/* Convenience function that is called when the kernel reports an exit
3086 event. This decides whether to report the event to GDB as a
3087 process exit event, a thread exit event, or to suppress the
3088 event. */
3089
3090static ptid_t
3091filter_exit_event (struct lwp_info *event_child,
3092 struct target_waitstatus *ourstatus)
3093{
3094 ptid_t ptid = event_child->ptid;
3095
3096 if (!is_leader (event_child))
3097 {
3099 ourstatus->set_thread_exited (0);
3100 else
3101 ourstatus->set_ignore ();
3102
3103 exit_lwp (event_child);
3104 }
3105
3106 return ptid;
3107}
3108
3109static ptid_t
3110linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus,
3111 target_wait_flags target_options)
3112{
3113 sigset_t prev_mask;
3115 struct lwp_info *lp;
3116 int status;
3117
3118 linux_nat_debug_printf ("enter");
3119
3120 /* The first time we get here after starting a new inferior, we may
3121 not have added it to the LWP list yet - this is the earliest
3122 moment at which we know its PID. */
3123 if (ptid.is_pid () && find_lwp_pid (ptid) == nullptr)
3124 {
3125 ptid_t lwp_ptid (ptid.pid (), ptid.pid ());
3126
3127 /* Upgrade the main thread's ptid. */
3129 lp = add_initial_lwp (lwp_ptid);
3130 lp->resumed = 1;
3131 }
3132
3133 /* Make sure SIGCHLD is blocked until the sigsuspend below. */
3134 block_child_signals (&prev_mask);
3135
3136 /* First check if there is a LWP with a wait status pending. */
3138 if (lp != NULL)
3139 {
3140 linux_nat_debug_printf ("Using pending wait status %s for %s.",
3141 status_to_str (lp->status).c_str (),
3142 lp->ptid.to_string ().c_str ());
3143 }
3144
3145 /* But if we don't find a pending event, we'll have to wait. Always
3146 pull all events out of the kernel. We'll randomly select an
3147 event LWP out of all that have events, to prevent starvation. */
3148
3149 while (lp == NULL)
3150 {
3151 pid_t lwpid;
3152
3153 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3154 quirks:
3155
3156 - If the thread group leader exits while other threads in the
3157 thread group still exist, waitpid(TGID, ...) hangs. That
3158 waitpid won't return an exit status until the other threads
3159 in the group are reaped.
3160
3161 - When a non-leader thread execs, that thread just vanishes
3162 without reporting an exit (so we'd hang if we waited for it
3163 explicitly in that case). The exec event is reported to
3164 the TGID pid. */
3165
3166 errno = 0;
3167 lwpid = my_waitpid (-1, &status, __WALL | WNOHANG);
3168
3169 linux_nat_debug_printf ("waitpid(-1, ...) returned %d, %s",
3170 lwpid,
3171 errno ? safe_strerror (errno) : "ERRNO-OK");
3172
3173 if (lwpid > 0)
3174 {
3175 linux_nat_debug_printf ("waitpid %ld received %s",
3176 (long) lwpid,
3177 status_to_str (status).c_str ());
3178
3180 /* Retry until nothing comes out of waitpid. A single
3181 SIGCHLD can indicate more than one child stopped. */
3182 continue;
3183 }
3184
3185 /* Now that we've pulled all events out of the kernel, resume
3186 LWPs that don't have an interesting event to report. */
3187 iterate_over_lwps (minus_one_ptid,
3188 [] (struct lwp_info *info)
3189 {
3190 return resume_stopped_resumed_lwps (info, minus_one_ptid);
3191 });
3192
3193 /* ... and find an LWP with a status to report to the core, if
3194 any. */
3196 if (lp != NULL)
3197 break;
3198
3199 /* Check for zombie thread group leaders. Those can't be reaped
3200 until all other threads in the thread group are. */
3202
3203 /* If there are no resumed children left, bail. We'd be stuck
3204 forever in the sigsuspend call below otherwise. */
3206 {
3207 linux_nat_debug_printf ("exit (no resumed LWP)");
3208
3209 ourstatus->set_no_resumed ();
3210
3211 restore_child_signals_mask (&prev_mask);
3212 return minus_one_ptid;
3213 }
3214
3215 /* No interesting event to report to the core. */
3216
3217 if (target_options & TARGET_WNOHANG)
3218 {
3219 linux_nat_debug_printf ("exit (ignore)");
3220
3221 ourstatus->set_ignore ();
3222 restore_child_signals_mask (&prev_mask);
3223 return minus_one_ptid;
3224 }
3225
3226 /* We shouldn't end up here unless we want to try again. */
3227 gdb_assert (lp == NULL);
3228
3229 /* Block until we get an event reported with SIGCHLD. */
3230 wait_for_signal ();
3231 }
3232
3233 gdb_assert (lp);
3234
3235 status = lp->status;
3236 lp->status = 0;
3237
3238 if (!target_is_non_stop_p ())
3239 {
3240 /* Now stop all other LWP's ... */
3241 iterate_over_lwps (minus_one_ptid, stop_callback);
3242
3243 /* ... and wait until all of them have reported back that
3244 they're no longer running. */
3245 iterate_over_lwps (minus_one_ptid, stop_wait_callback);
3246 }
3247
3248 /* If we're not waiting for a specific LWP, choose an event LWP from
3249 among those that have had events. Giving equal priority to all
3250 LWPs that have had events helps prevent starvation. */
3251 if (ptid == minus_one_ptid || ptid.is_pid ())
3252 select_event_lwp (ptid, &lp, &status);
3253
3254 gdb_assert (lp != NULL);
3255
3256 /* Now that we've selected our final event LWP, un-adjust its PC if
3257 it was a software breakpoint, and we can't reliably support the
3258 "stopped by software breakpoint" stop reason. */
3261 {
3263 struct gdbarch *gdbarch = regcache->arch ();
3264 int decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3265
3266 if (decr_pc != 0)
3267 {
3268 CORE_ADDR pc;
3269
3271 regcache_write_pc (regcache, pc + decr_pc);
3272 }
3273 }
3274
3275 /* We'll need this to determine whether to report a SIGSTOP as
3276 GDB_SIGNAL_0. Need to take a copy because resume_clear_callback
3277 clears it. */
3278 last_resume_kind = lp->last_resume_kind;
3279
3280 if (!target_is_non_stop_p ())
3281 {
3282 /* In all-stop, from the core's perspective, all LWPs are now
3283 stopped until a new resume action is sent over. */
3284 iterate_over_lwps (minus_one_ptid, resume_clear_callback);
3285 }
3286 else
3287 {
3289 }
3290
3292 {
3293 linux_nat_debug_printf ("trap ptid is %s.",
3294 lp->ptid.to_string ().c_str ());
3295 }
3296
3298 {
3299 *ourstatus = lp->waitstatus;
3300 lp->waitstatus.set_ignore ();
3301 }
3302 else
3303 *ourstatus = host_status_to_waitstatus (status);
3304
3305 linux_nat_debug_printf ("exit");
3306
3307 restore_child_signals_mask (&prev_mask);
3308
3309 if (last_resume_kind == resume_stop
3310 && ourstatus->kind () == TARGET_WAITKIND_STOPPED
3311 && WSTOPSIG (status) == SIGSTOP)
3312 {
3313 /* A thread that has been requested to stop by GDB with
3314 target_stop, and it stopped cleanly, so report as SIG0. The
3315 use of SIGSTOP is an implementation detail. */
3316 ourstatus->set_stopped (GDB_SIGNAL_0);
3317 }
3318
3319 if (ourstatus->kind () == TARGET_WAITKIND_EXITED
3320 || ourstatus->kind () == TARGET_WAITKIND_SIGNALLED)
3321 lp->core = -1;
3322 else
3324
3325 if (ourstatus->kind () == TARGET_WAITKIND_EXITED)
3326 return filter_exit_event (lp, ourstatus);
3327
3328 return lp->ptid;
3329}
3330
3331/* Resume LWPs that are currently stopped without any pending status
3332 to report, but are resumed from the core's perspective. */
3333
3334static int
3335resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid)
3336{
3337 if (!lp->stopped)
3338 {
3339 linux_nat_debug_printf ("NOT resuming LWP %s, not stopped",
3340 lp->ptid.to_string ().c_str ());
3341 }
3342 else if (!lp->resumed)
3343 {
3344 linux_nat_debug_printf ("NOT resuming LWP %s, not resumed",
3345 lp->ptid.to_string ().c_str ());
3346 }
3347 else if (lwp_status_pending_p (lp))
3348 {
3349 linux_nat_debug_printf ("NOT resuming LWP %s, has pending status",
3350 lp->ptid.to_string ().c_str ());
3351 }
3352 else
3353 {
3355 struct gdbarch *gdbarch = regcache->arch ();
3356
3357 try
3358 {
3359 CORE_ADDR pc = regcache_read_pc (regcache);
3360 int leave_stopped = 0;
3361
3362 /* Don't bother if there's a breakpoint at PC that we'd hit
3363 immediately, and we're not waiting for this LWP. */
3364 if (!lp->ptid.matches (wait_ptid))
3365 {
3367 leave_stopped = 1;
3368 }
3369
3370 if (!leave_stopped)
3371 {
3373 ("resuming stopped-resumed LWP %s at %s: step=%d",
3374 lp->ptid.to_string ().c_str (), paddress (gdbarch, pc),
3375 lp->step);
3376
3377 linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0);
3378 }
3379 }
3380 catch (const gdb_exception_error &ex)
3381 {
3383 throw;
3384 }
3385 }
3386
3387 return 0;
3388}
3389
3390ptid_t
3391linux_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
3392 target_wait_flags target_options)
3393{
3394 ptid_t event_ptid;
3395
3396 linux_nat_debug_printf ("[%s], [%s]", ptid.to_string ().c_str (),
3397 target_options_to_string (target_options).c_str ());
3398
3399 /* Flush the async file first. */
3400 if (target_is_async_p ())
3402
3403 /* Resume LWPs that are currently stopped without any pending status
3404 to report, but are resumed from the core's perspective. LWPs get
3405 in this state if we find them stopping at a time we're not
3406 interested in reporting the event (target_wait on a
3407 specific_process, for example, see linux_nat_wait_1), and
3408 meanwhile the event became uninteresting. Don't bother resuming
3409 LWPs we're not going to wait for if they'd stop immediately. */
3410 if (target_is_non_stop_p ())
3411 iterate_over_lwps (minus_one_ptid,
3412 [=] (struct lwp_info *info)
3413 {
3414 return resume_stopped_resumed_lwps (info, ptid);
3415 });
3416
3417 event_ptid = linux_nat_wait_1 (ptid, ourstatus, target_options);
3418
3419 /* If we requested any event, and something came out, assume there
3420 may be more. If we requested a specific lwp or process, also
3421 assume there may be more. */
3422 if (target_is_async_p ()
3423 && ((ourstatus->kind () != TARGET_WAITKIND_IGNORE
3424 && ourstatus->kind () != TARGET_WAITKIND_NO_RESUMED)
3425 || ptid != minus_one_ptid))
3426 async_file_mark ();
3427
3428 return event_ptid;
3429}
3430
3431/* Kill one LWP. */
3432
3433static void
3435{
3436 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
3437
3438 errno = 0;
3439 kill_lwp (pid, SIGKILL);
3440
3441 if (debug_linux_nat)
3442 {
3443 int save_errno = errno;
3444
3446 ("kill (SIGKILL) %ld, 0, 0 (%s)", (long) pid,
3447 save_errno != 0 ? safe_strerror (save_errno) : "OK");
3448 }
3449
3450 /* Some kernels ignore even SIGKILL for processes under ptrace. */
3451
3452 errno = 0;
3453 ptrace (PTRACE_KILL, pid, 0, 0);
3454 if (debug_linux_nat)
3455 {
3456 int save_errno = errno;
3457
3459 ("PTRACE_KILL %ld, 0, 0 (%s)", (long) pid,
3460 save_errno ? safe_strerror (save_errno) : "OK");
3461 }
3462}
3463
3464/* Wait for an LWP to die. */
3465
3466static void
3468{
3469 pid_t res;
3470
3471 /* We must make sure that there are no pending events (delayed
3472 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3473 program doesn't interfere with any following debugging session. */
3474
3475 do
3476 {
3477 res = my_waitpid (pid, NULL, __WALL);
3478 if (res != (pid_t) -1)
3479 {
3480 linux_nat_debug_printf ("wait %ld received unknown.", (long) pid);
3481
3482 /* The Linux kernel sometimes fails to kill a thread
3483 completely after PTRACE_KILL; that goes from the stop
3484 point in do_fork out to the one in get_signal_to_deliver
3485 and waits again. So kill it again. */
3486 kill_one_lwp (pid);
3487 }
3488 }
3489 while (res == pid);
3490
3491 gdb_assert (res == -1 && errno == ECHILD);
3492}
3493
3494/* Callback for iterate_over_lwps. */
3495
3496static int
3498{
3499 kill_one_lwp (lp->ptid.lwp ());
3500 return 0;
3501}
3502
3503/* Callback for iterate_over_lwps. */
3504
3505static int
3507{
3508 kill_wait_one_lwp (lp->ptid.lwp ());
3509 return 0;
3510}
3511
3512/* Kill the fork children of any threads of inferior INF that are
3513 stopped at a fork event. */
3514
3515static void
3517{
3518 for (thread_info *thread : inf->non_exited_threads ())
3519 {
3520 struct target_waitstatus *ws = &thread->pending_follow;
3521
3522 if (ws->kind () == TARGET_WAITKIND_FORKED
3523 || ws->kind () == TARGET_WAITKIND_VFORKED)
3524 {
3525 ptid_t child_ptid = ws->child_ptid ();
3526 int child_pid = child_ptid.pid ();
3527 int child_lwp = child_ptid.lwp ();
3528
3529 kill_one_lwp (child_lwp);
3530 kill_wait_one_lwp (child_lwp);
3531
3532 /* Let the arch-specific native code know this process is
3533 gone. */
3534 linux_target->low_forget_process (child_pid);
3535 }
3536 }
3537}
3538
3539void
3541{
3542 /* If we're stopped while forking and we haven't followed yet,
3543 kill the other task. We need to do this first because the
3544 parent will be sleeping if this is a vfork. */
3546
3547 if (forks_exist_p ())
3549 else
3550 {
3551 ptid_t ptid = ptid_t (inferior_ptid.pid ());
3552
3553 /* Stop all threads before killing them, since ptrace requires
3554 that the thread is stopped to successfully PTRACE_KILL. */
3556 /* ... and wait until all of them have reported back that
3557 they're no longer running. */
3559
3560 /* Kill all LWP's ... */
3562
3563 /* ... and wait until we've flushed all events. */
3565 }
3566
3568}
3569
3570void
3572{
3573 int pid = inferior_ptid.pid ();
3574
3576
3578
3579 if (! forks_exist_p ())
3580 /* Normal case, no other forks available. */
3582 else
3583 /* Multi-fork case. The current inferior_ptid has exited, but
3584 there are other viable forks to debug. Delete the exiting
3585 one and context-switch to the first available. */
3587
3588 /* Let the arch-specific native code know this process is gone. */
3590}
3591
3592/* Convert a native/host siginfo object, into/from the siginfo in the
3593 layout of the inferiors' architecture. */
3594
3595static void
3596siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
3597{
3598 /* If the low target didn't do anything, then just do a straight
3599 memcpy. */
3600 if (!linux_target->low_siginfo_fixup (siginfo, inf_siginfo, direction))
3601 {
3602 if (direction == 1)
3603 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
3604 else
3605 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
3606 }
3607}
3608
3609static enum target_xfer_status
3610linux_xfer_siginfo (ptid_t ptid, enum target_object object,
3611 const char *annex, gdb_byte *readbuf,
3612 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3613 ULONGEST *xfered_len)
3614{
3615 siginfo_t siginfo;
3616 gdb_byte inf_siginfo[sizeof (siginfo_t)];
3617
3618 gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
3619 gdb_assert (readbuf || writebuf);
3620
3621 if (offset > sizeof (siginfo))
3622 return TARGET_XFER_E_IO;
3623
3624 if (!linux_nat_get_siginfo (ptid, &siginfo))
3625 return TARGET_XFER_E_IO;
3626
3627 /* When GDB is built as a 64-bit application, ptrace writes into
3628 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3629 inferior with a 64-bit GDB should look the same as debugging it
3630 with a 32-bit GDB, we need to convert it. GDB core always sees
3631 the converted layout, so any read/write will have to be done
3632 post-conversion. */
3633 siginfo_fixup (&siginfo, inf_siginfo, 0);
3634
3635 if (offset + len > sizeof (siginfo))
3636 len = sizeof (siginfo) - offset;
3637
3638 if (readbuf != NULL)
3639 memcpy (readbuf, inf_siginfo + offset, len);
3640 else
3641 {
3642 memcpy (inf_siginfo + offset, writebuf, len);
3643
3644 /* Convert back to ptrace layout before flushing it out. */
3645 siginfo_fixup (&siginfo, inf_siginfo, 1);
3646
3647 int pid = get_ptrace_pid (ptid);
3648 errno = 0;
3649 ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3650 if (errno != 0)
3651 return TARGET_XFER_E_IO;
3652 }
3653
3654 *xfered_len = len;
3655 return TARGET_XFER_OK;
3656}
3657
3658static enum target_xfer_status
3660 const char *annex, gdb_byte *readbuf,
3661 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3662 ULONGEST *xfered_len);
3663
3664static enum target_xfer_status
3665linux_proc_xfer_memory_partial (int pid, gdb_byte *readbuf,
3666 const gdb_byte *writebuf, ULONGEST offset,
3667 LONGEST len, ULONGEST *xfered_len);
3668
3671 const char *annex, gdb_byte *readbuf,
3672 const gdb_byte *writebuf,
3673 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
3674{
3675 if (object == TARGET_OBJECT_SIGNAL_INFO)
3676 return linux_xfer_siginfo (inferior_ptid, object, annex, readbuf, writebuf,
3677 offset, len, xfered_len);
3678
3679 /* The target is connected but no live inferior is selected. Pass
3680 this request down to a lower stratum (e.g., the executable
3681 file). */
3682 if (object == TARGET_OBJECT_MEMORY && inferior_ptid == null_ptid)
3683 return TARGET_XFER_EOF;
3684
3685 if (object == TARGET_OBJECT_AUXV)
3686 return memory_xfer_auxv (this, object, annex, readbuf, writebuf,
3687 offset, len, xfered_len);
3688
3689 if (object == TARGET_OBJECT_OSDATA)
3690 return linux_nat_xfer_osdata (object, annex, readbuf, writebuf,
3691 offset, len, xfered_len);
3692
3693 if (object == TARGET_OBJECT_MEMORY)
3694 {
3695 /* GDB calculates all addresses in the largest possible address
3696 width. The address width must be masked before its final use
3697 by linux_proc_xfer_partial.
3698
3699 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
3700 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
3701
3702 if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
3703 offset &= ((ULONGEST) 1 << addr_bit) - 1;
3704
3705 /* If /proc/pid/mem is writable, don't fallback to ptrace. If
3706 the write via /proc/pid/mem fails because the inferior execed
3707 (and we haven't seen the exec event yet), a subsequent ptrace
3708 poke would incorrectly write memory to the post-exec address
3709 space, while the core was trying to write to the pre-exec
3710 address space. */
3712 return linux_proc_xfer_memory_partial (inferior_ptid.pid (), readbuf,
3713 writebuf, offset, len,
3714 xfered_len);
3715 }
3716
3717 return inf_ptrace_target::xfer_partial (object, annex, readbuf, writebuf,
3718 offset, len, xfered_len);
3719}
3720
3721bool
3723{
3724 /* As long as a PTID is in lwp list, consider it alive. */
3725 return find_lwp_pid (ptid) != NULL;
3726}
3727
3728/* Implement the to_update_thread_list target method for this
3729 target. */
3730
3731void
3733{
3734 /* We add/delete threads from the list as clone/exit events are
3735 processed, so just try deleting exited threads still in the
3736 thread list. */
3738
3739 /* Update the processor core that each lwp/thread was last seen
3740 running on. */
3741 for (lwp_info *lwp : all_lwps ())
3742 {
3743 /* Avoid accessing /proc if the thread hasn't run since we last
3744 time we fetched the thread's core. Accessing /proc becomes
3745 noticeably expensive when we have thousands of LWPs. */
3746 if (lwp->core == -1)
3747 lwp->core = linux_common_core_of_thread (lwp->ptid);
3748 }
3749}
3750
3751std::string
3753{
3754 if (ptid.lwp_p ()
3755 && (ptid.pid () != ptid.lwp ()
3756 || num_lwps (ptid.pid ()) > 1))
3757 return string_printf ("LWP %ld", ptid.lwp ());
3758
3759 return normal_pid_to_str (ptid);
3760}
3761
3762const char *
3764{
3765 return linux_proc_tid_get_name (thr->ptid);
3766}
3767
3768/* Accepts an integer PID; Returns a string representing a file that
3769 can be opened to get the symbols for the child process. */
3770
3771const char *
3773{
3775}
3776
3777/* Object representing an /proc/PID/mem open file. We keep one such
3778 file open per inferior.
3779
3780 It might be tempting to think about only ever opening one file at
3781 most for all inferiors, closing/reopening the file as we access
3782 memory of different inferiors, to minimize number of file
3783 descriptors open, which can otherwise run into resource limits.
3784 However, that does not work correctly -- if the inferior execs and
3785 we haven't processed the exec event yet, and, we opened a
3786 /proc/PID/mem file, we will get a mem file accessing the post-exec
3787 address space, thinking we're opening it for the pre-exec address
3788 space. That is dangerous as we can poke memory (e.g. clearing
3789 breakpoints) in the post-exec memory by mistake, corrupting the
3790 inferior. For that reason, we open the mem file as early as
3791 possible, right after spawning, forking or attaching to the
3792 inferior, when the inferior is stopped and thus before it has a
3793 chance of execing.
3794
3795 Note that after opening the file, even if the thread we opened it
3796 for subsequently exits, the open file is still usable for accessing
3797 memory. It's only when the whole process exits or execs that the
3798 file becomes invalid, at which point reads/writes return EOF. */
3799
3801{
3802public:
3803 proc_mem_file (ptid_t ptid, int fd)
3804 : m_ptid (ptid), m_fd (fd)
3805 {
3806 gdb_assert (m_fd != -1);
3807 }
3808
3810 {
3811 linux_nat_debug_printf ("closing fd %d for /proc/%d/task/%ld/mem",
3812 m_fd, m_ptid.pid (), m_ptid.lwp ());
3813 close (m_fd);
3814 }
3815
3817
3818 int fd ()
3819 {
3820 return m_fd;
3821 }
3822
3823private:
3824 /* The LWP this file was opened for. Just for debugging
3825 purposes. */
3826 ptid_t m_ptid;
3827
3828 /* The file descriptor. */
3829 int m_fd = -1;
3830};
3831
3832/* The map between an inferior process id, and the open /proc/PID/mem
3833 file. This is stored in a map instead of in a per-inferior
3834 structure because we need to be able to access memory of processes
3835 which don't have a corresponding struct inferior object. E.g.,
3836 with "detach-on-fork on" (the default), and "follow-fork parent"
3837 (also default), we don't create an inferior for the fork child, but
3838 we still need to remove breakpoints from the fork child's
3839 memory. */
3840static std::unordered_map<int, proc_mem_file> proc_mem_file_map;
3841
3842/* Close the /proc/PID/mem file for PID. */
3843
3844static void
3846{
3847 proc_mem_file_map.erase (pid);
3848}
3849
3850/* Open the /proc/PID/mem file for the process (thread group) of PTID.
3851 We actually open /proc/PID/task/LWP/mem, as that's the LWP we know
3852 exists and is stopped right now. We prefer the
3853 /proc/PID/task/LWP/mem form over /proc/LWP/mem to avoid tid-reuse
3854 races, just in case this is ever called on an already-waited
3855 LWP. */
3856
3857static void
3859{
3860 auto iter = proc_mem_file_map.find (ptid.pid ());
3861 gdb_assert (iter == proc_mem_file_map.end ());
3862
3863 char filename[64];
3864 xsnprintf (filename, sizeof filename,
3865 "/proc/%d/task/%ld/mem", ptid.pid (), ptid.lwp ());
3866
3867 int fd = gdb_open_cloexec (filename, O_RDWR | O_LARGEFILE, 0).release ();
3868
3869 if (fd == -1)
3870 {
3871 warning (_("opening /proc/PID/mem file for lwp %d.%ld failed: %s (%d)"),
3872 ptid.pid (), ptid.lwp (),
3873 safe_strerror (errno), errno);
3874 return;
3875 }
3876
3877 proc_mem_file_map.emplace (std::piecewise_construct,
3878 std::forward_as_tuple (ptid.pid ()),
3879 std::forward_as_tuple (ptid, fd));
3880
3881 linux_nat_debug_printf ("opened fd %d for lwp %d.%ld",
3882 fd, ptid.pid (), ptid.lwp ());
3883}
3884
3885/* Helper for linux_proc_xfer_memory_partial and
3886 proc_mem_file_is_writable. FD is the already opened /proc/pid/mem
3887 file, and PID is the pid of the corresponding process. The rest of
3888 the arguments are like linux_proc_xfer_memory_partial's. */
3889
3890static enum target_xfer_status
3892 gdb_byte *readbuf, const gdb_byte *writebuf,
3893 ULONGEST offset, LONGEST len,
3894 ULONGEST *xfered_len)
3895{
3896 ssize_t ret;
3897
3898 gdb_assert (fd != -1);
3899
3900 /* Use pread64/pwrite64 if available, since they save a syscall and can
3901 handle 64-bit offsets even on 32-bit platforms (for instance, SPARC
3902 debugging a SPARC64 application). */
3903#ifdef HAVE_PREAD64
3904 ret = (readbuf ? pread64 (fd, readbuf, len, offset)
3905 : pwrite64 (fd, writebuf, len, offset));
3906#else
3907 ret = lseek (fd, offset, SEEK_SET);
3908 if (ret != -1)
3909 ret = (readbuf ? read (fd, readbuf, len)
3910 : write (fd, writebuf, len));
3911#endif
3912
3913 if (ret == -1)
3914 {
3915 linux_nat_debug_printf ("accessing fd %d for pid %d failed: %s (%d)",
3916 fd, pid, safe_strerror (errno), errno);
3917 return TARGET_XFER_E_IO;
3918 }
3919 else if (ret == 0)
3920 {
3921 /* EOF means the address space is gone, the whole process exited
3922 or execed. */
3923 linux_nat_debug_printf ("accessing fd %d for pid %d got EOF",
3924 fd, pid);
3925 return TARGET_XFER_EOF;
3926 }
3927 else
3928 {
3929 *xfered_len = ret;
3930 return TARGET_XFER_OK;
3931 }
3932}
3933
3934/* Implement the to_xfer_partial target method using /proc/PID/mem.
3935 Because we can use a single read/write call, this can be much more
3936 efficient than banging away at PTRACE_PEEKTEXT. Also, unlike
3937 PTRACE_PEEKTEXT/PTRACE_POKETEXT, this works with running
3938 threads. */
3939
3940static enum target_xfer_status
3941linux_proc_xfer_memory_partial (int pid, gdb_byte *readbuf,
3942 const gdb_byte *writebuf, ULONGEST offset,
3943 LONGEST len, ULONGEST *xfered_len)
3944{
3945 auto iter = proc_mem_file_map.find (pid);
3946 if (iter == proc_mem_file_map.end ())
3947 return TARGET_XFER_EOF;
3948
3949 int fd = iter->second.fd ();
3950
3951 return linux_proc_xfer_memory_partial_fd (fd, pid, readbuf, writebuf, offset,
3952 len, xfered_len);
3953}
3954
3955/* Check whether /proc/pid/mem is writable in the current kernel, and
3956 return true if so. It wasn't writable before Linux 2.6.39, but
3957 there's no way to know whether the feature was backported to older
3958 kernels. So we check to see if it works. The result is cached,
3959 and this is garanteed to be called once early during inferior
3960 startup, so that any warning is printed out consistently between
3961 GDB invocations. Note we don't call it during GDB startup instead
3962 though, because then we might warn with e.g. just "gdb --version"
3963 on sandboxed systems. See PR gdb/29907. */
3964
3965static bool
3967{
3968 static gdb::optional<bool> writable;
3969
3970 if (writable.has_value ())
3971 return *writable;
3972
3973 writable.emplace (false);
3974
3975 /* We check whether /proc/pid/mem is writable by trying to write to
3976 one of our variables via /proc/self/mem. */
3977
3978 int fd = gdb_open_cloexec ("/proc/self/mem", O_RDWR | O_LARGEFILE, 0).release ();
3979
3980 if (fd == -1)
3981 {
3982 warning (_("opening /proc/self/mem file failed: %s (%d)"),
3983 safe_strerror (errno), errno);
3984 return *writable;
3985 }
3986
3987 SCOPE_EXIT { close (fd); };
3988
3989 /* This is the variable we try to write to. Note OFFSET below. */
3990 volatile gdb_byte test_var = 0;
3991
3992 gdb_byte writebuf[] = {0x55};
3993 ULONGEST offset = (uintptr_t) &test_var;
3994 ULONGEST xfered_len;
3995
3996 enum target_xfer_status res
3997 = linux_proc_xfer_memory_partial_fd (fd, getpid (), nullptr, writebuf,
3998 offset, 1, &xfered_len);
3999
4000 if (res == TARGET_XFER_OK)
4001 {
4002 gdb_assert (xfered_len == 1);
4003 gdb_assert (test_var == 0x55);
4004 /* Success. */
4005 *writable = true;
4006 }
4007
4008 return *writable;
4009}
4010
4011/* Parse LINE as a signal set and add its set bits to SIGS. */
4012
4013static void
4014add_line_to_sigset (const char *line, sigset_t *sigs)
4015{
4016 int len = strlen (line) - 1;
4017 const char *p;
4018 int signum;
4019
4020 if (line[len] != '\n')
4021 error (_("Could not parse signal set: %s"), line);
4022
4023 p = line;
4024 signum = len * 4;
4025 while (len-- > 0)
4026 {
4027 int digit;
4028
4029 if (*p >= '0' && *p <= '9')
4030 digit = *p - '0';
4031 else if (*p >= 'a' && *p <= 'f')
4032 digit = *p - 'a' + 10;
4033 else
4034 error (_("Could not parse signal set: %s"), line);
4035
4036 signum -= 4;
4037
4038 if (digit & 1)
4039 sigaddset (sigs, signum + 1);
4040 if (digit & 2)
4041 sigaddset (sigs, signum + 2);
4042 if (digit & 4)
4043 sigaddset (sigs, signum + 3);
4044 if (digit & 8)
4045 sigaddset (sigs, signum + 4);
4046
4047 p++;
4048 }
4049}
4050
4051/* Find process PID's pending signals from /proc/pid/status and set
4052 SIGS to match. */
4053
4054void
4056 sigset_t *blocked, sigset_t *ignored)
4057{
4058 char buffer[PATH_MAX], fname[PATH_MAX];
4059
4060 sigemptyset (pending);
4061 sigemptyset (blocked);
4062 sigemptyset (ignored);
4063 xsnprintf (fname, sizeof fname, "/proc/%d/status", pid);
4064 gdb_file_up procfile = gdb_fopen_cloexec (fname, "r");
4065 if (procfile == NULL)
4066 error (_("Could not open %s"), fname);
4067
4068 while (fgets (buffer, PATH_MAX, procfile.get ()) != NULL)
4069 {
4070 /* Normal queued signals are on the SigPnd line in the status
4071 file. However, 2.6 kernels also have a "shared" pending
4072 queue for delivering signals to a thread group, so check for
4073 a ShdPnd line also.
4074
4075 Unfortunately some Red Hat kernels include the shared pending
4076 queue but not the ShdPnd status field. */
4077
4078 if (startswith (buffer, "SigPnd:\t"))
4079 add_line_to_sigset (buffer + 8, pending);
4080 else if (startswith (buffer, "ShdPnd:\t"))
4081 add_line_to_sigset (buffer + 8, pending);
4082 else if (startswith (buffer, "SigBlk:\t"))
4083 add_line_to_sigset (buffer + 8, blocked);
4084 else if (startswith (buffer, "SigIgn:\t"))
4085 add_line_to_sigset (buffer + 8, ignored);
4086 }
4087}
4088
4089static enum target_xfer_status
4091 const char *annex, gdb_byte *readbuf,
4092 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4093 ULONGEST *xfered_len)
4094{
4095 gdb_assert (object == TARGET_OBJECT_OSDATA);
4096
4097 *xfered_len = linux_common_xfer_osdata (annex, readbuf, offset, len);
4098 if (*xfered_len == 0)
4099 return TARGET_XFER_EOF;
4100 else
4101 return TARGET_XFER_OK;
4102}
4103
4104std::vector<static_tracepoint_marker>
4106{
4107 char s[IPA_CMD_BUF_SIZE];
4108 int pid = inferior_ptid.pid ();
4109 std::vector<static_tracepoint_marker> markers;
4110 const char *p = s;
4111 ptid_t ptid = ptid_t (pid, 0);
4113
4114 /* Pause all */
4115 target_stop (ptid);
4116
4117 memcpy (s, "qTfSTM", sizeof ("qTfSTM"));
4118 s[sizeof ("qTfSTM")] = 0;
4119
4120 agent_run_command (pid, s, strlen (s) + 1);
4121
4122 /* Unpause all. */
4123 SCOPE_EXIT { target_continue_no_signal (ptid); };
4124
4125 while (*p++ == 'm')
4126 {
4127 do
4128 {
4130
4131 if (strid == NULL || marker.str_id == strid)
4132 markers.push_back (std::move (marker));
4133 }
4134 while (*p++ == ','); /* comma-separated list */
4135
4136 memcpy (s, "qTsSTM", sizeof ("qTsSTM"));
4137 s[sizeof ("qTsSTM")] = 0;
4138 agent_run_command (pid, s, strlen (s) + 1);
4139 p = s;
4140 }
4141
4142 return markers;
4143}
4144
4145/* target_can_async_p implementation. */
4146
4147bool
4149{
4150 /* This flag should be checked in the common target.c code. */
4151 gdb_assert (target_async_permitted);
4152
4153 /* Otherwise, this targets is always able to support async mode. */
4154 return true;
4155}
4156
4157bool
4159{
4160 return true;
4161}
4162
4163/* to_always_non_stop_p implementation. */
4164
4165bool
4167{
4168 return true;
4169}
4170
4171bool
4173{
4174 return true;
4175}
4176
4177bool
4179{
4180 return true;
4181}
4182
4183/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4184 so we notice when any child changes state, and notify the
4185 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4186 above to wait for the arrival of a SIGCHLD. */
4187
4188static void
4190{
4191 int old_errno = errno;
4192
4193 if (debug_linux_nat)
4194 gdb_stdlog->write_async_safe ("sigchld\n", sizeof ("sigchld\n") - 1);
4195
4196 if (signo == SIGCHLD)
4197 {
4198 /* Let the event loop know that there are events to handle. */
4200 }
4201
4202 errno = old_errno;
4203}
4204
4205/* Callback registered with the target events file descriptor. */
4206
4207static void
4208handle_target_event (int error, gdb_client_data client_data)
4209{
4211}
4212
4213/* target_async implementation. */
4214
4215void
4217{
4218 if (enable == is_async_p ())
4219 return;
4220
4221 /* Block child signals while we create/destroy the pipe, as their
4222 handler writes to it. */
4223 gdb::block_signals blocker;
4224
4225 if (enable)
4226 {
4227 if (!async_file_open ())
4228 internal_error ("creating event pipe failed.");
4229
4230 add_file_handler (async_wait_fd (), handle_target_event, NULL,
4231 "linux-nat");
4232
4233 /* There may be pending events to handle. Tell the event loop
4234 to poll them. */
4235 async_file_mark ();
4236 }
4237 else
4238 {
4239 delete_file_handler (async_wait_fd ());
4241 }
4242}
4243
4244/* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4245 event came out. */
4246
4247static int
4249{
4250 if (!lwp->stopped)
4251 {
4252 linux_nat_debug_printf ("running -> suspending %s",
4253 lwp->ptid.to_string ().c_str ());
4254
4255
4256 if (lwp->last_resume_kind == resume_stop)
4257 {
4258 linux_nat_debug_printf ("already stopping LWP %ld at GDB's request",
4259 lwp->ptid.lwp ());
4260 return 0;
4261 }
4262
4263 stop_callback (lwp);
4265 }
4266 else
4267 {
4268 /* Already known to be stopped; do nothing. */
4269
4270 if (debug_linux_nat)
4271 {
4273 linux_nat_debug_printf ("already stopped/stop_requested %s",
4274 lwp->ptid.to_string ().c_str ());
4275 else
4276 linux_nat_debug_printf ("already stopped/no stop_requested yet %s",
4277 lwp->ptid.to_string ().c_str ());
4278 }
4279 }
4280 return 0;
4281}
4282
4283void
4285{
4288}
4289
4290/* When requests are passed down from the linux-nat layer to the
4291 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4292 used. The address space pointer is stored in the inferior object,
4293 but the common code that is passed such ptid can't tell whether
4294 lwpid is a "main" process id or not (it assumes so). We reverse
4295 look up the "main" process id from the lwp here. */
4296
4297struct address_space *
4299{
4300 struct lwp_info *lwp;
4301 struct inferior *inf;
4302 int pid;
4303
4304 if (ptid.lwp () == 0)
4305 {
4306 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
4307 tgid. */
4308 lwp = find_lwp_pid (ptid);
4309 pid = lwp->ptid.pid ();
4310 }
4311 else
4312 {
4313 /* A (pid,lwpid,0) ptid. */
4314 pid = ptid.pid ();
4315 }
4316
4317 inf = find_inferior_pid (this, pid);
4318 gdb_assert (inf != NULL);
4319 return inf->aspace;
4320}
4321
4322/* Return the cached value of the processor core for thread PTID. */
4323
4324int
4326{
4327 struct lwp_info *info = find_lwp_pid (ptid);
4328
4329 if (info)
4330 return info->core;
4331 return -1;
4332}
4333
4334/* Implementation of to_filesystem_is_local. */
4335
4336bool
4338{
4339 struct inferior *inf = current_inferior ();
4340
4341 if (inf->fake_pid_p || inf->pid == 0)
4342 return true;
4343
4344 return linux_ns_same (inf->pid, LINUX_NS_MNT);
4345}
4346
4347/* Convert the INF argument passed to a to_fileio_* method
4348 to a process ID suitable for passing to its corresponding
4349 linux_mntns_* function. If INF is non-NULL then the
4350 caller is requesting the filesystem seen by INF. If INF
4351 is NULL then the caller is requesting the filesystem seen
4352 by the GDB. We fall back to GDB's filesystem in the case
4353 that INF is non-NULL but its PID is unknown. */
4354
4355static pid_t
4357{
4358 if (inf == NULL || inf->fake_pid_p || inf->pid == 0)
4359 return getpid ();
4360 else
4361 return inf->pid;
4362}
4363
4364/* Implementation of to_fileio_open. */
4365
4366int
4367linux_nat_target::fileio_open (struct inferior *inf, const char *filename,
4368 int flags, int mode, int warn_if_slow,
4369 fileio_error *target_errno)
4370{
4371 int nat_flags;
4372 mode_t nat_mode;
4373 int fd;
4374
4375 if (fileio_to_host_openflags (flags, &nat_flags) == -1
4376 || fileio_to_host_mode (mode, &nat_mode) == -1)
4377 {
4378 *target_errno = FILEIO_EINVAL;
4379 return -1;
4380 }
4381
4383 filename, nat_flags, nat_mode);
4384 if (fd == -1)
4385 *target_errno = host_to_fileio_error (errno);
4386
4387 return fd;
4388}
4389
4390/* Implementation of to_fileio_readlink. */
4391
4392gdb::optional<std::string>
4393linux_nat_target::fileio_readlink (struct inferior *inf, const char *filename,
4394 fileio_error *target_errno)
4395{
4396 char buf[PATH_MAX];
4397 int len;
4398
4400 filename, buf, sizeof (buf));
4401 if (len < 0)
4402 {
4403 *target_errno = host_to_fileio_error (errno);
4404 return {};
4405 }
4406
4407 return std::string (buf, len);
4408}
4409
4410/* Implementation of to_fileio_unlink. */
4411
4412int
4413linux_nat_target::fileio_unlink (struct inferior *inf, const char *filename,
4414 fileio_error *target_errno)
4415{
4416 int ret;
4417
4419 filename);
4420 if (ret == -1)
4421 *target_errno = host_to_fileio_error (errno);
4422
4423 return ret;
4424}
4425
4426/* Implementation of the to_thread_events method. */
4427
4428void
4430{
4432}
4433
4435{
4436 /* We don't change the stratum; this target will sit at
4437 process_stratum and thread_db will set at thread_stratum. This
4438 is a little strange, since this is a multi-threaded-capable
4439 target, but we want to be on the stack below thread_db, and we
4440 also want to be used for single-threaded processes. */
4441}
4442
4443/* See linux-nat.h. */
4444
4445bool
4446linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo)
4447{
4448 int pid = get_ptrace_pid (ptid);
4449 return ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo) == 0;
4450}
4451
4452/* See nat/linux-nat.h. */
4453
4454ptid_t
4456{
4457 gdb_assert (inferior_ptid.lwp_p ());
4458 return inferior_ptid;
4459}
4460
4461void _initialize_linux_nat ();
4462void
4464{
4466 &debug_linux_nat, _("\
4467Set debugging of GNU/Linux native target."), _(" \
4468Show debugging of GNU/Linux native target."), _(" \
4469When on, print debug messages relating to the GNU/Linux native target."),
4470 nullptr,
4473
4474 add_setshow_boolean_cmd ("linux-namespaces", class_maintenance,
4476Set debugging of GNU/Linux namespaces module."), _("\
4477Show debugging of GNU/Linux namespaces module."), _("\
4478Enables printf debugging output."),
4479 NULL,
4480 NULL,
4482
4483 /* Install a SIGCHLD handler. */
4484 sigchld_action.sa_handler = sigchld_handler;
4485 sigemptyset (&sigchld_action.sa_mask);
4486 sigchld_action.sa_flags = SA_RESTART;
4487
4488 /* Make it the default. */
4489 sigaction (SIGCHLD, &sigchld_action, NULL);
4490
4491 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4492 gdb_sigmask (SIG_SETMASK, NULL, &suspend_mask);
4493 sigdelset (&suspend_mask, SIGCHLD);
4494
4495 sigemptyset (&blocked_mask);
4496
4498}
4499
4500
4501/* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4502 the GNU/Linux Threads library and therefore doesn't really belong
4503 here. */
4504
4505/* NPTL reserves the first two RT signals, but does not provide any
4506 way for the debugger to query the signal numbers - fortunately
4507 they don't change. */
4509
4510/* See linux-nat.h. */
4511
4512unsigned int
4514{
4515 return sizeof (lin_thread_signals) / sizeof (lin_thread_signals[0]);
4516}
4517
4518/* See linux-nat.h. */
4519
4520int
4522{
4523 gdb_assert (i < lin_thread_get_thread_signal_num ());
4524 return lin_thread_signals[i];
4525}
void xfree(void *)
struct gdbarch * target_gdbarch(void)
target_xfer_partial_ftype memory_xfer_auxv
int catch_syscall_enabled(void)
bool catching_syscall_number(int syscall_number)
int software_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
int detach_breakpoints(ptid_t ptid)
void remove_breakpoints_inf(inferior *inf)
int hardware_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
int breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
const target_info & info() const override
Definition inf-child.c:49
gdb::optional< std::string > fileio_readlink(struct inferior *inf, const char *filename, fileio_error *target_errno) override
Definition linux-nat.c:4393
struct address_space * thread_address_space(ptid_t) override
Definition linux-nat.c:4298
void kill() override
Definition linux-nat.c:3540
void post_startup_inferior(ptid_t) override
Definition linux-nat.c:390
int core_of_thread(ptid_t ptid) override
Definition linux-nat.c:4325
bool always_non_stop_p() override
Definition linux-nat.c:4166
virtual void low_prepare_to_resume(struct lwp_info *)
Definition linux-nat.h:171
bool thread_alive(ptid_t ptid) override
Definition linux-nat.c:3722
bool supports_stopped_by_sw_breakpoint() override
Definition linux-nat.c:2651
void attach(const char *, int) override
Definition linux-nat.c:1057
void post_attach(int) override
Definition linux-nat.c:382
virtual bool low_status_is_event(int status)
Definition linux-nat.c:2327
~linux_nat_target() override=0
Definition linux-nat.c:378
void resume(ptid_t, int, enum gdb_signal) override
Definition linux-nat.c:1599
int insert_exec_catchpoint(int) override
Definition linux-nat.c:545
virtual void low_new_thread(struct lwp_info *)
Definition linux-nat.h:148
std::string pid_to_str(ptid_t) override
Definition linux-nat.c:3752
const char * pid_to_exec_file(int pid) override
Definition linux-nat.c:3772
bool can_async_p() override
Definition linux-nat.c:4148
int fileio_open(struct inferior *inf, const char *filename, int flags, int mode, int warn_if_slow, fileio_error *target_errno) override
Definition linux-nat.c:4367
int fileio_unlink(struct inferior *inf, const char *filename, fileio_error *target_errno) override
Definition linux-nat.c:4413
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
Definition linux-nat.c:3391
virtual void low_resume(ptid_t ptid, int step, enum gdb_signal sig)
Definition linux-nat.h:138
virtual void low_forget_process(pid_t pid)
Definition linux-nat.h:167
virtual void low_delete_thread(struct arch_lwp_info *lp)
Definition linux-nat.h:152
bool supports_stopped_by_hw_breakpoint() override
Definition linux-nat.c:2672
bool supports_disable_randomization() override
Definition linux-nat.c:4178
void detach(inferior *, int) override
Definition linux-nat.c:1384
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
Definition linux-nat.c:3670
bool stopped_by_sw_breakpoint() override
Definition linux-nat.c:2639
virtual bool low_stopped_data_address(CORE_ADDR *addr_p)
Definition linux-nat.h:144
int insert_fork_catchpoint(int) override
Definition linux-nat.c:521
virtual void low_new_clone(struct lwp_info *parent, pid_t child_lwp)
Definition linux-nat.h:162
bool stopped_by_hw_breakpoint() override
Definition linux-nat.c:2660
bool stopped_by_watchpoint() override
Definition linux-nat.c:2303
virtual void low_new_fork(struct lwp_info *parent, pid_t child_pid)
Definition linux-nat.h:158
int remove_exec_catchpoint(int) override
Definition linux-nat.c:551
const char * thread_name(struct thread_info *) override
Definition linux-nat.c:3763
virtual bool low_stopped_by_watchpoint()
Definition linux-nat.h:141
void follow_fork(inferior *, ptid_t, target_waitkind, bool, bool) override
Definition linux-nat.c:426
int insert_vfork_catchpoint(int) override
Definition linux-nat.c:533
bool filesystem_is_local() override
Definition linux-nat.c:4337
int remove_fork_catchpoint(int) override
Definition linux-nat.c:527
void update_thread_list() override
Definition linux-nat.c:3732
void thread_events(int) override
Definition linux-nat.c:4429
bool supports_multi_process() override
Definition linux-nat.c:4172
int set_syscall_catchpoint(int pid, bool needed, int any_count, gdb::array_view< const int > syscall_counts) override
Definition linux-nat.c:557
std::vector< static_tracepoint_marker > static_tracepoint_markers_by_strid(const char *id) override
Definition linux-nat.c:4105
void create_inferior(const char *, const std::string &, char **, int) override
Definition linux-nat.c:966
void async(bool) override
Definition linux-nat.c:4216
int remove_vfork_catchpoint(int) override
Definition linux-nat.c:539
virtual bool low_siginfo_fixup(siginfo_t *ptrace, gdb_byte *inf, int direction)
Definition linux-nat.h:179
void mourn_inferior() override
Definition linux-nat.c:3571
bool stopped_data_address(CORE_ADDR *) override
Definition linux-nat.c:2313
bool supports_non_stop() override
Definition linux-nat.c:4158
void pass_signals(gdb::array_view< const unsigned char >) override
Definition linux-nat.c:697
DISABLE_COPY_AND_ASSIGN(proc_mem_file)
proc_mem_file(ptid_t ptid, int fd)
Definition linux-nat.c:3803
void follow_fork(inferior *child_inf, ptid_t child_ptid, target_waitkind fork_kind, bool follow_child, bool detach_on_fork) override
gdbarch * arch() const
Definition regcache.c:230
const address_space * aspace() const
Definition regcache.h:342
static bool is_ours()
Definition target.h:189
static void ours()
Definition target.c:1065
ptid_t ptid
Definition gdbthread.h:256
gdb_signal stop_signal() const
Definition gdbthread.h:421
bool has_pending_waitstatus() const
Definition gdbthread.h:391
struct target_waitstatus pending_follow
Definition gdbthread.h:513
const target_waitstatus & pending_waitstatus() const
Definition gdbthread.h:400
bool executing() const
Definition gdbthread.h:316
int stop_requested
Definition gdbthread.h:516
void set_stop_signal(gdb_signal sig)
Definition gdbthread.h:428
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:165
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:163
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:739
@ class_maintenance
Definition command.h:65
#define SEEK_SET
Definition defs.h:103
int check_quit_flag(void)
Definition extension.c:805
ssize_t read(int fd, void *buf, size_t count)
static void handle_target_event(int error, gdb_client_data client_data)
Definition fbsd-nat.c:966
#define ptrace(request, pid, addr, data)
Definition gdb_ptrace.h:141
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1708
LONGEST gdbarch_get_syscall_number(struct gdbarch *gdbarch, thread_info *thread)
Definition gdbarch.c:4399
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
Definition gdbarch.c:2838
bool gdbarch_software_single_step_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3223
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:303
thread_info * find_thread_ptid(inferior *inf, ptid_t ptid)
Definition thread.c:528
void delete_thread(struct thread_info *thread)
Definition thread.c:483
void set_executing(process_stratum_target *targ, ptid_t ptid, bool executing)
Definition thread.c:880
void set_running(process_stratum_target *targ, ptid_t ptid, bool running)
Definition thread.c:863
bool print_thread_events
Definition thread.c:1932
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
Definition thread.c:792
void delete_exited_threads(void)
Definition thread.c:734
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition gnu-nat.c:1790
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1862
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1792
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1791
unsigned dummy
Definition go32-nat.c:8
unsigned short selector
Definition go32-nat.c:1
target_waitstatus host_status_to_waitstatus(int hoststatus)
Definition inf-child.c:57
void inferior_event_handler(enum inferior_event_type event_type)
Definition inf-loop.c:36
pid_t get_ptrace_pid(ptid_t ptid)
Definition inf-ptrace.c:238
ptid_t inferior_ptid
Definition infcmd.c:91
struct inferior * find_inferior_ptid(process_stratum_target *targ, ptid_t ptid)
Definition inferior.c:365
struct inferior * find_inferior_pid(process_stratum_target *targ, int pid)
Definition inferior.c:348
struct inferior * current_inferior(void)
Definition inferior.c:54
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:758
static bool detach_fork
Definition infrun.c:162
bool disable_randomization
Definition infrun.c:174
int signal_pass_state(int signo)
Definition infrun.c:8780
void get_last_target_status(process_stratum_target **target, ptid_t *ptid, target_waitstatus *status)
Definition infrun.c:4345
int linux_fork_checkpointing_p(int pid)
Definition linux-fork.c:615
void linux_fork_killall(void)
Definition linux-fork.c:295
void add_fork(pid_t pid)
Definition linux-fork.c:119
void linux_fork_mourn_inferior(void)
Definition linux-fork.c:328
int forks_exist_p(void)
Definition linux-fork.c:92
struct fork_info * find_fork_pid(pid_t pid)
Definition linux-fork.c:178
void linux_fork_detach(int from_tty)
Definition linux-fork.c:364
int linux_ns_same(pid_t pid, enum linux_ns_type type)
ssize_t linux_mntns_readlink(pid_t pid, const char *filename, char *buf, size_t bufsiz)
bool debug_linux_namespaces
int linux_mntns_open_cloexec(pid_t pid, const char *filename, int flags, mode_t mode)
int linux_mntns_unlink(pid_t pid, const char *filename)
@ LINUX_NS_MNT
ptid_t ptid_of_lwp(struct lwp_info *lwp)
Definition linux-nat.c:265
static void detach_one_pid(int pid, int signo)
Definition linux-nat.c:1150
static void check_zombie_leaders(void)
Definition linux-nat.c:3011
void linux_stop_lwp(struct lwp_info *lwp)
Definition linux-nat.c:2187
#define O_LARGEFILE
Definition linux-nat.c:187
static int linux_handle_syscall_trap(struct lwp_info *lp, int stopping)
Definition linux-nat.c:1704
static int resume_stopped_resumed_lwps(struct lwp_info *lp, const ptid_t wait_ptid)
Definition linux-nat.c:3335
void linux_unstop_all_lwps(void)
Definition linux-nat.c:2208
int lin_thread_get_thread_signal(unsigned int i)
Definition linux-nat.c:4521
static int lwp_lwpid_htab_remove_pid(void **slot, void *info)
Definition linux-nat.c:731
static void purge_lwp_list(int pid)
Definition linux-nat.c:749
static void linux_nat_filter_event(int lwpid, int status)
Definition linux-nat.c:2763
static struct lwp_info * find_lwp_pid(ptid_t ptid)
Definition linux-nat.c:832
static void detach_one_lwp(struct lwp_info *lp, int *signo_p)
Definition linux-nat.c:1282
static int get_detach_signal(struct lwp_info *lp)
Definition linux-nat.c:1192
static void exit_lwp(struct lwp_info *lp)
Definition linux-nat.c:892
static int lwp_status_pending_p(struct lwp_info *lp)
Definition linux-nat.c:2493
static void kill_one_lwp(pid_t pid)
Definition linux-nat.c:3434
static void lwp_lwpid_htab_add_lwp(struct lwp_info *lp)
Definition linux-nat.c:607
static enum target_xfer_status linux_proc_xfer_memory_partial(int pid, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
Definition linux-nat.c:3941
std::unique_ptr< struct lwp_info, lwp_deleter > lwp_info_up
Definition linux-nat.c:421
static void sigchld_handler(int signo)
Definition linux-nat.c:4189
static bool is_leader(lwp_info *lp)
Definition linux-nat.c:254
static void lwp_list_add(struct lwp_info *lp)
Definition linux-nat.c:642
#define linux_nat_debug_printf(fmt,...)
Definition linux-nat.c:211
static int kill_callback(struct lwp_info *lp)
Definition linux-nat.c:3497
lwp_info_range all_lwps()
Definition linux-nat.c:626
void linux_proc_pending_signals(int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored)
Definition linux-nat.c:4055
static int stop_callback(struct lwp_info *lp)
Definition linux-nat.c:2163
static void siginfo_fixup(siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
Definition linux-nat.c:3596
static ptid_t linux_nat_wait_1(ptid_t ptid, struct target_waitstatus *ourstatus, target_wait_flags target_options)
Definition linux-nat.c:3110
static int attach_proc_task_lwp_callback(ptid_t ptid)
Definition linux-nat.c:989
static int status_callback(struct lwp_info *lp)
Definition linux-nat.c:2411
bool linux_nat_get_siginfo(ptid_t ptid, siginfo_t *siginfo)
Definition linux-nat.c:4446
static int set_ignore_sigint(struct lwp_info *lp)
Definition linux-nat.c:2236
void _initialize_linux_nat()
Definition linux-nat.c:4463
static struct simple_pid_list * stopped_pids
Definition linux-nat.c:225
static int select_event_lwp_callback(struct lwp_info *lp, int *selector)
Definition linux-nat.c:2504
static int lwp_lwpid_htab_eq(const void *a, const void *b)
Definition linux-nat.c:588
static void add_to_pid_list(struct simple_pid_list **listp, int pid, int status)
Definition linux-nat.c:315
static void linux_resume_one_lwp_throw(struct lwp_info *lp, int step, enum gdb_signal signo)
Definition linux-nat.c:1438
ptid_t current_lwp_ptid(void)
Definition linux-nat.c:4455
static int resume_set_callback(struct lwp_info *lp)
Definition linux-nat.c:1591
static void maybe_clear_ignore_sigint(struct lwp_info *lp)
Definition linux-nat.c:2256
lwp_info_safe_range all_lwps_safe()
Definition linux-nat.c:634
static int check_stopped_by_watchpoint(struct lwp_info *lp)
Definition linux-nat.c:2285
static void open_proc_mem_file(ptid_t ptid)
Definition linux-nat.c:3858
static void resume_lwp(struct lwp_info *lp, int step, enum gdb_signal signo)
Definition linux-nat.c:1522
static struct lwp_info * add_initial_lwp(ptid_t ptid)
Definition linux-nat.c:769
static void wait_for_signal()
Definition linux-nat.c:1996
static int detach_callback(struct lwp_info *lp)
Definition linux-nat.c:1373
static enum target_xfer_status linux_nat_xfer_osdata(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition linux-nat.c:4090
static void kill_unfollowed_fork_children(struct inferior *inf)
Definition linux-nat.c:3516
static int linux_nat_post_attach_wait(ptid_t ptid, int *signalled)
Definition linux-nat.c:912
static int kill_wait_callback(struct lwp_info *lp)
Definition linux-nat.c:3506
static void lwp_lwpid_htab_create(void)
Definition linux-nat.c:599
static pid_t linux_nat_fileio_pid_of(struct inferior *inf)
Definition linux-nat.c:4356
static void add_line_to_sigset(const char *line, sigset_t *sigs)
Definition linux-nat.c:4014
static int linux_handle_extended_wait(struct lwp_info *lp, int status)
Definition linux-nat.c:1819
static struct lwp_info * add_lwp(ptid_t ptid)
Definition linux-nat.c:790
static int wait_lwp(struct lwp_info *lp)
Definition linux-nat.c:2019
static int linux_nat_resume_callback(struct lwp_info *lp, struct lwp_info *except)
Definition linux-nat.c:1559
void lwp_set_arch_private_info(struct lwp_info *lwp, struct arch_lwp_info *info)
Definition linux-nat.c:273
static int linux_nat_has_pending_sigint(int pid)
Definition linux-nat.c:2220
static htab_t lwp_lwpid_htab
Definition linux-nat.c:571
static int select_singlestep_lwp_callback(struct lwp_info *lp)
Definition linux-nat.c:2481
static void linux_init_ptrace_procfs(pid_t pid, int attached)
Definition linux-nat.c:368
static void select_event_lwp(ptid_t filter, struct lwp_info **orig_lp, int *status)
Definition linux-nat.c:2680
struct arch_lwp_info * lwp_arch_private_info(struct lwp_info *lwp)
Definition linux-nat.c:282
static int count_events_callback(struct lwp_info *lp, int *count)
Definition linux-nat.c:2467
static sigset_t pass_mask
Definition linux-nat.c:692
static int pull_pid_from_list(struct simple_pid_list **listp, int pid, int *statusp)
Definition linux-nat.c:326
static void lwp_list_remove(struct lwp_info *lp)
Definition linux-nat.c:651
static int report_thread_events
Definition linux-nat.c:228
static int linux_nat_stop_lwp(struct lwp_info *lwp)
Definition linux-nat.c:4248
static bool debug_linux_nat
Definition linux-nat.c:197
static void linux_resume_one_lwp(struct lwp_info *lp, int step, enum gdb_signal signo)
Definition linux-nat.c:1506
static void restore_child_signals_mask(sigset_t *prev_mask)
Definition linux-nat.c:686
unsigned int lin_thread_get_thread_signal_num(void)
Definition linux-nat.c:4513
static std::unordered_map< int, proc_mem_file > proc_mem_file_map
Definition linux-nat.c:3840
static void delete_lwp(ptid_t ptid)
Definition linux-nat.c:808
static int linux_nat_ptrace_options(int attached)
Definition linux-nat.c:346
static int resume_clear_callback(struct lwp_info *lp)
Definition linux-nat.c:1583
struct lwp_info * iterate_over_lwps(ptid_t filter, gdb::function_view< iterate_over_lwps_ftype > callback)
Definition linux-nat.c:848
struct linux_nat_target * linux_target
Definition linux-nat.c:190
void linux_stop_and_wait_all_lwps(void)
Definition linux-nat.c:2195
static enum target_xfer_status linux_xfer_siginfo(ptid_t ptid, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition linux-nat.c:3610
static int num_lwps(int pid)
Definition linux-nat.c:398
static void handle_target_event(int error, gdb_client_data client_data)
Definition linux-nat.c:4208
static ptid_t filter_exit_event(struct lwp_info *event_child, struct target_waitstatus *ourstatus)
Definition linux-nat.c:3091
enum tribool have_ptrace_getregset
Definition linux-nat.c:193
static int lin_thread_signals[]
Definition linux-nat.c:4508
static bool proc_mem_file_is_writable()
Definition linux-nat.c:3966
static void save_stop_reason(struct lwp_info *lp)
Definition linux-nat.c:2523
int lwp_is_stepping(struct lwp_info *lwp)
Definition linux-nat.c:306
static void close_proc_mem_file(pid_t pid)
Definition linux-nat.c:3845
static enum target_xfer_status linux_proc_xfer_memory_partial_fd(int fd, int pid, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
Definition linux-nat.c:3891
static int kill_lwp(int lwpid, int signo)
Definition linux-nat.c:1682
static int stop_wait_callback(struct lwp_info *lp)
Definition linux-nat.c:2335
#define LINUX_NAT_SCOPED_DEBUG_ENTER_EXIT
Definition linux-nat.c:216
static intrusive_list< lwp_info > lwp_list
Definition linux-nat.c:621
void linux_nat_switch_fork(ptid_t new_ptid)
Definition linux-nat.c:869
static hashval_t lwp_info_hash(const void *ap)
Definition linux-nat.c:576
static sigset_t suspend_mask
Definition linux-nat.c:661
static sigset_t blocked_mask
Definition linux-nat.c:664
static int resumed_callback(struct lwp_info *lp)
Definition linux-nat.c:2753
static int check_ptrace_stopped_lwp_gone(struct lwp_info *lp)
Definition linux-nat.c:1477
static void block_child_signals(sigset_t *prev_mask)
Definition linux-nat.c:673
static void kill_wait_one_lwp(pid_t pid)
Definition linux-nat.c:3467
static void show_debug_linux_nat(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition linux-nat.c:202
int lwp_is_stopped(struct lwp_info *lwp)
Definition linux-nat.c:290
static struct sigaction sigchld_action
Definition linux-nat.c:667
enum target_stop_reason lwp_stop_reason(struct lwp_info *lwp)
Definition linux-nat.c:298
lwp_info_range all_lwps()
Definition linux-nat.c:626
int thread_db_notice_clone(ptid_t parent, ptid_t child)
linux_nat_target * linux_target
Definition linux-nat.c:190
iterator_range< lwp_info_iterator > lwp_info_range
Definition linux-nat.h:286
basic_safe_range< lwp_info_range > lwp_info_safe_range
Definition linux-nat.h:287
LONGEST linux_common_xfer_osdata(const char *annex, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
int linux_common_core_of_thread(ptid_t ptid)
int linux_proc_pid_is_gone(pid_t pid)
const char * linux_proc_pid_to_exec_file(int pid)
void linux_proc_init_warnings()
int linux_proc_pid_is_trace_stopped_nowarn(pid_t pid)
int linux_proc_pid_is_zombie(pid_t pid)
void linux_proc_attach_tgid_threads(pid_t pid, linux_proc_attach_lwp_func attach_lwp)
const char * linux_proc_tid_get_name(ptid_t ptid)
int linux_proc_pid_is_stopped(pid_t pid)
int linux_is_extended_waitstatus(int wstat)
void linux_enable_event_reporting(pid_t pid, int options)
int linux_ptrace_get_extended_event(int wstat)
int linux_wstatus_maybe_breakpoint(int wstat)
void linux_ptrace_init_warnings(void)
void linux_disable_event_reporting(pid_t pid)
std::string linux_ptrace_attach_fail_reason_string(ptid_t ptid, int err)
std::string linux_ptrace_attach_fail_reason(pid_t pid)
#define PTRACE_O_TRACEEXEC
#define PTRACE_GETSIGINFO
#define USE_SIGTRAP_SIGINFO
#define PTRACE_O_TRACEFORK
#define PTRACE_TYPE_ARG3
#define GDB_ARCH_IS_TRAP_HWBKPT(X)
#define PTRACE_EVENT_VFORK_DONE
#define GDB_ARCH_IS_TRAP_BRKPT(X)
#define PTRACE_GETEVENTMSG
#define PTRACE_EVENT_FORK
#define PTRACE_EVENT_CLONE
#define __WALL
#define PTRACE_O_EXITKILL
#define PTRACE_SETSIGINFO
#define PTRACE_EVENT_VFORK
#define PTRACE_O_TRACEVFORK
#define PTRACE_EVENT_EXEC
#define PTRACE_O_TRACESYSGOOD
#define PTRACE_O_TRACEVFORKDONE
int my_waitpid(int pid, int *status, int flags)
std::string status_to_str(int status)
#define SYSCALL_SIGTRAP
Definition linux-nat.h:37
#define __SIGRTMIN
Definition linux-nat.h:31
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition regcache.c:1324
void registers_changed_ptid(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:494
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition regcache.c:1368
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:397
void registers_changed(void)
Definition regcache.c:577
resume_kind
Definition resume.h:26
@ resume_step
Definition resume.h:31
@ resume_continue
Definition resume.h:28
@ resume_stop
Definition resume.h:34
#define enable()
Definition ser-go32.c:239
void create_inferior(const char *, const std::string &, char **, int) override
Definition inf-ptrace.c:75
void async_file_flush()
Definition inf-ptrace.h:83
void async_file_mark()
Definition inf-ptrace.h:85
void detach_success(inferior *inf)
Definition inf-ptrace.c:208
void async_file_close()
Definition inf-ptrace.h:81
int async_wait_fd() override
Definition inf-ptrace.h:66
bool is_async_p() override
Definition inf-ptrace.h:63
void mourn_inferior() override
Definition inf-ptrace.c:115
void attach(const char *, int) override
Definition inf-ptrace.c:132
bool async_file_open()
Definition inf-ptrace.h:79
static void async_file_mark_if_open()
Definition inf-ptrace.h:71
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
Definition inf-ptrace.c:424
Definition gnu-nat.c:154
pid_t pid
Definition gnu-nat.c:166
void operator()(struct lwp_info *lwp) const
Definition linux-nat.c:413
ptid_t ptid
Definition linux-nat.h:211
struct target_waitstatus waitstatus
Definition linux-nat.h:266
int resumed
Definition linux-nat.h:230
CORE_ADDR stop_pc
Definition linux-nat.h:243
CORE_ADDR stopped_data_address
Definition linux-nat.h:258
int signalled
Definition linux-nat.h:219
int stopped
Definition linux-nat.h:222
target_stop_reason stop_reason
Definition linux-nat.h:250
int must_set_ptrace_flags
Definition linux-nat.h:215
int status
Definition linux-nat.h:236
int stopped_data_address_p
Definition linux-nat.h:257
int ignore_sigint
Definition linux-nat.h:261
resume_kind last_resume_kind
Definition linux-nat.h:233
struct arch_lwp_info * arch_private
Definition linux-nat.h:279
enum target_waitkind syscall_state
Definition linux-nat.h:273
struct simple_pid_list * next
Definition linux-nat.c:223
virtual gdb::byte_vector virtual thread_info_to_thread_handle(struct thread_info *) TARGET_DEFAULT_RETURN(gdb voi stop)(ptid_t) TARGET_DEFAULT_IGNORE()
Definition target.h:684
target_waitstatus & set_spurious()
Definition waitstatus.h:300
target_waitstatus & set_syscall_return(int syscall_number)
Definition waitstatus.h:292
target_waitstatus & set_no_resumed()
Definition waitstatus.h:321
target_waitstatus & set_vfork_done()
Definition waitstatus.h:277
target_waitstatus & set_forked(ptid_t child_ptid)
Definition waitstatus.h:253
target_waitstatus & set_execd(gdb::unique_xmalloc_ptr< char > execd_pathname)
Definition waitstatus.h:269
target_waitstatus & set_stopped(gdb_signal sig)
Definition waitstatus.h:230
enum gdb_signal sig
Definition waitstatus.h:414
target_waitstatus & set_vforked(ptid_t child_ptid)
Definition waitstatus.h:261
target_waitstatus & set_thread_exited(int exit_status)
Definition waitstatus.h:335
target_waitstatus & set_syscall_entry(int syscall_number)
Definition waitstatus.h:284
target_waitstatus & set_ignore()
Definition waitstatus.h:307
target_waitkind kind() const
Definition waitstatus.h:345
target_waitstatus & set_thread_created()
Definition waitstatus.h:328
Definition value.c:181
void target_announce_detach(int from_tty)
Definition target.c:3601
bool target_is_async_p()
Definition target.c:403
void target_async(bool enable)
Definition target.c:4330
bool target_async_permitted
Definition target.c:4349
bool target_can_async_p()
Definition target.c:385
gdbarch * target_thread_architecture(ptid_t ptid)
Definition target.c:435
void target_stop(ptid_t ptid)
Definition target.c:3775
std::string target_options_to_string(target_wait_flags target_options)
Definition target.c:3905
bool target_is_non_stop_p()
Definition target.c:4387
std::string target_pid_to_str(ptid_t ptid)
Definition target.c:2602
std::string normal_pid_to_str(ptid_t ptid)
Definition target.c:3672
void target_continue_no_signal(ptid_t ptid)
Definition target.c:3863
void target_pass_ctrlc(void)
Definition target.c:3805
void target_mourn_inferior(ptid_t ptid)
Definition target.c:2737
@ INF_REG_EVENT
Definition target.h:129
target_xfer_status
Definition target.h:214
@ TARGET_XFER_E_IO
Definition target.h:227
@ TARGET_XFER_EOF
Definition target.h:219
@ TARGET_XFER_OK
Definition target.h:216
target_object
Definition target.h:138
@ TARGET_OBJECT_AUXV
Definition target.h:157
@ TARGET_OBJECT_OSDATA
Definition target.h:179
@ TARGET_OBJECT_SIGNAL_INFO
Definition target.h:182
@ TARGET_OBJECT_MEMORY
Definition target.h:142
void parse_static_tracepoint_marker_definition(const char *line, const char **pp, static_tracepoint_marker *marker)
void perror_with_name(const char *string)
Definition utils.c:643
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3114
void perror_warning_with_name(const char *string)
Definition utils.c:652
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
int parse_pid_to_attach(const char *args)
Definition utils.c:3279
#define gdb_stdlog
Definition utils.h:196
@ TARGET_WNOHANG
Definition wait.h:32
target_waitkind
Definition waitstatus.h:30
@ TARGET_WAITKIND_NO_RESUMED
Definition waitstatus.h:96
@ TARGET_WAITKIND_SIGNALLED
Definition waitstatus.h:40
@ TARGET_WAITKIND_STOPPED
Definition waitstatus.h:36
@ TARGET_WAITKIND_EXITED
Definition waitstatus.h:32
@ TARGET_WAITKIND_SYSCALL_RETURN
Definition waitstatus.h:73
@ TARGET_WAITKIND_SYSCALL_ENTRY
Definition waitstatus.h:72
@ TARGET_WAITKIND_FORKED
Definition waitstatus.h:49
@ TARGET_WAITKIND_VFORKED
Definition waitstatus.h:53
@ TARGET_WAITKIND_IGNORE
Definition waitstatus.h:89
target_stop_reason
Definition waitstatus.h:428
@ TARGET_STOPPED_BY_SW_BREAKPOINT
Definition waitstatus.h:434
@ TARGET_STOPPED_BY_WATCHPOINT
Definition waitstatus.h:440
@ TARGET_STOPPED_BY_HW_BREAKPOINT
Definition waitstatus.h:437
@ TARGET_STOPPED_BY_NO_REASON
Definition waitstatus.h:431