1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995-2023 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "linux-low.h"
21 #include "nat/linux-osdata.h"
22 #include "gdbsupport/agent.h"
24 #include "gdbsupport/event-loop.h"
25 #include "gdbsupport/event-pipe.h"
26 #include "gdbsupport/rsp-low.h"
27 #include "gdbsupport/signals-state-save-restore.h"
28 #include "nat/linux-nat.h"
29 #include "nat/linux-waitpid.h"
30 #include "gdbsupport/gdb_wait.h"
31 #include "nat/gdb_ptrace.h"
32 #include "nat/linux-ptrace.h"
33 #include "nat/linux-procfs.h"
34 #include "nat/linux-personality.h"
36 #include <sys/ioctl.h>
39 #include <sys/syscall.h>
43 #include <sys/types.h>
48 #include "gdbsupport/filestuff.h"
49 #include "tracepoint.h"
51 #include "gdbsupport/common-inferior.h"
52 #include "nat/fork-inferior.h"
53 #include "gdbsupport/environ.h"
54 #include "gdbsupport/gdb-sigmask.h"
55 #include "gdbsupport/scoped_restore.h"
57 /* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
58 then ELFMAG0 will have been defined. If it didn't get included by
59 gdb_proc_service.h then including it will likely introduce a duplicate
60 definition of elf_fpregset_t. */
63 #include "nat/linux-namespaces.h"
73 /* Some targets did not define these ptrace constants from the start,
74 so gdbserver defines them locally here. In the future, these may
75 be removed after they are added to asm/ptrace.h. */
76 #if !(defined(PT_TEXT_ADDR) \
77 || defined(PT_DATA_ADDR) \
78 || defined(PT_TEXT_END_ADDR))
79 #if defined(__mcoldfire__)
80 /* These are still undefined in 3.10 kernels. */
81 #define PT_TEXT_ADDR 49*4
82 #define PT_DATA_ADDR 50*4
83 #define PT_TEXT_END_ADDR 51*4
84 /* These are still undefined in 3.10 kernels. */
85 #elif defined(__TMS320C6X__)
86 #define PT_TEXT_ADDR (0x10000*4)
87 #define PT_DATA_ADDR (0x10004*4)
88 #define PT_TEXT_END_ADDR (0x10008*4)
92 #if (defined(__UCLIBC__) \
93 && defined(HAS_NOMMU) \
94 && defined(PT_TEXT_ADDR) \
95 && defined(PT_DATA_ADDR) \
96 && defined(PT_TEXT_END_ADDR))
97 #define SUPPORTS_READ_OFFSETS
100 #ifdef HAVE_LINUX_BTRACE
101 # include "nat/linux-btrace.h"
102 # include "gdbsupport/btrace-common.h"
105 #ifndef HAVE_ELF32_AUXV_T
106 /* Copied from glibc's elf.h. */
109 uint32_t a_type
; /* Entry type */
112 uint32_t a_val
; /* Integer value */
113 /* We use to have pointer elements added here. We cannot do that,
114 though, since it does not work when using 32-bit definitions
115 on 64-bit platforms and vice versa. */
120 #ifndef HAVE_ELF64_AUXV_T
121 /* Copied from glibc's elf.h. */
124 uint64_t a_type
; /* Entry type */
127 uint64_t a_val
; /* Integer value */
128 /* We use to have pointer elements added here. We cannot do that,
129 though, since it does not work when using 32-bit definitions
130 on 64-bit platforms and vice versa. */
135 /* Does the current host support PTRACE_GETREGSET? */
136 int have_ptrace_getregset
= -1;
138 /* Return TRUE if THREAD is the leader thread of the process. */
141 is_leader (thread_info
*thread
)
143 ptid_t ptid
= ptid_of (thread
);
144 return ptid
.pid () == ptid
.lwp ();
147 /* Return true if we should report thread exit events to GDB, for
151 report_exit_events_for (thread_info
*thr
)
153 client_state
&cs
= get_client_state ();
155 return (cs
.report_thread_events
156 || (thr
->thread_options
& GDB_THREAD_OPTION_EXIT
) != 0);
161 /* See nat/linux-nat.h. */
164 ptid_of_lwp (struct lwp_info
*lwp
)
166 return ptid_of (get_lwp_thread (lwp
));
169 /* See nat/linux-nat.h. */
172 lwp_set_arch_private_info (struct lwp_info
*lwp
,
173 struct arch_lwp_info
*info
)
175 lwp
->arch_private
= info
;
178 /* See nat/linux-nat.h. */
180 struct arch_lwp_info
*
181 lwp_arch_private_info (struct lwp_info
*lwp
)
183 return lwp
->arch_private
;
186 /* See nat/linux-nat.h. */
189 lwp_is_stopped (struct lwp_info
*lwp
)
194 /* See nat/linux-nat.h. */
196 enum target_stop_reason
197 lwp_stop_reason (struct lwp_info
*lwp
)
199 return lwp
->stop_reason
;
202 /* See nat/linux-nat.h. */
205 lwp_is_stepping (struct lwp_info
*lwp
)
207 return lwp
->stepping
;
210 /* A list of all unknown processes which receive stop signals. Some
211 other process will presumably claim each of these as forked
212 children momentarily. */
214 struct simple_pid_list
216 /* The process ID. */
219 /* The status as reported by waitpid. */
223 struct simple_pid_list
*next
;
225 static struct simple_pid_list
*stopped_pids
;
227 /* Trivial list manipulation functions to keep track of a list of new
228 stopped processes. */
231 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
233 struct simple_pid_list
*new_pid
= XNEW (struct simple_pid_list
);
236 new_pid
->status
= status
;
237 new_pid
->next
= *listp
;
242 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
244 struct simple_pid_list
**p
;
246 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
247 if ((*p
)->pid
== pid
)
249 struct simple_pid_list
*next
= (*p
)->next
;
251 *statusp
= (*p
)->status
;
259 enum stopping_threads_kind
261 /* Not stopping threads presently. */
262 NOT_STOPPING_THREADS
,
264 /* Stopping threads. */
267 /* Stopping and suspending threads. */
268 STOPPING_AND_SUSPENDING_THREADS
271 /* This is set while stop_all_lwps is in effect. */
272 static stopping_threads_kind stopping_threads
= NOT_STOPPING_THREADS
;
274 /* FIXME make into a target method? */
275 int using_threads
= 1;
277 /* True if we're presently stabilizing threads (moving them out of
279 static int stabilizing_threads
;
281 static void unsuspend_all_lwps (struct lwp_info
*except
);
282 static void mark_lwp_dead (struct lwp_info
*lwp
, int wstat
);
283 static int lwp_is_marked_dead (struct lwp_info
*lwp
);
284 static int kill_lwp (unsigned long lwpid
, int signo
);
285 static void enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
);
286 static int linux_low_ptrace_options (int attached
);
287 static int check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
);
289 /* When the event-loop is doing a step-over, this points at the thread
291 static ptid_t step_over_bkpt
;
294 linux_process_target::low_supports_breakpoints ()
300 linux_process_target::low_get_pc (regcache
*regcache
)
306 linux_process_target::low_set_pc (regcache
*regcache
, CORE_ADDR newpc
)
308 gdb_assert_not_reached ("linux target op low_set_pc is not implemented");
311 std::vector
<CORE_ADDR
>
312 linux_process_target::low_get_next_pcs (regcache
*regcache
)
314 gdb_assert_not_reached ("linux target op low_get_next_pcs is not "
319 linux_process_target::low_decr_pc_after_break ()
324 /* True if LWP is stopped in its stepping range. */
327 lwp_in_step_range (struct lwp_info
*lwp
)
329 CORE_ADDR pc
= lwp
->stop_pc
;
331 return (pc
>= lwp
->step_range_start
&& pc
< lwp
->step_range_end
);
334 /* The event pipe registered as a waitable file in the event loop. */
335 static event_pipe linux_event_pipe
;
337 /* True if we're currently in async mode. */
338 #define target_is_async_p() (linux_event_pipe.is_open ())
340 static void send_sigstop (struct lwp_info
*lwp
);
342 /* Return non-zero if HEADER is a 64-bit ELF file. */
345 elf_64_header_p (const Elf64_Ehdr
*header
, unsigned int *machine
)
347 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
348 && header
->e_ident
[EI_MAG1
] == ELFMAG1
349 && header
->e_ident
[EI_MAG2
] == ELFMAG2
350 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
352 *machine
= header
->e_machine
;
353 return header
->e_ident
[EI_CLASS
] == ELFCLASS64
;
360 /* Return non-zero if FILE is a 64-bit ELF file,
361 zero if the file is not a 64-bit ELF file,
362 and -1 if the file is not accessible or doesn't exist. */
365 elf_64_file_p (const char *file
, unsigned int *machine
)
370 fd
= open (file
, O_RDONLY
);
374 if (read (fd
, &header
, sizeof (header
)) != sizeof (header
))
381 return elf_64_header_p (&header
, machine
);
384 /* Accepts an integer PID; Returns true if the executable PID is
385 running is a 64-bit ELF file.. */
388 linux_pid_exe_is_elf_64_file (int pid
, unsigned int *machine
)
392 sprintf (file
, "/proc/%d/exe", pid
);
393 return elf_64_file_p (file
, machine
);
397 linux_process_target::delete_lwp (lwp_info
*lwp
)
399 struct thread_info
*thr
= get_lwp_thread (lwp
);
401 threads_debug_printf ("deleting %ld", lwpid_of (thr
));
405 low_delete_thread (lwp
->arch_private
);
411 linux_process_target::low_delete_thread (arch_lwp_info
*info
)
413 /* Default implementation should be overridden if architecture-specific
414 info is being used. */
415 gdb_assert (info
== nullptr);
418 /* Open the /proc/PID/mem file for PROC. */
421 open_proc_mem_file (process_info
*proc
)
423 gdb_assert (proc
->priv
->mem_fd
== -1);
426 xsnprintf (filename
, sizeof filename
, "/proc/%d/mem", proc
->pid
);
429 = gdb_open_cloexec (filename
, O_RDWR
| O_LARGEFILE
, 0).release ();
433 linux_process_target::add_linux_process_no_mem_file (int pid
, int attached
)
435 struct process_info
*proc
;
437 proc
= add_process (pid
, attached
);
438 proc
->priv
= XCNEW (struct process_info_private
);
440 proc
->priv
->arch_private
= low_new_process ();
441 proc
->priv
->mem_fd
= -1;
448 linux_process_target::add_linux_process (int pid
, int attached
)
450 process_info
*proc
= add_linux_process_no_mem_file (pid
, attached
);
451 open_proc_mem_file (proc
);
456 linux_process_target::remove_linux_process (process_info
*proc
)
458 if (proc
->priv
->mem_fd
>= 0)
459 close (proc
->priv
->mem_fd
);
461 this->low_delete_process (proc
->priv
->arch_private
);
464 proc
->priv
= nullptr;
466 remove_process (proc
);
470 linux_process_target::low_new_process ()
476 linux_process_target::low_delete_process (arch_process_info
*info
)
478 /* Default implementation must be overridden if architecture-specific
480 gdb_assert (info
== nullptr);
484 linux_process_target::low_new_fork (process_info
*parent
, process_info
*child
)
490 linux_process_target::arch_setup_thread (thread_info
*thread
)
492 scoped_restore_current_thread restore_thread
;
493 switch_to_thread (thread
);
499 linux_process_target::handle_extended_wait (lwp_info
**orig_event_lwp
,
502 client_state
&cs
= get_client_state ();
503 struct lwp_info
*event_lwp
= *orig_event_lwp
;
504 int event
= linux_ptrace_get_extended_event (wstat
);
505 struct thread_info
*event_thr
= get_lwp_thread (event_lwp
);
507 gdb_assert (event_lwp
->waitstatus
.kind () == TARGET_WAITKIND_IGNORE
);
509 /* All extended events we currently use are mid-syscall. Only
510 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
511 you have to be using PTRACE_SEIZE to get that. */
512 event_lwp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
514 if ((event
== PTRACE_EVENT_FORK
) || (event
== PTRACE_EVENT_VFORK
)
515 || (event
== PTRACE_EVENT_CLONE
))
517 unsigned long new_pid
;
520 /* Get the pid of the new lwp. */
521 ptrace (PTRACE_GETEVENTMSG
, lwpid_of (event_thr
), (PTRACE_TYPE_ARG3
) 0,
524 /* If we haven't already seen the new PID stop, wait for it now. */
525 if (!pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
527 /* The new child has a pending SIGSTOP. We can't affect it until it
528 hits the SIGSTOP, but we're already attached. */
530 ret
= my_waitpid (new_pid
, &status
, __WALL
);
533 perror_with_name ("waiting for new child");
534 else if (ret
!= new_pid
)
535 warning ("wait returned unexpected PID %d", ret
);
536 else if (!WIFSTOPPED (status
))
537 warning ("wait returned unexpected status 0x%x", status
);
542 debug_printf ("HEW: Got %s event from LWP %ld, new child is %ld\n",
543 (event
== PTRACE_EVENT_FORK
? "fork"
544 : event
== PTRACE_EVENT_VFORK
? "vfork"
545 : event
== PTRACE_EVENT_CLONE
? "clone"
547 ptid_of (event_thr
).lwp (),
551 ptid_t child_ptid
= (event
!= PTRACE_EVENT_CLONE
552 ? ptid_t (new_pid
, new_pid
)
553 : ptid_t (ptid_of (event_thr
).pid (), new_pid
));
555 lwp_info
*child_lwp
= add_lwp (child_ptid
);
556 gdb_assert (child_lwp
!= NULL
);
557 child_lwp
->stopped
= 1;
558 if (event
!= PTRACE_EVENT_CLONE
)
559 child_lwp
->must_set_ptrace_flags
= 1;
560 child_lwp
->status_pending_p
= 0;
562 thread_info
*child_thr
= get_lwp_thread (child_lwp
);
564 /* If we're suspending all threads, leave this one suspended
565 too. If the fork/clone parent is stepping over a breakpoint,
566 all other threads have been suspended already. Leave the
567 child suspended too. */
568 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
569 || event_lwp
->bp_reinsert
!= 0)
571 threads_debug_printf ("leaving child suspended");
572 child_lwp
->suspended
= 1;
575 if (event_lwp
->bp_reinsert
!= 0
576 && supports_software_single_step ()
577 && event
== PTRACE_EVENT_VFORK
)
579 /* If we leave single-step breakpoints there, child will
580 hit it, so uninsert single-step breakpoints from parent
581 (and child). Once vfork child is done, reinsert
582 them back to parent. */
583 uninsert_single_step_breakpoints (event_thr
);
586 if (event
!= PTRACE_EVENT_CLONE
)
588 /* Add the new process to the tables and clone the breakpoint
589 lists of the parent. We need to do this even if the new process
590 will be detached, since we will need the process object and the
591 breakpoints to remove any breakpoints from memory when we
592 detach, and the client side will access registers. */
593 process_info
*child_proc
= add_linux_process (new_pid
, 0);
594 gdb_assert (child_proc
!= NULL
);
596 process_info
*parent_proc
= get_thread_process (event_thr
);
597 child_proc
->attached
= parent_proc
->attached
;
599 clone_all_breakpoints (child_thr
, event_thr
);
601 target_desc_up tdesc
= allocate_target_description ();
602 copy_target_description (tdesc
.get (), parent_proc
->tdesc
);
603 child_proc
->tdesc
= tdesc
.release ();
605 /* Clone arch-specific process data. */
606 low_new_fork (parent_proc
, child_proc
);
609 /* Save fork/clone info in the parent thread. */
610 if (event
== PTRACE_EVENT_FORK
)
611 event_lwp
->waitstatus
.set_forked (child_ptid
);
612 else if (event
== PTRACE_EVENT_VFORK
)
613 event_lwp
->waitstatus
.set_vforked (child_ptid
);
614 else if (event
== PTRACE_EVENT_CLONE
615 && (event_thr
->thread_options
& GDB_THREAD_OPTION_CLONE
) != 0)
616 event_lwp
->waitstatus
.set_thread_cloned (child_ptid
);
618 if (event
!= PTRACE_EVENT_CLONE
619 || (event_thr
->thread_options
& GDB_THREAD_OPTION_CLONE
) != 0)
621 /* The status_pending field contains bits denoting the
622 extended event, so when the pending event is handled, the
623 handler will look at lwp->waitstatus. */
624 event_lwp
->status_pending_p
= 1;
625 event_lwp
->status_pending
= wstat
;
627 /* Link the threads until the parent's event is passed on to
629 event_lwp
->relative
= child_lwp
;
630 child_lwp
->relative
= event_lwp
;
633 /* If the parent thread is doing step-over with single-step
634 breakpoints, the list of single-step breakpoints are cloned
635 from the parent's. Remove them from the child process.
636 In case of vfork, we'll reinsert them back once vforked
638 if (event_lwp
->bp_reinsert
!= 0
639 && supports_software_single_step ())
641 /* The child process is forked and stopped, so it is safe
642 to access its memory without stopping all other threads
643 from other processes. */
644 delete_single_step_breakpoints (child_thr
);
646 gdb_assert (has_single_step_breakpoints (event_thr
));
647 gdb_assert (!has_single_step_breakpoints (child_thr
));
650 /* Normally we will get the pending SIGSTOP. But in some cases
651 we might get another signal delivered to the group first.
652 If we do get another signal, be sure not to lose it. */
653 if (WSTOPSIG (status
) != SIGSTOP
)
655 child_lwp
->stop_expected
= 1;
656 child_lwp
->status_pending_p
= 1;
657 child_lwp
->status_pending
= status
;
659 else if (event
== PTRACE_EVENT_CLONE
&& cs
.report_thread_events
)
661 child_lwp
->waitstatus
.set_thread_created ();
662 child_lwp
->status_pending_p
= 1;
663 child_lwp
->status_pending
= status
;
666 if (event
== PTRACE_EVENT_CLONE
)
669 thread_db_notice_clone (event_thr
, child_ptid
);
673 if (event
== PTRACE_EVENT_CLONE
674 && (event_thr
->thread_options
& GDB_THREAD_OPTION_CLONE
) == 0)
677 ("not reporting clone event from LWP %ld, new child is %ld\n",
678 ptid_of (event_thr
).lwp (),
683 /* Leave the child stopped until GDB processes the parent
685 child_thr
->last_resume_kind
= resume_stop
;
686 child_thr
->last_status
.set_stopped (GDB_SIGNAL_0
);
688 /* Report the event. */
690 ("reporting %s event from LWP %ld, new child is %ld\n",
691 (event
== PTRACE_EVENT_FORK
? "fork"
692 : event
== PTRACE_EVENT_VFORK
? "vfork"
693 : event
== PTRACE_EVENT_CLONE
? "clone"
695 ptid_of (event_thr
).lwp (),
699 else if (event
== PTRACE_EVENT_VFORK_DONE
)
701 event_lwp
->waitstatus
.set_vfork_done ();
703 if (event_lwp
->bp_reinsert
!= 0 && supports_software_single_step ())
705 reinsert_single_step_breakpoints (event_thr
);
707 gdb_assert (has_single_step_breakpoints (event_thr
));
710 /* Report the event. */
713 else if (event
== PTRACE_EVENT_EXEC
&& cs
.report_exec_events
)
715 struct process_info
*proc
;
716 std::vector
<int> syscalls_to_catch
;
720 threads_debug_printf ("Got exec event from LWP %ld",
721 lwpid_of (event_thr
));
723 /* Get the event ptid. */
724 event_ptid
= ptid_of (event_thr
);
725 event_pid
= event_ptid
.pid ();
727 /* Save the syscall list from the execing process. */
728 proc
= get_thread_process (event_thr
);
729 syscalls_to_catch
= std::move (proc
->syscalls_to_catch
);
731 /* Delete the execing process and all its threads. */
733 switch_to_thread (nullptr);
735 /* Create a new process/lwp/thread. */
736 proc
= add_linux_process (event_pid
, 0);
737 event_lwp
= add_lwp (event_ptid
);
738 event_thr
= get_lwp_thread (event_lwp
);
739 gdb_assert (current_thread
== event_thr
);
740 arch_setup_thread (event_thr
);
742 /* Set the event status. */
743 event_lwp
->waitstatus
.set_execd
745 (linux_proc_pid_to_exec_file (lwpid_of (event_thr
))));
747 /* Mark the exec status as pending. */
748 event_lwp
->stopped
= 1;
749 event_lwp
->status_pending_p
= 1;
750 event_lwp
->status_pending
= wstat
;
751 event_thr
->last_resume_kind
= resume_continue
;
752 event_thr
->last_status
.set_ignore ();
754 /* Update syscall state in the new lwp, effectively mid-syscall too. */
755 event_lwp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
757 /* Restore the list to catch. Don't rely on the client, which is free
758 to avoid sending a new list when the architecture doesn't change.
759 Also, for ANY_SYSCALL, the architecture doesn't really matter. */
760 proc
->syscalls_to_catch
= std::move (syscalls_to_catch
);
762 /* Report the event. */
763 *orig_event_lwp
= event_lwp
;
767 internal_error (_("unknown ptrace event %d"), event
);
771 linux_process_target::get_pc (lwp_info
*lwp
)
773 process_info
*proc
= get_thread_process (get_lwp_thread (lwp
));
774 gdb_assert (!proc
->starting_up
);
776 if (!low_supports_breakpoints ())
779 scoped_restore_current_thread restore_thread
;
780 switch_to_thread (get_lwp_thread (lwp
));
782 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
783 CORE_ADDR pc
= low_get_pc (regcache
);
785 threads_debug_printf ("pc is 0x%lx", (long) pc
);
791 linux_process_target::get_syscall_trapinfo (lwp_info
*lwp
, int *sysno
)
793 struct regcache
*regcache
;
795 scoped_restore_current_thread restore_thread
;
796 switch_to_thread (get_lwp_thread (lwp
));
798 regcache
= get_thread_regcache (current_thread
, 1);
799 low_get_syscall_trapinfo (regcache
, sysno
);
801 threads_debug_printf ("get_syscall_trapinfo sysno %d", *sysno
);
805 linux_process_target::low_get_syscall_trapinfo (regcache
*regcache
, int *sysno
)
807 /* By default, report an unknown system call number. */
808 *sysno
= UNKNOWN_SYSCALL
;
812 linux_process_target::save_stop_reason (lwp_info
*lwp
)
815 CORE_ADDR sw_breakpoint_pc
;
816 #if USE_SIGTRAP_SIGINFO
820 if (!low_supports_breakpoints ())
823 process_info
*proc
= get_thread_process (get_lwp_thread (lwp
));
824 if (proc
->starting_up
)
826 /* Claim we have the stop PC so that the caller doesn't try to
832 sw_breakpoint_pc
= pc
- low_decr_pc_after_break ();
834 /* breakpoint_at reads from the current thread. */
835 scoped_restore_current_thread restore_thread
;
836 switch_to_thread (get_lwp_thread (lwp
));
838 #if USE_SIGTRAP_SIGINFO
839 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
840 (PTRACE_TYPE_ARG3
) 0, &siginfo
) == 0)
842 if (siginfo
.si_signo
== SIGTRAP
)
844 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
)
845 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
847 /* The si_code is ambiguous on this arch -- check debug
849 if (!check_stopped_by_watchpoint (lwp
))
850 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
852 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
))
854 /* If we determine the LWP stopped for a SW breakpoint,
855 trust it. Particularly don't check watchpoint
856 registers, because at least on s390, we'd find
857 stopped-by-watchpoint as long as there's a watchpoint
859 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
861 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
863 /* This can indicate either a hardware breakpoint or
864 hardware watchpoint. Check debug registers. */
865 if (!check_stopped_by_watchpoint (lwp
))
866 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
868 else if (siginfo
.si_code
== TRAP_TRACE
)
870 /* We may have single stepped an instruction that
871 triggered a watchpoint. In that case, on some
872 architectures (such as x86), instead of TRAP_HWBKPT,
873 si_code indicates TRAP_TRACE, and we need to check
874 the debug registers separately. */
875 if (!check_stopped_by_watchpoint (lwp
))
876 lwp
->stop_reason
= TARGET_STOPPED_BY_SINGLE_STEP
;
881 /* We may have just stepped a breakpoint instruction. E.g., in
882 non-stop mode, GDB first tells the thread A to step a range, and
883 then the user inserts a breakpoint inside the range. In that
884 case we need to report the breakpoint PC. */
885 if ((!lwp
->stepping
|| lwp
->stop_pc
== sw_breakpoint_pc
)
886 && low_breakpoint_at (sw_breakpoint_pc
))
887 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
889 if (hardware_breakpoint_inserted_here (pc
))
890 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
892 if (lwp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
)
893 check_stopped_by_watchpoint (lwp
);
896 if (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
)
899 ("%s stopped by software breakpoint",
900 target_pid_to_str (ptid_of (get_lwp_thread (lwp
))).c_str ());
902 /* Back up the PC if necessary. */
903 if (pc
!= sw_breakpoint_pc
)
905 struct regcache
*regcache
906 = get_thread_regcache (current_thread
, 1);
907 low_set_pc (regcache
, sw_breakpoint_pc
);
910 /* Update this so we record the correct stop PC below. */
911 pc
= sw_breakpoint_pc
;
913 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
915 ("%s stopped by hardware breakpoint",
916 target_pid_to_str (ptid_of (get_lwp_thread (lwp
))).c_str ());
917 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
919 ("%s stopped by hardware watchpoint",
920 target_pid_to_str (ptid_of (get_lwp_thread (lwp
))).c_str ());
921 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
923 ("%s stopped by trace",
924 target_pid_to_str (ptid_of (get_lwp_thread (lwp
))).c_str ());
931 linux_process_target::add_lwp (ptid_t ptid
)
933 lwp_info
*lwp
= new lwp_info
;
935 lwp
->thread
= add_thread (ptid
, lwp
);
937 low_new_thread (lwp
);
943 linux_process_target::low_new_thread (lwp_info
*info
)
948 /* Callback to be used when calling fork_inferior, responsible for
949 actually initiating the tracing of the inferior. */
954 if (ptrace (PTRACE_TRACEME
, 0, (PTRACE_TYPE_ARG3
) 0,
955 (PTRACE_TYPE_ARG4
) 0) < 0)
956 trace_start_error_with_name ("ptrace");
958 if (setpgid (0, 0) < 0)
959 trace_start_error_with_name ("setpgid");
961 /* If GDBserver is connected to gdb via stdio, redirect the inferior's
962 stdout to stderr so that inferior i/o doesn't corrupt the connection.
963 Also, redirect stdin to /dev/null. */
964 if (remote_connection_is_stdio ())
967 trace_start_error_with_name ("close");
968 if (open ("/dev/null", O_RDONLY
) < 0)
969 trace_start_error_with_name ("open");
971 trace_start_error_with_name ("dup2");
972 if (write (2, "stdin/stdout redirected\n",
973 sizeof ("stdin/stdout redirected\n") - 1) < 0)
975 /* Errors ignored. */;
980 /* Start an inferior process and returns its pid.
981 PROGRAM is the name of the program to be started, and PROGRAM_ARGS
982 are its arguments. */
985 linux_process_target::create_inferior (const char *program
,
986 const std::vector
<char *> &program_args
)
988 client_state
&cs
= get_client_state ();
989 struct lwp_info
*new_lwp
;
994 maybe_disable_address_space_randomization restore_personality
995 (cs
.disable_randomization
);
996 std::string str_program_args
= construct_inferior_arguments (program_args
);
998 pid
= fork_inferior (program
,
999 str_program_args
.c_str (),
1000 get_environ ()->envp (), linux_ptrace_fun
,
1001 NULL
, NULL
, NULL
, NULL
);
1004 /* When spawning a new process, we can't open the mem file yet. We
1005 still have to nurse the process through the shell, and that execs
1006 a couple times. The address space a /proc/PID/mem file is
1007 accessing is destroyed on exec. */
1008 process_info
*proc
= add_linux_process_no_mem_file (pid
, 0);
1010 ptid
= ptid_t (pid
, pid
);
1011 new_lwp
= add_lwp (ptid
);
1012 new_lwp
->must_set_ptrace_flags
= 1;
1014 post_fork_inferior (pid
, program
);
1016 /* PROC is now past the shell running the program we want, so we can
1017 open the /proc/PID/mem file. */
1018 open_proc_mem_file (proc
);
1023 /* Implement the post_create_inferior target_ops method. */
1026 linux_process_target::post_create_inferior ()
1028 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
1032 if (lwp
->must_set_ptrace_flags
)
1034 struct process_info
*proc
= current_process ();
1035 int options
= linux_low_ptrace_options (proc
->attached
);
1037 linux_enable_event_reporting (lwpid_of (current_thread
), options
);
1038 lwp
->must_set_ptrace_flags
= 0;
1043 linux_process_target::attach_lwp (ptid_t ptid
)
1045 struct lwp_info
*new_lwp
;
1046 int lwpid
= ptid
.lwp ();
1048 if (ptrace (PTRACE_ATTACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0)
1052 new_lwp
= add_lwp (ptid
);
1054 /* We need to wait for SIGSTOP before being able to make the next
1055 ptrace call on this LWP. */
1056 new_lwp
->must_set_ptrace_flags
= 1;
1058 if (linux_proc_pid_is_stopped (lwpid
))
1060 threads_debug_printf ("Attached to a stopped process");
1062 /* The process is definitely stopped. It is in a job control
1063 stop, unless the kernel predates the TASK_STOPPED /
1064 TASK_TRACED distinction, in which case it might be in a
1065 ptrace stop. Make sure it is in a ptrace stop; from there we
1066 can kill it, signal it, et cetera.
1068 First make sure there is a pending SIGSTOP. Since we are
1069 already attached, the process can not transition from stopped
1070 to running without a PTRACE_CONT; so we know this signal will
1071 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1072 probably already in the queue (unless this kernel is old
1073 enough to use TASK_STOPPED for ptrace stops); but since
1074 SIGSTOP is not an RT signal, it can only be queued once. */
1075 kill_lwp (lwpid
, SIGSTOP
);
1077 /* Finally, resume the stopped process. This will deliver the
1078 SIGSTOP (or a higher priority signal, just like normal
1079 PTRACE_ATTACH), which we'll catch later on. */
1080 ptrace (PTRACE_CONT
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1083 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
1084 brings it to a halt.
1086 There are several cases to consider here:
1088 1) gdbserver has already attached to the process and is being notified
1089 of a new thread that is being created.
1090 In this case we should ignore that SIGSTOP and resume the
1091 process. This is handled below by setting stop_expected = 1,
1092 and the fact that add_thread sets last_resume_kind ==
1095 2) This is the first thread (the process thread), and we're attaching
1096 to it via attach_inferior.
1097 In this case we want the process thread to stop.
1098 This is handled by having linux_attach set last_resume_kind ==
1099 resume_stop after we return.
1101 If the pid we are attaching to is also the tgid, we attach to and
1102 stop all the existing threads. Otherwise, we attach to pid and
1103 ignore any other threads in the same group as this pid.
1105 3) GDB is connecting to gdbserver and is requesting an enumeration of all
1107 In this case we want the thread to stop.
1108 FIXME: This case is currently not properly handled.
1109 We should wait for the SIGSTOP but don't. Things work apparently
1110 because enough time passes between when we ptrace (ATTACH) and when
1111 gdb makes the next ptrace call on the thread.
1113 On the other hand, if we are currently trying to stop all threads, we
1114 should treat the new thread as if we had sent it a SIGSTOP. This works
1115 because we are guaranteed that the add_lwp call above added us to the
1116 end of the list, and so the new thread has not yet reached
1117 wait_for_sigstop (but will). */
1118 new_lwp
->stop_expected
= 1;
1123 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1124 already attached. Returns true if a new LWP is found, false
1128 attach_proc_task_lwp_callback (ptid_t ptid
)
1130 /* Is this a new thread? */
1131 if (find_thread_ptid (ptid
) == NULL
)
1133 int lwpid
= ptid
.lwp ();
1136 threads_debug_printf ("Found new lwp %d", lwpid
);
1138 err
= the_linux_target
->attach_lwp (ptid
);
1140 /* Be quiet if we simply raced with the thread exiting. EPERM
1141 is returned if the thread's task still exists, and is marked
1142 as exited or zombie, as well as other conditions, so in that
1143 case, confirm the status in /proc/PID/status. */
1145 || (err
== EPERM
&& linux_proc_pid_is_gone (lwpid
)))
1146 threads_debug_printf
1147 ("Cannot attach to lwp %d: thread is gone (%d: %s)",
1148 lwpid
, err
, safe_strerror (err
));
1152 = linux_ptrace_attach_fail_reason_string (ptid
, err
);
1154 warning (_("Cannot attach to lwp %d: %s"), lwpid
, reason
.c_str ());
1162 static void async_file_mark (void);
1164 /* Attach to PID. If PID is the tgid, attach to it and all
1168 linux_process_target::attach (unsigned long pid
)
1170 struct process_info
*proc
;
1171 struct thread_info
*initial_thread
;
1172 ptid_t ptid
= ptid_t (pid
, pid
);
1175 /* Delay opening the /proc/PID/mem file until we've successfully
1177 proc
= add_linux_process_no_mem_file (pid
, 1);
1179 /* Attach to PID. We will check for other threads
1181 err
= attach_lwp (ptid
);
1184 this->remove_linux_process (proc
);
1186 std::string reason
= linux_ptrace_attach_fail_reason_string (ptid
, err
);
1187 error ("Cannot attach to process %ld: %s", pid
, reason
.c_str ());
1190 open_proc_mem_file (proc
);
1192 /* Don't ignore the initial SIGSTOP if we just attached to this
1193 process. It will be collected by wait shortly. */
1194 initial_thread
= find_thread_ptid (ptid_t (pid
, pid
));
1195 gdb_assert (initial_thread
!= nullptr);
1196 initial_thread
->last_resume_kind
= resume_stop
;
1198 /* We must attach to every LWP. If /proc is mounted, use that to
1199 find them now. On the one hand, the inferior may be using raw
1200 clone instead of using pthreads. On the other hand, even if it
1201 is using pthreads, GDB may not be connected yet (thread_db needs
1202 to do symbol lookups, through qSymbol). Also, thread_db walks
1203 structures in the inferior's address space to find the list of
1204 threads/LWPs, and those structures may well be corrupted. Note
1205 that once thread_db is loaded, we'll still use it to list threads
1206 and associate pthread info with each LWP. */
1207 linux_proc_attach_tgid_threads (pid
, attach_proc_task_lwp_callback
);
1209 /* GDB will shortly read the xml target description for this
1210 process, to figure out the process' architecture. But the target
1211 description is only filled in when the first process/thread in
1212 the thread group reports its initial PTRACE_ATTACH SIGSTOP. Do
1213 that now, otherwise, if GDB is fast enough, it could read the
1214 target description _before_ that initial stop. */
1217 struct lwp_info
*lwp
;
1219 ptid_t pid_ptid
= ptid_t (pid
);
1221 lwpid
= wait_for_event_filtered (pid_ptid
, pid_ptid
, &wstat
, __WALL
);
1222 gdb_assert (lwpid
> 0);
1224 lwp
= find_lwp_pid (ptid_t (lwpid
));
1225 gdb_assert (lwp
!= nullptr);
1227 if (!WIFSTOPPED (wstat
) || WSTOPSIG (wstat
) != SIGSTOP
)
1229 lwp
->status_pending_p
= 1;
1230 lwp
->status_pending
= wstat
;
1233 initial_thread
->last_resume_kind
= resume_continue
;
1237 gdb_assert (proc
->tdesc
!= NULL
);
1244 last_thread_of_process_p (int pid
)
1246 bool seen_one
= false;
1248 thread_info
*thread
= find_thread (pid
, [&] (thread_info
*thr_arg
)
1252 /* This is the first thread of this process we see. */
1258 /* This is the second thread of this process we see. */
1263 return thread
== NULL
;
1269 linux_kill_one_lwp (struct lwp_info
*lwp
)
1271 struct thread_info
*thr
= get_lwp_thread (lwp
);
1272 int pid
= lwpid_of (thr
);
1274 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
1275 there is no signal context, and ptrace(PTRACE_KILL) (or
1276 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
1277 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
1278 alternative is to kill with SIGKILL. We only need one SIGKILL
1279 per process, not one for each thread. But since we still support
1280 support debugging programs using raw clone without CLONE_THREAD,
1281 we send one for each thread. For years, we used PTRACE_KILL
1282 only, so we're being a bit paranoid about some old kernels where
1283 PTRACE_KILL might work better (dubious if there are any such, but
1284 that's why it's paranoia), so we try SIGKILL first, PTRACE_KILL
1285 second, and so we're fine everywhere. */
1288 kill_lwp (pid
, SIGKILL
);
1291 int save_errno
= errno
;
1293 threads_debug_printf ("kill_lwp (SIGKILL) %s, 0, 0 (%s)",
1294 target_pid_to_str (ptid_of (thr
)).c_str (),
1295 save_errno
? safe_strerror (save_errno
) : "OK");
1299 ptrace (PTRACE_KILL
, pid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1302 int save_errno
= errno
;
1304 threads_debug_printf ("PTRACE_KILL %s, 0, 0 (%s)",
1305 target_pid_to_str (ptid_of (thr
)).c_str (),
1306 save_errno
? safe_strerror (save_errno
) : "OK");
1310 /* Kill LWP and wait for it to die. */
1313 kill_wait_lwp (struct lwp_info
*lwp
)
1315 struct thread_info
*thr
= get_lwp_thread (lwp
);
1316 int pid
= ptid_of (thr
).pid ();
1317 int lwpid
= ptid_of (thr
).lwp ();
1321 threads_debug_printf ("killing lwp %d, for pid: %d", lwpid
, pid
);
1325 linux_kill_one_lwp (lwp
);
1327 /* Make sure it died. Notes:
1329 - The loop is most likely unnecessary.
1331 - We don't use wait_for_event as that could delete lwps
1332 while we're iterating over them. We're not interested in
1333 any pending status at this point, only in making sure all
1334 wait status on the kernel side are collected until the
1337 - We don't use __WALL here as the __WALL emulation relies on
1338 SIGCHLD, and killing a stopped process doesn't generate
1339 one, nor an exit status.
1341 res
= my_waitpid (lwpid
, &wstat
, 0);
1342 if (res
== -1 && errno
== ECHILD
)
1343 res
= my_waitpid (lwpid
, &wstat
, __WCLONE
);
1344 } while (res
> 0 && WIFSTOPPED (wstat
));
1346 /* Even if it was stopped, the child may have already disappeared.
1347 E.g., if it was killed by SIGKILL. */
1348 if (res
< 0 && errno
!= ECHILD
)
1349 perror_with_name ("kill_wait_lwp");
1352 /* Callback for `for_each_thread'. Kills an lwp of a given process,
1353 except the leader. */
1356 kill_one_lwp_callback (thread_info
*thread
, int pid
)
1358 struct lwp_info
*lwp
= get_thread_lwp (thread
);
1360 /* We avoid killing the first thread here, because of a Linux kernel (at
1361 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
1362 the children get a chance to be reaped, it will remain a zombie
1365 if (lwpid_of (thread
) == pid
)
1367 threads_debug_printf ("is last of process %s",
1368 target_pid_to_str (thread
->id
).c_str ());
1372 kill_wait_lwp (lwp
);
1376 linux_process_target::kill (process_info
*process
)
1378 int pid
= process
->pid
;
1380 /* If we're killing a running inferior, make sure it is stopped
1381 first, as PTRACE_KILL will not work otherwise. */
1382 stop_all_lwps (0, NULL
);
1384 for_each_thread (pid
, [&] (thread_info
*thread
)
1386 kill_one_lwp_callback (thread
, pid
);
1389 /* See the comment in linux_kill_one_lwp. We did not kill the first
1390 thread in the list, so do so now. */
1391 lwp_info
*lwp
= find_lwp_pid (ptid_t (pid
));
1394 threads_debug_printf ("cannot find lwp for pid: %d", pid
);
1396 kill_wait_lwp (lwp
);
1400 /* Since we presently can only stop all lwps of all processes, we
1401 need to unstop lwps of other processes. */
1402 unstop_all_lwps (0, NULL
);
1406 /* Get pending signal of THREAD, for detaching purposes. This is the
1407 signal the thread last stopped for, which we need to deliver to the
1408 thread when detaching, otherwise, it'd be suppressed/lost. */
1411 get_detach_signal (struct thread_info
*thread
)
1413 client_state
&cs
= get_client_state ();
1414 enum gdb_signal signo
= GDB_SIGNAL_0
;
1416 struct lwp_info
*lp
= get_thread_lwp (thread
);
1418 if (lp
->status_pending_p
)
1419 status
= lp
->status_pending
;
1422 /* If the thread had been suspended by gdbserver, and it stopped
1423 cleanly, then it'll have stopped with SIGSTOP. But we don't
1424 want to deliver that SIGSTOP. */
1425 if (thread
->last_status
.kind () != TARGET_WAITKIND_STOPPED
1426 || thread
->last_status
.sig () == GDB_SIGNAL_0
)
1429 /* Otherwise, we may need to deliver the signal we
1431 status
= lp
->last_status
;
1434 if (!WIFSTOPPED (status
))
1436 threads_debug_printf ("lwp %s hasn't stopped: no pending signal",
1437 target_pid_to_str (ptid_of (thread
)).c_str ());
1441 /* Extended wait statuses aren't real SIGTRAPs. */
1442 if (WSTOPSIG (status
) == SIGTRAP
&& linux_is_extended_waitstatus (status
))
1444 threads_debug_printf ("lwp %s had stopped with extended "
1445 "status: no pending signal",
1446 target_pid_to_str (ptid_of (thread
)).c_str ());
1450 signo
= gdb_signal_from_host (WSTOPSIG (status
));
1452 if (cs
.program_signals_p
&& !cs
.program_signals
[signo
])
1454 threads_debug_printf ("lwp %s had signal %s, but it is in nopass state",
1455 target_pid_to_str (ptid_of (thread
)).c_str (),
1456 gdb_signal_to_string (signo
));
1459 else if (!cs
.program_signals_p
1460 /* If we have no way to know which signals GDB does not
1461 want to have passed to the program, assume
1462 SIGTRAP/SIGINT, which is GDB's default. */
1463 && (signo
== GDB_SIGNAL_TRAP
|| signo
== GDB_SIGNAL_INT
))
1465 threads_debug_printf ("lwp %s had signal %s, "
1466 "but we don't know if we should pass it. "
1468 target_pid_to_str (ptid_of (thread
)).c_str (),
1469 gdb_signal_to_string (signo
));
1474 threads_debug_printf ("lwp %s has pending signal %s: delivering it",
1475 target_pid_to_str (ptid_of (thread
)).c_str (),
1476 gdb_signal_to_string (signo
));
1478 return WSTOPSIG (status
);
1483 linux_process_target::detach_one_lwp (lwp_info
*lwp
)
1485 struct thread_info
*thread
= get_lwp_thread (lwp
);
1489 /* If there is a pending SIGSTOP, get rid of it. */
1490 if (lwp
->stop_expected
)
1492 threads_debug_printf ("Sending SIGCONT to %s",
1493 target_pid_to_str (ptid_of (thread
)).c_str ());
1495 kill_lwp (lwpid_of (thread
), SIGCONT
);
1496 lwp
->stop_expected
= 0;
1499 /* Pass on any pending signal for this thread. */
1500 sig
= get_detach_signal (thread
);
1502 /* Preparing to resume may try to write registers, and fail if the
1503 lwp is zombie. If that happens, ignore the error. We'll handle
1504 it below, when detach fails with ESRCH. */
1507 /* Flush any pending changes to the process's registers. */
1508 regcache_invalidate_thread (thread
);
1510 /* Finally, let it resume. */
1511 low_prepare_to_resume (lwp
);
1513 catch (const gdb_exception_error
&ex
)
1515 if (!check_ptrace_stopped_lwp_gone (lwp
))
1519 lwpid
= lwpid_of (thread
);
1520 if (ptrace (PTRACE_DETACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0,
1521 (PTRACE_TYPE_ARG4
) (long) sig
) < 0)
1523 int save_errno
= errno
;
1525 /* We know the thread exists, so ESRCH must mean the lwp is
1526 zombie. This can happen if one of the already-detached
1527 threads exits the whole thread group. In that case we're
1528 still attached, and must reap the lwp. */
1529 if (save_errno
== ESRCH
)
1533 ret
= my_waitpid (lwpid
, &status
, __WALL
);
1536 warning (_("Couldn't reap LWP %d while detaching: %s"),
1537 lwpid
, safe_strerror (errno
));
1539 else if (!WIFEXITED (status
) && !WIFSIGNALED (status
))
1541 warning (_("Reaping LWP %d while detaching "
1542 "returned unexpected status 0x%x"),
1548 error (_("Can't detach %s: %s"),
1549 target_pid_to_str (ptid_of (thread
)).c_str (),
1550 safe_strerror (save_errno
));
1554 threads_debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)",
1555 target_pid_to_str (ptid_of (thread
)).c_str (),
1562 linux_process_target::detach (process_info
*process
)
1564 struct lwp_info
*main_lwp
;
1566 /* As there's a step over already in progress, let it finish first,
1567 otherwise nesting a stabilize_threads operation on top gets real
1569 complete_ongoing_step_over ();
1571 /* Stop all threads before detaching. First, ptrace requires that
1572 the thread is stopped to successfully detach. Second, thread_db
1573 may need to uninstall thread event breakpoints from memory, which
1574 only works with a stopped process anyway. */
1575 stop_all_lwps (0, NULL
);
1577 #ifdef USE_THREAD_DB
1578 thread_db_detach (process
);
1581 /* Stabilize threads (move out of jump pads). */
1582 target_stabilize_threads ();
1584 /* Detach from the clone lwps first. If the thread group exits just
1585 while we're detaching, we must reap the clone lwps before we're
1586 able to reap the leader. */
1587 for_each_thread (process
->pid
, [this] (thread_info
*thread
)
1589 /* We don't actually detach from the thread group leader just yet.
1590 If the thread group exits, we must reap the zombie clone lwps
1591 before we're able to reap the leader. */
1592 if (thread
->id
.pid () == thread
->id
.lwp ())
1595 lwp_info
*lwp
= get_thread_lwp (thread
);
1596 detach_one_lwp (lwp
);
1599 main_lwp
= find_lwp_pid (ptid_t (process
->pid
));
1600 gdb_assert (main_lwp
!= nullptr);
1601 detach_one_lwp (main_lwp
);
1605 /* Since we presently can only stop all lwps of all processes, we
1606 need to unstop lwps of other processes. */
1607 unstop_all_lwps (0, NULL
);
1611 /* Remove all LWPs that belong to process PROC from the lwp list. */
1614 linux_process_target::mourn (process_info
*process
)
1616 #ifdef USE_THREAD_DB
1617 thread_db_mourn (process
);
1620 for_each_thread (process
->pid
, [this] (thread_info
*thread
)
1622 delete_lwp (get_thread_lwp (thread
));
1625 this->remove_linux_process (process
);
1629 linux_process_target::join (int pid
)
1634 ret
= my_waitpid (pid
, &status
, 0);
1635 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1637 } while (ret
!= -1 || errno
!= ECHILD
);
1640 /* Return true if the given thread is still alive. */
1643 linux_process_target::thread_alive (ptid_t ptid
)
1645 struct lwp_info
*lwp
= find_lwp_pid (ptid
);
1647 /* We assume we always know if a thread exits. If a whole process
1648 exited but we still haven't been able to report it to GDB, we'll
1649 hold on to the last lwp of the dead process. */
1651 return !lwp_is_marked_dead (lwp
);
1657 linux_process_target::thread_still_has_status_pending (thread_info
*thread
)
1659 struct lwp_info
*lp
= get_thread_lwp (thread
);
1661 if (!lp
->status_pending_p
)
1664 if (thread
->last_resume_kind
!= resume_stop
1665 && (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1666 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
1671 gdb_assert (lp
->last_status
!= 0);
1675 scoped_restore_current_thread restore_thread
;
1676 switch_to_thread (thread
);
1678 if (pc
!= lp
->stop_pc
)
1680 threads_debug_printf ("PC of %ld changed",
1685 #if !USE_SIGTRAP_SIGINFO
1686 else if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1687 && !low_breakpoint_at (pc
))
1689 threads_debug_printf ("previous SW breakpoint of %ld gone",
1693 else if (lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
1694 && !hardware_breakpoint_inserted_here (pc
))
1696 threads_debug_printf ("previous HW breakpoint of %ld gone",
1704 threads_debug_printf ("discarding pending breakpoint status");
1705 lp
->status_pending_p
= 0;
1713 /* Returns true if LWP is resumed from the client's perspective. */
1716 lwp_resumed (struct lwp_info
*lwp
)
1718 struct thread_info
*thread
= get_lwp_thread (lwp
);
1720 if (thread
->last_resume_kind
!= resume_stop
)
1723 /* Did gdb send us a `vCont;t', but we haven't reported the
1724 corresponding stop to gdb yet? If so, the thread is still
1725 resumed/running from gdb's perspective. */
1726 if (thread
->last_resume_kind
== resume_stop
1727 && thread
->last_status
.kind () == TARGET_WAITKIND_IGNORE
)
1734 linux_process_target::status_pending_p_callback (thread_info
*thread
,
1737 struct lwp_info
*lp
= get_thread_lwp (thread
);
1739 /* Check if we're only interested in events from a specific process
1740 or a specific LWP. */
1741 if (!thread
->id
.matches (ptid
))
1744 if (!lwp_resumed (lp
))
1747 if (lp
->status_pending_p
1748 && !thread_still_has_status_pending (thread
))
1750 resume_one_lwp (lp
, lp
->stepping
, GDB_SIGNAL_0
, NULL
);
1754 return lp
->status_pending_p
;
1758 find_lwp_pid (ptid_t ptid
)
1760 long lwp
= ptid
.lwp () != 0 ? ptid
.lwp () : ptid
.pid ();
1761 thread_info
*thread
= find_thread ([lwp
] (thread_info
*thr_arg
)
1763 return thr_arg
->id
.lwp () == lwp
;
1769 return get_thread_lwp (thread
);
1772 /* Return the number of known LWPs in the tgid given by PID. */
1779 for_each_thread (pid
, [&] (thread_info
*thread
)
1787 /* See nat/linux-nat.h. */
1790 iterate_over_lwps (ptid_t filter
,
1791 gdb::function_view
<iterate_over_lwps_ftype
> callback
)
1793 thread_info
*thread
= find_thread (filter
, [&] (thread_info
*thr_arg
)
1795 lwp_info
*lwp
= get_thread_lwp (thr_arg
);
1797 return callback (lwp
);
1803 return get_thread_lwp (thread
);
1807 linux_process_target::check_zombie_leaders ()
1809 for_each_process ([this] (process_info
*proc
)
1811 pid_t leader_pid
= pid_of (proc
);
1812 lwp_info
*leader_lp
= find_lwp_pid (ptid_t (leader_pid
));
1814 threads_debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
1815 "num_lwps=%d, zombie=%d",
1816 leader_pid
, leader_lp
!= NULL
, num_lwps (leader_pid
),
1817 linux_proc_pid_is_zombie (leader_pid
));
1819 if (leader_lp
!= NULL
&& !leader_lp
->stopped
1820 /* Check if there are other threads in the group, as we may
1821 have raced with the inferior simply exiting. Note this
1822 isn't a watertight check. If the inferior is
1823 multi-threaded and is exiting, it may be we see the
1824 leader as zombie before we reap all the non-leader
1825 threads. See comments below. */
1826 && !last_thread_of_process_p (leader_pid
)
1827 && linux_proc_pid_is_zombie (leader_pid
))
1829 /* A zombie leader in a multi-threaded program can mean one
1832 #1 - Only the leader exited, not the whole program, e.g.,
1833 with pthread_exit. Since we can't reap the leader's exit
1834 status until all other threads are gone and reaped too,
1835 we want to delete the zombie leader right away, as it
1836 can't be debugged, we can't read its registers, etc.
1837 This is the main reason we check for zombie leaders
1840 #2 - The whole thread-group/process exited (a group exit,
1841 via e.g. exit(3), and there is (or will be shortly) an
1842 exit reported for each thread in the process, and then
1843 finally an exit for the leader once the non-leaders are
1846 #3 - There are 3 or more threads in the group, and a
1847 thread other than the leader exec'd. See comments on
1848 exec events at the top of the file.
1850 Ideally we would never delete the leader for case #2.
1851 Instead, we want to collect the exit status of each
1852 non-leader thread, and then finally collect the exit
1853 status of the leader as normal and use its exit code as
1854 whole-process exit code. Unfortunately, there's no
1855 race-free way to distinguish cases #1 and #2. We can't
1856 assume the exit events for the non-leaders threads are
1857 already pending in the kernel, nor can we assume the
1858 non-leader threads are in zombie state already. Between
1859 the leader becoming zombie and the non-leaders exiting
1860 and becoming zombie themselves, there's a small time
1861 window, so such a check would be racy. Temporarily
1862 pausing all threads and checking to see if all threads
1863 exit or not before re-resuming them would work in the
1864 case that all threads are running right now, but it
1865 wouldn't work if some thread is currently already
1866 ptrace-stopped, e.g., due to scheduler-locking.
1868 So what we do is we delete the leader anyhow, and then
1869 later on when we see its exit status, we re-add it back.
1870 We also make sure that we only report a whole-process
1871 exit when we see the leader exiting, as opposed to when
1872 the last LWP in the LWP list exits, which can be a
1873 non-leader if we deleted the leader here. */
1874 threads_debug_printf ("Thread group leader %d zombie "
1875 "(it exited, or another thread execd), "
1878 delete_lwp (leader_lp
);
1883 /* Callback for `find_thread'. Returns the first LWP that is not
1887 not_stopped_callback (thread_info
*thread
, ptid_t filter
)
1889 if (!thread
->id
.matches (filter
))
1892 lwp_info
*lwp
= get_thread_lwp (thread
);
1894 return !lwp
->stopped
;
1897 /* Increment LWP's suspend count. */
1900 lwp_suspended_inc (struct lwp_info
*lwp
)
1904 if (lwp
->suspended
> 4)
1905 threads_debug_printf
1906 ("LWP %ld has a suspiciously high suspend count, suspended=%d",
1907 lwpid_of (get_lwp_thread (lwp
)), lwp
->suspended
);
1910 /* Decrement LWP's suspend count. */
1913 lwp_suspended_decr (struct lwp_info
*lwp
)
1917 if (lwp
->suspended
< 0)
1919 struct thread_info
*thread
= get_lwp_thread (lwp
);
1921 internal_error ("unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread
),
1926 /* This function should only be called if the LWP got a SIGTRAP.
1928 Handle any tracepoint steps or hits. Return true if a tracepoint
1929 event was handled, 0 otherwise. */
1932 handle_tracepoints (struct lwp_info
*lwp
)
1934 struct thread_info
*tinfo
= get_lwp_thread (lwp
);
1935 int tpoint_related_event
= 0;
1937 gdb_assert (lwp
->suspended
== 0);
1939 /* If this tracepoint hit causes a tracing stop, we'll immediately
1940 uninsert tracepoints. To do this, we temporarily pause all
1941 threads, unpatch away, and then unpause threads. We need to make
1942 sure the unpausing doesn't resume LWP too. */
1943 lwp_suspended_inc (lwp
);
1945 /* And we need to be sure that any all-threads-stopping doesn't try
1946 to move threads out of the jump pads, as it could deadlock the
1947 inferior (LWP could be in the jump pad, maybe even holding the
1950 /* Do any necessary step collect actions. */
1951 tpoint_related_event
|= tracepoint_finished_step (tinfo
, lwp
->stop_pc
);
1953 tpoint_related_event
|= handle_tracepoint_bkpts (tinfo
, lwp
->stop_pc
);
1955 /* See if we just hit a tracepoint and do its main collect
1957 tpoint_related_event
|= tracepoint_was_hit (tinfo
, lwp
->stop_pc
);
1959 lwp_suspended_decr (lwp
);
1961 gdb_assert (lwp
->suspended
== 0);
1962 gdb_assert (!stabilizing_threads
1963 || (lwp
->collecting_fast_tracepoint
1964 != fast_tpoint_collect_result::not_collecting
));
1966 if (tpoint_related_event
)
1968 threads_debug_printf ("got a tracepoint event");
1975 fast_tpoint_collect_result
1976 linux_process_target::linux_fast_tracepoint_collecting
1977 (lwp_info
*lwp
, fast_tpoint_collect_status
*status
)
1979 CORE_ADDR thread_area
;
1980 struct thread_info
*thread
= get_lwp_thread (lwp
);
1982 /* Get the thread area address. This is used to recognize which
1983 thread is which when tracing with the in-process agent library.
1984 We don't read anything from the address, and treat it as opaque;
1985 it's the address itself that we assume is unique per-thread. */
1986 if (low_get_thread_area (lwpid_of (thread
), &thread_area
) == -1)
1987 return fast_tpoint_collect_result::not_collecting
;
1989 return fast_tracepoint_collecting (thread_area
, lwp
->stop_pc
, status
);
1993 linux_process_target::low_get_thread_area (int lwpid
, CORE_ADDR
*addrp
)
1999 linux_process_target::maybe_move_out_of_jump_pad (lwp_info
*lwp
, int *wstat
)
2001 scoped_restore_current_thread restore_thread
;
2002 switch_to_thread (get_lwp_thread (lwp
));
2005 || (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) != SIGTRAP
))
2006 && supports_fast_tracepoints ()
2007 && agent_loaded_p ())
2009 struct fast_tpoint_collect_status status
;
2011 threads_debug_printf
2012 ("Checking whether LWP %ld needs to move out of the jump pad.",
2013 lwpid_of (current_thread
));
2015 fast_tpoint_collect_result r
2016 = linux_fast_tracepoint_collecting (lwp
, &status
);
2019 || (WSTOPSIG (*wstat
) != SIGILL
2020 && WSTOPSIG (*wstat
) != SIGFPE
2021 && WSTOPSIG (*wstat
) != SIGSEGV
2022 && WSTOPSIG (*wstat
) != SIGBUS
))
2024 lwp
->collecting_fast_tracepoint
= r
;
2026 if (r
!= fast_tpoint_collect_result::not_collecting
)
2028 if (r
== fast_tpoint_collect_result::before_insn
2029 && lwp
->exit_jump_pad_bkpt
== NULL
)
2031 /* Haven't executed the original instruction yet.
2032 Set breakpoint there, and wait till it's hit,
2033 then single-step until exiting the jump pad. */
2034 lwp
->exit_jump_pad_bkpt
2035 = set_breakpoint_at (status
.adjusted_insn_addr
, NULL
);
2038 threads_debug_printf
2039 ("Checking whether LWP %ld needs to move out of the jump pad..."
2040 " it does", lwpid_of (current_thread
));
2047 /* If we get a synchronous signal while collecting, *and*
2048 while executing the (relocated) original instruction,
2049 reset the PC to point at the tpoint address, before
2050 reporting to GDB. Otherwise, it's an IPA lib bug: just
2051 report the signal to GDB, and pray for the best. */
2053 lwp
->collecting_fast_tracepoint
2054 = fast_tpoint_collect_result::not_collecting
;
2056 if (r
!= fast_tpoint_collect_result::not_collecting
2057 && (status
.adjusted_insn_addr
<= lwp
->stop_pc
2058 && lwp
->stop_pc
< status
.adjusted_insn_addr_end
))
2061 struct regcache
*regcache
;
2063 /* The si_addr on a few signals references the address
2064 of the faulting instruction. Adjust that as
2066 if ((WSTOPSIG (*wstat
) == SIGILL
2067 || WSTOPSIG (*wstat
) == SIGFPE
2068 || WSTOPSIG (*wstat
) == SIGBUS
2069 || WSTOPSIG (*wstat
) == SIGSEGV
)
2070 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
2071 (PTRACE_TYPE_ARG3
) 0, &info
) == 0
2072 /* Final check just to make sure we don't clobber
2073 the siginfo of non-kernel-sent signals. */
2074 && (uintptr_t) info
.si_addr
== lwp
->stop_pc
)
2076 info
.si_addr
= (void *) (uintptr_t) status
.tpoint_addr
;
2077 ptrace (PTRACE_SETSIGINFO
, lwpid_of (current_thread
),
2078 (PTRACE_TYPE_ARG3
) 0, &info
);
2081 regcache
= get_thread_regcache (current_thread
, 1);
2082 low_set_pc (regcache
, status
.tpoint_addr
);
2083 lwp
->stop_pc
= status
.tpoint_addr
;
2085 /* Cancel any fast tracepoint lock this thread was
2087 force_unlock_trace_buffer ();
2090 if (lwp
->exit_jump_pad_bkpt
!= NULL
)
2092 threads_debug_printf
2093 ("Cancelling fast exit-jump-pad: removing bkpt."
2094 "stopping all threads momentarily.");
2096 stop_all_lwps (1, lwp
);
2098 delete_breakpoint (lwp
->exit_jump_pad_bkpt
);
2099 lwp
->exit_jump_pad_bkpt
= NULL
;
2101 unstop_all_lwps (1, lwp
);
2103 gdb_assert (lwp
->suspended
>= 0);
2108 threads_debug_printf
2109 ("Checking whether LWP %ld needs to move out of the jump pad... no",
2110 lwpid_of (current_thread
));
2115 /* Enqueue one signal in the "signals to report later when out of the
2119 enqueue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2121 struct thread_info
*thread
= get_lwp_thread (lwp
);
2123 threads_debug_printf ("Deferring signal %d for LWP %ld.",
2124 WSTOPSIG (*wstat
), lwpid_of (thread
));
2128 for (const auto &sig
: lwp
->pending_signals_to_report
)
2129 threads_debug_printf (" Already queued %d", sig
.signal
);
2131 threads_debug_printf (" (no more currently queued signals)");
2134 /* Don't enqueue non-RT signals if they are already in the deferred
2135 queue. (SIGSTOP being the easiest signal to see ending up here
2137 if (WSTOPSIG (*wstat
) < __SIGRTMIN
)
2139 for (const auto &sig
: lwp
->pending_signals_to_report
)
2141 if (sig
.signal
== WSTOPSIG (*wstat
))
2143 threads_debug_printf
2144 ("Not requeuing already queued non-RT signal %d for LWP %ld",
2145 sig
.signal
, lwpid_of (thread
));
2151 lwp
->pending_signals_to_report
.emplace_back (WSTOPSIG (*wstat
));
2153 ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2154 &lwp
->pending_signals_to_report
.back ().info
);
2157 /* Dequeue one signal from the "signals to report later when out of
2158 the jump pad" list. */
2161 dequeue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2163 struct thread_info
*thread
= get_lwp_thread (lwp
);
2165 if (!lwp
->pending_signals_to_report
.empty ())
2167 const pending_signal
&p_sig
= lwp
->pending_signals_to_report
.front ();
2169 *wstat
= W_STOPCODE (p_sig
.signal
);
2170 if (p_sig
.info
.si_signo
!= 0)
2171 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2174 lwp
->pending_signals_to_report
.pop_front ();
2176 threads_debug_printf ("Reporting deferred signal %d for LWP %ld.",
2177 WSTOPSIG (*wstat
), lwpid_of (thread
));
2181 for (const auto &sig
: lwp
->pending_signals_to_report
)
2182 threads_debug_printf (" Still queued %d", sig
.signal
);
2184 threads_debug_printf (" (no more queued signals)");
2194 linux_process_target::check_stopped_by_watchpoint (lwp_info
*child
)
2196 scoped_restore_current_thread restore_thread
;
2197 switch_to_thread (get_lwp_thread (child
));
2199 if (low_stopped_by_watchpoint ())
2201 child
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
2202 child
->stopped_data_address
= low_stopped_data_address ();
2205 return child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2209 linux_process_target::low_stopped_by_watchpoint ()
2215 linux_process_target::low_stopped_data_address ()
2220 /* Return the ptrace options that we want to try to enable. */
2223 linux_low_ptrace_options (int attached
)
2225 client_state
&cs
= get_client_state ();
2229 options
|= PTRACE_O_EXITKILL
;
2231 if (cs
.report_fork_events
)
2232 options
|= PTRACE_O_TRACEFORK
;
2234 if (cs
.report_vfork_events
)
2235 options
|= (PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEVFORKDONE
);
2237 if (cs
.report_exec_events
)
2238 options
|= PTRACE_O_TRACEEXEC
;
2240 options
|= PTRACE_O_TRACESYSGOOD
;
2246 linux_process_target::filter_event (int lwpid
, int wstat
)
2248 struct lwp_info
*child
;
2249 struct thread_info
*thread
;
2250 int have_stop_pc
= 0;
2252 child
= find_lwp_pid (ptid_t (lwpid
));
2254 /* Check for events reported by anything not in our LWP list. */
2255 if (child
== nullptr)
2257 if (WIFSTOPPED (wstat
))
2259 if (WSTOPSIG (wstat
) == SIGTRAP
2260 && linux_ptrace_get_extended_event (wstat
) == PTRACE_EVENT_EXEC
)
2262 /* A non-leader thread exec'ed after we've seen the
2263 leader zombie, and removed it from our lists (in
2264 check_zombie_leaders). The non-leader thread changes
2265 its tid to the tgid. */
2266 threads_debug_printf
2267 ("Re-adding thread group leader LWP %d after exec.",
2270 child
= add_lwp (ptid_t (lwpid
, lwpid
));
2272 switch_to_thread (child
->thread
);
2276 /* A process we are controlling has forked and the new
2277 child's stop was reported to us by the kernel. Save
2278 its PID and go back to waiting for the fork event to
2279 be reported - the stopped process might be returned
2280 from waitpid before or after the fork event is. */
2281 threads_debug_printf
2282 ("Saving LWP %d status %s in stopped_pids list",
2283 lwpid
, status_to_str (wstat
).c_str ());
2284 add_to_pid_list (&stopped_pids
, lwpid
, wstat
);
2289 /* Don't report an event for the exit of an LWP not in our
2290 list, i.e. not part of any inferior we're debugging.
2291 This can happen if we detach from a program we originally
2292 forked and then it exits. However, note that we may have
2293 earlier deleted a leader of an inferior we're debugging,
2294 in check_zombie_leaders. Re-add it back here if so. */
2295 find_process ([&] (process_info
*proc
)
2297 if (proc
->pid
== lwpid
)
2299 threads_debug_printf
2300 ("Re-adding thread group leader LWP %d after exit.",
2303 child
= add_lwp (ptid_t (lwpid
, lwpid
));
2310 if (child
== nullptr)
2314 thread
= get_lwp_thread (child
);
2318 child
->last_status
= wstat
;
2320 /* Check if the thread has exited. */
2321 if ((WIFEXITED (wstat
) || WIFSIGNALED (wstat
)))
2323 threads_debug_printf ("%d exited", lwpid
);
2325 if (finish_step_over (child
))
2327 /* Unsuspend all other LWPs, and set them back running again. */
2328 unsuspend_all_lwps (child
);
2331 /* If this is not the leader LWP, then the exit signal was not
2332 the end of the debugged application and should be ignored,
2333 unless GDB wants to hear about thread exits. */
2334 if (report_exit_events_for (thread
) || is_leader (thread
))
2336 /* Since events are serialized to GDB core, and we can't
2337 report this one right now. Leave the status pending for
2338 the next time we're able to report it. */
2339 mark_lwp_dead (child
, wstat
);
2349 gdb_assert (WIFSTOPPED (wstat
));
2351 if (WIFSTOPPED (wstat
))
2353 struct process_info
*proc
;
2355 /* Architecture-specific setup after inferior is running. */
2356 proc
= find_process_pid (pid_of (thread
));
2357 if (proc
->tdesc
== NULL
)
2361 /* This needs to happen after we have attached to the
2362 inferior and it is stopped for the first time, but
2363 before we access any inferior registers. */
2364 arch_setup_thread (thread
);
2368 /* The process is started, but GDBserver will do
2369 architecture-specific setup after the program stops at
2370 the first instruction. */
2371 child
->status_pending_p
= 1;
2372 child
->status_pending
= wstat
;
2378 if (WIFSTOPPED (wstat
) && child
->must_set_ptrace_flags
)
2380 struct process_info
*proc
= find_process_pid (pid_of (thread
));
2381 int options
= linux_low_ptrace_options (proc
->attached
);
2383 linux_enable_event_reporting (lwpid
, options
);
2384 child
->must_set_ptrace_flags
= 0;
2387 /* Always update syscall_state, even if it will be filtered later. */
2388 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SYSCALL_SIGTRAP
)
2390 child
->syscall_state
2391 = (child
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
2392 ? TARGET_WAITKIND_SYSCALL_RETURN
2393 : TARGET_WAITKIND_SYSCALL_ENTRY
);
2397 /* Almost all other ptrace-stops are known to be outside of system
2398 calls, with further exceptions in handle_extended_wait. */
2399 child
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2402 /* Be careful to not overwrite stop_pc until save_stop_reason is
2404 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGTRAP
2405 && linux_is_extended_waitstatus (wstat
))
2407 child
->stop_pc
= get_pc (child
);
2408 if (handle_extended_wait (&child
, wstat
))
2410 /* The event has been handled, so just return without
2416 if (linux_wstatus_maybe_breakpoint (wstat
))
2418 if (save_stop_reason (child
))
2423 child
->stop_pc
= get_pc (child
);
2425 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGSTOP
2426 && child
->stop_expected
)
2428 threads_debug_printf ("Expected stop.");
2430 child
->stop_expected
= 0;
2432 if (thread
->last_resume_kind
== resume_stop
)
2434 /* We want to report the stop to the core. Treat the
2435 SIGSTOP as a normal event. */
2436 threads_debug_printf ("resume_stop SIGSTOP caught for %s.",
2437 target_pid_to_str (ptid_of (thread
)).c_str ());
2439 else if (stopping_threads
!= NOT_STOPPING_THREADS
)
2441 /* Stopping threads. We don't want this SIGSTOP to end up
2443 threads_debug_printf ("SIGSTOP caught for %s while stopping threads.",
2444 target_pid_to_str (ptid_of (thread
)).c_str ());
2449 /* This is a delayed SIGSTOP. Filter out the event. */
2450 threads_debug_printf ("%s %s, 0, 0 (discard delayed SIGSTOP)",
2451 child
->stepping
? "step" : "continue",
2452 target_pid_to_str (ptid_of (thread
)).c_str ());
2454 resume_one_lwp (child
, child
->stepping
, 0, NULL
);
2459 child
->status_pending_p
= 1;
2460 child
->status_pending
= wstat
;
2465 linux_process_target::maybe_hw_step (thread_info
*thread
)
2467 if (supports_hardware_single_step ())
2471 /* GDBserver must insert single-step breakpoint for software
2473 gdb_assert (has_single_step_breakpoints (thread
));
2479 linux_process_target::resume_stopped_resumed_lwps (thread_info
*thread
)
2481 struct lwp_info
*lp
= get_thread_lwp (thread
);
2485 && !lp
->status_pending_p
2486 && thread
->last_status
.kind () == TARGET_WAITKIND_IGNORE
)
2490 if (thread
->last_resume_kind
== resume_step
)
2492 if (supports_software_single_step ())
2493 install_software_single_step_breakpoints (lp
);
2495 step
= maybe_hw_step (thread
);
2498 threads_debug_printf ("resuming stopped-resumed LWP %s at %s: step=%d",
2499 target_pid_to_str (ptid_of (thread
)).c_str (),
2500 paddress (lp
->stop_pc
), step
);
2502 resume_one_lwp (lp
, step
, GDB_SIGNAL_0
, NULL
);
2507 linux_process_target::wait_for_event_filtered (ptid_t wait_ptid
,
2509 int *wstatp
, int options
)
2511 struct thread_info
*event_thread
;
2512 struct lwp_info
*event_child
, *requested_child
;
2513 sigset_t block_mask
, prev_mask
;
2516 /* N.B. event_thread points to the thread_info struct that contains
2517 event_child. Keep them in sync. */
2518 event_thread
= NULL
;
2520 requested_child
= NULL
;
2522 /* Check for a lwp with a pending status. */
2524 if (filter_ptid
== minus_one_ptid
|| filter_ptid
.is_pid ())
2526 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2528 return status_pending_p_callback (thread
, filter_ptid
);
2531 if (event_thread
!= NULL
)
2533 event_child
= get_thread_lwp (event_thread
);
2534 threads_debug_printf ("Got a pending child %ld", lwpid_of (event_thread
));
2537 else if (filter_ptid
!= null_ptid
)
2539 requested_child
= find_lwp_pid (filter_ptid
);
2540 gdb_assert (requested_child
!= nullptr);
2542 if (stopping_threads
== NOT_STOPPING_THREADS
2543 && requested_child
->status_pending_p
2544 && (requested_child
->collecting_fast_tracepoint
2545 != fast_tpoint_collect_result::not_collecting
))
2547 enqueue_one_deferred_signal (requested_child
,
2548 &requested_child
->status_pending
);
2549 requested_child
->status_pending_p
= 0;
2550 requested_child
->status_pending
= 0;
2551 resume_one_lwp (requested_child
, 0, 0, NULL
);
2554 if (requested_child
->suspended
2555 && requested_child
->status_pending_p
)
2557 internal_error ("requesting an event out of a"
2558 " suspended child?");
2561 if (requested_child
->status_pending_p
)
2563 event_child
= requested_child
;
2564 event_thread
= get_lwp_thread (event_child
);
2568 if (event_child
!= NULL
)
2570 threads_debug_printf ("Got an event from pending child %ld (%04x)",
2571 lwpid_of (event_thread
),
2572 event_child
->status_pending
);
2574 *wstatp
= event_child
->status_pending
;
2575 event_child
->status_pending_p
= 0;
2576 event_child
->status_pending
= 0;
2577 switch_to_thread (event_thread
);
2578 return lwpid_of (event_thread
);
2581 /* But if we don't find a pending event, we'll have to wait.
2583 We only enter this loop if no process has a pending wait status.
2584 Thus any action taken in response to a wait status inside this
2585 loop is responding as soon as we detect the status, not after any
2588 /* Make sure SIGCHLD is blocked until the sigsuspend below. Block
2589 all signals while here. */
2590 sigfillset (&block_mask
);
2591 gdb_sigmask (SIG_BLOCK
, &block_mask
, &prev_mask
);
2593 /* Always pull all events out of the kernel. We'll randomly select
2594 an event LWP out of all that have events, to prevent
2596 while (event_child
== NULL
)
2600 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
2603 - If the thread group leader exits while other threads in the
2604 thread group still exist, waitpid(TGID, ...) hangs. That
2605 waitpid won't return an exit status until the other threads
2606 in the group are reaped.
2608 - When a non-leader thread execs, that thread just vanishes
2609 without reporting an exit (so we'd hang if we waited for it
2610 explicitly in that case). The exec event is reported to
2613 ret
= my_waitpid (-1, wstatp
, options
| WNOHANG
);
2615 threads_debug_printf ("waitpid(-1, ...) returned %d, %s",
2616 ret
, errno
? safe_strerror (errno
) : "ERRNO-OK");
2620 threads_debug_printf ("waitpid %ld received %s",
2621 (long) ret
, status_to_str (*wstatp
).c_str ());
2623 /* Filter all events. IOW, leave all events pending. We'll
2624 randomly select an event LWP out of all that have events
2626 filter_event (ret
, *wstatp
);
2627 /* Retry until nothing comes out of waitpid. A single
2628 SIGCHLD can indicate more than one child stopped. */
2632 /* Now that we've pulled all events out of the kernel, resume
2633 LWPs that don't have an interesting event to report. */
2634 if (stopping_threads
== NOT_STOPPING_THREADS
)
2635 for_each_thread ([this] (thread_info
*thread
)
2637 resume_stopped_resumed_lwps (thread
);
2640 /* ... and find an LWP with a status to report to the core, if
2642 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2644 return status_pending_p_callback (thread
, filter_ptid
);
2647 if (event_thread
!= NULL
)
2649 event_child
= get_thread_lwp (event_thread
);
2650 *wstatp
= event_child
->status_pending
;
2651 event_child
->status_pending_p
= 0;
2652 event_child
->status_pending
= 0;
2656 /* Check for zombie thread group leaders. Those can't be reaped
2657 until all other threads in the thread group are. */
2658 check_zombie_leaders ();
2660 auto not_stopped
= [&] (thread_info
*thread
)
2662 return not_stopped_callback (thread
, wait_ptid
);
2665 /* If there are no resumed children left in the set of LWPs we
2666 want to wait for, bail. We can't just block in
2667 waitpid/sigsuspend, because lwps might have been left stopped
2668 in trace-stop state, and we'd be stuck forever waiting for
2669 their status to change (which would only happen if we resumed
2670 them). Even if WNOHANG is set, this return code is preferred
2671 over 0 (below), as it is more detailed. */
2672 if (find_thread (not_stopped
) == NULL
)
2674 threads_debug_printf ("exit (no unwaited-for LWP)");
2676 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2680 /* No interesting event to report to the caller. */
2681 if ((options
& WNOHANG
))
2683 threads_debug_printf ("WNOHANG set, no event found");
2685 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2689 /* Block until we get an event reported with SIGCHLD. */
2690 threads_debug_printf ("sigsuspend'ing");
2692 sigsuspend (&prev_mask
);
2693 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2697 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2699 switch_to_thread (event_thread
);
2701 return lwpid_of (event_thread
);
2705 linux_process_target::wait_for_event (ptid_t ptid
, int *wstatp
, int options
)
2707 return wait_for_event_filtered (ptid
, ptid
, wstatp
, options
);
2710 /* Select one LWP out of those that have events pending. */
2713 select_event_lwp (struct lwp_info
**orig_lp
)
2715 struct thread_info
*event_thread
= NULL
;
2717 /* In all-stop, give preference to the LWP that is being
2718 single-stepped. There will be at most one, and it's the LWP that
2719 the core is most interested in. If we didn't do this, then we'd
2720 have to handle pending step SIGTRAPs somehow in case the core
2721 later continues the previously-stepped thread, otherwise we'd
2722 report the pending SIGTRAP, and the core, not having stepped the
2723 thread, wouldn't understand what the trap was for, and therefore
2724 would report it to the user as a random signal. */
2727 event_thread
= find_thread ([] (thread_info
*thread
)
2729 lwp_info
*lp
= get_thread_lwp (thread
);
2731 return (thread
->last_status
.kind () == TARGET_WAITKIND_IGNORE
2732 && thread
->last_resume_kind
== resume_step
2733 && lp
->status_pending_p
);
2736 if (event_thread
!= NULL
)
2737 threads_debug_printf
2738 ("Select single-step %s",
2739 target_pid_to_str (ptid_of (event_thread
)).c_str ());
2741 if (event_thread
== NULL
)
2743 /* No single-stepping LWP. Select one at random, out of those
2744 which have had events. */
2746 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2748 lwp_info
*lp
= get_thread_lwp (thread
);
2750 /* Only resumed LWPs that have an event pending. */
2751 return (thread
->last_status
.kind () == TARGET_WAITKIND_IGNORE
2752 && lp
->status_pending_p
);
2756 if (event_thread
!= NULL
)
2758 struct lwp_info
*event_lp
= get_thread_lwp (event_thread
);
2760 /* Switch the event LWP. */
2761 *orig_lp
= event_lp
;
2765 /* Decrement the suspend count of all LWPs, except EXCEPT, if non
2769 unsuspend_all_lwps (struct lwp_info
*except
)
2771 for_each_thread ([&] (thread_info
*thread
)
2773 lwp_info
*lwp
= get_thread_lwp (thread
);
2776 lwp_suspended_decr (lwp
);
2780 static bool lwp_running (thread_info
*thread
);
2782 /* Stabilize threads (move out of jump pads).
2784 If a thread is midway collecting a fast tracepoint, we need to
2785 finish the collection and move it out of the jump pad before
2786 reporting the signal.
2788 This avoids recursion while collecting (when a signal arrives
2789 midway, and the signal handler itself collects), which would trash
2790 the trace buffer. In case the user set a breakpoint in a signal
2791 handler, this avoids the backtrace showing the jump pad, etc..
2792 Most importantly, there are certain things we can't do safely if
2793 threads are stopped in a jump pad (or in its callee's). For
2796 - starting a new trace run. A thread still collecting the
2797 previous run, could trash the trace buffer when resumed. The trace
2798 buffer control structures would have been reset but the thread had
2799 no way to tell. The thread could even midway memcpy'ing to the
2800 buffer, which would mean that when resumed, it would clobber the
2801 trace buffer that had been set for a new run.
2803 - we can't rewrite/reuse the jump pads for new tracepoints
2804 safely. Say you do tstart while a thread is stopped midway while
2805 collecting. When the thread is later resumed, it finishes the
2806 collection, and returns to the jump pad, to execute the original
2807 instruction that was under the tracepoint jump at the time the
2808 older run had been started. If the jump pad had been rewritten
2809 since for something else in the new run, the thread would now
2810 execute the wrong / random instructions. */
2813 linux_process_target::stabilize_threads ()
2815 thread_info
*thread_stuck
= find_thread ([this] (thread_info
*thread
)
2817 return stuck_in_jump_pad (thread
);
2820 if (thread_stuck
!= NULL
)
2822 threads_debug_printf ("can't stabilize, LWP %ld is stuck in jump pad",
2823 lwpid_of (thread_stuck
));
2827 scoped_restore_current_thread restore_thread
;
2829 stabilizing_threads
= 1;
2832 for_each_thread ([this] (thread_info
*thread
)
2834 move_out_of_jump_pad (thread
);
2837 /* Loop until all are stopped out of the jump pads. */
2838 while (find_thread (lwp_running
) != NULL
)
2840 struct target_waitstatus ourstatus
;
2841 struct lwp_info
*lwp
;
2844 /* Note that we go through the full wait even loop. While
2845 moving threads out of jump pad, we need to be able to step
2846 over internal breakpoints and such. */
2847 wait_1 (minus_one_ptid
, &ourstatus
, 0);
2849 if (ourstatus
.kind () == TARGET_WAITKIND_STOPPED
)
2851 lwp
= get_thread_lwp (current_thread
);
2854 lwp_suspended_inc (lwp
);
2856 if (ourstatus
.sig () != GDB_SIGNAL_0
2857 || current_thread
->last_resume_kind
== resume_stop
)
2859 wstat
= W_STOPCODE (gdb_signal_to_host (ourstatus
.sig ()));
2860 enqueue_one_deferred_signal (lwp
, &wstat
);
2865 unsuspend_all_lwps (NULL
);
2867 stabilizing_threads
= 0;
2871 thread_stuck
= find_thread ([this] (thread_info
*thread
)
2873 return stuck_in_jump_pad (thread
);
2876 if (thread_stuck
!= NULL
)
2877 threads_debug_printf
2878 ("couldn't stabilize, LWP %ld got stuck in jump pad",
2879 lwpid_of (thread_stuck
));
2883 /* Convenience function that is called when the kernel reports an
2884 event that is not passed out to GDB. */
2887 ignore_event (struct target_waitstatus
*ourstatus
)
2889 /* If we got an event, there may still be others, as a single
2890 SIGCHLD can indicate more than one child stopped. This forces
2891 another target_wait call. */
2894 ourstatus
->set_ignore ();
2899 linux_process_target::filter_exit_event (lwp_info
*event_child
,
2900 target_waitstatus
*ourstatus
)
2902 struct thread_info
*thread
= get_lwp_thread (event_child
);
2903 ptid_t ptid
= ptid_of (thread
);
2905 /* Note we must filter TARGET_WAITKIND_SIGNALLED as well, otherwise
2906 if a non-leader thread exits with a signal, we'd report it to the
2907 core which would interpret it as the whole-process exiting.
2908 There is no TARGET_WAITKIND_THREAD_SIGNALLED event kind. */
2909 if (ourstatus
->kind () != TARGET_WAITKIND_EXITED
2910 && ourstatus
->kind () != TARGET_WAITKIND_SIGNALLED
)
2913 if (!is_leader (thread
))
2915 if (report_exit_events_for (thread
))
2916 ourstatus
->set_thread_exited (0);
2918 ourstatus
->set_ignore ();
2920 delete_lwp (event_child
);
2925 /* Returns 1 if GDB is interested in any event_child syscalls. */
2928 gdb_catching_syscalls_p (struct lwp_info
*event_child
)
2930 struct thread_info
*thread
= get_lwp_thread (event_child
);
2931 struct process_info
*proc
= get_thread_process (thread
);
2933 return !proc
->syscalls_to_catch
.empty ();
2937 linux_process_target::gdb_catch_this_syscall (lwp_info
*event_child
)
2940 struct thread_info
*thread
= get_lwp_thread (event_child
);
2941 struct process_info
*proc
= get_thread_process (thread
);
2943 if (proc
->syscalls_to_catch
.empty ())
2946 if (proc
->syscalls_to_catch
[0] == ANY_SYSCALL
)
2949 get_syscall_trapinfo (event_child
, &sysno
);
2951 for (int iter
: proc
->syscalls_to_catch
)
2959 linux_process_target::wait_1 (ptid_t ptid
, target_waitstatus
*ourstatus
,
2960 target_wait_flags target_options
)
2962 THREADS_SCOPED_DEBUG_ENTER_EXIT
;
2964 client_state
&cs
= get_client_state ();
2966 struct lwp_info
*event_child
;
2969 int step_over_finished
;
2970 int bp_explains_trap
;
2971 int maybe_internal_trap
;
2977 threads_debug_printf ("[%s]", target_pid_to_str (ptid
).c_str ());
2979 /* Translate generic target options into linux options. */
2981 if (target_options
& TARGET_WNOHANG
)
2984 bp_explains_trap
= 0;
2987 ourstatus
->set_ignore ();
2989 auto status_pending_p_any
= [&] (thread_info
*thread
)
2991 return status_pending_p_callback (thread
, minus_one_ptid
);
2994 auto not_stopped
= [&] (thread_info
*thread
)
2996 return not_stopped_callback (thread
, minus_one_ptid
);
2999 /* Find a resumed LWP, if any. */
3000 if (find_thread (status_pending_p_any
) != NULL
)
3002 else if (find_thread (not_stopped
) != NULL
)
3007 if (step_over_bkpt
== null_ptid
)
3008 pid
= wait_for_event (ptid
, &w
, options
);
3011 threads_debug_printf ("step_over_bkpt set [%s], doing a blocking wait",
3012 target_pid_to_str (step_over_bkpt
).c_str ());
3013 pid
= wait_for_event (step_over_bkpt
, &w
, options
& ~WNOHANG
);
3016 if (pid
== 0 || (pid
== -1 && !any_resumed
))
3018 gdb_assert (target_options
& TARGET_WNOHANG
);
3020 threads_debug_printf ("ret = null_ptid, TARGET_WAITKIND_IGNORE");
3022 ourstatus
->set_ignore ();
3027 threads_debug_printf ("ret = null_ptid, TARGET_WAITKIND_NO_RESUMED");
3029 ourstatus
->set_no_resumed ();
3033 event_child
= get_thread_lwp (current_thread
);
3035 /* wait_for_event only returns an exit status for the last
3036 child of a process. Report it. */
3037 if (WIFEXITED (w
) || WIFSIGNALED (w
))
3041 ourstatus
->set_exited (WEXITSTATUS (w
));
3043 threads_debug_printf
3044 ("ret = %s, exited with retcode %d",
3045 target_pid_to_str (ptid_of (current_thread
)).c_str (),
3050 ourstatus
->set_signalled (gdb_signal_from_host (WTERMSIG (w
)));
3052 threads_debug_printf
3053 ("ret = %s, terminated with signal %d",
3054 target_pid_to_str (ptid_of (current_thread
)).c_str (),
3058 return filter_exit_event (event_child
, ourstatus
);
3061 /* If step-over executes a breakpoint instruction, in the case of a
3062 hardware single step it means a gdb/gdbserver breakpoint had been
3063 planted on top of a permanent breakpoint, in the case of a software
3064 single step it may just mean that gdbserver hit the reinsert breakpoint.
3065 The PC has been adjusted by save_stop_reason to point at
3066 the breakpoint address.
3067 So in the case of the hardware single step advance the PC manually
3068 past the breakpoint and in the case of software single step advance only
3069 if it's not the single_step_breakpoint we are hitting.
3070 This avoids that a program would keep trapping a permanent breakpoint
3072 if (step_over_bkpt
!= null_ptid
3073 && event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3074 && (event_child
->stepping
3075 || !single_step_breakpoint_inserted_here (event_child
->stop_pc
)))
3077 int increment_pc
= 0;
3078 int breakpoint_kind
= 0;
3079 CORE_ADDR stop_pc
= event_child
->stop_pc
;
3081 breakpoint_kind
= breakpoint_kind_from_current_state (&stop_pc
);
3082 sw_breakpoint_from_kind (breakpoint_kind
, &increment_pc
);
3084 threads_debug_printf
3085 ("step-over for %s executed software breakpoint",
3086 target_pid_to_str (ptid_of (current_thread
)).c_str ());
3088 if (increment_pc
!= 0)
3090 struct regcache
*regcache
3091 = get_thread_regcache (current_thread
, 1);
3093 event_child
->stop_pc
+= increment_pc
;
3094 low_set_pc (regcache
, event_child
->stop_pc
);
3096 if (!low_breakpoint_at (event_child
->stop_pc
))
3097 event_child
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3101 /* If this event was not handled before, and is not a SIGTRAP, we
3102 report it. SIGILL and SIGSEGV are also treated as traps in case
3103 a breakpoint is inserted at the current PC. If this target does
3104 not support internal breakpoints at all, we also report the
3105 SIGTRAP without further processing; it's of no concern to us. */
3107 = (low_supports_breakpoints ()
3108 && (WSTOPSIG (w
) == SIGTRAP
3109 || ((WSTOPSIG (w
) == SIGILL
3110 || WSTOPSIG (w
) == SIGSEGV
)
3111 && low_breakpoint_at (event_child
->stop_pc
))));
3113 if (maybe_internal_trap
)
3115 /* Handle anything that requires bookkeeping before deciding to
3116 report the event or continue waiting. */
3118 /* First check if we can explain the SIGTRAP with an internal
3119 breakpoint, or if we should possibly report the event to GDB.
3120 Do this before anything that may remove or insert a
3122 bp_explains_trap
= breakpoint_inserted_here (event_child
->stop_pc
);
3124 /* We have a SIGTRAP, possibly a step-over dance has just
3125 finished. If so, tweak the state machine accordingly,
3126 reinsert breakpoints and delete any single-step
3128 step_over_finished
= finish_step_over (event_child
);
3130 /* Now invoke the callbacks of any internal breakpoints there. */
3131 check_breakpoints (event_child
->stop_pc
);
3133 /* Handle tracepoint data collecting. This may overflow the
3134 trace buffer, and cause a tracing stop, removing
3136 trace_event
= handle_tracepoints (event_child
);
3138 if (bp_explains_trap
)
3139 threads_debug_printf ("Hit a gdbserver breakpoint.");
3143 /* We have some other signal, possibly a step-over dance was in
3144 progress, and it should be cancelled too. */
3145 step_over_finished
= finish_step_over (event_child
);
3148 /* We have all the data we need. Either report the event to GDB, or
3149 resume threads and keep waiting for more. */
3151 /* If we're collecting a fast tracepoint, finish the collection and
3152 move out of the jump pad before delivering a signal. See
3153 linux_stabilize_threads. */
3156 && WSTOPSIG (w
) != SIGTRAP
3157 && supports_fast_tracepoints ()
3158 && agent_loaded_p ())
3160 threads_debug_printf ("Got signal %d for LWP %ld. Check if we need "
3161 "to defer or adjust it.",
3162 WSTOPSIG (w
), lwpid_of (current_thread
));
3164 /* Allow debugging the jump pad itself. */
3165 if (current_thread
->last_resume_kind
!= resume_step
3166 && maybe_move_out_of_jump_pad (event_child
, &w
))
3168 enqueue_one_deferred_signal (event_child
, &w
);
3170 threads_debug_printf ("Signal %d for LWP %ld deferred (in jump pad)",
3171 WSTOPSIG (w
), lwpid_of (current_thread
));
3173 resume_one_lwp (event_child
, 0, 0, NULL
);
3175 return ignore_event (ourstatus
);
3179 if (event_child
->collecting_fast_tracepoint
3180 != fast_tpoint_collect_result::not_collecting
)
3182 threads_debug_printf
3183 ("LWP %ld was trying to move out of the jump pad (%d). "
3184 "Check if we're already there.",
3185 lwpid_of (current_thread
),
3186 (int) event_child
->collecting_fast_tracepoint
);
3190 event_child
->collecting_fast_tracepoint
3191 = linux_fast_tracepoint_collecting (event_child
, NULL
);
3193 if (event_child
->collecting_fast_tracepoint
3194 != fast_tpoint_collect_result::before_insn
)
3196 /* No longer need this breakpoint. */
3197 if (event_child
->exit_jump_pad_bkpt
!= NULL
)
3199 threads_debug_printf
3200 ("No longer need exit-jump-pad bkpt; removing it."
3201 "stopping all threads momentarily.");
3203 /* Other running threads could hit this breakpoint.
3204 We don't handle moribund locations like GDB does,
3205 instead we always pause all threads when removing
3206 breakpoints, so that any step-over or
3207 decr_pc_after_break adjustment is always taken
3208 care of while the breakpoint is still
3210 stop_all_lwps (1, event_child
);
3212 delete_breakpoint (event_child
->exit_jump_pad_bkpt
);
3213 event_child
->exit_jump_pad_bkpt
= NULL
;
3215 unstop_all_lwps (1, event_child
);
3217 gdb_assert (event_child
->suspended
>= 0);
3221 if (event_child
->collecting_fast_tracepoint
3222 == fast_tpoint_collect_result::not_collecting
)
3224 threads_debug_printf
3225 ("fast tracepoint finished collecting successfully.");
3227 /* We may have a deferred signal to report. */
3228 if (dequeue_one_deferred_signal (event_child
, &w
))
3229 threads_debug_printf ("dequeued one signal.");
3232 threads_debug_printf ("no deferred signals.");
3234 if (stabilizing_threads
)
3236 ourstatus
->set_stopped (GDB_SIGNAL_0
);
3238 threads_debug_printf
3239 ("ret = %s, stopped while stabilizing threads",
3240 target_pid_to_str (ptid_of (current_thread
)).c_str ());
3242 return ptid_of (current_thread
);
3248 /* Check whether GDB would be interested in this event. */
3250 /* Check if GDB is interested in this syscall. */
3252 && WSTOPSIG (w
) == SYSCALL_SIGTRAP
3253 && !gdb_catch_this_syscall (event_child
))
3255 threads_debug_printf ("Ignored syscall for LWP %ld.",
3256 lwpid_of (current_thread
));
3258 resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
3260 return ignore_event (ourstatus
);
3263 /* If GDB is not interested in this signal, don't stop other
3264 threads, and don't report it to GDB. Just resume the inferior
3265 right away. We do this for threading-related signals as well as
3266 any that GDB specifically requested we ignore. But never ignore
3267 SIGSTOP if we sent it ourselves, and do not ignore signals when
3268 stepping - they may require special handling to skip the signal
3269 handler. Also never ignore signals that could be caused by a
3272 && current_thread
->last_resume_kind
!= resume_step
3274 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
3275 (current_process ()->priv
->thread_db
!= NULL
3276 && (WSTOPSIG (w
) == __SIGRTMIN
3277 || WSTOPSIG (w
) == __SIGRTMIN
+ 1))
3280 (cs
.pass_signals
[gdb_signal_from_host (WSTOPSIG (w
))]
3281 && !(WSTOPSIG (w
) == SIGSTOP
3282 && current_thread
->last_resume_kind
== resume_stop
)
3283 && !linux_wstatus_maybe_breakpoint (w
))))
3285 siginfo_t info
, *info_p
;
3287 threads_debug_printf ("Ignored signal %d for LWP %ld.",
3288 WSTOPSIG (w
), lwpid_of (current_thread
));
3290 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
3291 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
3296 if (step_over_finished
)
3298 /* We cancelled this thread's step-over above. We still
3299 need to unsuspend all other LWPs, and set them back
3300 running again while the signal handler runs. */
3301 unsuspend_all_lwps (event_child
);
3303 /* Enqueue the pending signal info so that proceed_all_lwps
3305 enqueue_pending_signal (event_child
, WSTOPSIG (w
), info_p
);
3307 proceed_all_lwps ();
3311 resume_one_lwp (event_child
, event_child
->stepping
,
3312 WSTOPSIG (w
), info_p
);
3315 return ignore_event (ourstatus
);
3318 /* Note that all addresses are always "out of the step range" when
3319 there's no range to begin with. */
3320 in_step_range
= lwp_in_step_range (event_child
);
3322 /* If GDB wanted this thread to single step, and the thread is out
3323 of the step range, we always want to report the SIGTRAP, and let
3324 GDB handle it. Watchpoints should always be reported. So should
3325 signals we can't explain. A SIGTRAP we can't explain could be a
3326 GDB breakpoint --- we may or not support Z0 breakpoints. If we
3327 do, we're be able to handle GDB breakpoints on top of internal
3328 breakpoints, by handling the internal breakpoint and still
3329 reporting the event to GDB. If we don't, we're out of luck, GDB
3330 won't see the breakpoint hit. If we see a single-step event but
3331 the thread should be continuing, don't pass the trap to gdb.
3332 That indicates that we had previously finished a single-step but
3333 left the single-step pending -- see
3334 complete_ongoing_step_over. */
3335 report_to_gdb
= (!maybe_internal_trap
3336 || (current_thread
->last_resume_kind
== resume_step
3338 || event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3340 && !bp_explains_trap
3342 && !step_over_finished
3343 && !(current_thread
->last_resume_kind
== resume_continue
3344 && event_child
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
))
3345 || (gdb_breakpoint_here (event_child
->stop_pc
)
3346 && gdb_condition_true_at_breakpoint (event_child
->stop_pc
)
3347 && gdb_no_commands_at_breakpoint (event_child
->stop_pc
))
3348 || event_child
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
);
3350 run_breakpoint_commands (event_child
->stop_pc
);
3352 /* We found no reason GDB would want us to stop. We either hit one
3353 of our own breakpoints, or finished an internal step GDB
3354 shouldn't know about. */
3357 if (bp_explains_trap
)
3358 threads_debug_printf ("Hit a gdbserver breakpoint.");
3360 if (step_over_finished
)
3361 threads_debug_printf ("Step-over finished.");
3364 threads_debug_printf ("Tracepoint event.");
3366 if (lwp_in_step_range (event_child
))
3367 threads_debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).",
3368 paddress (event_child
->stop_pc
),
3369 paddress (event_child
->step_range_start
),
3370 paddress (event_child
->step_range_end
));
3372 /* We're not reporting this breakpoint to GDB, so apply the
3373 decr_pc_after_break adjustment to the inferior's regcache
3376 if (low_supports_breakpoints ())
3378 struct regcache
*regcache
3379 = get_thread_regcache (current_thread
, 1);
3380 low_set_pc (regcache
, event_child
->stop_pc
);
3383 if (step_over_finished
)
3385 /* If we have finished stepping over a breakpoint, we've
3386 stopped and suspended all LWPs momentarily except the
3387 stepping one. This is where we resume them all again.
3388 We're going to keep waiting, so use proceed, which
3389 handles stepping over the next breakpoint. */
3390 unsuspend_all_lwps (event_child
);
3394 /* Remove the single-step breakpoints if any. Note that
3395 there isn't single-step breakpoint if we finished stepping
3397 if (supports_software_single_step ()
3398 && has_single_step_breakpoints (current_thread
))
3400 stop_all_lwps (0, event_child
);
3401 delete_single_step_breakpoints (current_thread
);
3402 unstop_all_lwps (0, event_child
);
3406 threads_debug_printf ("proceeding all threads.");
3408 proceed_all_lwps ();
3410 return ignore_event (ourstatus
);
3415 if (event_child
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
3416 threads_debug_printf ("LWP %ld: extended event with waitstatus %s",
3417 lwpid_of (get_lwp_thread (event_child
)),
3418 event_child
->waitstatus
.to_string ().c_str ());
3420 if (current_thread
->last_resume_kind
== resume_step
)
3422 if (event_child
->step_range_start
== event_child
->step_range_end
)
3423 threads_debug_printf
3424 ("GDB wanted to single-step, reporting event.");
3425 else if (!lwp_in_step_range (event_child
))
3426 threads_debug_printf ("Out of step range, reporting event.");
3429 if (event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
3430 threads_debug_printf ("Stopped by watchpoint.");
3431 else if (gdb_breakpoint_here (event_child
->stop_pc
))
3432 threads_debug_printf ("Stopped by GDB breakpoint.");
3435 threads_debug_printf ("Hit a non-gdbserver trap event.");
3437 /* Alright, we're going to report a stop. */
3439 /* Remove single-step breakpoints. */
3440 if (supports_software_single_step ())
3442 /* Remove single-step breakpoints or not. It it is true, stop all
3443 lwps, so that other threads won't hit the breakpoint in the
3445 int remove_single_step_breakpoints_p
= 0;
3449 remove_single_step_breakpoints_p
3450 = has_single_step_breakpoints (current_thread
);
3454 /* In all-stop, a stop reply cancels all previous resume
3455 requests. Delete all single-step breakpoints. */
3457 find_thread ([&] (thread_info
*thread
) {
3458 if (has_single_step_breakpoints (thread
))
3460 remove_single_step_breakpoints_p
= 1;
3468 if (remove_single_step_breakpoints_p
)
3470 /* If we remove single-step breakpoints from memory, stop all lwps,
3471 so that other threads won't hit the breakpoint in the staled
3473 stop_all_lwps (0, event_child
);
3477 gdb_assert (has_single_step_breakpoints (current_thread
));
3478 delete_single_step_breakpoints (current_thread
);
3482 for_each_thread ([] (thread_info
*thread
){
3483 if (has_single_step_breakpoints (thread
))
3484 delete_single_step_breakpoints (thread
);
3488 unstop_all_lwps (0, event_child
);
3492 if (!stabilizing_threads
)
3494 /* In all-stop, stop all threads. */
3496 stop_all_lwps (0, NULL
);
3498 if (step_over_finished
)
3502 /* If we were doing a step-over, all other threads but
3503 the stepping one had been paused in start_step_over,
3504 with their suspend counts incremented. We don't want
3505 to do a full unstop/unpause, because we're in
3506 all-stop mode (so we want threads stopped), but we
3507 still need to unsuspend the other threads, to
3508 decrement their `suspended' count back. */
3509 unsuspend_all_lwps (event_child
);
3513 /* If we just finished a step-over, then all threads had
3514 been momentarily paused. In all-stop, that's fine,
3515 we want threads stopped by now anyway. In non-stop,
3516 we need to re-resume threads that GDB wanted to be
3518 unstop_all_lwps (1, event_child
);
3522 /* If we're not waiting for a specific LWP, choose an event LWP
3523 from among those that have had events. Giving equal priority
3524 to all LWPs that have had events helps prevent
3526 if (ptid
== minus_one_ptid
)
3528 event_child
->status_pending_p
= 1;
3529 event_child
->status_pending
= w
;
3531 select_event_lwp (&event_child
);
3533 /* current_thread and event_child must stay in sync. */
3534 switch_to_thread (get_lwp_thread (event_child
));
3536 event_child
->status_pending_p
= 0;
3537 w
= event_child
->status_pending
;
3541 /* Stabilize threads (move out of jump pads). */
3543 target_stabilize_threads ();
3547 /* If we just finished a step-over, then all threads had been
3548 momentarily paused. In all-stop, that's fine, we want
3549 threads stopped by now anyway. In non-stop, we need to
3550 re-resume threads that GDB wanted to be running. */
3551 if (step_over_finished
)
3552 unstop_all_lwps (1, event_child
);
3555 /* At this point, we haven't set OURSTATUS. This is where we do it. */
3556 gdb_assert (ourstatus
->kind () == TARGET_WAITKIND_IGNORE
);
3558 if (event_child
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
3560 /* If the reported event is an exit, fork, vfork, clone or exec,
3563 /* Break the unreported fork/vfork/clone relationship chain. */
3564 if (is_new_child_status (event_child
->waitstatus
.kind ()))
3566 event_child
->relative
->relative
= NULL
;
3567 event_child
->relative
= NULL
;
3570 *ourstatus
= event_child
->waitstatus
;
3571 /* Clear the event lwp's waitstatus since we handled it already. */
3572 event_child
->waitstatus
.set_ignore ();
3576 /* The LWP stopped due to a plain signal or a syscall signal. Either way,
3577 event_child->waitstatus wasn't filled in with the details, so look at
3578 the wait status W. */
3579 if (WSTOPSIG (w
) == SYSCALL_SIGTRAP
)
3583 get_syscall_trapinfo (event_child
, &syscall_number
);
3584 if (event_child
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
)
3585 ourstatus
->set_syscall_entry (syscall_number
);
3586 else if (event_child
->syscall_state
== TARGET_WAITKIND_SYSCALL_RETURN
)
3587 ourstatus
->set_syscall_return (syscall_number
);
3589 gdb_assert_not_reached ("unexpected syscall state");
3591 else if (current_thread
->last_resume_kind
== resume_stop
3592 && WSTOPSIG (w
) == SIGSTOP
)
3594 /* A thread that has been requested to stop by GDB with vCont;t,
3595 and it stopped cleanly, so report as SIG0. The use of
3596 SIGSTOP is an implementation detail. */
3597 ourstatus
->set_stopped (GDB_SIGNAL_0
);
3600 ourstatus
->set_stopped (gdb_signal_from_host (WSTOPSIG (w
)));
3603 /* Now that we've selected our final event LWP, un-adjust its PC if
3604 it was a software breakpoint, and the client doesn't know we can
3605 adjust the breakpoint ourselves. */
3606 if (event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3607 && !cs
.swbreak_feature
)
3609 int decr_pc
= low_decr_pc_after_break ();
3613 struct regcache
*regcache
3614 = get_thread_regcache (current_thread
, 1);
3615 low_set_pc (regcache
, event_child
->stop_pc
+ decr_pc
);
3619 gdb_assert (step_over_bkpt
== null_ptid
);
3621 threads_debug_printf ("ret = %s, %s",
3622 target_pid_to_str (ptid_of (current_thread
)).c_str (),
3623 ourstatus
->to_string ().c_str ());
3625 return filter_exit_event (event_child
, ourstatus
);
3628 /* Get rid of any pending event in the pipe. */
3630 async_file_flush (void)
3632 linux_event_pipe
.flush ();
3635 /* Put something in the pipe, so the event loop wakes up. */
3637 async_file_mark (void)
3639 linux_event_pipe
.mark ();
3643 linux_process_target::wait (ptid_t ptid
,
3644 target_waitstatus
*ourstatus
,
3645 target_wait_flags target_options
)
3649 /* Flush the async file first. */
3650 if (target_is_async_p ())
3651 async_file_flush ();
3655 event_ptid
= wait_1 (ptid
, ourstatus
, target_options
);
3657 while ((target_options
& TARGET_WNOHANG
) == 0
3658 && ourstatus
->kind () == TARGET_WAITKIND_IGNORE
);
3660 /* If at least one stop was reported, there may be more. A single
3661 SIGCHLD can signal more than one child stop. */
3662 if (target_is_async_p ()
3663 && (target_options
& TARGET_WNOHANG
) != 0
3664 && event_ptid
!= null_ptid
)
3670 /* Send a signal to an LWP. */
3673 kill_lwp (unsigned long lwpid
, int signo
)
3678 ret
= syscall (__NR_tkill
, lwpid
, signo
);
3679 if (errno
== ENOSYS
)
3681 /* If tkill fails, then we are not using nptl threads, a
3682 configuration we no longer support. */
3683 perror_with_name (("tkill"));
3689 linux_stop_lwp (struct lwp_info
*lwp
)
3695 send_sigstop (struct lwp_info
*lwp
)
3699 pid
= lwpid_of (get_lwp_thread (lwp
));
3701 /* If we already have a pending stop signal for this process, don't
3703 if (lwp
->stop_expected
)
3705 threads_debug_printf ("Have pending sigstop for lwp %d", pid
);
3710 threads_debug_printf ("Sending sigstop to lwp %d", pid
);
3712 lwp
->stop_expected
= 1;
3713 kill_lwp (pid
, SIGSTOP
);
3717 send_sigstop (thread_info
*thread
, lwp_info
*except
)
3719 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3721 /* Ignore EXCEPT. */
3731 /* Increment the suspend count of an LWP, and stop it, if not stopped
3734 suspend_and_send_sigstop (thread_info
*thread
, lwp_info
*except
)
3736 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3738 /* Ignore EXCEPT. */
3742 lwp_suspended_inc (lwp
);
3744 send_sigstop (thread
, except
);
3748 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
3750 /* Store the exit status for later. */
3751 lwp
->status_pending_p
= 1;
3752 lwp
->status_pending
= wstat
;
3754 /* Store in waitstatus as well, as there's nothing else to process
3756 if (WIFEXITED (wstat
))
3757 lwp
->waitstatus
.set_exited (WEXITSTATUS (wstat
));
3758 else if (WIFSIGNALED (wstat
))
3759 lwp
->waitstatus
.set_signalled (gdb_signal_from_host (WTERMSIG (wstat
)));
3761 /* Prevent trying to stop it. */
3764 /* No further stops are expected from a dead lwp. */
3765 lwp
->stop_expected
= 0;
3768 /* Return true if LWP has exited already, and has a pending exit event
3769 to report to GDB. */
3772 lwp_is_marked_dead (struct lwp_info
*lwp
)
3774 return (lwp
->status_pending_p
3775 && (WIFEXITED (lwp
->status_pending
)
3776 || WIFSIGNALED (lwp
->status_pending
)));
3780 linux_process_target::wait_for_sigstop ()
3782 struct thread_info
*saved_thread
;
3787 saved_thread
= current_thread
;
3788 if (saved_thread
!= NULL
)
3789 saved_tid
= saved_thread
->id
;
3791 saved_tid
= null_ptid
; /* avoid bogus unused warning */
3793 scoped_restore_current_thread restore_thread
;
3795 threads_debug_printf ("pulling events");
3797 /* Passing NULL_PTID as filter indicates we want all events to be
3798 left pending. Eventually this returns when there are no
3799 unwaited-for children left. */
3800 ret
= wait_for_event_filtered (minus_one_ptid
, null_ptid
, &wstat
, __WALL
);
3801 gdb_assert (ret
== -1);
3803 if (saved_thread
== NULL
|| mythread_alive (saved_tid
))
3807 threads_debug_printf ("Previously current thread died.");
3809 /* We can't change the current inferior behind GDB's back,
3810 otherwise, a subsequent command may apply to the wrong
3812 restore_thread
.dont_restore ();
3813 switch_to_thread (nullptr);
3818 linux_process_target::stuck_in_jump_pad (thread_info
*thread
)
3820 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3822 if (lwp
->suspended
!= 0)
3824 internal_error ("LWP %ld is suspended, suspended=%d\n",
3825 lwpid_of (thread
), lwp
->suspended
);
3827 gdb_assert (lwp
->stopped
);
3829 /* Allow debugging the jump pad, gdb_collect, etc.. */
3830 return (supports_fast_tracepoints ()
3831 && agent_loaded_p ()
3832 && (gdb_breakpoint_here (lwp
->stop_pc
)
3833 || lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3834 || thread
->last_resume_kind
== resume_step
)
3835 && (linux_fast_tracepoint_collecting (lwp
, NULL
)
3836 != fast_tpoint_collect_result::not_collecting
));
3840 linux_process_target::move_out_of_jump_pad (thread_info
*thread
)
3842 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3845 if (lwp
->suspended
!= 0)
3847 internal_error ("LWP %ld is suspended, suspended=%d\n",
3848 lwpid_of (thread
), lwp
->suspended
);
3850 gdb_assert (lwp
->stopped
);
3852 /* For gdb_breakpoint_here. */
3853 scoped_restore_current_thread restore_thread
;
3854 switch_to_thread (thread
);
3856 wstat
= lwp
->status_pending_p
? &lwp
->status_pending
: NULL
;
3858 /* Allow debugging the jump pad, gdb_collect, etc. */
3859 if (!gdb_breakpoint_here (lwp
->stop_pc
)
3860 && lwp
->stop_reason
!= TARGET_STOPPED_BY_WATCHPOINT
3861 && thread
->last_resume_kind
!= resume_step
3862 && maybe_move_out_of_jump_pad (lwp
, wstat
))
3864 threads_debug_printf ("LWP %ld needs stabilizing (in jump pad)",
3869 lwp
->status_pending_p
= 0;
3870 enqueue_one_deferred_signal (lwp
, wstat
);
3872 threads_debug_printf ("Signal %d for LWP %ld deferred (in jump pad",
3873 WSTOPSIG (*wstat
), lwpid_of (thread
));
3876 resume_one_lwp (lwp
, 0, 0, NULL
);
3879 lwp_suspended_inc (lwp
);
3883 lwp_running (thread_info
*thread
)
3885 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3887 if (lwp_is_marked_dead (lwp
))
3890 return !lwp
->stopped
;
3894 linux_process_target::stop_all_lwps (int suspend
, lwp_info
*except
)
3896 /* Should not be called recursively. */
3897 gdb_assert (stopping_threads
== NOT_STOPPING_THREADS
);
3899 THREADS_SCOPED_DEBUG_ENTER_EXIT
;
3901 threads_debug_printf
3902 ("%s, except=%s", suspend
? "stop-and-suspend" : "stop",
3904 ? target_pid_to_str (ptid_of (get_lwp_thread (except
))).c_str ()
3907 stopping_threads
= (suspend
3908 ? STOPPING_AND_SUSPENDING_THREADS
3909 : STOPPING_THREADS
);
3912 for_each_thread ([&] (thread_info
*thread
)
3914 suspend_and_send_sigstop (thread
, except
);
3917 for_each_thread ([&] (thread_info
*thread
)
3919 send_sigstop (thread
, except
);
3922 wait_for_sigstop ();
3923 stopping_threads
= NOT_STOPPING_THREADS
;
3925 threads_debug_printf ("setting stopping_threads back to !stopping");
3928 /* Enqueue one signal in the chain of signals which need to be
3929 delivered to this process on next resume. */
3932 enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
)
3934 lwp
->pending_signals
.emplace_back (signal
);
3935 if (info
== nullptr)
3936 memset (&lwp
->pending_signals
.back ().info
, 0, sizeof (siginfo_t
));
3938 lwp
->pending_signals
.back ().info
= *info
;
3942 linux_process_target::install_software_single_step_breakpoints (lwp_info
*lwp
)
3944 struct thread_info
*thread
= get_lwp_thread (lwp
);
3945 struct regcache
*regcache
= get_thread_regcache (thread
, 1);
3947 scoped_restore_current_thread restore_thread
;
3949 switch_to_thread (thread
);
3950 std::vector
<CORE_ADDR
> next_pcs
= low_get_next_pcs (regcache
);
3952 for (CORE_ADDR pc
: next_pcs
)
3953 set_single_step_breakpoint (pc
, current_ptid
);
3957 linux_process_target::single_step (lwp_info
* lwp
)
3961 if (supports_hardware_single_step ())
3965 else if (supports_software_single_step ())
3967 install_software_single_step_breakpoints (lwp
);
3971 threads_debug_printf ("stepping is not implemented on this target");
3976 /* The signal can be delivered to the inferior if we are not trying to
3977 finish a fast tracepoint collect. Since signal can be delivered in
3978 the step-over, the program may go to signal handler and trap again
3979 after return from the signal handler. We can live with the spurious
3983 lwp_signal_can_be_delivered (struct lwp_info
*lwp
)
3985 return (lwp
->collecting_fast_tracepoint
3986 == fast_tpoint_collect_result::not_collecting
);
3990 linux_process_target::resume_one_lwp_throw (lwp_info
*lwp
, int step
,
3991 int signal
, siginfo_t
*info
)
3993 struct thread_info
*thread
= get_lwp_thread (lwp
);
3995 struct process_info
*proc
= get_thread_process (thread
);
3997 /* Note that target description may not be initialised
3998 (proc->tdesc == NULL) at this point because the program hasn't
3999 stopped at the first instruction yet. It means GDBserver skips
4000 the extra traps from the wrapper program (see option --wrapper).
4001 Code in this function that requires register access should be
4002 guarded by proc->tdesc == NULL or something else. */
4004 if (lwp
->stopped
== 0)
4007 gdb_assert (lwp
->waitstatus
.kind () == TARGET_WAITKIND_IGNORE
);
4009 fast_tpoint_collect_result fast_tp_collecting
4010 = lwp
->collecting_fast_tracepoint
;
4012 gdb_assert (!stabilizing_threads
4013 || (fast_tp_collecting
4014 != fast_tpoint_collect_result::not_collecting
));
4016 /* Cancel actions that rely on GDB not changing the PC (e.g., the
4017 user used the "jump" command, or "set $pc = foo"). */
4018 if (thread
->while_stepping
!= NULL
&& lwp
->stop_pc
!= get_pc (lwp
))
4020 /* Collecting 'while-stepping' actions doesn't make sense
4022 release_while_stepping_state_list (thread
);
4025 /* If we have pending signals or status, and a new signal, enqueue the
4026 signal. Also enqueue the signal if it can't be delivered to the
4027 inferior right now. */
4029 && (lwp
->status_pending_p
4030 || !lwp
->pending_signals
.empty ()
4031 || !lwp_signal_can_be_delivered (lwp
)))
4033 enqueue_pending_signal (lwp
, signal
, info
);
4035 /* Postpone any pending signal. It was enqueued above. */
4039 if (lwp
->status_pending_p
)
4041 threads_debug_printf
4042 ("Not resuming lwp %ld (%s, stop %s); has pending status",
4043 lwpid_of (thread
), step
? "step" : "continue",
4044 lwp
->stop_expected
? "expected" : "not expected");
4048 scoped_restore_current_thread restore_thread
;
4049 switch_to_thread (thread
);
4051 /* This bit needs some thinking about. If we get a signal that
4052 we must report while a single-step reinsert is still pending,
4053 we often end up resuming the thread. It might be better to
4054 (ew) allow a stack of pending events; then we could be sure that
4055 the reinsert happened right away and not lose any signals.
4057 Making this stack would also shrink the window in which breakpoints are
4058 uninserted (see comment in linux_wait_for_lwp) but not enough for
4059 complete correctness, so it won't solve that problem. It may be
4060 worthwhile just to solve this one, however. */
4061 if (lwp
->bp_reinsert
!= 0)
4063 threads_debug_printf (" pending reinsert at 0x%s",
4064 paddress (lwp
->bp_reinsert
));
4066 if (supports_hardware_single_step ())
4068 if (fast_tp_collecting
== fast_tpoint_collect_result::not_collecting
)
4071 warning ("BAD - reinserting but not stepping.");
4073 warning ("BAD - reinserting and suspended(%d).",
4078 step
= maybe_hw_step (thread
);
4081 if (fast_tp_collecting
== fast_tpoint_collect_result::before_insn
)
4082 threads_debug_printf
4083 ("lwp %ld wants to get out of fast tracepoint jump pad "
4084 "(exit-jump-pad-bkpt)", lwpid_of (thread
));
4086 else if (fast_tp_collecting
== fast_tpoint_collect_result::at_insn
)
4088 threads_debug_printf
4089 ("lwp %ld wants to get out of fast tracepoint jump pad single-stepping",
4092 if (supports_hardware_single_step ())
4096 internal_error ("moving out of jump pad single-stepping"
4097 " not implemented on this target");
4101 /* If we have while-stepping actions in this thread set it stepping.
4102 If we have a signal to deliver, it may or may not be set to
4103 SIG_IGN, we don't know. Assume so, and allow collecting
4104 while-stepping into a signal handler. A possible smart thing to
4105 do would be to set an internal breakpoint at the signal return
4106 address, continue, and carry on catching this while-stepping
4107 action only when that breakpoint is hit. A future
4109 if (thread
->while_stepping
!= NULL
)
4111 threads_debug_printf
4112 ("lwp %ld has a while-stepping action -> forcing step.",
4115 step
= single_step (lwp
);
4118 if (proc
->tdesc
!= NULL
&& low_supports_breakpoints ())
4120 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
4122 lwp
->stop_pc
= low_get_pc (regcache
);
4124 threads_debug_printf (" %s from pc 0x%lx", step
? "step" : "continue",
4125 (long) lwp
->stop_pc
);
4128 /* If we have pending signals, consume one if it can be delivered to
4130 if (!lwp
->pending_signals
.empty () && lwp_signal_can_be_delivered (lwp
))
4132 const pending_signal
&p_sig
= lwp
->pending_signals
.front ();
4134 signal
= p_sig
.signal
;
4135 if (p_sig
.info
.si_signo
!= 0)
4136 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
4139 lwp
->pending_signals
.pop_front ();
4142 threads_debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)",
4143 lwpid_of (thread
), step
? "step" : "continue", signal
,
4144 lwp
->stop_expected
? "expected" : "not expected");
4146 low_prepare_to_resume (lwp
);
4148 regcache_invalidate_thread (thread
);
4150 lwp
->stepping
= step
;
4152 ptrace_request
= PTRACE_SINGLESTEP
;
4153 else if (gdb_catching_syscalls_p (lwp
))
4154 ptrace_request
= PTRACE_SYSCALL
;
4156 ptrace_request
= PTRACE_CONT
;
4157 ptrace (ptrace_request
,
4159 (PTRACE_TYPE_ARG3
) 0,
4160 /* Coerce to a uintptr_t first to avoid potential gcc warning
4161 of coercing an 8 byte integer to a 4 byte pointer. */
4162 (PTRACE_TYPE_ARG4
) (uintptr_t) signal
);
4166 int saved_errno
= errno
;
4168 threads_debug_printf ("ptrace errno = %d (%s)",
4169 saved_errno
, strerror (saved_errno
));
4171 errno
= saved_errno
;
4172 perror_with_name ("resuming thread");
4175 /* Successfully resumed. Clear state that no longer makes sense,
4176 and mark the LWP as running. Must not do this before resuming
4177 otherwise if that fails other code will be confused. E.g., we'd
4178 later try to stop the LWP and hang forever waiting for a stop
4179 status. Note that we must not throw after this is cleared,
4180 otherwise handle_zombie_lwp_error would get confused. */
4182 lwp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4186 linux_process_target::low_prepare_to_resume (lwp_info
*lwp
)
4191 /* Called when we try to resume a stopped LWP and that errors out. If
4192 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
4193 or about to become), discard the error, clear any pending status
4194 the LWP may have, and return true (we'll collect the exit status
4195 soon enough). Otherwise, return false. */
4198 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
4200 struct thread_info
*thread
= get_lwp_thread (lp
);
4202 /* If we get an error after resuming the LWP successfully, we'd
4203 confuse !T state for the LWP being gone. */
4204 gdb_assert (lp
->stopped
);
4206 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
4207 because even if ptrace failed with ESRCH, the tracee may be "not
4208 yet fully dead", but already refusing ptrace requests. In that
4209 case the tracee has 'R (Running)' state for a little bit
4210 (observed in Linux 3.18). See also the note on ESRCH in the
4211 ptrace(2) man page. Instead, check whether the LWP has any state
4212 other than ptrace-stopped. */
4214 /* Don't assume anything if /proc/PID/status can't be read. */
4215 if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread
)) == 0)
4217 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4218 lp
->status_pending_p
= 0;
4225 linux_process_target::resume_one_lwp (lwp_info
*lwp
, int step
, int signal
,
4230 resume_one_lwp_throw (lwp
, step
, signal
, info
);
4232 catch (const gdb_exception_error
&ex
)
4234 if (check_ptrace_stopped_lwp_gone (lwp
))
4236 /* This could because we tried to resume an LWP after its leader
4237 exited. Mark it as resumed, so we can collect an exit event
4240 lwp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4247 /* This function is called once per thread via for_each_thread.
4248 We look up which resume request applies to THREAD and mark it with a
4249 pointer to the appropriate resume request.
4251 This algorithm is O(threads * resume elements), but resume elements
4252 is small (and will remain small at least until GDB supports thread
4256 linux_set_resume_request (thread_info
*thread
, thread_resume
*resume
, size_t n
)
4258 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4260 for (int ndx
= 0; ndx
< n
; ndx
++)
4262 ptid_t ptid
= resume
[ndx
].thread
;
4263 if (ptid
== minus_one_ptid
4264 || ptid
== thread
->id
4265 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
4267 || (ptid
.pid () == pid_of (thread
)
4269 || ptid
.lwp () == -1)))
4271 if (resume
[ndx
].kind
== resume_stop
4272 && thread
->last_resume_kind
== resume_stop
)
4274 threads_debug_printf
4275 ("already %s LWP %ld at GDB's request",
4276 (thread
->last_status
.kind () == TARGET_WAITKIND_STOPPED
4277 ? "stopped" : "stopping"),
4283 /* Ignore (wildcard) resume requests for already-resumed
4285 if (resume
[ndx
].kind
!= resume_stop
4286 && thread
->last_resume_kind
!= resume_stop
)
4288 threads_debug_printf
4289 ("already %s LWP %ld at GDB's request",
4290 (thread
->last_resume_kind
== resume_step
4291 ? "stepping" : "continuing"),
4296 /* Don't let wildcard resumes resume fork/vfork/clone
4297 children that GDB does not yet know are new children. */
4298 if (lwp
->relative
!= NULL
)
4300 struct lwp_info
*rel
= lwp
->relative
;
4302 if (rel
->status_pending_p
4303 && is_new_child_status (rel
->waitstatus
.kind ()))
4305 threads_debug_printf
4306 ("not resuming LWP %ld: has queued stop reply",
4312 /* If the thread has a pending event that has already been
4313 reported to GDBserver core, but GDB has not pulled the
4314 event out of the vStopped queue yet, likewise, ignore the
4315 (wildcard) resume request. */
4316 if (in_queued_stop_replies (thread
->id
))
4318 threads_debug_printf
4319 ("not resuming LWP %ld: has queued stop reply",
4324 lwp
->resume
= &resume
[ndx
];
4325 thread
->last_resume_kind
= lwp
->resume
->kind
;
4327 lwp
->step_range_start
= lwp
->resume
->step_range_start
;
4328 lwp
->step_range_end
= lwp
->resume
->step_range_end
;
4330 /* If we had a deferred signal to report, dequeue one now.
4331 This can happen if LWP gets more than one signal while
4332 trying to get out of a jump pad. */
4334 && !lwp
->status_pending_p
4335 && dequeue_one_deferred_signal (lwp
, &lwp
->status_pending
))
4337 lwp
->status_pending_p
= 1;
4339 threads_debug_printf
4340 ("Dequeueing deferred signal %d for LWP %ld, "
4341 "leaving status pending.",
4342 WSTOPSIG (lwp
->status_pending
),
4350 /* No resume action for this thread. */
4355 linux_process_target::resume_status_pending (thread_info
*thread
)
4357 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4359 /* LWPs which will not be resumed are not interesting, because
4360 we might not wait for them next time through linux_wait. */
4361 if (lwp
->resume
== NULL
)
4364 return thread_still_has_status_pending (thread
);
4368 linux_process_target::thread_needs_step_over (thread_info
*thread
)
4370 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4372 struct process_info
*proc
= get_thread_process (thread
);
4374 /* GDBserver is skipping the extra traps from the wrapper program,
4375 don't have to do step over. */
4376 if (proc
->tdesc
== NULL
)
4379 /* LWPs which will not be resumed are not interesting, because we
4380 might not wait for them next time through linux_wait. */
4384 threads_debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped",
4389 if (thread
->last_resume_kind
== resume_stop
)
4391 threads_debug_printf
4392 ("Need step over [LWP %ld]? Ignoring, should remain stopped",
4397 gdb_assert (lwp
->suspended
>= 0);
4401 threads_debug_printf ("Need step over [LWP %ld]? Ignoring, suspended",
4406 if (lwp
->status_pending_p
)
4408 threads_debug_printf
4409 ("Need step over [LWP %ld]? Ignoring, has pending status.",
4414 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
4418 /* If the PC has changed since we stopped, then don't do anything,
4419 and let the breakpoint/tracepoint be hit. This happens if, for
4420 instance, GDB handled the decr_pc_after_break subtraction itself,
4421 GDB is OOL stepping this thread, or the user has issued a "jump"
4422 command, or poked thread's registers herself. */
4423 if (pc
!= lwp
->stop_pc
)
4425 threads_debug_printf
4426 ("Need step over [LWP %ld]? Cancelling, PC was changed. "
4427 "Old stop_pc was 0x%s, PC is now 0x%s", lwpid_of (thread
),
4428 paddress (lwp
->stop_pc
), paddress (pc
));
4432 /* On software single step target, resume the inferior with signal
4433 rather than stepping over. */
4434 if (supports_software_single_step ()
4435 && !lwp
->pending_signals
.empty ()
4436 && lwp_signal_can_be_delivered (lwp
))
4438 threads_debug_printf
4439 ("Need step over [LWP %ld]? Ignoring, has pending signals.",
4445 scoped_restore_current_thread restore_thread
;
4446 switch_to_thread (thread
);
4448 /* We can only step over breakpoints we know about. */
4449 if (breakpoint_here (pc
) || fast_tracepoint_jump_here (pc
))
4451 /* Don't step over a breakpoint that GDB expects to hit
4452 though. If the condition is being evaluated on the target's side
4453 and it evaluate to false, step over this breakpoint as well. */
4454 if (gdb_breakpoint_here (pc
)
4455 && gdb_condition_true_at_breakpoint (pc
)
4456 && gdb_no_commands_at_breakpoint (pc
))
4458 threads_debug_printf ("Need step over [LWP %ld]? yes, but found"
4459 " GDB breakpoint at 0x%s; skipping step over",
4460 lwpid_of (thread
), paddress (pc
));
4466 threads_debug_printf ("Need step over [LWP %ld]? yes, "
4467 "found breakpoint at 0x%s",
4468 lwpid_of (thread
), paddress (pc
));
4470 /* We've found an lwp that needs stepping over --- return 1 so
4471 that find_thread stops looking. */
4476 threads_debug_printf
4477 ("Need step over [LWP %ld]? No, no breakpoint found at 0x%s",
4478 lwpid_of (thread
), paddress (pc
));
4484 linux_process_target::start_step_over (lwp_info
*lwp
)
4486 struct thread_info
*thread
= get_lwp_thread (lwp
);
4489 threads_debug_printf ("Starting step-over on LWP %ld. Stopping all threads",
4492 stop_all_lwps (1, lwp
);
4494 if (lwp
->suspended
!= 0)
4496 internal_error ("LWP %ld suspended=%d\n", lwpid_of (thread
),
4500 threads_debug_printf ("Done stopping all threads for step-over.");
4502 /* Note, we should always reach here with an already adjusted PC,
4503 either by GDB (if we're resuming due to GDB's request), or by our
4504 caller, if we just finished handling an internal breakpoint GDB
4505 shouldn't care about. */
4510 scoped_restore_current_thread restore_thread
;
4511 switch_to_thread (thread
);
4513 lwp
->bp_reinsert
= pc
;
4514 uninsert_breakpoints_at (pc
);
4515 uninsert_fast_tracepoint_jumps_at (pc
);
4517 step
= single_step (lwp
);
4520 resume_one_lwp (lwp
, step
, 0, NULL
);
4522 /* Require next event from this LWP. */
4523 step_over_bkpt
= thread
->id
;
4527 linux_process_target::finish_step_over (lwp_info
*lwp
)
4529 if (lwp
->bp_reinsert
!= 0)
4531 scoped_restore_current_thread restore_thread
;
4533 threads_debug_printf ("Finished step over.");
4535 switch_to_thread (get_lwp_thread (lwp
));
4537 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
4538 may be no breakpoint to reinsert there by now. */
4539 reinsert_breakpoints_at (lwp
->bp_reinsert
);
4540 reinsert_fast_tracepoint_jumps_at (lwp
->bp_reinsert
);
4542 lwp
->bp_reinsert
= 0;
4544 /* Delete any single-step breakpoints. No longer needed. We
4545 don't have to worry about other threads hitting this trap,
4546 and later not being able to explain it, because we were
4547 stepping over a breakpoint, and we hold all threads but
4548 LWP stopped while doing that. */
4549 if (!supports_hardware_single_step ())
4551 gdb_assert (has_single_step_breakpoints (current_thread
));
4552 delete_single_step_breakpoints (current_thread
);
4555 step_over_bkpt
= null_ptid
;
4563 linux_process_target::complete_ongoing_step_over ()
4565 if (step_over_bkpt
!= null_ptid
)
4567 struct lwp_info
*lwp
;
4571 threads_debug_printf ("detach: step over in progress, finish it first");
4573 /* Passing NULL_PTID as filter indicates we want all events to
4574 be left pending. Eventually this returns when there are no
4575 unwaited-for children left. */
4576 ret
= wait_for_event_filtered (minus_one_ptid
, null_ptid
, &wstat
,
4578 gdb_assert (ret
== -1);
4580 lwp
= find_lwp_pid (step_over_bkpt
);
4583 finish_step_over (lwp
);
4585 /* If we got our step SIGTRAP, don't leave it pending,
4586 otherwise we would report it to GDB as a spurious
4588 gdb_assert (lwp
->status_pending_p
);
4589 if (WIFSTOPPED (lwp
->status_pending
)
4590 && WSTOPSIG (lwp
->status_pending
) == SIGTRAP
)
4592 thread_info
*thread
= get_lwp_thread (lwp
);
4593 if (thread
->last_resume_kind
!= resume_step
)
4595 threads_debug_printf ("detach: discard step-over SIGTRAP");
4597 lwp
->status_pending_p
= 0;
4598 lwp
->status_pending
= 0;
4599 resume_one_lwp (lwp
, lwp
->stepping
, 0, NULL
);
4602 threads_debug_printf
4603 ("detach: resume_step, not discarding step-over SIGTRAP");
4606 step_over_bkpt
= null_ptid
;
4607 unsuspend_all_lwps (lwp
);
4612 linux_process_target::resume_one_thread (thread_info
*thread
,
4613 bool leave_all_stopped
)
4615 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4618 if (lwp
->resume
== NULL
)
4621 if (lwp
->resume
->kind
== resume_stop
)
4623 threads_debug_printf ("resume_stop request for LWP %ld",
4628 threads_debug_printf ("stopping LWP %ld", lwpid_of (thread
));
4630 /* Stop the thread, and wait for the event asynchronously,
4631 through the event loop. */
4636 threads_debug_printf ("already stopped LWP %ld", lwpid_of (thread
));
4638 /* The LWP may have been stopped in an internal event that
4639 was not meant to be notified back to GDB (e.g., gdbserver
4640 breakpoint), so we should be reporting a stop event in
4643 /* If the thread already has a pending SIGSTOP, this is a
4644 no-op. Otherwise, something later will presumably resume
4645 the thread and this will cause it to cancel any pending
4646 operation, due to last_resume_kind == resume_stop. If
4647 the thread already has a pending status to report, we
4648 will still report it the next time we wait - see
4649 status_pending_p_callback. */
4651 /* If we already have a pending signal to report, then
4652 there's no need to queue a SIGSTOP, as this means we're
4653 midway through moving the LWP out of the jumppad, and we
4654 will report the pending signal as soon as that is
4656 if (lwp
->pending_signals_to_report
.empty ())
4660 /* For stop requests, we're done. */
4662 thread
->last_status
.set_ignore ();
4666 /* If this thread which is about to be resumed has a pending status,
4667 then don't resume it - we can just report the pending status.
4668 Likewise if it is suspended, because e.g., another thread is
4669 stepping past a breakpoint. Make sure to queue any signals that
4670 would otherwise be sent. In all-stop mode, we do this decision
4671 based on if *any* thread has a pending status. If there's a
4672 thread that needs the step-over-breakpoint dance, then don't
4673 resume any other thread but that particular one. */
4674 leave_pending
= (lwp
->suspended
4675 || lwp
->status_pending_p
4676 || leave_all_stopped
);
4678 /* If we have a new signal, enqueue the signal. */
4679 if (lwp
->resume
->sig
!= 0)
4681 siginfo_t info
, *info_p
;
4683 /* If this is the same signal we were previously stopped by,
4684 make sure to queue its siginfo. */
4685 if (WIFSTOPPED (lwp
->last_status
)
4686 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
4687 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
),
4688 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
4693 enqueue_pending_signal (lwp
, lwp
->resume
->sig
, info_p
);
4698 threads_debug_printf ("resuming LWP %ld", lwpid_of (thread
));
4700 proceed_one_lwp (thread
, NULL
);
4703 threads_debug_printf ("leaving LWP %ld stopped", lwpid_of (thread
));
4705 thread
->last_status
.set_ignore ();
4710 linux_process_target::resume (thread_resume
*resume_info
, size_t n
)
4712 struct thread_info
*need_step_over
= NULL
;
4714 THREADS_SCOPED_DEBUG_ENTER_EXIT
;
4716 for_each_thread ([&] (thread_info
*thread
)
4718 linux_set_resume_request (thread
, resume_info
, n
);
4721 /* If there is a thread which would otherwise be resumed, which has
4722 a pending status, then don't resume any threads - we can just
4723 report the pending status. Make sure to queue any signals that
4724 would otherwise be sent. In non-stop mode, we'll apply this
4725 logic to each thread individually. We consume all pending events
4726 before considering to start a step-over (in all-stop). */
4727 bool any_pending
= false;
4729 any_pending
= find_thread ([this] (thread_info
*thread
)
4731 return resume_status_pending (thread
);
4734 /* If there is a thread which would otherwise be resumed, which is
4735 stopped at a breakpoint that needs stepping over, then don't
4736 resume any threads - have it step over the breakpoint with all
4737 other threads stopped, then resume all threads again. Make sure
4738 to queue any signals that would otherwise be delivered or
4740 if (!any_pending
&& low_supports_breakpoints ())
4741 need_step_over
= find_thread ([this] (thread_info
*thread
)
4743 return thread_needs_step_over (thread
);
4746 bool leave_all_stopped
= (need_step_over
!= NULL
|| any_pending
);
4748 if (need_step_over
!= NULL
)
4749 threads_debug_printf ("Not resuming all, need step over");
4750 else if (any_pending
)
4751 threads_debug_printf ("Not resuming, all-stop and found "
4752 "an LWP with pending status");
4754 threads_debug_printf ("Resuming, no pending status or step over needed");
4756 /* Even if we're leaving threads stopped, queue all signals we'd
4757 otherwise deliver. */
4758 for_each_thread ([&] (thread_info
*thread
)
4760 resume_one_thread (thread
, leave_all_stopped
);
4764 start_step_over (get_thread_lwp (need_step_over
));
4766 /* We may have events that were pending that can/should be sent to
4767 the client now. Trigger a linux_wait call. */
4768 if (target_is_async_p ())
4773 linux_process_target::proceed_one_lwp (thread_info
*thread
, lwp_info
*except
)
4775 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4781 threads_debug_printf ("lwp %ld", lwpid_of (thread
));
4785 threads_debug_printf (" LWP %ld already running", lwpid_of (thread
));
4789 if (thread
->last_resume_kind
== resume_stop
4790 && thread
->last_status
.kind () != TARGET_WAITKIND_IGNORE
)
4792 threads_debug_printf (" client wants LWP to remain %ld stopped",
4797 if (lwp
->status_pending_p
)
4799 threads_debug_printf (" LWP %ld has pending status, leaving stopped",
4804 gdb_assert (lwp
->suspended
>= 0);
4808 threads_debug_printf (" LWP %ld is suspended", lwpid_of (thread
));
4812 if (thread
->last_resume_kind
== resume_stop
4813 && lwp
->pending_signals_to_report
.empty ()
4814 && (lwp
->collecting_fast_tracepoint
4815 == fast_tpoint_collect_result::not_collecting
))
4817 /* We haven't reported this LWP as stopped yet (otherwise, the
4818 last_status.kind check above would catch it, and we wouldn't
4819 reach here. This LWP may have been momentarily paused by a
4820 stop_all_lwps call while handling for example, another LWP's
4821 step-over. In that case, the pending expected SIGSTOP signal
4822 that was queued at vCont;t handling time will have already
4823 been consumed by wait_for_sigstop, and so we need to requeue
4824 another one here. Note that if the LWP already has a SIGSTOP
4825 pending, this is a no-op. */
4827 threads_debug_printf
4828 ("Client wants LWP %ld to stop. Making sure it has a SIGSTOP pending",
4834 if (thread
->last_resume_kind
== resume_step
)
4836 threads_debug_printf (" stepping LWP %ld, client wants it stepping",
4839 /* If resume_step is requested by GDB, install single-step
4840 breakpoints when the thread is about to be actually resumed if
4841 the single-step breakpoints weren't removed. */
4842 if (supports_software_single_step ()
4843 && !has_single_step_breakpoints (thread
))
4844 install_software_single_step_breakpoints (lwp
);
4846 step
= maybe_hw_step (thread
);
4848 else if (lwp
->bp_reinsert
!= 0)
4850 threads_debug_printf (" stepping LWP %ld, reinsert set",
4853 step
= maybe_hw_step (thread
);
4858 resume_one_lwp (lwp
, step
, 0, NULL
);
4862 linux_process_target::unsuspend_and_proceed_one_lwp (thread_info
*thread
,
4865 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4870 lwp_suspended_decr (lwp
);
4872 proceed_one_lwp (thread
, except
);
4876 linux_process_target::proceed_all_lwps ()
4878 struct thread_info
*need_step_over
;
4880 /* If there is a thread which would otherwise be resumed, which is
4881 stopped at a breakpoint that needs stepping over, then don't
4882 resume any threads - have it step over the breakpoint with all
4883 other threads stopped, then resume all threads again. */
4885 if (low_supports_breakpoints ())
4887 need_step_over
= find_thread ([this] (thread_info
*thread
)
4889 return thread_needs_step_over (thread
);
4892 if (need_step_over
!= NULL
)
4894 threads_debug_printf ("found thread %ld needing a step-over",
4895 lwpid_of (need_step_over
));
4897 start_step_over (get_thread_lwp (need_step_over
));
4902 threads_debug_printf ("Proceeding, no step-over needed");
4904 for_each_thread ([this] (thread_info
*thread
)
4906 proceed_one_lwp (thread
, NULL
);
4911 linux_process_target::unstop_all_lwps (int unsuspend
, lwp_info
*except
)
4913 THREADS_SCOPED_DEBUG_ENTER_EXIT
;
4916 threads_debug_printf ("except=(LWP %ld)",
4917 lwpid_of (get_lwp_thread (except
)));
4919 threads_debug_printf ("except=nullptr");
4922 for_each_thread ([&] (thread_info
*thread
)
4924 unsuspend_and_proceed_one_lwp (thread
, except
);
4927 for_each_thread ([&] (thread_info
*thread
)
4929 proceed_one_lwp (thread
, except
);
4934 #ifdef HAVE_LINUX_REGSETS
4936 #define use_linux_regsets 1
4938 /* Returns true if REGSET has been disabled. */
4941 regset_disabled (struct regsets_info
*info
, struct regset_info
*regset
)
4943 return (info
->disabled_regsets
!= NULL
4944 && info
->disabled_regsets
[regset
- info
->regsets
]);
4947 /* Disable REGSET. */
4950 disable_regset (struct regsets_info
*info
, struct regset_info
*regset
)
4954 dr_offset
= regset
- info
->regsets
;
4955 if (info
->disabled_regsets
== NULL
)
4956 info
->disabled_regsets
= (char *) xcalloc (1, info
->num_regsets
);
4957 info
->disabled_regsets
[dr_offset
] = 1;
4961 regsets_fetch_inferior_registers (struct regsets_info
*regsets_info
,
4962 struct regcache
*regcache
)
4964 struct regset_info
*regset
;
4965 int saw_general_regs
= 0;
4969 pid
= lwpid_of (current_thread
);
4970 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
4975 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
))
4978 buf
= xmalloc (regset
->size
);
4980 nt_type
= regset
->nt_type
;
4984 iov
.iov_len
= regset
->size
;
4985 data
= (void *) &iov
;
4991 res
= ptrace (regset
->get_request
, pid
,
4992 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
4994 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
4999 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5001 /* If we get EIO on a regset, or an EINVAL and the regset is
5002 optional, do not try it again for this process mode. */
5003 disable_regset (regsets_info
, regset
);
5005 else if (errno
== ENODATA
)
5007 /* ENODATA may be returned if the regset is currently
5008 not "active". This can happen in normal operation,
5009 so suppress the warning in this case. */
5011 else if (errno
== ESRCH
)
5013 /* At this point, ESRCH should mean the process is
5014 already gone, in which case we simply ignore attempts
5015 to read its registers. */
5020 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
5027 if (regset
->type
== GENERAL_REGS
)
5028 saw_general_regs
= 1;
5029 regset
->store_function (regcache
, buf
);
5033 if (saw_general_regs
)
5040 regsets_store_inferior_registers (struct regsets_info
*regsets_info
,
5041 struct regcache
*regcache
)
5043 struct regset_info
*regset
;
5044 int saw_general_regs
= 0;
5048 pid
= lwpid_of (current_thread
);
5049 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
5054 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
)
5055 || regset
->fill_function
== NULL
)
5058 buf
= xmalloc (regset
->size
);
5060 /* First fill the buffer with the current register set contents,
5061 in case there are any items in the kernel's regset that are
5062 not in gdbserver's regcache. */
5064 nt_type
= regset
->nt_type
;
5068 iov
.iov_len
= regset
->size
;
5069 data
= (void *) &iov
;
5075 res
= ptrace (regset
->get_request
, pid
,
5076 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5078 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
5083 /* Then overlay our cached registers on that. */
5084 regset
->fill_function (regcache
, buf
);
5086 /* Only now do we write the register set. */
5088 res
= ptrace (regset
->set_request
, pid
,
5089 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5091 res
= ptrace (regset
->set_request
, pid
, data
, nt_type
);
5098 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5100 /* If we get EIO on a regset, or an EINVAL and the regset is
5101 optional, do not try it again for this process mode. */
5102 disable_regset (regsets_info
, regset
);
5104 else if (errno
== ESRCH
)
5106 /* At this point, ESRCH should mean the process is
5107 already gone, in which case we simply ignore attempts
5108 to change its registers. See also the related
5109 comment in resume_one_lwp. */
5115 perror ("Warning: ptrace(regsets_store_inferior_registers)");
5118 else if (regset
->type
== GENERAL_REGS
)
5119 saw_general_regs
= 1;
5122 if (saw_general_regs
)
5128 #else /* !HAVE_LINUX_REGSETS */
5130 #define use_linux_regsets 0
5131 #define regsets_fetch_inferior_registers(regsets_info, regcache) 1
5132 #define regsets_store_inferior_registers(regsets_info, regcache) 1
5136 /* Return 1 if register REGNO is supported by one of the regset ptrace
5137 calls or 0 if it has to be transferred individually. */
5140 linux_register_in_regsets (const struct regs_info
*regs_info
, int regno
)
5142 unsigned char mask
= 1 << (regno
% 8);
5143 size_t index
= regno
/ 8;
5145 return (use_linux_regsets
5146 && (regs_info
->regset_bitmap
== NULL
5147 || (regs_info
->regset_bitmap
[index
] & mask
) != 0));
5150 #ifdef HAVE_LINUX_USRREGS
5153 register_addr (const struct usrregs_info
*usrregs
, int regnum
)
5157 if (regnum
< 0 || regnum
>= usrregs
->num_regs
)
5158 error ("Invalid register number %d.", regnum
);
5160 addr
= usrregs
->regmap
[regnum
];
5167 linux_process_target::fetch_register (const usrregs_info
*usrregs
,
5168 regcache
*regcache
, int regno
)
5175 if (regno
>= usrregs
->num_regs
)
5177 if (low_cannot_fetch_register (regno
))
5180 regaddr
= register_addr (usrregs
, regno
);
5184 size
= ((register_size (regcache
->tdesc
, regno
)
5185 + sizeof (PTRACE_XFER_TYPE
) - 1)
5186 & -sizeof (PTRACE_XFER_TYPE
));
5187 buf
= (char *) alloca (size
);
5189 pid
= lwpid_of (current_thread
);
5190 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5193 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
5194 ptrace (PTRACE_PEEKUSER
, pid
,
5195 /* Coerce to a uintptr_t first to avoid potential gcc warning
5196 of coercing an 8 byte integer to a 4 byte pointer. */
5197 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
, (PTRACE_TYPE_ARG4
) 0);
5198 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5201 /* Mark register REGNO unavailable. */
5202 supply_register (regcache
, regno
, NULL
);
5207 low_supply_ptrace_register (regcache
, regno
, buf
);
5211 linux_process_target::store_register (const usrregs_info
*usrregs
,
5212 regcache
*regcache
, int regno
)
5219 if (regno
>= usrregs
->num_regs
)
5221 if (low_cannot_store_register (regno
))
5224 regaddr
= register_addr (usrregs
, regno
);
5228 size
= ((register_size (regcache
->tdesc
, regno
)
5229 + sizeof (PTRACE_XFER_TYPE
) - 1)
5230 & -sizeof (PTRACE_XFER_TYPE
));
5231 buf
= (char *) alloca (size
);
5232 memset (buf
, 0, size
);
5234 low_collect_ptrace_register (regcache
, regno
, buf
);
5236 pid
= lwpid_of (current_thread
);
5237 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5240 ptrace (PTRACE_POKEUSER
, pid
,
5241 /* Coerce to a uintptr_t first to avoid potential gcc warning
5242 about coercing an 8 byte integer to a 4 byte pointer. */
5243 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
,
5244 (PTRACE_TYPE_ARG4
) *(PTRACE_XFER_TYPE
*) (buf
+ i
));
5247 /* At this point, ESRCH should mean the process is
5248 already gone, in which case we simply ignore attempts
5249 to change its registers. See also the related
5250 comment in resume_one_lwp. */
5255 if (!low_cannot_store_register (regno
))
5256 error ("writing register %d: %s", regno
, safe_strerror (errno
));
5258 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5261 #endif /* HAVE_LINUX_USRREGS */
5264 linux_process_target::low_collect_ptrace_register (regcache
*regcache
,
5265 int regno
, char *buf
)
5267 collect_register (regcache
, regno
, buf
);
5271 linux_process_target::low_supply_ptrace_register (regcache
*regcache
,
5272 int regno
, const char *buf
)
5274 supply_register (regcache
, regno
, buf
);
5278 linux_process_target::usr_fetch_inferior_registers (const regs_info
*regs_info
,
5282 #ifdef HAVE_LINUX_USRREGS
5283 struct usrregs_info
*usr
= regs_info
->usrregs
;
5287 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5288 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5289 fetch_register (usr
, regcache
, regno
);
5292 fetch_register (usr
, regcache
, regno
);
5297 linux_process_target::usr_store_inferior_registers (const regs_info
*regs_info
,
5301 #ifdef HAVE_LINUX_USRREGS
5302 struct usrregs_info
*usr
= regs_info
->usrregs
;
5306 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5307 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5308 store_register (usr
, regcache
, regno
);
5311 store_register (usr
, regcache
, regno
);
5316 linux_process_target::fetch_registers (regcache
*regcache
, int regno
)
5320 const regs_info
*regs_info
= get_regs_info ();
5324 if (regs_info
->usrregs
!= NULL
)
5325 for (regno
= 0; regno
< regs_info
->usrregs
->num_regs
; regno
++)
5326 low_fetch_register (regcache
, regno
);
5328 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
, regcache
);
5329 if (regs_info
->usrregs
!= NULL
)
5330 usr_fetch_inferior_registers (regs_info
, regcache
, -1, all
);
5334 if (low_fetch_register (regcache
, regno
))
5337 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5339 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
,
5341 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5342 usr_fetch_inferior_registers (regs_info
, regcache
, regno
, 1);
5347 linux_process_target::store_registers (regcache
*regcache
, int regno
)
5351 const regs_info
*regs_info
= get_regs_info ();
5355 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5357 if (regs_info
->usrregs
!= NULL
)
5358 usr_store_inferior_registers (regs_info
, regcache
, regno
, all
);
5362 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5364 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5366 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5367 usr_store_inferior_registers (regs_info
, regcache
, regno
, 1);
5372 linux_process_target::low_fetch_register (regcache
*regcache
, int regno
)
5377 /* A wrapper for the read_memory target op. */
5380 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
5382 return the_target
->read_memory (memaddr
, myaddr
, len
);
5386 /* Helper for read_memory/write_memory using /proc/PID/mem. Because
5387 we can use a single read/write call, this can be much more
5388 efficient than banging away at PTRACE_PEEKTEXT. Also, unlike
5389 PTRACE_PEEKTEXT/PTRACE_POKETEXT, this works with running threads.
5390 One an only one of READBUF and WRITEBUF is non-null. If READBUF is
5391 not null, then we're reading, otherwise we're writing. */
5394 proc_xfer_memory (CORE_ADDR memaddr
, unsigned char *readbuf
,
5395 const gdb_byte
*writebuf
, int len
)
5397 gdb_assert ((readbuf
== nullptr) != (writebuf
== nullptr));
5399 process_info
*proc
= current_process ();
5401 int fd
= proc
->priv
->mem_fd
;
5409 /* Use pread64/pwrite64 if available, since they save a syscall
5410 and can handle 64-bit offsets even on 32-bit platforms (for
5411 instance, SPARC debugging a SPARC64 application). But only
5412 use them if the offset isn't so high that when cast to off_t
5413 it'd be negative, as seen on SPARC64. pread64/pwrite64
5414 outright reject such offsets. lseek does not. */
5416 if ((off_t
) memaddr
>= 0)
5417 bytes
= (readbuf
!= nullptr
5418 ? pread64 (fd
, readbuf
, len
, memaddr
)
5419 : pwrite64 (fd
, writebuf
, len
, memaddr
));
5424 if (lseek (fd
, memaddr
, SEEK_SET
) != -1)
5425 bytes
= (readbuf
!= nullptr
5426 ? read (fd
, readbuf
, len
)
5427 : write (fd
, writebuf
, len
));
5432 else if (bytes
== 0)
5434 /* EOF means the address space is gone, the whole process
5435 exited or execed. */
5440 if (readbuf
!= nullptr)
5451 linux_process_target::read_memory (CORE_ADDR memaddr
,
5452 unsigned char *myaddr
, int len
)
5454 return proc_xfer_memory (memaddr
, myaddr
, nullptr, len
);
5457 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
5458 memory at MEMADDR. On failure (cannot write to the inferior)
5459 returns the value of errno. Always succeeds if LEN is zero. */
5462 linux_process_target::write_memory (CORE_ADDR memaddr
,
5463 const unsigned char *myaddr
, int len
)
5467 /* Dump up to four bytes. */
5468 char str
[4 * 2 + 1];
5470 int dump
= len
< 4 ? len
: 4;
5472 for (int i
= 0; i
< dump
; i
++)
5474 sprintf (p
, "%02x", myaddr
[i
]);
5479 threads_debug_printf ("Writing %s to 0x%08lx in process %d",
5480 str
, (long) memaddr
, current_process ()->pid
);
5483 return proc_xfer_memory (memaddr
, nullptr, myaddr
, len
);
5487 linux_process_target::look_up_symbols ()
5489 #ifdef USE_THREAD_DB
5490 struct process_info
*proc
= current_process ();
5492 if (proc
->priv
->thread_db
!= NULL
)
5500 linux_process_target::request_interrupt ()
5502 /* Send a SIGINT to the process group. This acts just like the user
5503 typed a ^C on the controlling terminal. */
5504 int res
= ::kill (-signal_pid
, SIGINT
);
5506 warning (_("Sending SIGINT to process group of pid %ld failed: %s"),
5507 signal_pid
, safe_strerror (errno
));
5511 linux_process_target::supports_read_auxv ()
5516 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
5517 to debugger memory starting at MYADDR. */
5520 linux_process_target::read_auxv (int pid
, CORE_ADDR offset
,
5521 unsigned char *myaddr
, unsigned int len
)
5523 char filename
[PATH_MAX
];
5526 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
5528 fd
= open (filename
, O_RDONLY
);
5532 if (offset
!= (CORE_ADDR
) 0
5533 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5536 n
= read (fd
, myaddr
, len
);
5544 linux_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5545 int size
, raw_breakpoint
*bp
)
5547 if (type
== raw_bkpt_type_sw
)
5548 return insert_memory_breakpoint (bp
);
5550 return low_insert_point (type
, addr
, size
, bp
);
5554 linux_process_target::low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
5555 int size
, raw_breakpoint
*bp
)
5557 /* Unsupported (see target.h). */
5562 linux_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5563 int size
, raw_breakpoint
*bp
)
5565 if (type
== raw_bkpt_type_sw
)
5566 return remove_memory_breakpoint (bp
);
5568 return low_remove_point (type
, addr
, size
, bp
);
5572 linux_process_target::low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
5573 int size
, raw_breakpoint
*bp
)
5575 /* Unsupported (see target.h). */
5579 /* Implement the stopped_by_sw_breakpoint target_ops
5583 linux_process_target::stopped_by_sw_breakpoint ()
5585 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5587 return (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
5590 /* Implement the supports_stopped_by_sw_breakpoint target_ops
5594 linux_process_target::supports_stopped_by_sw_breakpoint ()
5596 return USE_SIGTRAP_SIGINFO
;
5599 /* Implement the stopped_by_hw_breakpoint target_ops
5603 linux_process_target::stopped_by_hw_breakpoint ()
5605 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5607 return (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
5610 /* Implement the supports_stopped_by_hw_breakpoint target_ops
5614 linux_process_target::supports_stopped_by_hw_breakpoint ()
5616 return USE_SIGTRAP_SIGINFO
;
5619 /* Implement the supports_hardware_single_step target_ops method. */
5622 linux_process_target::supports_hardware_single_step ()
5628 linux_process_target::stopped_by_watchpoint ()
5630 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5632 return lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
5636 linux_process_target::stopped_data_address ()
5638 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5640 return lwp
->stopped_data_address
;
5643 /* This is only used for targets that define PT_TEXT_ADDR,
5644 PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
5645 the target has different ways of acquiring this information, like
5649 linux_process_target::supports_read_offsets ()
5651 #ifdef SUPPORTS_READ_OFFSETS
5658 /* Under uClinux, programs are loaded at non-zero offsets, which we need
5659 to tell gdb about. */
5662 linux_process_target::read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
5664 #ifdef SUPPORTS_READ_OFFSETS
5665 unsigned long text
, text_end
, data
;
5666 int pid
= lwpid_of (current_thread
);
5670 text
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_ADDR
,
5671 (PTRACE_TYPE_ARG4
) 0);
5672 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_END_ADDR
,
5673 (PTRACE_TYPE_ARG4
) 0);
5674 data
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_DATA_ADDR
,
5675 (PTRACE_TYPE_ARG4
) 0);
5679 /* Both text and data offsets produced at compile-time (and so
5680 used by gdb) are relative to the beginning of the program,
5681 with the data segment immediately following the text segment.
5682 However, the actual runtime layout in memory may put the data
5683 somewhere else, so when we send gdb a data base-address, we
5684 use the real data base address and subtract the compile-time
5685 data base-address from it (which is just the length of the
5686 text segment). BSS immediately follows data in both
5689 *data_p
= data
- (text_end
- text
);
5695 gdb_assert_not_reached ("target op read_offsets not supported");
5700 linux_process_target::supports_get_tls_address ()
5702 #ifdef USE_THREAD_DB
5710 linux_process_target::get_tls_address (thread_info
*thread
,
5712 CORE_ADDR load_module
,
5715 #ifdef USE_THREAD_DB
5716 return thread_db_get_tls_address (thread
, offset
, load_module
, address
);
5723 linux_process_target::supports_qxfer_osdata ()
5729 linux_process_target::qxfer_osdata (const char *annex
,
5730 unsigned char *readbuf
,
5731 unsigned const char *writebuf
,
5732 CORE_ADDR offset
, int len
)
5734 return linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
5738 linux_process_target::siginfo_fixup (siginfo_t
*siginfo
,
5739 gdb_byte
*inf_siginfo
, int direction
)
5741 bool done
= low_siginfo_fixup (siginfo
, inf_siginfo
, direction
);
5743 /* If there was no callback, or the callback didn't do anything,
5744 then just do a straight memcpy. */
5748 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
5750 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
5755 linux_process_target::low_siginfo_fixup (siginfo_t
*native
, gdb_byte
*inf
,
5762 linux_process_target::supports_qxfer_siginfo ()
5768 linux_process_target::qxfer_siginfo (const char *annex
,
5769 unsigned char *readbuf
,
5770 unsigned const char *writebuf
,
5771 CORE_ADDR offset
, int len
)
5775 gdb_byte inf_siginfo
[sizeof (siginfo_t
)];
5777 if (current_thread
== NULL
)
5780 pid
= lwpid_of (current_thread
);
5782 threads_debug_printf ("%s siginfo for lwp %d.",
5783 readbuf
!= NULL
? "Reading" : "Writing",
5786 if (offset
>= sizeof (siginfo
))
5789 if (ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
5792 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
5793 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
5794 inferior with a 64-bit GDBSERVER should look the same as debugging it
5795 with a 32-bit GDBSERVER, we need to convert it. */
5796 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
5798 if (offset
+ len
> sizeof (siginfo
))
5799 len
= sizeof (siginfo
) - offset
;
5801 if (readbuf
!= NULL
)
5802 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
5805 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
5807 /* Convert back to ptrace layout before flushing it out. */
5808 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
5810 if (ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
5817 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5818 so we notice when children change state; as the handler for the
5819 sigsuspend in my_waitpid. */
5822 sigchld_handler (int signo
)
5824 int old_errno
= errno
;
5830 /* Use the async signal safe debug function. */
5831 if (debug_write ("sigchld_handler\n",
5832 sizeof ("sigchld_handler\n") - 1) < 0)
5833 break; /* just ignore */
5837 if (target_is_async_p ())
5838 async_file_mark (); /* trigger a linux_wait */
5844 linux_process_target::supports_non_stop ()
5850 linux_process_target::async (bool enable
)
5852 bool previous
= target_is_async_p ();
5854 threads_debug_printf ("async (%d), previous=%d",
5857 if (previous
!= enable
)
5860 sigemptyset (&mask
);
5861 sigaddset (&mask
, SIGCHLD
);
5863 gdb_sigmask (SIG_BLOCK
, &mask
, NULL
);
5867 if (!linux_event_pipe
.open_pipe ())
5869 gdb_sigmask (SIG_UNBLOCK
, &mask
, NULL
);
5871 warning ("creating event pipe failed.");
5875 /* Register the event loop handler. */
5876 add_file_handler (linux_event_pipe
.event_fd (),
5877 handle_target_event
, NULL
,
5880 /* Always trigger a linux_wait. */
5885 delete_file_handler (linux_event_pipe
.event_fd ());
5887 linux_event_pipe
.close_pipe ();
5890 gdb_sigmask (SIG_UNBLOCK
, &mask
, NULL
);
5897 linux_process_target::start_non_stop (bool nonstop
)
5899 /* Register or unregister from event-loop accordingly. */
5900 target_async (nonstop
);
5902 if (target_is_async_p () != (nonstop
!= false))
5909 linux_process_target::supports_multi_process ()
5914 /* Check if fork events are supported. */
5917 linux_process_target::supports_fork_events ()
5922 /* Check if vfork events are supported. */
5925 linux_process_target::supports_vfork_events ()
5930 /* Return the set of supported thread options. */
5933 linux_process_target::supported_thread_options ()
5935 return GDB_THREAD_OPTION_CLONE
| GDB_THREAD_OPTION_EXIT
;
5938 /* Check if exec events are supported. */
5941 linux_process_target::supports_exec_events ()
5946 /* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
5947 ptrace flags for all inferiors. This is in case the new GDB connection
5948 doesn't support the same set of events that the previous one did. */
5951 linux_process_target::handle_new_gdb_connection ()
5953 /* Request that all the lwps reset their ptrace options. */
5954 for_each_thread ([] (thread_info
*thread
)
5956 struct lwp_info
*lwp
= get_thread_lwp (thread
);
5960 /* Stop the lwp so we can modify its ptrace options. */
5961 lwp
->must_set_ptrace_flags
= 1;
5962 linux_stop_lwp (lwp
);
5966 /* Already stopped; go ahead and set the ptrace options. */
5967 struct process_info
*proc
= find_process_pid (pid_of (thread
));
5968 int options
= linux_low_ptrace_options (proc
->attached
);
5970 linux_enable_event_reporting (lwpid_of (thread
), options
);
5971 lwp
->must_set_ptrace_flags
= 0;
5977 linux_process_target::handle_monitor_command (char *mon
)
5979 #ifdef USE_THREAD_DB
5980 return thread_db_handle_monitor_command (mon
);
5987 linux_process_target::core_of_thread (ptid_t ptid
)
5989 return linux_common_core_of_thread (ptid
);
5993 linux_process_target::supports_disable_randomization ()
5999 linux_process_target::supports_agent ()
6005 linux_process_target::supports_range_stepping ()
6007 if (supports_software_single_step ())
6010 return low_supports_range_stepping ();
6014 linux_process_target::low_supports_range_stepping ()
6020 linux_process_target::supports_pid_to_exec_file ()
6026 linux_process_target::pid_to_exec_file (int pid
)
6028 return linux_proc_pid_to_exec_file (pid
);
6032 linux_process_target::supports_multifs ()
6038 linux_process_target::multifs_open (int pid
, const char *filename
,
6039 int flags
, mode_t mode
)
6041 return linux_mntns_open_cloexec (pid
, filename
, flags
, mode
);
6045 linux_process_target::multifs_unlink (int pid
, const char *filename
)
6047 return linux_mntns_unlink (pid
, filename
);
6051 linux_process_target::multifs_readlink (int pid
, const char *filename
,
6052 char *buf
, size_t bufsiz
)
6054 return linux_mntns_readlink (pid
, filename
, buf
, bufsiz
);
6057 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
6058 struct target_loadseg
6060 /* Core address to which the segment is mapped. */
6062 /* VMA recorded in the program header. */
6064 /* Size of this segment in memory. */
6068 # if defined PT_GETDSBT
6069 struct target_loadmap
6071 /* Protocol version number, must be zero. */
6073 /* Pointer to the DSBT table, its size, and the DSBT index. */
6074 unsigned *dsbt_table
;
6075 unsigned dsbt_size
, dsbt_index
;
6076 /* Number of segments in this map. */
6078 /* The actual memory map. */
6079 struct target_loadseg segs
[/*nsegs*/];
6081 # define LINUX_LOADMAP PT_GETDSBT
6082 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
6083 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
6085 struct target_loadmap
6087 /* Protocol version number, must be zero. */
6089 /* Number of segments in this map. */
6091 /* The actual memory map. */
6092 struct target_loadseg segs
[/*nsegs*/];
6094 # define LINUX_LOADMAP PTRACE_GETFDPIC
6095 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
6096 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
6100 linux_process_target::supports_read_loadmap ()
6106 linux_process_target::read_loadmap (const char *annex
, CORE_ADDR offset
,
6107 unsigned char *myaddr
, unsigned int len
)
6109 int pid
= lwpid_of (current_thread
);
6111 struct target_loadmap
*data
= NULL
;
6112 unsigned int actual_length
, copy_length
;
6114 if (strcmp (annex
, "exec") == 0)
6115 addr
= (int) LINUX_LOADMAP_EXEC
;
6116 else if (strcmp (annex
, "interp") == 0)
6117 addr
= (int) LINUX_LOADMAP_INTERP
;
6121 if (ptrace (LINUX_LOADMAP
, pid
, addr
, &data
) != 0)
6127 actual_length
= sizeof (struct target_loadmap
)
6128 + sizeof (struct target_loadseg
) * data
->nsegs
;
6130 if (offset
< 0 || offset
> actual_length
)
6133 copy_length
= actual_length
- offset
< len
? actual_length
- offset
: len
;
6134 memcpy (myaddr
, (char *) data
+ offset
, copy_length
);
6137 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
6140 linux_process_target::supports_catch_syscall ()
6142 return low_supports_catch_syscall ();
6146 linux_process_target::low_supports_catch_syscall ()
6152 linux_process_target::read_pc (regcache
*regcache
)
6154 if (!low_supports_breakpoints ())
6157 return low_get_pc (regcache
);
6161 linux_process_target::write_pc (regcache
*regcache
, CORE_ADDR pc
)
6163 gdb_assert (low_supports_breakpoints ());
6165 low_set_pc (regcache
, pc
);
6169 linux_process_target::supports_thread_stopped ()
6175 linux_process_target::thread_stopped (thread_info
*thread
)
6177 return get_thread_lwp (thread
)->stopped
;
6180 /* This exposes stop-all-threads functionality to other modules. */
6183 linux_process_target::pause_all (bool freeze
)
6185 stop_all_lwps (freeze
, NULL
);
6188 /* This exposes unstop-all-threads functionality to other gdbserver
6192 linux_process_target::unpause_all (bool unfreeze
)
6194 unstop_all_lwps (unfreeze
, NULL
);
6197 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
6200 get_phdr_phnum_from_proc_auxv (const int pid
, const int is_elf64
,
6201 CORE_ADDR
*phdr_memaddr
, int *num_phdr
)
6203 char filename
[PATH_MAX
];
6205 const int auxv_size
= is_elf64
6206 ? sizeof (Elf64_auxv_t
) : sizeof (Elf32_auxv_t
);
6207 char buf
[sizeof (Elf64_auxv_t
)]; /* The larger of the two. */
6209 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
6211 fd
= open (filename
, O_RDONLY
);
6217 while (read (fd
, buf
, auxv_size
) == auxv_size
6218 && (*phdr_memaddr
== 0 || *num_phdr
== 0))
6222 Elf64_auxv_t
*const aux
= (Elf64_auxv_t
*) buf
;
6224 switch (aux
->a_type
)
6227 *phdr_memaddr
= aux
->a_un
.a_val
;
6230 *num_phdr
= aux
->a_un
.a_val
;
6236 Elf32_auxv_t
*const aux
= (Elf32_auxv_t
*) buf
;
6238 switch (aux
->a_type
)
6241 *phdr_memaddr
= aux
->a_un
.a_val
;
6244 *num_phdr
= aux
->a_un
.a_val
;
6252 if (*phdr_memaddr
== 0 || *num_phdr
== 0)
6254 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
6255 "phdr_memaddr = %ld, phdr_num = %d",
6256 (long) *phdr_memaddr
, *num_phdr
);
6263 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
6266 get_dynamic (const int pid
, const int is_elf64
)
6268 CORE_ADDR phdr_memaddr
, relocation
;
6270 unsigned char *phdr_buf
;
6271 const int phdr_size
= is_elf64
? sizeof (Elf64_Phdr
) : sizeof (Elf32_Phdr
);
6273 if (get_phdr_phnum_from_proc_auxv (pid
, is_elf64
, &phdr_memaddr
, &num_phdr
))
6276 gdb_assert (num_phdr
< 100); /* Basic sanity check. */
6277 phdr_buf
= (unsigned char *) alloca (num_phdr
* phdr_size
);
6279 if (linux_read_memory (phdr_memaddr
, phdr_buf
, num_phdr
* phdr_size
))
6282 /* Compute relocation: it is expected to be 0 for "regular" executables,
6283 non-zero for PIE ones. */
6285 for (i
= 0; relocation
== -1 && i
< num_phdr
; i
++)
6288 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6290 if (p
->p_type
== PT_PHDR
)
6291 relocation
= phdr_memaddr
- p
->p_vaddr
;
6295 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6297 if (p
->p_type
== PT_PHDR
)
6298 relocation
= phdr_memaddr
- p
->p_vaddr
;
6301 if (relocation
== -1)
6303 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
6304 any real world executables, including PIE executables, have always
6305 PT_PHDR present. PT_PHDR is not present in some shared libraries or
6306 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
6307 or present DT_DEBUG anyway (fpc binaries are statically linked).
6309 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
6311 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
6316 for (i
= 0; i
< num_phdr
; i
++)
6320 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6322 if (p
->p_type
== PT_DYNAMIC
)
6323 return p
->p_vaddr
+ relocation
;
6327 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6329 if (p
->p_type
== PT_DYNAMIC
)
6330 return p
->p_vaddr
+ relocation
;
6337 /* Return &_r_debug in the inferior, or -1 if not present. Return value
6338 can be 0 if the inferior does not yet have the library list initialized.
6339 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
6340 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
6343 get_r_debug (const int pid
, const int is_elf64
)
6345 CORE_ADDR dynamic_memaddr
;
6346 const int dyn_size
= is_elf64
? sizeof (Elf64_Dyn
) : sizeof (Elf32_Dyn
);
6347 unsigned char buf
[sizeof (Elf64_Dyn
)]; /* The larger of the two. */
6350 dynamic_memaddr
= get_dynamic (pid
, is_elf64
);
6351 if (dynamic_memaddr
== 0)
6354 while (linux_read_memory (dynamic_memaddr
, buf
, dyn_size
) == 0)
6358 Elf64_Dyn
*const dyn
= (Elf64_Dyn
*) buf
;
6359 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6363 unsigned char buf
[sizeof (Elf64_Xword
)];
6367 #ifdef DT_MIPS_RLD_MAP
6368 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6370 if (linux_read_memory (dyn
->d_un
.d_val
,
6371 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6376 #endif /* DT_MIPS_RLD_MAP */
6377 #ifdef DT_MIPS_RLD_MAP_REL
6378 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6380 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6381 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6386 #endif /* DT_MIPS_RLD_MAP_REL */
6388 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6389 map
= dyn
->d_un
.d_val
;
6391 if (dyn
->d_tag
== DT_NULL
)
6396 Elf32_Dyn
*const dyn
= (Elf32_Dyn
*) buf
;
6397 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6401 unsigned char buf
[sizeof (Elf32_Word
)];
6405 #ifdef DT_MIPS_RLD_MAP
6406 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6408 if (linux_read_memory (dyn
->d_un
.d_val
,
6409 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6414 #endif /* DT_MIPS_RLD_MAP */
6415 #ifdef DT_MIPS_RLD_MAP_REL
6416 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6418 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6419 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6424 #endif /* DT_MIPS_RLD_MAP_REL */
6426 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6427 map
= dyn
->d_un
.d_val
;
6429 if (dyn
->d_tag
== DT_NULL
)
6433 dynamic_memaddr
+= dyn_size
;
6439 /* Read one pointer from MEMADDR in the inferior. */
6442 read_one_ptr (CORE_ADDR memaddr
, CORE_ADDR
*ptr
, int ptr_size
)
6446 /* Go through a union so this works on either big or little endian
6447 hosts, when the inferior's pointer size is smaller than the size
6448 of CORE_ADDR. It is assumed the inferior's endianness is the
6449 same of the superior's. */
6452 CORE_ADDR core_addr
;
6457 ret
= linux_read_memory (memaddr
, &addr
.uc
, ptr_size
);
6460 if (ptr_size
== sizeof (CORE_ADDR
))
6461 *ptr
= addr
.core_addr
;
6462 else if (ptr_size
== sizeof (unsigned int))
6465 gdb_assert_not_reached ("unhandled pointer size");
6471 linux_process_target::supports_qxfer_libraries_svr4 ()
6476 struct link_map_offsets
6478 /* Offset and size of r_debug.r_version. */
6479 int r_version_offset
;
6481 /* Offset and size of r_debug.r_map. */
6484 /* Offset of r_debug_extended.r_next. */
6487 /* Offset to l_addr field in struct link_map. */
6490 /* Offset to l_name field in struct link_map. */
6493 /* Offset to l_ld field in struct link_map. */
6496 /* Offset to l_next field in struct link_map. */
6499 /* Offset to l_prev field in struct link_map. */
6503 static const link_map_offsets lmo_32bit_offsets
=
6505 0, /* r_version offset. */
6506 4, /* r_debug.r_map offset. */
6507 20, /* r_debug_extended.r_next. */
6508 0, /* l_addr offset in link_map. */
6509 4, /* l_name offset in link_map. */
6510 8, /* l_ld offset in link_map. */
6511 12, /* l_next offset in link_map. */
6512 16 /* l_prev offset in link_map. */
6515 static const link_map_offsets lmo_64bit_offsets
=
6517 0, /* r_version offset. */
6518 8, /* r_debug.r_map offset. */
6519 40, /* r_debug_extended.r_next. */
6520 0, /* l_addr offset in link_map. */
6521 8, /* l_name offset in link_map. */
6522 16, /* l_ld offset in link_map. */
6523 24, /* l_next offset in link_map. */
6524 32 /* l_prev offset in link_map. */
6527 /* Get the loaded shared libraries from one namespace. */
6530 read_link_map (std::string
&document
, CORE_ADDR lmid
, CORE_ADDR lm_addr
,
6531 CORE_ADDR lm_prev
, int ptr_size
, const link_map_offsets
*lmo
)
6533 CORE_ADDR l_name
, l_addr
, l_ld
, l_next
, l_prev
;
6536 && read_one_ptr (lm_addr
+ lmo
->l_name_offset
,
6537 &l_name
, ptr_size
) == 0
6538 && read_one_ptr (lm_addr
+ lmo
->l_addr_offset
,
6539 &l_addr
, ptr_size
) == 0
6540 && read_one_ptr (lm_addr
+ lmo
->l_ld_offset
,
6541 &l_ld
, ptr_size
) == 0
6542 && read_one_ptr (lm_addr
+ lmo
->l_prev_offset
,
6543 &l_prev
, ptr_size
) == 0
6544 && read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
6545 &l_next
, ptr_size
) == 0)
6547 unsigned char libname
[PATH_MAX
];
6549 if (lm_prev
!= l_prev
)
6551 warning ("Corrupted shared library list: 0x%s != 0x%s",
6552 paddress (lm_prev
), paddress (l_prev
));
6556 /* Not checking for error because reading may stop before we've got
6557 PATH_MAX worth of characters. */
6559 linux_read_memory (l_name
, libname
, sizeof (libname
) - 1);
6560 libname
[sizeof (libname
) - 1] = '\0';
6561 if (libname
[0] != '\0')
6563 string_appendf (document
, "<library name=\"");
6564 xml_escape_text_append (document
, (char *) libname
);
6565 string_appendf (document
, "\" lm=\"0x%s\" l_addr=\"0x%s\" "
6566 "l_ld=\"0x%s\" lmid=\"0x%s\"/>",
6567 paddress (lm_addr
), paddress (l_addr
),
6568 paddress (l_ld
), paddress (lmid
));
6576 /* Construct qXfer:libraries-svr4:read reply. */
6579 linux_process_target::qxfer_libraries_svr4 (const char *annex
,
6580 unsigned char *readbuf
,
6581 unsigned const char *writebuf
,
6582 CORE_ADDR offset
, int len
)
6584 struct process_info_private
*const priv
= current_process ()->priv
;
6585 char filename
[PATH_MAX
];
6587 unsigned int machine
;
6588 CORE_ADDR lmid
= 0, lm_addr
= 0, lm_prev
= 0;
6590 if (writebuf
!= NULL
)
6592 if (readbuf
== NULL
)
6595 pid
= lwpid_of (current_thread
);
6596 xsnprintf (filename
, sizeof filename
, "/proc/%d/exe", pid
);
6597 is_elf64
= elf_64_file_p (filename
, &machine
);
6598 const link_map_offsets
*lmo
;
6602 lmo
= &lmo_64bit_offsets
;
6607 lmo
= &lmo_32bit_offsets
;
6611 while (annex
[0] != '\0')
6617 sep
= strchr (annex
, '=');
6621 name_len
= sep
- annex
;
6622 if (name_len
== 4 && startswith (annex
, "lmid"))
6624 else if (name_len
== 5 && startswith (annex
, "start"))
6626 else if (name_len
== 4 && startswith (annex
, "prev"))
6630 annex
= strchr (sep
, ';');
6637 annex
= decode_address_to_semicolon (addrp
, sep
+ 1);
6640 std::string document
= "<library-list-svr4 version=\"1.0\"";
6642 /* When the starting LM_ADDR is passed in the annex, only traverse that
6643 namespace, which is assumed to be identified by LMID.
6645 Otherwise, start with R_DEBUG and traverse all namespaces we find. */
6649 read_link_map (document
, lmid
, lm_addr
, lm_prev
, ptr_size
, lmo
);
6654 warning ("ignoring prev=0x%s without start", paddress (lm_prev
));
6656 /* We could interpret LMID as 'provide only the libraries for this
6657 namespace' but GDB is currently only providing lmid, start, and
6658 prev, or nothing. */
6660 warning ("ignoring lmid=0x%s without start", paddress (lmid
));
6662 CORE_ADDR r_debug
= priv
->r_debug
;
6664 r_debug
= priv
->r_debug
= get_r_debug (pid
, is_elf64
);
6666 /* We failed to find DT_DEBUG. Such situation will not change
6667 for this inferior - do not retry it. Report it to GDB as
6668 E01, see for the reasons at the GDB solib-svr4.c side. */
6669 if (r_debug
== (CORE_ADDR
) -1)
6672 /* Terminate the header if we end up with an empty list. */
6676 while (r_debug
!= 0)
6679 if (linux_read_memory (r_debug
+ lmo
->r_version_offset
,
6680 (unsigned char *) &r_version
,
6681 sizeof (r_version
)) != 0)
6683 warning ("unable to read r_version from 0x%s",
6684 paddress (r_debug
+ lmo
->r_version_offset
));
6690 warning ("unexpected r_debug version %d", r_version
);
6694 if (read_one_ptr (r_debug
+ lmo
->r_map_offset
, &lm_addr
,
6697 warning ("unable to read r_map from 0x%s",
6698 paddress (r_debug
+ lmo
->r_map_offset
));
6702 /* We read the entire namespace. */
6705 /* The first entry corresponds to the main executable unless the
6706 dynamic loader was loaded late by a static executable. But
6707 in such case the main executable does not have PT_DYNAMIC
6708 present and we would not have gotten here. */
6709 if (r_debug
== priv
->r_debug
)
6712 string_appendf (document
, " main-lm=\"0x%s\">",
6713 paddress (lm_addr
));
6718 if (read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
6719 &lm_addr
, ptr_size
) != 0)
6721 warning ("unable to read l_next from 0x%s",
6722 paddress (lm_addr
+ lmo
->l_next_offset
));
6727 read_link_map (document
, r_debug
, lm_addr
, lm_prev
, ptr_size
, lmo
);
6732 if (read_one_ptr (r_debug
+ lmo
->r_next_offset
, &r_debug
,
6735 warning ("unable to read r_next from 0x%s",
6736 paddress (r_debug
+ lmo
->r_next_offset
));
6742 document
+= "</library-list-svr4>";
6744 int document_len
= document
.length ();
6745 if (offset
< document_len
)
6746 document_len
-= offset
;
6749 if (len
> document_len
)
6752 memcpy (readbuf
, document
.data () + offset
, len
);
6757 #ifdef HAVE_LINUX_BTRACE
6760 linux_process_target::supports_btrace ()
6765 btrace_target_info
*
6766 linux_process_target::enable_btrace (thread_info
*tp
,
6767 const btrace_config
*conf
)
6769 return linux_enable_btrace (tp
->id
, conf
);
6772 /* See to_disable_btrace target method. */
6775 linux_process_target::disable_btrace (btrace_target_info
*tinfo
)
6777 enum btrace_error err
;
6779 err
= linux_disable_btrace (tinfo
);
6780 return (err
== BTRACE_ERR_NONE
? 0 : -1);
6783 /* Encode an Intel Processor Trace configuration. */
6786 linux_low_encode_pt_config (std::string
*buffer
,
6787 const struct btrace_data_pt_config
*config
)
6789 *buffer
+= "<pt-config>\n";
6791 switch (config
->cpu
.vendor
)
6794 string_xml_appendf (*buffer
, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
6795 "model=\"%u\" stepping=\"%u\"/>\n",
6796 config
->cpu
.family
, config
->cpu
.model
,
6797 config
->cpu
.stepping
);
6804 *buffer
+= "</pt-config>\n";
6807 /* Encode a raw buffer. */
6810 linux_low_encode_raw (std::string
*buffer
, const gdb_byte
*data
,
6816 /* We use hex encoding - see gdbsupport/rsp-low.h. */
6817 *buffer
+= "<raw>\n";
6823 elem
[0] = tohex ((*data
>> 4) & 0xf);
6824 elem
[1] = tohex (*data
++ & 0xf);
6826 buffer
->append (elem
, 2);
6829 *buffer
+= "</raw>\n";
6832 /* See to_read_btrace target method. */
6835 linux_process_target::read_btrace (btrace_target_info
*tinfo
,
6836 std::string
*buffer
,
6837 enum btrace_read_type type
)
6839 struct btrace_data btrace
;
6840 enum btrace_error err
;
6842 err
= linux_read_btrace (&btrace
, tinfo
, type
);
6843 if (err
!= BTRACE_ERR_NONE
)
6845 if (err
== BTRACE_ERR_OVERFLOW
)
6846 *buffer
+= "E.Overflow.";
6848 *buffer
+= "E.Generic Error.";
6853 switch (btrace
.format
)
6855 case BTRACE_FORMAT_NONE
:
6856 *buffer
+= "E.No Trace.";
6859 case BTRACE_FORMAT_BTS
:
6860 *buffer
+= "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n";
6861 *buffer
+= "<btrace version=\"1.0\">\n";
6863 for (const btrace_block
&block
: *btrace
.variant
.bts
.blocks
)
6864 string_xml_appendf (*buffer
, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
6865 paddress (block
.begin
), paddress (block
.end
));
6867 *buffer
+= "</btrace>\n";
6870 case BTRACE_FORMAT_PT
:
6871 *buffer
+= "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n";
6872 *buffer
+= "<btrace version=\"1.0\">\n";
6873 *buffer
+= "<pt>\n";
6875 linux_low_encode_pt_config (buffer
, &btrace
.variant
.pt
.config
);
6877 linux_low_encode_raw (buffer
, btrace
.variant
.pt
.data
,
6878 btrace
.variant
.pt
.size
);
6880 *buffer
+= "</pt>\n";
6881 *buffer
+= "</btrace>\n";
6885 *buffer
+= "E.Unsupported Trace Format.";
6892 /* See to_btrace_conf target method. */
6895 linux_process_target::read_btrace_conf (const btrace_target_info
*tinfo
,
6896 std::string
*buffer
)
6898 const struct btrace_config
*conf
;
6900 *buffer
+= "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n";
6901 *buffer
+= "<btrace-conf version=\"1.0\">\n";
6903 conf
= linux_btrace_conf (tinfo
);
6906 switch (conf
->format
)
6908 case BTRACE_FORMAT_NONE
:
6911 case BTRACE_FORMAT_BTS
:
6912 string_xml_appendf (*buffer
, "<bts");
6913 string_xml_appendf (*buffer
, " size=\"0x%x\"", conf
->bts
.size
);
6914 string_xml_appendf (*buffer
, " />\n");
6917 case BTRACE_FORMAT_PT
:
6918 string_xml_appendf (*buffer
, "<pt");
6919 string_xml_appendf (*buffer
, " size=\"0x%x\"", conf
->pt
.size
);
6920 string_xml_appendf (*buffer
, "/>\n");
6925 *buffer
+= "</btrace-conf>\n";
6928 #endif /* HAVE_LINUX_BTRACE */
6930 /* See nat/linux-nat.h. */
6933 current_lwp_ptid (void)
6935 return ptid_of (current_thread
);
6939 linux_process_target::thread_name (ptid_t thread
)
6941 return linux_proc_tid_get_name (thread
);
6946 linux_process_target::thread_handle (ptid_t ptid
, gdb_byte
**handle
,
6949 return thread_db_thread_handle (ptid
, handle
, handle_len
);
6954 linux_process_target::thread_pending_parent (thread_info
*thread
)
6956 lwp_info
*parent
= get_thread_lwp (thread
)->pending_parent ();
6958 if (parent
== nullptr)
6961 return get_lwp_thread (parent
);
6965 linux_process_target::thread_pending_child (thread_info
*thread
,
6966 target_waitkind
*kind
)
6968 lwp_info
*child
= get_thread_lwp (thread
)->pending_child (kind
);
6970 if (child
== nullptr)
6973 return get_lwp_thread (child
);
6976 /* Default implementation of linux_target_ops method "set_pc" for
6977 32-bit pc register which is literally named "pc". */
6980 linux_set_pc_32bit (struct regcache
*regcache
, CORE_ADDR pc
)
6982 uint32_t newpc
= pc
;
6984 supply_register_by_name (regcache
, "pc", &newpc
);
6987 /* Default implementation of linux_target_ops method "get_pc" for
6988 32-bit pc register which is literally named "pc". */
6991 linux_get_pc_32bit (struct regcache
*regcache
)
6995 collect_register_by_name (regcache
, "pc", &pc
);
6996 threads_debug_printf ("stop pc is 0x%" PRIx32
, pc
);
7000 /* Default implementation of linux_target_ops method "set_pc" for
7001 64-bit pc register which is literally named "pc". */
7004 linux_set_pc_64bit (struct regcache
*regcache
, CORE_ADDR pc
)
7006 uint64_t newpc
= pc
;
7008 supply_register_by_name (regcache
, "pc", &newpc
);
7011 /* Default implementation of linux_target_ops method "get_pc" for
7012 64-bit pc register which is literally named "pc". */
7015 linux_get_pc_64bit (struct regcache
*regcache
)
7019 collect_register_by_name (regcache
, "pc", &pc
);
7020 threads_debug_printf ("stop pc is 0x%" PRIx64
, pc
);
7024 /* See linux-low.h. */
7027 linux_get_auxv (int pid
, int wordsize
, CORE_ADDR match
, CORE_ADDR
*valp
)
7029 gdb_byte
*data
= (gdb_byte
*) alloca (2 * wordsize
);
7032 gdb_assert (wordsize
== 4 || wordsize
== 8);
7034 while (the_target
->read_auxv (pid
, offset
, data
, 2 * wordsize
)
7039 uint32_t *data_p
= (uint32_t *) data
;
7040 if (data_p
[0] == match
)
7048 uint64_t *data_p
= (uint64_t *) data
;
7049 if (data_p
[0] == match
)
7056 offset
+= 2 * wordsize
;
7062 /* See linux-low.h. */
7065 linux_get_hwcap (int pid
, int wordsize
)
7067 CORE_ADDR hwcap
= 0;
7068 linux_get_auxv (pid
, wordsize
, AT_HWCAP
, &hwcap
);
7072 /* See linux-low.h. */
7075 linux_get_hwcap2 (int pid
, int wordsize
)
7077 CORE_ADDR hwcap2
= 0;
7078 linux_get_auxv (pid
, wordsize
, AT_HWCAP2
, &hwcap2
);
7082 #ifdef HAVE_LINUX_REGSETS
7084 initialize_regsets_info (struct regsets_info
*info
)
7086 for (info
->num_regsets
= 0;
7087 info
->regsets
[info
->num_regsets
].size
>= 0;
7088 info
->num_regsets
++)
7094 initialize_low (void)
7096 struct sigaction sigchld_action
;
7098 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
7099 set_target_ops (the_linux_target
);
7101 linux_ptrace_init_warnings ();
7102 linux_proc_init_warnings ();
7104 sigchld_action
.sa_handler
= sigchld_handler
;
7105 sigemptyset (&sigchld_action
.sa_mask
);
7106 sigchld_action
.sa_flags
= SA_RESTART
;
7107 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
7109 initialize_low_arch ();
7111 linux_check_ptrace_features ();