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
;
2976 threads_debug_printf ("[%s]", target_pid_to_str (ptid
).c_str ());
2978 /* Translate generic target options into linux options. */
2980 if (target_options
& TARGET_WNOHANG
)
2983 bp_explains_trap
= 0;
2986 ourstatus
->set_ignore ();
2988 bool was_any_resumed
= any_resumed ();
2990 if (step_over_bkpt
== null_ptid
)
2991 pid
= wait_for_event (ptid
, &w
, options
);
2994 threads_debug_printf ("step_over_bkpt set [%s], doing a blocking wait",
2995 target_pid_to_str (step_over_bkpt
).c_str ());
2996 pid
= wait_for_event (step_over_bkpt
, &w
, options
& ~WNOHANG
);
2999 if (pid
== 0 || (pid
== -1 && !was_any_resumed
))
3001 gdb_assert (target_options
& TARGET_WNOHANG
);
3003 threads_debug_printf ("ret = null_ptid, TARGET_WAITKIND_IGNORE");
3005 ourstatus
->set_ignore ();
3010 threads_debug_printf ("ret = null_ptid, TARGET_WAITKIND_NO_RESUMED");
3012 ourstatus
->set_no_resumed ();
3016 event_child
= get_thread_lwp (current_thread
);
3018 /* wait_for_event only returns an exit status for the last
3019 child of a process. Report it. */
3020 if (WIFEXITED (w
) || WIFSIGNALED (w
))
3024 ourstatus
->set_exited (WEXITSTATUS (w
));
3026 threads_debug_printf
3027 ("ret = %s, exited with retcode %d",
3028 target_pid_to_str (ptid_of (current_thread
)).c_str (),
3033 ourstatus
->set_signalled (gdb_signal_from_host (WTERMSIG (w
)));
3035 threads_debug_printf
3036 ("ret = %s, terminated with signal %d",
3037 target_pid_to_str (ptid_of (current_thread
)).c_str (),
3041 return filter_exit_event (event_child
, ourstatus
);
3044 /* If step-over executes a breakpoint instruction, in the case of a
3045 hardware single step it means a gdb/gdbserver breakpoint had been
3046 planted on top of a permanent breakpoint, in the case of a software
3047 single step it may just mean that gdbserver hit the reinsert breakpoint.
3048 The PC has been adjusted by save_stop_reason to point at
3049 the breakpoint address.
3050 So in the case of the hardware single step advance the PC manually
3051 past the breakpoint and in the case of software single step advance only
3052 if it's not the single_step_breakpoint we are hitting.
3053 This avoids that a program would keep trapping a permanent breakpoint
3055 if (step_over_bkpt
!= null_ptid
3056 && event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3057 && (event_child
->stepping
3058 || !single_step_breakpoint_inserted_here (event_child
->stop_pc
)))
3060 int increment_pc
= 0;
3061 int breakpoint_kind
= 0;
3062 CORE_ADDR stop_pc
= event_child
->stop_pc
;
3064 breakpoint_kind
= breakpoint_kind_from_current_state (&stop_pc
);
3065 sw_breakpoint_from_kind (breakpoint_kind
, &increment_pc
);
3067 threads_debug_printf
3068 ("step-over for %s executed software breakpoint",
3069 target_pid_to_str (ptid_of (current_thread
)).c_str ());
3071 if (increment_pc
!= 0)
3073 struct regcache
*regcache
3074 = get_thread_regcache (current_thread
, 1);
3076 event_child
->stop_pc
+= increment_pc
;
3077 low_set_pc (regcache
, event_child
->stop_pc
);
3079 if (!low_breakpoint_at (event_child
->stop_pc
))
3080 event_child
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3084 /* If this event was not handled before, and is not a SIGTRAP, we
3085 report it. SIGILL and SIGSEGV are also treated as traps in case
3086 a breakpoint is inserted at the current PC. If this target does
3087 not support internal breakpoints at all, we also report the
3088 SIGTRAP without further processing; it's of no concern to us. */
3090 = (low_supports_breakpoints ()
3091 && (WSTOPSIG (w
) == SIGTRAP
3092 || ((WSTOPSIG (w
) == SIGILL
3093 || WSTOPSIG (w
) == SIGSEGV
)
3094 && low_breakpoint_at (event_child
->stop_pc
))));
3096 if (maybe_internal_trap
)
3098 /* Handle anything that requires bookkeeping before deciding to
3099 report the event or continue waiting. */
3101 /* First check if we can explain the SIGTRAP with an internal
3102 breakpoint, or if we should possibly report the event to GDB.
3103 Do this before anything that may remove or insert a
3105 bp_explains_trap
= breakpoint_inserted_here (event_child
->stop_pc
);
3107 /* We have a SIGTRAP, possibly a step-over dance has just
3108 finished. If so, tweak the state machine accordingly,
3109 reinsert breakpoints and delete any single-step
3111 step_over_finished
= finish_step_over (event_child
);
3113 /* Now invoke the callbacks of any internal breakpoints there. */
3114 check_breakpoints (event_child
->stop_pc
);
3116 /* Handle tracepoint data collecting. This may overflow the
3117 trace buffer, and cause a tracing stop, removing
3119 trace_event
= handle_tracepoints (event_child
);
3121 if (bp_explains_trap
)
3122 threads_debug_printf ("Hit a gdbserver breakpoint.");
3126 /* We have some other signal, possibly a step-over dance was in
3127 progress, and it should be cancelled too. */
3128 step_over_finished
= finish_step_over (event_child
);
3131 /* We have all the data we need. Either report the event to GDB, or
3132 resume threads and keep waiting for more. */
3134 /* If we're collecting a fast tracepoint, finish the collection and
3135 move out of the jump pad before delivering a signal. See
3136 linux_stabilize_threads. */
3139 && WSTOPSIG (w
) != SIGTRAP
3140 && supports_fast_tracepoints ()
3141 && agent_loaded_p ())
3143 threads_debug_printf ("Got signal %d for LWP %ld. Check if we need "
3144 "to defer or adjust it.",
3145 WSTOPSIG (w
), lwpid_of (current_thread
));
3147 /* Allow debugging the jump pad itself. */
3148 if (current_thread
->last_resume_kind
!= resume_step
3149 && maybe_move_out_of_jump_pad (event_child
, &w
))
3151 enqueue_one_deferred_signal (event_child
, &w
);
3153 threads_debug_printf ("Signal %d for LWP %ld deferred (in jump pad)",
3154 WSTOPSIG (w
), lwpid_of (current_thread
));
3156 resume_one_lwp (event_child
, 0, 0, NULL
);
3158 return ignore_event (ourstatus
);
3162 if (event_child
->collecting_fast_tracepoint
3163 != fast_tpoint_collect_result::not_collecting
)
3165 threads_debug_printf
3166 ("LWP %ld was trying to move out of the jump pad (%d). "
3167 "Check if we're already there.",
3168 lwpid_of (current_thread
),
3169 (int) event_child
->collecting_fast_tracepoint
);
3173 event_child
->collecting_fast_tracepoint
3174 = linux_fast_tracepoint_collecting (event_child
, NULL
);
3176 if (event_child
->collecting_fast_tracepoint
3177 != fast_tpoint_collect_result::before_insn
)
3179 /* No longer need this breakpoint. */
3180 if (event_child
->exit_jump_pad_bkpt
!= NULL
)
3182 threads_debug_printf
3183 ("No longer need exit-jump-pad bkpt; removing it."
3184 "stopping all threads momentarily.");
3186 /* Other running threads could hit this breakpoint.
3187 We don't handle moribund locations like GDB does,
3188 instead we always pause all threads when removing
3189 breakpoints, so that any step-over or
3190 decr_pc_after_break adjustment is always taken
3191 care of while the breakpoint is still
3193 stop_all_lwps (1, event_child
);
3195 delete_breakpoint (event_child
->exit_jump_pad_bkpt
);
3196 event_child
->exit_jump_pad_bkpt
= NULL
;
3198 unstop_all_lwps (1, event_child
);
3200 gdb_assert (event_child
->suspended
>= 0);
3204 if (event_child
->collecting_fast_tracepoint
3205 == fast_tpoint_collect_result::not_collecting
)
3207 threads_debug_printf
3208 ("fast tracepoint finished collecting successfully.");
3210 /* We may have a deferred signal to report. */
3211 if (dequeue_one_deferred_signal (event_child
, &w
))
3212 threads_debug_printf ("dequeued one signal.");
3215 threads_debug_printf ("no deferred signals.");
3217 if (stabilizing_threads
)
3219 ourstatus
->set_stopped (GDB_SIGNAL_0
);
3221 threads_debug_printf
3222 ("ret = %s, stopped while stabilizing threads",
3223 target_pid_to_str (ptid_of (current_thread
)).c_str ());
3225 return ptid_of (current_thread
);
3231 /* Check whether GDB would be interested in this event. */
3233 /* Check if GDB is interested in this syscall. */
3235 && WSTOPSIG (w
) == SYSCALL_SIGTRAP
3236 && !gdb_catch_this_syscall (event_child
))
3238 threads_debug_printf ("Ignored syscall for LWP %ld.",
3239 lwpid_of (current_thread
));
3241 resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
3243 return ignore_event (ourstatus
);
3246 /* If GDB is not interested in this signal, don't stop other
3247 threads, and don't report it to GDB. Just resume the inferior
3248 right away. We do this for threading-related signals as well as
3249 any that GDB specifically requested we ignore. But never ignore
3250 SIGSTOP if we sent it ourselves, and do not ignore signals when
3251 stepping - they may require special handling to skip the signal
3252 handler. Also never ignore signals that could be caused by a
3255 && current_thread
->last_resume_kind
!= resume_step
3257 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
3258 (current_process ()->priv
->thread_db
!= NULL
3259 && (WSTOPSIG (w
) == __SIGRTMIN
3260 || WSTOPSIG (w
) == __SIGRTMIN
+ 1))
3263 (cs
.pass_signals
[gdb_signal_from_host (WSTOPSIG (w
))]
3264 && !(WSTOPSIG (w
) == SIGSTOP
3265 && current_thread
->last_resume_kind
== resume_stop
)
3266 && !linux_wstatus_maybe_breakpoint (w
))))
3268 siginfo_t info
, *info_p
;
3270 threads_debug_printf ("Ignored signal %d for LWP %ld.",
3271 WSTOPSIG (w
), lwpid_of (current_thread
));
3273 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
3274 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
3279 if (step_over_finished
)
3281 /* We cancelled this thread's step-over above. We still
3282 need to unsuspend all other LWPs, and set them back
3283 running again while the signal handler runs. */
3284 unsuspend_all_lwps (event_child
);
3286 /* Enqueue the pending signal info so that proceed_all_lwps
3288 enqueue_pending_signal (event_child
, WSTOPSIG (w
), info_p
);
3290 proceed_all_lwps ();
3294 resume_one_lwp (event_child
, event_child
->stepping
,
3295 WSTOPSIG (w
), info_p
);
3298 return ignore_event (ourstatus
);
3301 /* Note that all addresses are always "out of the step range" when
3302 there's no range to begin with. */
3303 in_step_range
= lwp_in_step_range (event_child
);
3305 /* If GDB wanted this thread to single step, and the thread is out
3306 of the step range, we always want to report the SIGTRAP, and let
3307 GDB handle it. Watchpoints should always be reported. So should
3308 signals we can't explain. A SIGTRAP we can't explain could be a
3309 GDB breakpoint --- we may or not support Z0 breakpoints. If we
3310 do, we're be able to handle GDB breakpoints on top of internal
3311 breakpoints, by handling the internal breakpoint and still
3312 reporting the event to GDB. If we don't, we're out of luck, GDB
3313 won't see the breakpoint hit. If we see a single-step event but
3314 the thread should be continuing, don't pass the trap to gdb.
3315 That indicates that we had previously finished a single-step but
3316 left the single-step pending -- see
3317 complete_ongoing_step_over. */
3318 report_to_gdb
= (!maybe_internal_trap
3319 || (current_thread
->last_resume_kind
== resume_step
3321 || event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3323 && !bp_explains_trap
3325 && !step_over_finished
3326 && !(current_thread
->last_resume_kind
== resume_continue
3327 && event_child
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
))
3328 || (gdb_breakpoint_here (event_child
->stop_pc
)
3329 && gdb_condition_true_at_breakpoint (event_child
->stop_pc
)
3330 && gdb_no_commands_at_breakpoint (event_child
->stop_pc
))
3331 || event_child
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
);
3333 run_breakpoint_commands (event_child
->stop_pc
);
3335 /* We found no reason GDB would want us to stop. We either hit one
3336 of our own breakpoints, or finished an internal step GDB
3337 shouldn't know about. */
3340 if (bp_explains_trap
)
3341 threads_debug_printf ("Hit a gdbserver breakpoint.");
3343 if (step_over_finished
)
3344 threads_debug_printf ("Step-over finished.");
3347 threads_debug_printf ("Tracepoint event.");
3349 if (lwp_in_step_range (event_child
))
3350 threads_debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).",
3351 paddress (event_child
->stop_pc
),
3352 paddress (event_child
->step_range_start
),
3353 paddress (event_child
->step_range_end
));
3355 /* We're not reporting this breakpoint to GDB, so apply the
3356 decr_pc_after_break adjustment to the inferior's regcache
3359 if (low_supports_breakpoints ())
3361 struct regcache
*regcache
3362 = get_thread_regcache (current_thread
, 1);
3363 low_set_pc (regcache
, event_child
->stop_pc
);
3366 if (step_over_finished
)
3368 /* If we have finished stepping over a breakpoint, we've
3369 stopped and suspended all LWPs momentarily except the
3370 stepping one. This is where we resume them all again.
3371 We're going to keep waiting, so use proceed, which
3372 handles stepping over the next breakpoint. */
3373 unsuspend_all_lwps (event_child
);
3377 /* Remove the single-step breakpoints if any. Note that
3378 there isn't single-step breakpoint if we finished stepping
3380 if (supports_software_single_step ()
3381 && has_single_step_breakpoints (current_thread
))
3383 stop_all_lwps (0, event_child
);
3384 delete_single_step_breakpoints (current_thread
);
3385 unstop_all_lwps (0, event_child
);
3389 threads_debug_printf ("proceeding all threads.");
3391 proceed_all_lwps ();
3393 return ignore_event (ourstatus
);
3398 if (event_child
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
3399 threads_debug_printf ("LWP %ld: extended event with waitstatus %s",
3400 lwpid_of (get_lwp_thread (event_child
)),
3401 event_child
->waitstatus
.to_string ().c_str ());
3403 if (current_thread
->last_resume_kind
== resume_step
)
3405 if (event_child
->step_range_start
== event_child
->step_range_end
)
3406 threads_debug_printf
3407 ("GDB wanted to single-step, reporting event.");
3408 else if (!lwp_in_step_range (event_child
))
3409 threads_debug_printf ("Out of step range, reporting event.");
3412 if (event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
3413 threads_debug_printf ("Stopped by watchpoint.");
3414 else if (gdb_breakpoint_here (event_child
->stop_pc
))
3415 threads_debug_printf ("Stopped by GDB breakpoint.");
3418 threads_debug_printf ("Hit a non-gdbserver trap event.");
3420 /* Alright, we're going to report a stop. */
3422 /* Remove single-step breakpoints. */
3423 if (supports_software_single_step ())
3425 /* Remove single-step breakpoints or not. It it is true, stop all
3426 lwps, so that other threads won't hit the breakpoint in the
3428 int remove_single_step_breakpoints_p
= 0;
3432 remove_single_step_breakpoints_p
3433 = has_single_step_breakpoints (current_thread
);
3437 /* In all-stop, a stop reply cancels all previous resume
3438 requests. Delete all single-step breakpoints. */
3440 find_thread ([&] (thread_info
*thread
) {
3441 if (has_single_step_breakpoints (thread
))
3443 remove_single_step_breakpoints_p
= 1;
3451 if (remove_single_step_breakpoints_p
)
3453 /* If we remove single-step breakpoints from memory, stop all lwps,
3454 so that other threads won't hit the breakpoint in the staled
3456 stop_all_lwps (0, event_child
);
3460 gdb_assert (has_single_step_breakpoints (current_thread
));
3461 delete_single_step_breakpoints (current_thread
);
3465 for_each_thread ([] (thread_info
*thread
){
3466 if (has_single_step_breakpoints (thread
))
3467 delete_single_step_breakpoints (thread
);
3471 unstop_all_lwps (0, event_child
);
3475 if (!stabilizing_threads
)
3477 /* In all-stop, stop all threads. */
3479 stop_all_lwps (0, NULL
);
3481 if (step_over_finished
)
3485 /* If we were doing a step-over, all other threads but
3486 the stepping one had been paused in start_step_over,
3487 with their suspend counts incremented. We don't want
3488 to do a full unstop/unpause, because we're in
3489 all-stop mode (so we want threads stopped), but we
3490 still need to unsuspend the other threads, to
3491 decrement their `suspended' count back. */
3492 unsuspend_all_lwps (event_child
);
3496 /* If we just finished a step-over, then all threads had
3497 been momentarily paused. In all-stop, that's fine,
3498 we want threads stopped by now anyway. In non-stop,
3499 we need to re-resume threads that GDB wanted to be
3501 unstop_all_lwps (1, event_child
);
3505 /* If we're not waiting for a specific LWP, choose an event LWP
3506 from among those that have had events. Giving equal priority
3507 to all LWPs that have had events helps prevent
3509 if (ptid
== minus_one_ptid
)
3511 event_child
->status_pending_p
= 1;
3512 event_child
->status_pending
= w
;
3514 select_event_lwp (&event_child
);
3516 /* current_thread and event_child must stay in sync. */
3517 switch_to_thread (get_lwp_thread (event_child
));
3519 event_child
->status_pending_p
= 0;
3520 w
= event_child
->status_pending
;
3524 /* Stabilize threads (move out of jump pads). */
3526 target_stabilize_threads ();
3530 /* If we just finished a step-over, then all threads had been
3531 momentarily paused. In all-stop, that's fine, we want
3532 threads stopped by now anyway. In non-stop, we need to
3533 re-resume threads that GDB wanted to be running. */
3534 if (step_over_finished
)
3535 unstop_all_lwps (1, event_child
);
3538 /* At this point, we haven't set OURSTATUS. This is where we do it. */
3539 gdb_assert (ourstatus
->kind () == TARGET_WAITKIND_IGNORE
);
3541 if (event_child
->waitstatus
.kind () != TARGET_WAITKIND_IGNORE
)
3543 /* If the reported event is an exit, fork, vfork, clone or exec,
3546 /* Break the unreported fork/vfork/clone relationship chain. */
3547 if (is_new_child_status (event_child
->waitstatus
.kind ()))
3549 event_child
->relative
->relative
= NULL
;
3550 event_child
->relative
= NULL
;
3553 *ourstatus
= event_child
->waitstatus
;
3554 /* Clear the event lwp's waitstatus since we handled it already. */
3555 event_child
->waitstatus
.set_ignore ();
3559 /* The LWP stopped due to a plain signal or a syscall signal. Either way,
3560 event_child->waitstatus wasn't filled in with the details, so look at
3561 the wait status W. */
3562 if (WSTOPSIG (w
) == SYSCALL_SIGTRAP
)
3566 get_syscall_trapinfo (event_child
, &syscall_number
);
3567 if (event_child
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
)
3568 ourstatus
->set_syscall_entry (syscall_number
);
3569 else if (event_child
->syscall_state
== TARGET_WAITKIND_SYSCALL_RETURN
)
3570 ourstatus
->set_syscall_return (syscall_number
);
3572 gdb_assert_not_reached ("unexpected syscall state");
3574 else if (current_thread
->last_resume_kind
== resume_stop
3575 && WSTOPSIG (w
) == SIGSTOP
)
3577 /* A thread that has been requested to stop by GDB with vCont;t,
3578 and it stopped cleanly, so report as SIG0. The use of
3579 SIGSTOP is an implementation detail. */
3580 ourstatus
->set_stopped (GDB_SIGNAL_0
);
3583 ourstatus
->set_stopped (gdb_signal_from_host (WSTOPSIG (w
)));
3586 /* Now that we've selected our final event LWP, un-adjust its PC if
3587 it was a software breakpoint, and the client doesn't know we can
3588 adjust the breakpoint ourselves. */
3589 if (event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3590 && !cs
.swbreak_feature
)
3592 int decr_pc
= low_decr_pc_after_break ();
3596 struct regcache
*regcache
3597 = get_thread_regcache (current_thread
, 1);
3598 low_set_pc (regcache
, event_child
->stop_pc
+ decr_pc
);
3602 gdb_assert (step_over_bkpt
== null_ptid
);
3604 threads_debug_printf ("ret = %s, %s",
3605 target_pid_to_str (ptid_of (current_thread
)).c_str (),
3606 ourstatus
->to_string ().c_str ());
3608 return filter_exit_event (event_child
, ourstatus
);
3611 /* Get rid of any pending event in the pipe. */
3613 async_file_flush (void)
3615 linux_event_pipe
.flush ();
3618 /* Put something in the pipe, so the event loop wakes up. */
3620 async_file_mark (void)
3622 linux_event_pipe
.mark ();
3626 linux_process_target::wait (ptid_t ptid
,
3627 target_waitstatus
*ourstatus
,
3628 target_wait_flags target_options
)
3632 /* Flush the async file first. */
3633 if (target_is_async_p ())
3634 async_file_flush ();
3638 event_ptid
= wait_1 (ptid
, ourstatus
, target_options
);
3640 while ((target_options
& TARGET_WNOHANG
) == 0
3641 && ourstatus
->kind () == TARGET_WAITKIND_IGNORE
);
3643 /* If at least one stop was reported, there may be more. A single
3644 SIGCHLD can signal more than one child stop. */
3645 if (target_is_async_p ()
3646 && (target_options
& TARGET_WNOHANG
) != 0
3647 && event_ptid
!= null_ptid
)
3653 /* Send a signal to an LWP. */
3656 kill_lwp (unsigned long lwpid
, int signo
)
3661 ret
= syscall (__NR_tkill
, lwpid
, signo
);
3662 if (errno
== ENOSYS
)
3664 /* If tkill fails, then we are not using nptl threads, a
3665 configuration we no longer support. */
3666 perror_with_name (("tkill"));
3672 linux_stop_lwp (struct lwp_info
*lwp
)
3678 send_sigstop (struct lwp_info
*lwp
)
3682 pid
= lwpid_of (get_lwp_thread (lwp
));
3684 /* If we already have a pending stop signal for this process, don't
3686 if (lwp
->stop_expected
)
3688 threads_debug_printf ("Have pending sigstop for lwp %d", pid
);
3693 threads_debug_printf ("Sending sigstop to lwp %d", pid
);
3695 lwp
->stop_expected
= 1;
3696 kill_lwp (pid
, SIGSTOP
);
3700 send_sigstop (thread_info
*thread
, lwp_info
*except
)
3702 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3704 /* Ignore EXCEPT. */
3714 /* Increment the suspend count of an LWP, and stop it, if not stopped
3717 suspend_and_send_sigstop (thread_info
*thread
, lwp_info
*except
)
3719 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3721 /* Ignore EXCEPT. */
3725 lwp_suspended_inc (lwp
);
3727 send_sigstop (thread
, except
);
3731 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
3733 /* Store the exit status for later. */
3734 lwp
->status_pending_p
= 1;
3735 lwp
->status_pending
= wstat
;
3737 /* Store in waitstatus as well, as there's nothing else to process
3739 if (WIFEXITED (wstat
))
3740 lwp
->waitstatus
.set_exited (WEXITSTATUS (wstat
));
3741 else if (WIFSIGNALED (wstat
))
3742 lwp
->waitstatus
.set_signalled (gdb_signal_from_host (WTERMSIG (wstat
)));
3744 /* Prevent trying to stop it. */
3747 /* No further stops are expected from a dead lwp. */
3748 lwp
->stop_expected
= 0;
3751 /* Return true if LWP has exited already, and has a pending exit event
3752 to report to GDB. */
3755 lwp_is_marked_dead (struct lwp_info
*lwp
)
3757 return (lwp
->status_pending_p
3758 && (WIFEXITED (lwp
->status_pending
)
3759 || WIFSIGNALED (lwp
->status_pending
)));
3763 linux_process_target::wait_for_sigstop ()
3765 struct thread_info
*saved_thread
;
3770 saved_thread
= current_thread
;
3771 if (saved_thread
!= NULL
)
3772 saved_tid
= saved_thread
->id
;
3774 saved_tid
= null_ptid
; /* avoid bogus unused warning */
3776 scoped_restore_current_thread restore_thread
;
3778 threads_debug_printf ("pulling events");
3780 /* Passing NULL_PTID as filter indicates we want all events to be
3781 left pending. Eventually this returns when there are no
3782 unwaited-for children left. */
3783 ret
= wait_for_event_filtered (minus_one_ptid
, null_ptid
, &wstat
, __WALL
);
3784 gdb_assert (ret
== -1);
3786 if (saved_thread
== NULL
|| mythread_alive (saved_tid
))
3790 threads_debug_printf ("Previously current thread died.");
3792 /* We can't change the current inferior behind GDB's back,
3793 otherwise, a subsequent command may apply to the wrong
3795 restore_thread
.dont_restore ();
3796 switch_to_thread (nullptr);
3801 linux_process_target::stuck_in_jump_pad (thread_info
*thread
)
3803 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3805 if (lwp
->suspended
!= 0)
3807 internal_error ("LWP %ld is suspended, suspended=%d\n",
3808 lwpid_of (thread
), lwp
->suspended
);
3810 gdb_assert (lwp
->stopped
);
3812 /* Allow debugging the jump pad, gdb_collect, etc.. */
3813 return (supports_fast_tracepoints ()
3814 && agent_loaded_p ()
3815 && (gdb_breakpoint_here (lwp
->stop_pc
)
3816 || lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3817 || thread
->last_resume_kind
== resume_step
)
3818 && (linux_fast_tracepoint_collecting (lwp
, NULL
)
3819 != fast_tpoint_collect_result::not_collecting
));
3823 linux_process_target::move_out_of_jump_pad (thread_info
*thread
)
3825 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3828 if (lwp
->suspended
!= 0)
3830 internal_error ("LWP %ld is suspended, suspended=%d\n",
3831 lwpid_of (thread
), lwp
->suspended
);
3833 gdb_assert (lwp
->stopped
);
3835 /* For gdb_breakpoint_here. */
3836 scoped_restore_current_thread restore_thread
;
3837 switch_to_thread (thread
);
3839 wstat
= lwp
->status_pending_p
? &lwp
->status_pending
: NULL
;
3841 /* Allow debugging the jump pad, gdb_collect, etc. */
3842 if (!gdb_breakpoint_here (lwp
->stop_pc
)
3843 && lwp
->stop_reason
!= TARGET_STOPPED_BY_WATCHPOINT
3844 && thread
->last_resume_kind
!= resume_step
3845 && maybe_move_out_of_jump_pad (lwp
, wstat
))
3847 threads_debug_printf ("LWP %ld needs stabilizing (in jump pad)",
3852 lwp
->status_pending_p
= 0;
3853 enqueue_one_deferred_signal (lwp
, wstat
);
3855 threads_debug_printf ("Signal %d for LWP %ld deferred (in jump pad",
3856 WSTOPSIG (*wstat
), lwpid_of (thread
));
3859 resume_one_lwp (lwp
, 0, 0, NULL
);
3862 lwp_suspended_inc (lwp
);
3866 lwp_running (thread_info
*thread
)
3868 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3870 if (lwp_is_marked_dead (lwp
))
3873 return !lwp
->stopped
;
3877 linux_process_target::stop_all_lwps (int suspend
, lwp_info
*except
)
3879 /* Should not be called recursively. */
3880 gdb_assert (stopping_threads
== NOT_STOPPING_THREADS
);
3882 THREADS_SCOPED_DEBUG_ENTER_EXIT
;
3884 threads_debug_printf
3885 ("%s, except=%s", suspend
? "stop-and-suspend" : "stop",
3887 ? target_pid_to_str (ptid_of (get_lwp_thread (except
))).c_str ()
3890 stopping_threads
= (suspend
3891 ? STOPPING_AND_SUSPENDING_THREADS
3892 : STOPPING_THREADS
);
3895 for_each_thread ([&] (thread_info
*thread
)
3897 suspend_and_send_sigstop (thread
, except
);
3900 for_each_thread ([&] (thread_info
*thread
)
3902 send_sigstop (thread
, except
);
3905 wait_for_sigstop ();
3906 stopping_threads
= NOT_STOPPING_THREADS
;
3908 threads_debug_printf ("setting stopping_threads back to !stopping");
3911 /* Enqueue one signal in the chain of signals which need to be
3912 delivered to this process on next resume. */
3915 enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
)
3917 lwp
->pending_signals
.emplace_back (signal
);
3918 if (info
== nullptr)
3919 memset (&lwp
->pending_signals
.back ().info
, 0, sizeof (siginfo_t
));
3921 lwp
->pending_signals
.back ().info
= *info
;
3925 linux_process_target::install_software_single_step_breakpoints (lwp_info
*lwp
)
3927 struct thread_info
*thread
= get_lwp_thread (lwp
);
3928 struct regcache
*regcache
= get_thread_regcache (thread
, 1);
3930 scoped_restore_current_thread restore_thread
;
3932 switch_to_thread (thread
);
3933 std::vector
<CORE_ADDR
> next_pcs
= low_get_next_pcs (regcache
);
3935 for (CORE_ADDR pc
: next_pcs
)
3936 set_single_step_breakpoint (pc
, current_ptid
);
3940 linux_process_target::single_step (lwp_info
* lwp
)
3944 if (supports_hardware_single_step ())
3948 else if (supports_software_single_step ())
3950 install_software_single_step_breakpoints (lwp
);
3954 threads_debug_printf ("stepping is not implemented on this target");
3959 /* The signal can be delivered to the inferior if we are not trying to
3960 finish a fast tracepoint collect. Since signal can be delivered in
3961 the step-over, the program may go to signal handler and trap again
3962 after return from the signal handler. We can live with the spurious
3966 lwp_signal_can_be_delivered (struct lwp_info
*lwp
)
3968 return (lwp
->collecting_fast_tracepoint
3969 == fast_tpoint_collect_result::not_collecting
);
3973 linux_process_target::resume_one_lwp_throw (lwp_info
*lwp
, int step
,
3974 int signal
, siginfo_t
*info
)
3976 struct thread_info
*thread
= get_lwp_thread (lwp
);
3978 struct process_info
*proc
= get_thread_process (thread
);
3980 /* Note that target description may not be initialised
3981 (proc->tdesc == NULL) at this point because the program hasn't
3982 stopped at the first instruction yet. It means GDBserver skips
3983 the extra traps from the wrapper program (see option --wrapper).
3984 Code in this function that requires register access should be
3985 guarded by proc->tdesc == NULL or something else. */
3987 if (lwp
->stopped
== 0)
3990 gdb_assert (lwp
->waitstatus
.kind () == TARGET_WAITKIND_IGNORE
);
3992 fast_tpoint_collect_result fast_tp_collecting
3993 = lwp
->collecting_fast_tracepoint
;
3995 gdb_assert (!stabilizing_threads
3996 || (fast_tp_collecting
3997 != fast_tpoint_collect_result::not_collecting
));
3999 /* Cancel actions that rely on GDB not changing the PC (e.g., the
4000 user used the "jump" command, or "set $pc = foo"). */
4001 if (thread
->while_stepping
!= NULL
&& lwp
->stop_pc
!= get_pc (lwp
))
4003 /* Collecting 'while-stepping' actions doesn't make sense
4005 release_while_stepping_state_list (thread
);
4008 /* If we have pending signals or status, and a new signal, enqueue the
4009 signal. Also enqueue the signal if it can't be delivered to the
4010 inferior right now. */
4012 && (lwp
->status_pending_p
4013 || !lwp
->pending_signals
.empty ()
4014 || !lwp_signal_can_be_delivered (lwp
)))
4016 enqueue_pending_signal (lwp
, signal
, info
);
4018 /* Postpone any pending signal. It was enqueued above. */
4022 if (lwp
->status_pending_p
)
4024 threads_debug_printf
4025 ("Not resuming lwp %ld (%s, stop %s); has pending status",
4026 lwpid_of (thread
), step
? "step" : "continue",
4027 lwp
->stop_expected
? "expected" : "not expected");
4031 scoped_restore_current_thread restore_thread
;
4032 switch_to_thread (thread
);
4034 /* This bit needs some thinking about. If we get a signal that
4035 we must report while a single-step reinsert is still pending,
4036 we often end up resuming the thread. It might be better to
4037 (ew) allow a stack of pending events; then we could be sure that
4038 the reinsert happened right away and not lose any signals.
4040 Making this stack would also shrink the window in which breakpoints are
4041 uninserted (see comment in linux_wait_for_lwp) but not enough for
4042 complete correctness, so it won't solve that problem. It may be
4043 worthwhile just to solve this one, however. */
4044 if (lwp
->bp_reinsert
!= 0)
4046 threads_debug_printf (" pending reinsert at 0x%s",
4047 paddress (lwp
->bp_reinsert
));
4049 if (supports_hardware_single_step ())
4051 if (fast_tp_collecting
== fast_tpoint_collect_result::not_collecting
)
4054 warning ("BAD - reinserting but not stepping.");
4056 warning ("BAD - reinserting and suspended(%d).",
4061 step
= maybe_hw_step (thread
);
4064 if (fast_tp_collecting
== fast_tpoint_collect_result::before_insn
)
4065 threads_debug_printf
4066 ("lwp %ld wants to get out of fast tracepoint jump pad "
4067 "(exit-jump-pad-bkpt)", lwpid_of (thread
));
4069 else if (fast_tp_collecting
== fast_tpoint_collect_result::at_insn
)
4071 threads_debug_printf
4072 ("lwp %ld wants to get out of fast tracepoint jump pad single-stepping",
4075 if (supports_hardware_single_step ())
4079 internal_error ("moving out of jump pad single-stepping"
4080 " not implemented on this target");
4084 /* If we have while-stepping actions in this thread set it stepping.
4085 If we have a signal to deliver, it may or may not be set to
4086 SIG_IGN, we don't know. Assume so, and allow collecting
4087 while-stepping into a signal handler. A possible smart thing to
4088 do would be to set an internal breakpoint at the signal return
4089 address, continue, and carry on catching this while-stepping
4090 action only when that breakpoint is hit. A future
4092 if (thread
->while_stepping
!= NULL
)
4094 threads_debug_printf
4095 ("lwp %ld has a while-stepping action -> forcing step.",
4098 step
= single_step (lwp
);
4101 if (proc
->tdesc
!= NULL
&& low_supports_breakpoints ())
4103 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
4105 lwp
->stop_pc
= low_get_pc (regcache
);
4107 threads_debug_printf (" %s from pc 0x%lx", step
? "step" : "continue",
4108 (long) lwp
->stop_pc
);
4111 /* If we have pending signals, consume one if it can be delivered to
4113 if (!lwp
->pending_signals
.empty () && lwp_signal_can_be_delivered (lwp
))
4115 const pending_signal
&p_sig
= lwp
->pending_signals
.front ();
4117 signal
= p_sig
.signal
;
4118 if (p_sig
.info
.si_signo
!= 0)
4119 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
4122 lwp
->pending_signals
.pop_front ();
4125 threads_debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)",
4126 lwpid_of (thread
), step
? "step" : "continue", signal
,
4127 lwp
->stop_expected
? "expected" : "not expected");
4129 low_prepare_to_resume (lwp
);
4131 regcache_invalidate_thread (thread
);
4133 lwp
->stepping
= step
;
4135 ptrace_request
= PTRACE_SINGLESTEP
;
4136 else if (gdb_catching_syscalls_p (lwp
))
4137 ptrace_request
= PTRACE_SYSCALL
;
4139 ptrace_request
= PTRACE_CONT
;
4140 ptrace (ptrace_request
,
4142 (PTRACE_TYPE_ARG3
) 0,
4143 /* Coerce to a uintptr_t first to avoid potential gcc warning
4144 of coercing an 8 byte integer to a 4 byte pointer. */
4145 (PTRACE_TYPE_ARG4
) (uintptr_t) signal
);
4149 int saved_errno
= errno
;
4151 threads_debug_printf ("ptrace errno = %d (%s)",
4152 saved_errno
, strerror (saved_errno
));
4154 errno
= saved_errno
;
4155 perror_with_name ("resuming thread");
4158 /* Successfully resumed. Clear state that no longer makes sense,
4159 and mark the LWP as running. Must not do this before resuming
4160 otherwise if that fails other code will be confused. E.g., we'd
4161 later try to stop the LWP and hang forever waiting for a stop
4162 status. Note that we must not throw after this is cleared,
4163 otherwise handle_zombie_lwp_error would get confused. */
4165 lwp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4169 linux_process_target::low_prepare_to_resume (lwp_info
*lwp
)
4174 /* Called when we try to resume a stopped LWP and that errors out. If
4175 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
4176 or about to become), discard the error, clear any pending status
4177 the LWP may have, and return true (we'll collect the exit status
4178 soon enough). Otherwise, return false. */
4181 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
4183 struct thread_info
*thread
= get_lwp_thread (lp
);
4185 /* If we get an error after resuming the LWP successfully, we'd
4186 confuse !T state for the LWP being gone. */
4187 gdb_assert (lp
->stopped
);
4189 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
4190 because even if ptrace failed with ESRCH, the tracee may be "not
4191 yet fully dead", but already refusing ptrace requests. In that
4192 case the tracee has 'R (Running)' state for a little bit
4193 (observed in Linux 3.18). See also the note on ESRCH in the
4194 ptrace(2) man page. Instead, check whether the LWP has any state
4195 other than ptrace-stopped. */
4197 /* Don't assume anything if /proc/PID/status can't be read. */
4198 if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread
)) == 0)
4200 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4201 lp
->status_pending_p
= 0;
4208 linux_process_target::resume_one_lwp (lwp_info
*lwp
, int step
, int signal
,
4213 resume_one_lwp_throw (lwp
, step
, signal
, info
);
4215 catch (const gdb_exception_error
&ex
)
4217 if (check_ptrace_stopped_lwp_gone (lwp
))
4219 /* This could because we tried to resume an LWP after its leader
4220 exited. Mark it as resumed, so we can collect an exit event
4223 lwp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4230 /* This function is called once per thread via for_each_thread.
4231 We look up which resume request applies to THREAD and mark it with a
4232 pointer to the appropriate resume request.
4234 This algorithm is O(threads * resume elements), but resume elements
4235 is small (and will remain small at least until GDB supports thread
4239 linux_set_resume_request (thread_info
*thread
, thread_resume
*resume
, size_t n
)
4241 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4243 for (int ndx
= 0; ndx
< n
; ndx
++)
4245 ptid_t ptid
= resume
[ndx
].thread
;
4246 if (ptid
== minus_one_ptid
4247 || ptid
== thread
->id
4248 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
4250 || (ptid
.pid () == pid_of (thread
)
4252 || ptid
.lwp () == -1)))
4254 if (resume
[ndx
].kind
== resume_stop
4255 && thread
->last_resume_kind
== resume_stop
)
4257 threads_debug_printf
4258 ("already %s LWP %ld at GDB's request",
4259 (thread
->last_status
.kind () == TARGET_WAITKIND_STOPPED
4260 ? "stopped" : "stopping"),
4266 /* Ignore (wildcard) resume requests for already-resumed
4268 if (resume
[ndx
].kind
!= resume_stop
4269 && thread
->last_resume_kind
!= resume_stop
)
4271 threads_debug_printf
4272 ("already %s LWP %ld at GDB's request",
4273 (thread
->last_resume_kind
== resume_step
4274 ? "stepping" : "continuing"),
4279 /* Don't let wildcard resumes resume fork/vfork/clone
4280 children that GDB does not yet know are new children. */
4281 if (lwp
->relative
!= NULL
)
4283 struct lwp_info
*rel
= lwp
->relative
;
4285 if (rel
->status_pending_p
4286 && is_new_child_status (rel
->waitstatus
.kind ()))
4288 threads_debug_printf
4289 ("not resuming LWP %ld: has queued stop reply",
4295 /* If the thread has a pending event that has already been
4296 reported to GDBserver core, but GDB has not pulled the
4297 event out of the vStopped queue yet, likewise, ignore the
4298 (wildcard) resume request. */
4299 if (in_queued_stop_replies (thread
->id
))
4301 threads_debug_printf
4302 ("not resuming LWP %ld: has queued stop reply",
4307 lwp
->resume
= &resume
[ndx
];
4308 thread
->last_resume_kind
= lwp
->resume
->kind
;
4310 lwp
->step_range_start
= lwp
->resume
->step_range_start
;
4311 lwp
->step_range_end
= lwp
->resume
->step_range_end
;
4313 /* If we had a deferred signal to report, dequeue one now.
4314 This can happen if LWP gets more than one signal while
4315 trying to get out of a jump pad. */
4317 && !lwp
->status_pending_p
4318 && dequeue_one_deferred_signal (lwp
, &lwp
->status_pending
))
4320 lwp
->status_pending_p
= 1;
4322 threads_debug_printf
4323 ("Dequeueing deferred signal %d for LWP %ld, "
4324 "leaving status pending.",
4325 WSTOPSIG (lwp
->status_pending
),
4333 /* No resume action for this thread. */
4338 linux_process_target::resume_status_pending (thread_info
*thread
)
4340 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4342 /* LWPs which will not be resumed are not interesting, because
4343 we might not wait for them next time through linux_wait. */
4344 if (lwp
->resume
== NULL
)
4347 return thread_still_has_status_pending (thread
);
4351 linux_process_target::thread_needs_step_over (thread_info
*thread
)
4353 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4355 struct process_info
*proc
= get_thread_process (thread
);
4357 /* GDBserver is skipping the extra traps from the wrapper program,
4358 don't have to do step over. */
4359 if (proc
->tdesc
== NULL
)
4362 /* LWPs which will not be resumed are not interesting, because we
4363 might not wait for them next time through linux_wait. */
4367 threads_debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped",
4372 if (thread
->last_resume_kind
== resume_stop
)
4374 threads_debug_printf
4375 ("Need step over [LWP %ld]? Ignoring, should remain stopped",
4380 gdb_assert (lwp
->suspended
>= 0);
4384 threads_debug_printf ("Need step over [LWP %ld]? Ignoring, suspended",
4389 if (lwp
->status_pending_p
)
4391 threads_debug_printf
4392 ("Need step over [LWP %ld]? Ignoring, has pending status.",
4397 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
4401 /* If the PC has changed since we stopped, then don't do anything,
4402 and let the breakpoint/tracepoint be hit. This happens if, for
4403 instance, GDB handled the decr_pc_after_break subtraction itself,
4404 GDB is OOL stepping this thread, or the user has issued a "jump"
4405 command, or poked thread's registers herself. */
4406 if (pc
!= lwp
->stop_pc
)
4408 threads_debug_printf
4409 ("Need step over [LWP %ld]? Cancelling, PC was changed. "
4410 "Old stop_pc was 0x%s, PC is now 0x%s", lwpid_of (thread
),
4411 paddress (lwp
->stop_pc
), paddress (pc
));
4415 /* On software single step target, resume the inferior with signal
4416 rather than stepping over. */
4417 if (supports_software_single_step ()
4418 && !lwp
->pending_signals
.empty ()
4419 && lwp_signal_can_be_delivered (lwp
))
4421 threads_debug_printf
4422 ("Need step over [LWP %ld]? Ignoring, has pending signals.",
4428 scoped_restore_current_thread restore_thread
;
4429 switch_to_thread (thread
);
4431 /* We can only step over breakpoints we know about. */
4432 if (breakpoint_here (pc
) || fast_tracepoint_jump_here (pc
))
4434 /* Don't step over a breakpoint that GDB expects to hit
4435 though. If the condition is being evaluated on the target's side
4436 and it evaluate to false, step over this breakpoint as well. */
4437 if (gdb_breakpoint_here (pc
)
4438 && gdb_condition_true_at_breakpoint (pc
)
4439 && gdb_no_commands_at_breakpoint (pc
))
4441 threads_debug_printf ("Need step over [LWP %ld]? yes, but found"
4442 " GDB breakpoint at 0x%s; skipping step over",
4443 lwpid_of (thread
), paddress (pc
));
4449 threads_debug_printf ("Need step over [LWP %ld]? yes, "
4450 "found breakpoint at 0x%s",
4451 lwpid_of (thread
), paddress (pc
));
4453 /* We've found an lwp that needs stepping over --- return 1 so
4454 that find_thread stops looking. */
4459 threads_debug_printf
4460 ("Need step over [LWP %ld]? No, no breakpoint found at 0x%s",
4461 lwpid_of (thread
), paddress (pc
));
4467 linux_process_target::start_step_over (lwp_info
*lwp
)
4469 struct thread_info
*thread
= get_lwp_thread (lwp
);
4472 threads_debug_printf ("Starting step-over on LWP %ld. Stopping all threads",
4475 stop_all_lwps (1, lwp
);
4477 if (lwp
->suspended
!= 0)
4479 internal_error ("LWP %ld suspended=%d\n", lwpid_of (thread
),
4483 threads_debug_printf ("Done stopping all threads for step-over.");
4485 /* Note, we should always reach here with an already adjusted PC,
4486 either by GDB (if we're resuming due to GDB's request), or by our
4487 caller, if we just finished handling an internal breakpoint GDB
4488 shouldn't care about. */
4493 scoped_restore_current_thread restore_thread
;
4494 switch_to_thread (thread
);
4496 lwp
->bp_reinsert
= pc
;
4497 uninsert_breakpoints_at (pc
);
4498 uninsert_fast_tracepoint_jumps_at (pc
);
4500 step
= single_step (lwp
);
4503 resume_one_lwp (lwp
, step
, 0, NULL
);
4505 /* Require next event from this LWP. */
4506 step_over_bkpt
= thread
->id
;
4510 linux_process_target::finish_step_over (lwp_info
*lwp
)
4512 if (lwp
->bp_reinsert
!= 0)
4514 scoped_restore_current_thread restore_thread
;
4516 threads_debug_printf ("Finished step over.");
4518 switch_to_thread (get_lwp_thread (lwp
));
4520 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
4521 may be no breakpoint to reinsert there by now. */
4522 reinsert_breakpoints_at (lwp
->bp_reinsert
);
4523 reinsert_fast_tracepoint_jumps_at (lwp
->bp_reinsert
);
4525 lwp
->bp_reinsert
= 0;
4527 /* Delete any single-step breakpoints. No longer needed. We
4528 don't have to worry about other threads hitting this trap,
4529 and later not being able to explain it, because we were
4530 stepping over a breakpoint, and we hold all threads but
4531 LWP stopped while doing that. */
4532 if (!supports_hardware_single_step ())
4534 gdb_assert (has_single_step_breakpoints (current_thread
));
4535 delete_single_step_breakpoints (current_thread
);
4538 step_over_bkpt
= null_ptid
;
4546 linux_process_target::complete_ongoing_step_over ()
4548 if (step_over_bkpt
!= null_ptid
)
4550 struct lwp_info
*lwp
;
4554 threads_debug_printf ("detach: step over in progress, finish it first");
4556 /* Passing NULL_PTID as filter indicates we want all events to
4557 be left pending. Eventually this returns when there are no
4558 unwaited-for children left. */
4559 ret
= wait_for_event_filtered (minus_one_ptid
, null_ptid
, &wstat
,
4561 gdb_assert (ret
== -1);
4563 lwp
= find_lwp_pid (step_over_bkpt
);
4566 finish_step_over (lwp
);
4568 /* If we got our step SIGTRAP, don't leave it pending,
4569 otherwise we would report it to GDB as a spurious
4571 gdb_assert (lwp
->status_pending_p
);
4572 if (WIFSTOPPED (lwp
->status_pending
)
4573 && WSTOPSIG (lwp
->status_pending
) == SIGTRAP
)
4575 thread_info
*thread
= get_lwp_thread (lwp
);
4576 if (thread
->last_resume_kind
!= resume_step
)
4578 threads_debug_printf ("detach: discard step-over SIGTRAP");
4580 lwp
->status_pending_p
= 0;
4581 lwp
->status_pending
= 0;
4582 resume_one_lwp (lwp
, lwp
->stepping
, 0, NULL
);
4585 threads_debug_printf
4586 ("detach: resume_step, not discarding step-over SIGTRAP");
4589 step_over_bkpt
= null_ptid
;
4590 unsuspend_all_lwps (lwp
);
4595 linux_process_target::resume_one_thread (thread_info
*thread
,
4596 bool leave_all_stopped
)
4598 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4601 if (lwp
->resume
== NULL
)
4604 if (lwp
->resume
->kind
== resume_stop
)
4606 threads_debug_printf ("resume_stop request for LWP %ld",
4611 threads_debug_printf ("stopping LWP %ld", lwpid_of (thread
));
4613 /* Stop the thread, and wait for the event asynchronously,
4614 through the event loop. */
4619 threads_debug_printf ("already stopped LWP %ld", lwpid_of (thread
));
4621 /* The LWP may have been stopped in an internal event that
4622 was not meant to be notified back to GDB (e.g., gdbserver
4623 breakpoint), so we should be reporting a stop event in
4626 /* If the thread already has a pending SIGSTOP, this is a
4627 no-op. Otherwise, something later will presumably resume
4628 the thread and this will cause it to cancel any pending
4629 operation, due to last_resume_kind == resume_stop. If
4630 the thread already has a pending status to report, we
4631 will still report it the next time we wait - see
4632 status_pending_p_callback. */
4634 /* If we already have a pending signal to report, then
4635 there's no need to queue a SIGSTOP, as this means we're
4636 midway through moving the LWP out of the jumppad, and we
4637 will report the pending signal as soon as that is
4639 if (lwp
->pending_signals_to_report
.empty ())
4643 /* For stop requests, we're done. */
4645 thread
->last_status
.set_ignore ();
4649 /* If this thread which is about to be resumed has a pending status,
4650 then don't resume it - we can just report the pending status.
4651 Likewise if it is suspended, because e.g., another thread is
4652 stepping past a breakpoint. Make sure to queue any signals that
4653 would otherwise be sent. In all-stop mode, we do this decision
4654 based on if *any* thread has a pending status. If there's a
4655 thread that needs the step-over-breakpoint dance, then don't
4656 resume any other thread but that particular one. */
4657 leave_pending
= (lwp
->suspended
4658 || lwp
->status_pending_p
4659 || leave_all_stopped
);
4661 /* If we have a new signal, enqueue the signal. */
4662 if (lwp
->resume
->sig
!= 0)
4664 siginfo_t info
, *info_p
;
4666 /* If this is the same signal we were previously stopped by,
4667 make sure to queue its siginfo. */
4668 if (WIFSTOPPED (lwp
->last_status
)
4669 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
4670 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
),
4671 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
4676 enqueue_pending_signal (lwp
, lwp
->resume
->sig
, info_p
);
4681 threads_debug_printf ("resuming LWP %ld", lwpid_of (thread
));
4683 proceed_one_lwp (thread
, NULL
);
4686 threads_debug_printf ("leaving LWP %ld stopped", lwpid_of (thread
));
4688 thread
->last_status
.set_ignore ();
4693 linux_process_target::resume (thread_resume
*resume_info
, size_t n
)
4695 struct thread_info
*need_step_over
= NULL
;
4697 THREADS_SCOPED_DEBUG_ENTER_EXIT
;
4699 for_each_thread ([&] (thread_info
*thread
)
4701 linux_set_resume_request (thread
, resume_info
, n
);
4704 /* If there is a thread which would otherwise be resumed, which has
4705 a pending status, then don't resume any threads - we can just
4706 report the pending status. Make sure to queue any signals that
4707 would otherwise be sent. In non-stop mode, we'll apply this
4708 logic to each thread individually. We consume all pending events
4709 before considering to start a step-over (in all-stop). */
4710 bool any_pending
= false;
4712 any_pending
= find_thread ([this] (thread_info
*thread
)
4714 return resume_status_pending (thread
);
4717 /* If there is a thread which would otherwise be resumed, which is
4718 stopped at a breakpoint that needs stepping over, then don't
4719 resume any threads - have it step over the breakpoint with all
4720 other threads stopped, then resume all threads again. Make sure
4721 to queue any signals that would otherwise be delivered or
4723 if (!any_pending
&& low_supports_breakpoints ())
4724 need_step_over
= find_thread ([this] (thread_info
*thread
)
4726 return thread_needs_step_over (thread
);
4729 bool leave_all_stopped
= (need_step_over
!= NULL
|| any_pending
);
4731 if (need_step_over
!= NULL
)
4732 threads_debug_printf ("Not resuming all, need step over");
4733 else if (any_pending
)
4734 threads_debug_printf ("Not resuming, all-stop and found "
4735 "an LWP with pending status");
4737 threads_debug_printf ("Resuming, no pending status or step over needed");
4739 /* Even if we're leaving threads stopped, queue all signals we'd
4740 otherwise deliver. */
4741 for_each_thread ([&] (thread_info
*thread
)
4743 resume_one_thread (thread
, leave_all_stopped
);
4747 start_step_over (get_thread_lwp (need_step_over
));
4749 /* We may have events that were pending that can/should be sent to
4750 the client now. Trigger a linux_wait call. */
4751 if (target_is_async_p ())
4756 linux_process_target::proceed_one_lwp (thread_info
*thread
, lwp_info
*except
)
4758 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4764 threads_debug_printf ("lwp %ld", lwpid_of (thread
));
4768 threads_debug_printf (" LWP %ld already running", lwpid_of (thread
));
4772 if (thread
->last_resume_kind
== resume_stop
4773 && thread
->last_status
.kind () != TARGET_WAITKIND_IGNORE
)
4775 threads_debug_printf (" client wants LWP to remain %ld stopped",
4780 if (lwp
->status_pending_p
)
4782 threads_debug_printf (" LWP %ld has pending status, leaving stopped",
4787 gdb_assert (lwp
->suspended
>= 0);
4791 threads_debug_printf (" LWP %ld is suspended", lwpid_of (thread
));
4795 if (thread
->last_resume_kind
== resume_stop
4796 && lwp
->pending_signals_to_report
.empty ()
4797 && (lwp
->collecting_fast_tracepoint
4798 == fast_tpoint_collect_result::not_collecting
))
4800 /* We haven't reported this LWP as stopped yet (otherwise, the
4801 last_status.kind check above would catch it, and we wouldn't
4802 reach here. This LWP may have been momentarily paused by a
4803 stop_all_lwps call while handling for example, another LWP's
4804 step-over. In that case, the pending expected SIGSTOP signal
4805 that was queued at vCont;t handling time will have already
4806 been consumed by wait_for_sigstop, and so we need to requeue
4807 another one here. Note that if the LWP already has a SIGSTOP
4808 pending, this is a no-op. */
4810 threads_debug_printf
4811 ("Client wants LWP %ld to stop. Making sure it has a SIGSTOP pending",
4817 if (thread
->last_resume_kind
== resume_step
)
4819 threads_debug_printf (" stepping LWP %ld, client wants it stepping",
4822 /* If resume_step is requested by GDB, install single-step
4823 breakpoints when the thread is about to be actually resumed if
4824 the single-step breakpoints weren't removed. */
4825 if (supports_software_single_step ()
4826 && !has_single_step_breakpoints (thread
))
4827 install_software_single_step_breakpoints (lwp
);
4829 step
= maybe_hw_step (thread
);
4831 else if (lwp
->bp_reinsert
!= 0)
4833 threads_debug_printf (" stepping LWP %ld, reinsert set",
4836 step
= maybe_hw_step (thread
);
4841 resume_one_lwp (lwp
, step
, 0, NULL
);
4845 linux_process_target::unsuspend_and_proceed_one_lwp (thread_info
*thread
,
4848 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4853 lwp_suspended_decr (lwp
);
4855 proceed_one_lwp (thread
, except
);
4859 linux_process_target::proceed_all_lwps ()
4861 struct thread_info
*need_step_over
;
4863 /* If there is a thread which would otherwise be resumed, which is
4864 stopped at a breakpoint that needs stepping over, then don't
4865 resume any threads - have it step over the breakpoint with all
4866 other threads stopped, then resume all threads again. */
4868 if (low_supports_breakpoints ())
4870 need_step_over
= find_thread ([this] (thread_info
*thread
)
4872 return thread_needs_step_over (thread
);
4875 if (need_step_over
!= NULL
)
4877 threads_debug_printf ("found thread %ld needing a step-over",
4878 lwpid_of (need_step_over
));
4880 start_step_over (get_thread_lwp (need_step_over
));
4885 threads_debug_printf ("Proceeding, no step-over needed");
4887 for_each_thread ([this] (thread_info
*thread
)
4889 proceed_one_lwp (thread
, NULL
);
4894 linux_process_target::unstop_all_lwps (int unsuspend
, lwp_info
*except
)
4896 THREADS_SCOPED_DEBUG_ENTER_EXIT
;
4899 threads_debug_printf ("except=(LWP %ld)",
4900 lwpid_of (get_lwp_thread (except
)));
4902 threads_debug_printf ("except=nullptr");
4905 for_each_thread ([&] (thread_info
*thread
)
4907 unsuspend_and_proceed_one_lwp (thread
, except
);
4910 for_each_thread ([&] (thread_info
*thread
)
4912 proceed_one_lwp (thread
, except
);
4917 #ifdef HAVE_LINUX_REGSETS
4919 #define use_linux_regsets 1
4921 /* Returns true if REGSET has been disabled. */
4924 regset_disabled (struct regsets_info
*info
, struct regset_info
*regset
)
4926 return (info
->disabled_regsets
!= NULL
4927 && info
->disabled_regsets
[regset
- info
->regsets
]);
4930 /* Disable REGSET. */
4933 disable_regset (struct regsets_info
*info
, struct regset_info
*regset
)
4937 dr_offset
= regset
- info
->regsets
;
4938 if (info
->disabled_regsets
== NULL
)
4939 info
->disabled_regsets
= (char *) xcalloc (1, info
->num_regsets
);
4940 info
->disabled_regsets
[dr_offset
] = 1;
4944 regsets_fetch_inferior_registers (struct regsets_info
*regsets_info
,
4945 struct regcache
*regcache
)
4947 struct regset_info
*regset
;
4948 int saw_general_regs
= 0;
4952 pid
= lwpid_of (current_thread
);
4953 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
4958 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
))
4961 buf
= xmalloc (regset
->size
);
4963 nt_type
= regset
->nt_type
;
4967 iov
.iov_len
= regset
->size
;
4968 data
= (void *) &iov
;
4974 res
= ptrace (regset
->get_request
, pid
,
4975 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
4977 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
4982 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
4984 /* If we get EIO on a regset, or an EINVAL and the regset is
4985 optional, do not try it again for this process mode. */
4986 disable_regset (regsets_info
, regset
);
4988 else if (errno
== ENODATA
)
4990 /* ENODATA may be returned if the regset is currently
4991 not "active". This can happen in normal operation,
4992 so suppress the warning in this case. */
4994 else if (errno
== ESRCH
)
4996 /* At this point, ESRCH should mean the process is
4997 already gone, in which case we simply ignore attempts
4998 to read its registers. */
5003 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
5010 if (regset
->type
== GENERAL_REGS
)
5011 saw_general_regs
= 1;
5012 regset
->store_function (regcache
, buf
);
5016 if (saw_general_regs
)
5023 regsets_store_inferior_registers (struct regsets_info
*regsets_info
,
5024 struct regcache
*regcache
)
5026 struct regset_info
*regset
;
5027 int saw_general_regs
= 0;
5031 pid
= lwpid_of (current_thread
);
5032 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
5037 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
)
5038 || regset
->fill_function
== NULL
)
5041 buf
= xmalloc (regset
->size
);
5043 /* First fill the buffer with the current register set contents,
5044 in case there are any items in the kernel's regset that are
5045 not in gdbserver's regcache. */
5047 nt_type
= regset
->nt_type
;
5051 iov
.iov_len
= regset
->size
;
5052 data
= (void *) &iov
;
5058 res
= ptrace (regset
->get_request
, pid
,
5059 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5061 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
5066 /* Then overlay our cached registers on that. */
5067 regset
->fill_function (regcache
, buf
);
5069 /* Only now do we write the register set. */
5071 res
= ptrace (regset
->set_request
, pid
,
5072 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5074 res
= ptrace (regset
->set_request
, pid
, data
, nt_type
);
5081 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5083 /* If we get EIO on a regset, or an EINVAL and the regset is
5084 optional, do not try it again for this process mode. */
5085 disable_regset (regsets_info
, regset
);
5087 else if (errno
== ESRCH
)
5089 /* At this point, ESRCH should mean the process is
5090 already gone, in which case we simply ignore attempts
5091 to change its registers. See also the related
5092 comment in resume_one_lwp. */
5098 perror ("Warning: ptrace(regsets_store_inferior_registers)");
5101 else if (regset
->type
== GENERAL_REGS
)
5102 saw_general_regs
= 1;
5105 if (saw_general_regs
)
5111 #else /* !HAVE_LINUX_REGSETS */
5113 #define use_linux_regsets 0
5114 #define regsets_fetch_inferior_registers(regsets_info, regcache) 1
5115 #define regsets_store_inferior_registers(regsets_info, regcache) 1
5119 /* Return 1 if register REGNO is supported by one of the regset ptrace
5120 calls or 0 if it has to be transferred individually. */
5123 linux_register_in_regsets (const struct regs_info
*regs_info
, int regno
)
5125 unsigned char mask
= 1 << (regno
% 8);
5126 size_t index
= regno
/ 8;
5128 return (use_linux_regsets
5129 && (regs_info
->regset_bitmap
== NULL
5130 || (regs_info
->regset_bitmap
[index
] & mask
) != 0));
5133 #ifdef HAVE_LINUX_USRREGS
5136 register_addr (const struct usrregs_info
*usrregs
, int regnum
)
5140 if (regnum
< 0 || regnum
>= usrregs
->num_regs
)
5141 error ("Invalid register number %d.", regnum
);
5143 addr
= usrregs
->regmap
[regnum
];
5150 linux_process_target::fetch_register (const usrregs_info
*usrregs
,
5151 regcache
*regcache
, int regno
)
5158 if (regno
>= usrregs
->num_regs
)
5160 if (low_cannot_fetch_register (regno
))
5163 regaddr
= register_addr (usrregs
, regno
);
5167 size
= ((register_size (regcache
->tdesc
, regno
)
5168 + sizeof (PTRACE_XFER_TYPE
) - 1)
5169 & -sizeof (PTRACE_XFER_TYPE
));
5170 buf
= (char *) alloca (size
);
5172 pid
= lwpid_of (current_thread
);
5173 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5176 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
5177 ptrace (PTRACE_PEEKUSER
, pid
,
5178 /* Coerce to a uintptr_t first to avoid potential gcc warning
5179 of coercing an 8 byte integer to a 4 byte pointer. */
5180 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
, (PTRACE_TYPE_ARG4
) 0);
5181 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5184 /* Mark register REGNO unavailable. */
5185 supply_register (regcache
, regno
, NULL
);
5190 low_supply_ptrace_register (regcache
, regno
, buf
);
5194 linux_process_target::store_register (const usrregs_info
*usrregs
,
5195 regcache
*regcache
, int regno
)
5202 if (regno
>= usrregs
->num_regs
)
5204 if (low_cannot_store_register (regno
))
5207 regaddr
= register_addr (usrregs
, regno
);
5211 size
= ((register_size (regcache
->tdesc
, regno
)
5212 + sizeof (PTRACE_XFER_TYPE
) - 1)
5213 & -sizeof (PTRACE_XFER_TYPE
));
5214 buf
= (char *) alloca (size
);
5215 memset (buf
, 0, size
);
5217 low_collect_ptrace_register (regcache
, regno
, buf
);
5219 pid
= lwpid_of (current_thread
);
5220 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5223 ptrace (PTRACE_POKEUSER
, pid
,
5224 /* Coerce to a uintptr_t first to avoid potential gcc warning
5225 about coercing an 8 byte integer to a 4 byte pointer. */
5226 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
,
5227 (PTRACE_TYPE_ARG4
) *(PTRACE_XFER_TYPE
*) (buf
+ i
));
5230 /* At this point, ESRCH should mean the process is
5231 already gone, in which case we simply ignore attempts
5232 to change its registers. See also the related
5233 comment in resume_one_lwp. */
5238 if (!low_cannot_store_register (regno
))
5239 error ("writing register %d: %s", regno
, safe_strerror (errno
));
5241 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5244 #endif /* HAVE_LINUX_USRREGS */
5247 linux_process_target::low_collect_ptrace_register (regcache
*regcache
,
5248 int regno
, char *buf
)
5250 collect_register (regcache
, regno
, buf
);
5254 linux_process_target::low_supply_ptrace_register (regcache
*regcache
,
5255 int regno
, const char *buf
)
5257 supply_register (regcache
, regno
, buf
);
5261 linux_process_target::usr_fetch_inferior_registers (const regs_info
*regs_info
,
5265 #ifdef HAVE_LINUX_USRREGS
5266 struct usrregs_info
*usr
= regs_info
->usrregs
;
5270 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5271 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5272 fetch_register (usr
, regcache
, regno
);
5275 fetch_register (usr
, regcache
, regno
);
5280 linux_process_target::usr_store_inferior_registers (const regs_info
*regs_info
,
5284 #ifdef HAVE_LINUX_USRREGS
5285 struct usrregs_info
*usr
= regs_info
->usrregs
;
5289 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5290 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5291 store_register (usr
, regcache
, regno
);
5294 store_register (usr
, regcache
, regno
);
5299 linux_process_target::fetch_registers (regcache
*regcache
, int regno
)
5303 const regs_info
*regs_info
= get_regs_info ();
5307 if (regs_info
->usrregs
!= NULL
)
5308 for (regno
= 0; regno
< regs_info
->usrregs
->num_regs
; regno
++)
5309 low_fetch_register (regcache
, regno
);
5311 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
, regcache
);
5312 if (regs_info
->usrregs
!= NULL
)
5313 usr_fetch_inferior_registers (regs_info
, regcache
, -1, all
);
5317 if (low_fetch_register (regcache
, regno
))
5320 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5322 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
,
5324 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5325 usr_fetch_inferior_registers (regs_info
, regcache
, regno
, 1);
5330 linux_process_target::store_registers (regcache
*regcache
, int regno
)
5334 const regs_info
*regs_info
= get_regs_info ();
5338 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5340 if (regs_info
->usrregs
!= NULL
)
5341 usr_store_inferior_registers (regs_info
, regcache
, regno
, all
);
5345 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5347 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5349 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5350 usr_store_inferior_registers (regs_info
, regcache
, regno
, 1);
5355 linux_process_target::low_fetch_register (regcache
*regcache
, int regno
)
5360 /* A wrapper for the read_memory target op. */
5363 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
5365 return the_target
->read_memory (memaddr
, myaddr
, len
);
5369 /* Helper for read_memory/write_memory using /proc/PID/mem. Because
5370 we can use a single read/write call, this can be much more
5371 efficient than banging away at PTRACE_PEEKTEXT. Also, unlike
5372 PTRACE_PEEKTEXT/PTRACE_POKETEXT, this works with running threads.
5373 One an only one of READBUF and WRITEBUF is non-null. If READBUF is
5374 not null, then we're reading, otherwise we're writing. */
5377 proc_xfer_memory (CORE_ADDR memaddr
, unsigned char *readbuf
,
5378 const gdb_byte
*writebuf
, int len
)
5380 gdb_assert ((readbuf
== nullptr) != (writebuf
== nullptr));
5382 process_info
*proc
= current_process ();
5384 int fd
= proc
->priv
->mem_fd
;
5392 /* Use pread64/pwrite64 if available, since they save a syscall
5393 and can handle 64-bit offsets even on 32-bit platforms (for
5394 instance, SPARC debugging a SPARC64 application). But only
5395 use them if the offset isn't so high that when cast to off_t
5396 it'd be negative, as seen on SPARC64. pread64/pwrite64
5397 outright reject such offsets. lseek does not. */
5399 if ((off_t
) memaddr
>= 0)
5400 bytes
= (readbuf
!= nullptr
5401 ? pread64 (fd
, readbuf
, len
, memaddr
)
5402 : pwrite64 (fd
, writebuf
, len
, memaddr
));
5407 if (lseek (fd
, memaddr
, SEEK_SET
) != -1)
5408 bytes
= (readbuf
!= nullptr
5409 ? read (fd
, readbuf
, len
)
5410 : write (fd
, writebuf
, len
));
5415 else if (bytes
== 0)
5417 /* EOF means the address space is gone, the whole process
5418 exited or execed. */
5423 if (readbuf
!= nullptr)
5434 linux_process_target::read_memory (CORE_ADDR memaddr
,
5435 unsigned char *myaddr
, int len
)
5437 return proc_xfer_memory (memaddr
, myaddr
, nullptr, len
);
5440 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
5441 memory at MEMADDR. On failure (cannot write to the inferior)
5442 returns the value of errno. Always succeeds if LEN is zero. */
5445 linux_process_target::write_memory (CORE_ADDR memaddr
,
5446 const unsigned char *myaddr
, int len
)
5450 /* Dump up to four bytes. */
5451 char str
[4 * 2 + 1];
5453 int dump
= len
< 4 ? len
: 4;
5455 for (int i
= 0; i
< dump
; i
++)
5457 sprintf (p
, "%02x", myaddr
[i
]);
5462 threads_debug_printf ("Writing %s to 0x%08lx in process %d",
5463 str
, (long) memaddr
, current_process ()->pid
);
5466 return proc_xfer_memory (memaddr
, nullptr, myaddr
, len
);
5470 linux_process_target::look_up_symbols ()
5472 #ifdef USE_THREAD_DB
5473 struct process_info
*proc
= current_process ();
5475 if (proc
->priv
->thread_db
!= NULL
)
5483 linux_process_target::request_interrupt ()
5485 /* Send a SIGINT to the process group. This acts just like the user
5486 typed a ^C on the controlling terminal. */
5487 int res
= ::kill (-signal_pid
, SIGINT
);
5489 warning (_("Sending SIGINT to process group of pid %ld failed: %s"),
5490 signal_pid
, safe_strerror (errno
));
5494 linux_process_target::supports_read_auxv ()
5499 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
5500 to debugger memory starting at MYADDR. */
5503 linux_process_target::read_auxv (int pid
, CORE_ADDR offset
,
5504 unsigned char *myaddr
, unsigned int len
)
5506 char filename
[PATH_MAX
];
5509 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
5511 fd
= open (filename
, O_RDONLY
);
5515 if (offset
!= (CORE_ADDR
) 0
5516 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5519 n
= read (fd
, myaddr
, len
);
5527 linux_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5528 int size
, raw_breakpoint
*bp
)
5530 if (type
== raw_bkpt_type_sw
)
5531 return insert_memory_breakpoint (bp
);
5533 return low_insert_point (type
, addr
, size
, bp
);
5537 linux_process_target::low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
5538 int size
, raw_breakpoint
*bp
)
5540 /* Unsupported (see target.h). */
5545 linux_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5546 int size
, raw_breakpoint
*bp
)
5548 if (type
== raw_bkpt_type_sw
)
5549 return remove_memory_breakpoint (bp
);
5551 return low_remove_point (type
, addr
, size
, bp
);
5555 linux_process_target::low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
5556 int size
, raw_breakpoint
*bp
)
5558 /* Unsupported (see target.h). */
5562 /* Implement the stopped_by_sw_breakpoint target_ops
5566 linux_process_target::stopped_by_sw_breakpoint ()
5568 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5570 return (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
5573 /* Implement the supports_stopped_by_sw_breakpoint target_ops
5577 linux_process_target::supports_stopped_by_sw_breakpoint ()
5579 return USE_SIGTRAP_SIGINFO
;
5582 /* Implement the stopped_by_hw_breakpoint target_ops
5586 linux_process_target::stopped_by_hw_breakpoint ()
5588 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5590 return (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
5593 /* Implement the supports_stopped_by_hw_breakpoint target_ops
5597 linux_process_target::supports_stopped_by_hw_breakpoint ()
5599 return USE_SIGTRAP_SIGINFO
;
5602 /* Implement the supports_hardware_single_step target_ops method. */
5605 linux_process_target::supports_hardware_single_step ()
5611 linux_process_target::stopped_by_watchpoint ()
5613 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5615 return lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
5619 linux_process_target::stopped_data_address ()
5621 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5623 return lwp
->stopped_data_address
;
5626 /* This is only used for targets that define PT_TEXT_ADDR,
5627 PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
5628 the target has different ways of acquiring this information, like
5632 linux_process_target::supports_read_offsets ()
5634 #ifdef SUPPORTS_READ_OFFSETS
5641 /* Under uClinux, programs are loaded at non-zero offsets, which we need
5642 to tell gdb about. */
5645 linux_process_target::read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
5647 #ifdef SUPPORTS_READ_OFFSETS
5648 unsigned long text
, text_end
, data
;
5649 int pid
= lwpid_of (current_thread
);
5653 text
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_ADDR
,
5654 (PTRACE_TYPE_ARG4
) 0);
5655 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_END_ADDR
,
5656 (PTRACE_TYPE_ARG4
) 0);
5657 data
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_DATA_ADDR
,
5658 (PTRACE_TYPE_ARG4
) 0);
5662 /* Both text and data offsets produced at compile-time (and so
5663 used by gdb) are relative to the beginning of the program,
5664 with the data segment immediately following the text segment.
5665 However, the actual runtime layout in memory may put the data
5666 somewhere else, so when we send gdb a data base-address, we
5667 use the real data base address and subtract the compile-time
5668 data base-address from it (which is just the length of the
5669 text segment). BSS immediately follows data in both
5672 *data_p
= data
- (text_end
- text
);
5678 gdb_assert_not_reached ("target op read_offsets not supported");
5683 linux_process_target::supports_get_tls_address ()
5685 #ifdef USE_THREAD_DB
5693 linux_process_target::get_tls_address (thread_info
*thread
,
5695 CORE_ADDR load_module
,
5698 #ifdef USE_THREAD_DB
5699 return thread_db_get_tls_address (thread
, offset
, load_module
, address
);
5706 linux_process_target::supports_qxfer_osdata ()
5712 linux_process_target::qxfer_osdata (const char *annex
,
5713 unsigned char *readbuf
,
5714 unsigned const char *writebuf
,
5715 CORE_ADDR offset
, int len
)
5717 return linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
5721 linux_process_target::siginfo_fixup (siginfo_t
*siginfo
,
5722 gdb_byte
*inf_siginfo
, int direction
)
5724 bool done
= low_siginfo_fixup (siginfo
, inf_siginfo
, direction
);
5726 /* If there was no callback, or the callback didn't do anything,
5727 then just do a straight memcpy. */
5731 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
5733 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
5738 linux_process_target::low_siginfo_fixup (siginfo_t
*native
, gdb_byte
*inf
,
5745 linux_process_target::supports_qxfer_siginfo ()
5751 linux_process_target::qxfer_siginfo (const char *annex
,
5752 unsigned char *readbuf
,
5753 unsigned const char *writebuf
,
5754 CORE_ADDR offset
, int len
)
5758 gdb_byte inf_siginfo
[sizeof (siginfo_t
)];
5760 if (current_thread
== NULL
)
5763 pid
= lwpid_of (current_thread
);
5765 threads_debug_printf ("%s siginfo for lwp %d.",
5766 readbuf
!= NULL
? "Reading" : "Writing",
5769 if (offset
>= sizeof (siginfo
))
5772 if (ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
5775 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
5776 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
5777 inferior with a 64-bit GDBSERVER should look the same as debugging it
5778 with a 32-bit GDBSERVER, we need to convert it. */
5779 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
5781 if (offset
+ len
> sizeof (siginfo
))
5782 len
= sizeof (siginfo
) - offset
;
5784 if (readbuf
!= NULL
)
5785 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
5788 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
5790 /* Convert back to ptrace layout before flushing it out. */
5791 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
5793 if (ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
5800 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5801 so we notice when children change state; as the handler for the
5802 sigsuspend in my_waitpid. */
5805 sigchld_handler (int signo
)
5807 int old_errno
= errno
;
5813 /* Use the async signal safe debug function. */
5814 if (debug_write ("sigchld_handler\n",
5815 sizeof ("sigchld_handler\n") - 1) < 0)
5816 break; /* just ignore */
5820 if (target_is_async_p ())
5821 async_file_mark (); /* trigger a linux_wait */
5827 linux_process_target::supports_non_stop ()
5833 linux_process_target::async (bool enable
)
5835 bool previous
= target_is_async_p ();
5837 threads_debug_printf ("async (%d), previous=%d",
5840 if (previous
!= enable
)
5843 sigemptyset (&mask
);
5844 sigaddset (&mask
, SIGCHLD
);
5846 gdb_sigmask (SIG_BLOCK
, &mask
, NULL
);
5850 if (!linux_event_pipe
.open_pipe ())
5852 gdb_sigmask (SIG_UNBLOCK
, &mask
, NULL
);
5854 warning ("creating event pipe failed.");
5858 /* Register the event loop handler. */
5859 add_file_handler (linux_event_pipe
.event_fd (),
5860 handle_target_event
, NULL
,
5863 /* Always trigger a linux_wait. */
5868 delete_file_handler (linux_event_pipe
.event_fd ());
5870 linux_event_pipe
.close_pipe ();
5873 gdb_sigmask (SIG_UNBLOCK
, &mask
, NULL
);
5880 linux_process_target::start_non_stop (bool nonstop
)
5882 /* Register or unregister from event-loop accordingly. */
5883 target_async (nonstop
);
5885 if (target_is_async_p () != (nonstop
!= false))
5892 linux_process_target::supports_multi_process ()
5897 /* Check if fork events are supported. */
5900 linux_process_target::supports_fork_events ()
5905 /* Check if vfork events are supported. */
5908 linux_process_target::supports_vfork_events ()
5913 /* Return the set of supported thread options. */
5916 linux_process_target::supported_thread_options ()
5918 return GDB_THREAD_OPTION_CLONE
| GDB_THREAD_OPTION_EXIT
;
5921 /* Check if exec events are supported. */
5924 linux_process_target::supports_exec_events ()
5929 /* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
5930 ptrace flags for all inferiors. This is in case the new GDB connection
5931 doesn't support the same set of events that the previous one did. */
5934 linux_process_target::handle_new_gdb_connection ()
5936 /* Request that all the lwps reset their ptrace options. */
5937 for_each_thread ([] (thread_info
*thread
)
5939 struct lwp_info
*lwp
= get_thread_lwp (thread
);
5943 /* Stop the lwp so we can modify its ptrace options. */
5944 lwp
->must_set_ptrace_flags
= 1;
5945 linux_stop_lwp (lwp
);
5949 /* Already stopped; go ahead and set the ptrace options. */
5950 struct process_info
*proc
= find_process_pid (pid_of (thread
));
5951 int options
= linux_low_ptrace_options (proc
->attached
);
5953 linux_enable_event_reporting (lwpid_of (thread
), options
);
5954 lwp
->must_set_ptrace_flags
= 0;
5960 linux_process_target::handle_monitor_command (char *mon
)
5962 #ifdef USE_THREAD_DB
5963 return thread_db_handle_monitor_command (mon
);
5970 linux_process_target::core_of_thread (ptid_t ptid
)
5972 return linux_common_core_of_thread (ptid
);
5976 linux_process_target::supports_disable_randomization ()
5982 linux_process_target::supports_agent ()
5988 linux_process_target::supports_range_stepping ()
5990 if (supports_software_single_step ())
5993 return low_supports_range_stepping ();
5997 linux_process_target::low_supports_range_stepping ()
6003 linux_process_target::supports_pid_to_exec_file ()
6009 linux_process_target::pid_to_exec_file (int pid
)
6011 return linux_proc_pid_to_exec_file (pid
);
6015 linux_process_target::supports_multifs ()
6021 linux_process_target::multifs_open (int pid
, const char *filename
,
6022 int flags
, mode_t mode
)
6024 return linux_mntns_open_cloexec (pid
, filename
, flags
, mode
);
6028 linux_process_target::multifs_unlink (int pid
, const char *filename
)
6030 return linux_mntns_unlink (pid
, filename
);
6034 linux_process_target::multifs_readlink (int pid
, const char *filename
,
6035 char *buf
, size_t bufsiz
)
6037 return linux_mntns_readlink (pid
, filename
, buf
, bufsiz
);
6040 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
6041 struct target_loadseg
6043 /* Core address to which the segment is mapped. */
6045 /* VMA recorded in the program header. */
6047 /* Size of this segment in memory. */
6051 # if defined PT_GETDSBT
6052 struct target_loadmap
6054 /* Protocol version number, must be zero. */
6056 /* Pointer to the DSBT table, its size, and the DSBT index. */
6057 unsigned *dsbt_table
;
6058 unsigned dsbt_size
, dsbt_index
;
6059 /* Number of segments in this map. */
6061 /* The actual memory map. */
6062 struct target_loadseg segs
[/*nsegs*/];
6064 # define LINUX_LOADMAP PT_GETDSBT
6065 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
6066 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
6068 struct target_loadmap
6070 /* Protocol version number, must be zero. */
6072 /* Number of segments in this map. */
6074 /* The actual memory map. */
6075 struct target_loadseg segs
[/*nsegs*/];
6077 # define LINUX_LOADMAP PTRACE_GETFDPIC
6078 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
6079 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
6083 linux_process_target::supports_read_loadmap ()
6089 linux_process_target::read_loadmap (const char *annex
, CORE_ADDR offset
,
6090 unsigned char *myaddr
, unsigned int len
)
6092 int pid
= lwpid_of (current_thread
);
6094 struct target_loadmap
*data
= NULL
;
6095 unsigned int actual_length
, copy_length
;
6097 if (strcmp (annex
, "exec") == 0)
6098 addr
= (int) LINUX_LOADMAP_EXEC
;
6099 else if (strcmp (annex
, "interp") == 0)
6100 addr
= (int) LINUX_LOADMAP_INTERP
;
6104 if (ptrace (LINUX_LOADMAP
, pid
, addr
, &data
) != 0)
6110 actual_length
= sizeof (struct target_loadmap
)
6111 + sizeof (struct target_loadseg
) * data
->nsegs
;
6113 if (offset
< 0 || offset
> actual_length
)
6116 copy_length
= actual_length
- offset
< len
? actual_length
- offset
: len
;
6117 memcpy (myaddr
, (char *) data
+ offset
, copy_length
);
6120 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
6123 linux_process_target::supports_catch_syscall ()
6125 return low_supports_catch_syscall ();
6129 linux_process_target::low_supports_catch_syscall ()
6135 linux_process_target::read_pc (regcache
*regcache
)
6137 if (!low_supports_breakpoints ())
6140 return low_get_pc (regcache
);
6144 linux_process_target::write_pc (regcache
*regcache
, CORE_ADDR pc
)
6146 gdb_assert (low_supports_breakpoints ());
6148 low_set_pc (regcache
, pc
);
6152 linux_process_target::supports_thread_stopped ()
6158 linux_process_target::thread_stopped (thread_info
*thread
)
6160 return get_thread_lwp (thread
)->stopped
;
6164 linux_process_target::any_resumed ()
6168 auto status_pending_p_any
= [&] (thread_info
*thread
)
6170 return status_pending_p_callback (thread
, minus_one_ptid
);
6173 auto not_stopped
= [&] (thread_info
*thread
)
6175 return not_stopped_callback (thread
, minus_one_ptid
);
6178 /* Find a resumed LWP, if any. */
6179 if (find_thread (status_pending_p_any
) != NULL
)
6181 else if (find_thread (not_stopped
) != NULL
)
6189 /* This exposes stop-all-threads functionality to other modules. */
6192 linux_process_target::pause_all (bool freeze
)
6194 stop_all_lwps (freeze
, NULL
);
6197 /* This exposes unstop-all-threads functionality to other gdbserver
6201 linux_process_target::unpause_all (bool unfreeze
)
6203 unstop_all_lwps (unfreeze
, NULL
);
6206 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
6209 get_phdr_phnum_from_proc_auxv (const int pid
, const int is_elf64
,
6210 CORE_ADDR
*phdr_memaddr
, int *num_phdr
)
6212 char filename
[PATH_MAX
];
6214 const int auxv_size
= is_elf64
6215 ? sizeof (Elf64_auxv_t
) : sizeof (Elf32_auxv_t
);
6216 char buf
[sizeof (Elf64_auxv_t
)]; /* The larger of the two. */
6218 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
6220 fd
= open (filename
, O_RDONLY
);
6226 while (read (fd
, buf
, auxv_size
) == auxv_size
6227 && (*phdr_memaddr
== 0 || *num_phdr
== 0))
6231 Elf64_auxv_t
*const aux
= (Elf64_auxv_t
*) buf
;
6233 switch (aux
->a_type
)
6236 *phdr_memaddr
= aux
->a_un
.a_val
;
6239 *num_phdr
= aux
->a_un
.a_val
;
6245 Elf32_auxv_t
*const aux
= (Elf32_auxv_t
*) buf
;
6247 switch (aux
->a_type
)
6250 *phdr_memaddr
= aux
->a_un
.a_val
;
6253 *num_phdr
= aux
->a_un
.a_val
;
6261 if (*phdr_memaddr
== 0 || *num_phdr
== 0)
6263 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
6264 "phdr_memaddr = %ld, phdr_num = %d",
6265 (long) *phdr_memaddr
, *num_phdr
);
6272 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
6275 get_dynamic (const int pid
, const int is_elf64
)
6277 CORE_ADDR phdr_memaddr
, relocation
;
6279 unsigned char *phdr_buf
;
6280 const int phdr_size
= is_elf64
? sizeof (Elf64_Phdr
) : sizeof (Elf32_Phdr
);
6282 if (get_phdr_phnum_from_proc_auxv (pid
, is_elf64
, &phdr_memaddr
, &num_phdr
))
6285 gdb_assert (num_phdr
< 100); /* Basic sanity check. */
6286 phdr_buf
= (unsigned char *) alloca (num_phdr
* phdr_size
);
6288 if (linux_read_memory (phdr_memaddr
, phdr_buf
, num_phdr
* phdr_size
))
6291 /* Compute relocation: it is expected to be 0 for "regular" executables,
6292 non-zero for PIE ones. */
6294 for (i
= 0; relocation
== -1 && i
< num_phdr
; i
++)
6297 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6299 if (p
->p_type
== PT_PHDR
)
6300 relocation
= phdr_memaddr
- p
->p_vaddr
;
6304 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6306 if (p
->p_type
== PT_PHDR
)
6307 relocation
= phdr_memaddr
- p
->p_vaddr
;
6310 if (relocation
== -1)
6312 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
6313 any real world executables, including PIE executables, have always
6314 PT_PHDR present. PT_PHDR is not present in some shared libraries or
6315 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
6316 or present DT_DEBUG anyway (fpc binaries are statically linked).
6318 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
6320 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
6325 for (i
= 0; i
< num_phdr
; i
++)
6329 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6331 if (p
->p_type
== PT_DYNAMIC
)
6332 return p
->p_vaddr
+ relocation
;
6336 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6338 if (p
->p_type
== PT_DYNAMIC
)
6339 return p
->p_vaddr
+ relocation
;
6346 /* Return &_r_debug in the inferior, or -1 if not present. Return value
6347 can be 0 if the inferior does not yet have the library list initialized.
6348 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
6349 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
6352 get_r_debug (const int pid
, const int is_elf64
)
6354 CORE_ADDR dynamic_memaddr
;
6355 const int dyn_size
= is_elf64
? sizeof (Elf64_Dyn
) : sizeof (Elf32_Dyn
);
6356 unsigned char buf
[sizeof (Elf64_Dyn
)]; /* The larger of the two. */
6359 dynamic_memaddr
= get_dynamic (pid
, is_elf64
);
6360 if (dynamic_memaddr
== 0)
6363 while (linux_read_memory (dynamic_memaddr
, buf
, dyn_size
) == 0)
6367 Elf64_Dyn
*const dyn
= (Elf64_Dyn
*) buf
;
6368 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6372 unsigned char buf
[sizeof (Elf64_Xword
)];
6376 #ifdef DT_MIPS_RLD_MAP
6377 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6379 if (linux_read_memory (dyn
->d_un
.d_val
,
6380 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6385 #endif /* DT_MIPS_RLD_MAP */
6386 #ifdef DT_MIPS_RLD_MAP_REL
6387 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6389 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6390 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6395 #endif /* DT_MIPS_RLD_MAP_REL */
6397 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6398 map
= dyn
->d_un
.d_val
;
6400 if (dyn
->d_tag
== DT_NULL
)
6405 Elf32_Dyn
*const dyn
= (Elf32_Dyn
*) buf
;
6406 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6410 unsigned char buf
[sizeof (Elf32_Word
)];
6414 #ifdef DT_MIPS_RLD_MAP
6415 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6417 if (linux_read_memory (dyn
->d_un
.d_val
,
6418 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6423 #endif /* DT_MIPS_RLD_MAP */
6424 #ifdef DT_MIPS_RLD_MAP_REL
6425 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6427 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6428 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6433 #endif /* DT_MIPS_RLD_MAP_REL */
6435 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6436 map
= dyn
->d_un
.d_val
;
6438 if (dyn
->d_tag
== DT_NULL
)
6442 dynamic_memaddr
+= dyn_size
;
6448 /* Read one pointer from MEMADDR in the inferior. */
6451 read_one_ptr (CORE_ADDR memaddr
, CORE_ADDR
*ptr
, int ptr_size
)
6455 /* Go through a union so this works on either big or little endian
6456 hosts, when the inferior's pointer size is smaller than the size
6457 of CORE_ADDR. It is assumed the inferior's endianness is the
6458 same of the superior's. */
6461 CORE_ADDR core_addr
;
6466 ret
= linux_read_memory (memaddr
, &addr
.uc
, ptr_size
);
6469 if (ptr_size
== sizeof (CORE_ADDR
))
6470 *ptr
= addr
.core_addr
;
6471 else if (ptr_size
== sizeof (unsigned int))
6474 gdb_assert_not_reached ("unhandled pointer size");
6480 linux_process_target::supports_qxfer_libraries_svr4 ()
6485 struct link_map_offsets
6487 /* Offset and size of r_debug.r_version. */
6488 int r_version_offset
;
6490 /* Offset and size of r_debug.r_map. */
6493 /* Offset of r_debug_extended.r_next. */
6496 /* Offset to l_addr field in struct link_map. */
6499 /* Offset to l_name field in struct link_map. */
6502 /* Offset to l_ld field in struct link_map. */
6505 /* Offset to l_next field in struct link_map. */
6508 /* Offset to l_prev field in struct link_map. */
6512 static const link_map_offsets lmo_32bit_offsets
=
6514 0, /* r_version offset. */
6515 4, /* r_debug.r_map offset. */
6516 20, /* r_debug_extended.r_next. */
6517 0, /* l_addr offset in link_map. */
6518 4, /* l_name offset in link_map. */
6519 8, /* l_ld offset in link_map. */
6520 12, /* l_next offset in link_map. */
6521 16 /* l_prev offset in link_map. */
6524 static const link_map_offsets lmo_64bit_offsets
=
6526 0, /* r_version offset. */
6527 8, /* r_debug.r_map offset. */
6528 40, /* r_debug_extended.r_next. */
6529 0, /* l_addr offset in link_map. */
6530 8, /* l_name offset in link_map. */
6531 16, /* l_ld offset in link_map. */
6532 24, /* l_next offset in link_map. */
6533 32 /* l_prev offset in link_map. */
6536 /* Get the loaded shared libraries from one namespace. */
6539 read_link_map (std::string
&document
, CORE_ADDR lmid
, CORE_ADDR lm_addr
,
6540 CORE_ADDR lm_prev
, int ptr_size
, const link_map_offsets
*lmo
)
6542 CORE_ADDR l_name
, l_addr
, l_ld
, l_next
, l_prev
;
6545 && read_one_ptr (lm_addr
+ lmo
->l_name_offset
,
6546 &l_name
, ptr_size
) == 0
6547 && read_one_ptr (lm_addr
+ lmo
->l_addr_offset
,
6548 &l_addr
, ptr_size
) == 0
6549 && read_one_ptr (lm_addr
+ lmo
->l_ld_offset
,
6550 &l_ld
, ptr_size
) == 0
6551 && read_one_ptr (lm_addr
+ lmo
->l_prev_offset
,
6552 &l_prev
, ptr_size
) == 0
6553 && read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
6554 &l_next
, ptr_size
) == 0)
6556 unsigned char libname
[PATH_MAX
];
6558 if (lm_prev
!= l_prev
)
6560 warning ("Corrupted shared library list: 0x%s != 0x%s",
6561 paddress (lm_prev
), paddress (l_prev
));
6565 /* Not checking for error because reading may stop before we've got
6566 PATH_MAX worth of characters. */
6568 linux_read_memory (l_name
, libname
, sizeof (libname
) - 1);
6569 libname
[sizeof (libname
) - 1] = '\0';
6570 if (libname
[0] != '\0')
6572 string_appendf (document
, "<library name=\"");
6573 xml_escape_text_append (document
, (char *) libname
);
6574 string_appendf (document
, "\" lm=\"0x%s\" l_addr=\"0x%s\" "
6575 "l_ld=\"0x%s\" lmid=\"0x%s\"/>",
6576 paddress (lm_addr
), paddress (l_addr
),
6577 paddress (l_ld
), paddress (lmid
));
6585 /* Construct qXfer:libraries-svr4:read reply. */
6588 linux_process_target::qxfer_libraries_svr4 (const char *annex
,
6589 unsigned char *readbuf
,
6590 unsigned const char *writebuf
,
6591 CORE_ADDR offset
, int len
)
6593 struct process_info_private
*const priv
= current_process ()->priv
;
6594 char filename
[PATH_MAX
];
6596 unsigned int machine
;
6597 CORE_ADDR lmid
= 0, lm_addr
= 0, lm_prev
= 0;
6599 if (writebuf
!= NULL
)
6601 if (readbuf
== NULL
)
6604 pid
= lwpid_of (current_thread
);
6605 xsnprintf (filename
, sizeof filename
, "/proc/%d/exe", pid
);
6606 is_elf64
= elf_64_file_p (filename
, &machine
);
6607 const link_map_offsets
*lmo
;
6611 lmo
= &lmo_64bit_offsets
;
6616 lmo
= &lmo_32bit_offsets
;
6620 while (annex
[0] != '\0')
6626 sep
= strchr (annex
, '=');
6630 name_len
= sep
- annex
;
6631 if (name_len
== 4 && startswith (annex
, "lmid"))
6633 else if (name_len
== 5 && startswith (annex
, "start"))
6635 else if (name_len
== 4 && startswith (annex
, "prev"))
6639 annex
= strchr (sep
, ';');
6646 annex
= decode_address_to_semicolon (addrp
, sep
+ 1);
6649 std::string document
= "<library-list-svr4 version=\"1.0\"";
6651 /* When the starting LM_ADDR is passed in the annex, only traverse that
6652 namespace, which is assumed to be identified by LMID.
6654 Otherwise, start with R_DEBUG and traverse all namespaces we find. */
6658 read_link_map (document
, lmid
, lm_addr
, lm_prev
, ptr_size
, lmo
);
6663 warning ("ignoring prev=0x%s without start", paddress (lm_prev
));
6665 /* We could interpret LMID as 'provide only the libraries for this
6666 namespace' but GDB is currently only providing lmid, start, and
6667 prev, or nothing. */
6669 warning ("ignoring lmid=0x%s without start", paddress (lmid
));
6671 CORE_ADDR r_debug
= priv
->r_debug
;
6673 r_debug
= priv
->r_debug
= get_r_debug (pid
, is_elf64
);
6675 /* We failed to find DT_DEBUG. Such situation will not change
6676 for this inferior - do not retry it. Report it to GDB as
6677 E01, see for the reasons at the GDB solib-svr4.c side. */
6678 if (r_debug
== (CORE_ADDR
) -1)
6681 /* Terminate the header if we end up with an empty list. */
6685 while (r_debug
!= 0)
6688 if (linux_read_memory (r_debug
+ lmo
->r_version_offset
,
6689 (unsigned char *) &r_version
,
6690 sizeof (r_version
)) != 0)
6692 warning ("unable to read r_version from 0x%s",
6693 paddress (r_debug
+ lmo
->r_version_offset
));
6699 warning ("unexpected r_debug version %d", r_version
);
6703 if (read_one_ptr (r_debug
+ lmo
->r_map_offset
, &lm_addr
,
6706 warning ("unable to read r_map from 0x%s",
6707 paddress (r_debug
+ lmo
->r_map_offset
));
6711 /* We read the entire namespace. */
6714 /* The first entry corresponds to the main executable unless the
6715 dynamic loader was loaded late by a static executable. But
6716 in such case the main executable does not have PT_DYNAMIC
6717 present and we would not have gotten here. */
6718 if (r_debug
== priv
->r_debug
)
6721 string_appendf (document
, " main-lm=\"0x%s\">",
6722 paddress (lm_addr
));
6727 if (read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
6728 &lm_addr
, ptr_size
) != 0)
6730 warning ("unable to read l_next from 0x%s",
6731 paddress (lm_addr
+ lmo
->l_next_offset
));
6736 read_link_map (document
, r_debug
, lm_addr
, lm_prev
, ptr_size
, lmo
);
6741 if (read_one_ptr (r_debug
+ lmo
->r_next_offset
, &r_debug
,
6744 warning ("unable to read r_next from 0x%s",
6745 paddress (r_debug
+ lmo
->r_next_offset
));
6751 document
+= "</library-list-svr4>";
6753 int document_len
= document
.length ();
6754 if (offset
< document_len
)
6755 document_len
-= offset
;
6758 if (len
> document_len
)
6761 memcpy (readbuf
, document
.data () + offset
, len
);
6766 #ifdef HAVE_LINUX_BTRACE
6769 linux_process_target::supports_btrace ()
6774 btrace_target_info
*
6775 linux_process_target::enable_btrace (thread_info
*tp
,
6776 const btrace_config
*conf
)
6778 return linux_enable_btrace (tp
->id
, conf
);
6781 /* See to_disable_btrace target method. */
6784 linux_process_target::disable_btrace (btrace_target_info
*tinfo
)
6786 enum btrace_error err
;
6788 err
= linux_disable_btrace (tinfo
);
6789 return (err
== BTRACE_ERR_NONE
? 0 : -1);
6792 /* Encode an Intel Processor Trace configuration. */
6795 linux_low_encode_pt_config (std::string
*buffer
,
6796 const struct btrace_data_pt_config
*config
)
6798 *buffer
+= "<pt-config>\n";
6800 switch (config
->cpu
.vendor
)
6803 string_xml_appendf (*buffer
, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
6804 "model=\"%u\" stepping=\"%u\"/>\n",
6805 config
->cpu
.family
, config
->cpu
.model
,
6806 config
->cpu
.stepping
);
6813 *buffer
+= "</pt-config>\n";
6816 /* Encode a raw buffer. */
6819 linux_low_encode_raw (std::string
*buffer
, const gdb_byte
*data
,
6825 /* We use hex encoding - see gdbsupport/rsp-low.h. */
6826 *buffer
+= "<raw>\n";
6832 elem
[0] = tohex ((*data
>> 4) & 0xf);
6833 elem
[1] = tohex (*data
++ & 0xf);
6835 buffer
->append (elem
, 2);
6838 *buffer
+= "</raw>\n";
6841 /* See to_read_btrace target method. */
6844 linux_process_target::read_btrace (btrace_target_info
*tinfo
,
6845 std::string
*buffer
,
6846 enum btrace_read_type type
)
6848 struct btrace_data btrace
;
6849 enum btrace_error err
;
6851 err
= linux_read_btrace (&btrace
, tinfo
, type
);
6852 if (err
!= BTRACE_ERR_NONE
)
6854 if (err
== BTRACE_ERR_OVERFLOW
)
6855 *buffer
+= "E.Overflow.";
6857 *buffer
+= "E.Generic Error.";
6862 switch (btrace
.format
)
6864 case BTRACE_FORMAT_NONE
:
6865 *buffer
+= "E.No Trace.";
6868 case BTRACE_FORMAT_BTS
:
6869 *buffer
+= "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n";
6870 *buffer
+= "<btrace version=\"1.0\">\n";
6872 for (const btrace_block
&block
: *btrace
.variant
.bts
.blocks
)
6873 string_xml_appendf (*buffer
, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
6874 paddress (block
.begin
), paddress (block
.end
));
6876 *buffer
+= "</btrace>\n";
6879 case BTRACE_FORMAT_PT
:
6880 *buffer
+= "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n";
6881 *buffer
+= "<btrace version=\"1.0\">\n";
6882 *buffer
+= "<pt>\n";
6884 linux_low_encode_pt_config (buffer
, &btrace
.variant
.pt
.config
);
6886 linux_low_encode_raw (buffer
, btrace
.variant
.pt
.data
,
6887 btrace
.variant
.pt
.size
);
6889 *buffer
+= "</pt>\n";
6890 *buffer
+= "</btrace>\n";
6894 *buffer
+= "E.Unsupported Trace Format.";
6901 /* See to_btrace_conf target method. */
6904 linux_process_target::read_btrace_conf (const btrace_target_info
*tinfo
,
6905 std::string
*buffer
)
6907 const struct btrace_config
*conf
;
6909 *buffer
+= "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n";
6910 *buffer
+= "<btrace-conf version=\"1.0\">\n";
6912 conf
= linux_btrace_conf (tinfo
);
6915 switch (conf
->format
)
6917 case BTRACE_FORMAT_NONE
:
6920 case BTRACE_FORMAT_BTS
:
6921 string_xml_appendf (*buffer
, "<bts");
6922 string_xml_appendf (*buffer
, " size=\"0x%x\"", conf
->bts
.size
);
6923 string_xml_appendf (*buffer
, " />\n");
6926 case BTRACE_FORMAT_PT
:
6927 string_xml_appendf (*buffer
, "<pt");
6928 string_xml_appendf (*buffer
, " size=\"0x%x\"", conf
->pt
.size
);
6929 string_xml_appendf (*buffer
, "/>\n");
6934 *buffer
+= "</btrace-conf>\n";
6937 #endif /* HAVE_LINUX_BTRACE */
6939 /* See nat/linux-nat.h. */
6942 current_lwp_ptid (void)
6944 return ptid_of (current_thread
);
6948 linux_process_target::thread_name (ptid_t thread
)
6950 return linux_proc_tid_get_name (thread
);
6955 linux_process_target::thread_handle (ptid_t ptid
, gdb_byte
**handle
,
6958 return thread_db_thread_handle (ptid
, handle
, handle_len
);
6963 linux_process_target::thread_pending_parent (thread_info
*thread
)
6965 lwp_info
*parent
= get_thread_lwp (thread
)->pending_parent ();
6967 if (parent
== nullptr)
6970 return get_lwp_thread (parent
);
6974 linux_process_target::thread_pending_child (thread_info
*thread
,
6975 target_waitkind
*kind
)
6977 lwp_info
*child
= get_thread_lwp (thread
)->pending_child (kind
);
6979 if (child
== nullptr)
6982 return get_lwp_thread (child
);
6985 /* Default implementation of linux_target_ops method "set_pc" for
6986 32-bit pc register which is literally named "pc". */
6989 linux_set_pc_32bit (struct regcache
*regcache
, CORE_ADDR pc
)
6991 uint32_t newpc
= pc
;
6993 supply_register_by_name (regcache
, "pc", &newpc
);
6996 /* Default implementation of linux_target_ops method "get_pc" for
6997 32-bit pc register which is literally named "pc". */
7000 linux_get_pc_32bit (struct regcache
*regcache
)
7004 collect_register_by_name (regcache
, "pc", &pc
);
7005 threads_debug_printf ("stop pc is 0x%" PRIx32
, pc
);
7009 /* Default implementation of linux_target_ops method "set_pc" for
7010 64-bit pc register which is literally named "pc". */
7013 linux_set_pc_64bit (struct regcache
*regcache
, CORE_ADDR pc
)
7015 uint64_t newpc
= pc
;
7017 supply_register_by_name (regcache
, "pc", &newpc
);
7020 /* Default implementation of linux_target_ops method "get_pc" for
7021 64-bit pc register which is literally named "pc". */
7024 linux_get_pc_64bit (struct regcache
*regcache
)
7028 collect_register_by_name (regcache
, "pc", &pc
);
7029 threads_debug_printf ("stop pc is 0x%" PRIx64
, pc
);
7033 /* See linux-low.h. */
7036 linux_get_auxv (int pid
, int wordsize
, CORE_ADDR match
, CORE_ADDR
*valp
)
7038 gdb_byte
*data
= (gdb_byte
*) alloca (2 * wordsize
);
7041 gdb_assert (wordsize
== 4 || wordsize
== 8);
7043 while (the_target
->read_auxv (pid
, offset
, data
, 2 * wordsize
)
7048 uint32_t *data_p
= (uint32_t *) data
;
7049 if (data_p
[0] == match
)
7057 uint64_t *data_p
= (uint64_t *) data
;
7058 if (data_p
[0] == match
)
7065 offset
+= 2 * wordsize
;
7071 /* See linux-low.h. */
7074 linux_get_hwcap (int pid
, int wordsize
)
7076 CORE_ADDR hwcap
= 0;
7077 linux_get_auxv (pid
, wordsize
, AT_HWCAP
, &hwcap
);
7081 /* See linux-low.h. */
7084 linux_get_hwcap2 (int pid
, int wordsize
)
7086 CORE_ADDR hwcap2
= 0;
7087 linux_get_auxv (pid
, wordsize
, AT_HWCAP2
, &hwcap2
);
7091 #ifdef HAVE_LINUX_REGSETS
7093 initialize_regsets_info (struct regsets_info
*info
)
7095 for (info
->num_regsets
= 0;
7096 info
->regsets
[info
->num_regsets
].size
>= 0;
7097 info
->num_regsets
++)
7103 initialize_low (void)
7105 struct sigaction sigchld_action
;
7107 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
7108 set_target_ops (the_linux_target
);
7110 linux_ptrace_init_warnings ();
7111 linux_proc_init_warnings ();
7113 sigchld_action
.sa_handler
= sigchld_handler
;
7114 sigemptyset (&sigchld_action
.sa_mask
);
7115 sigchld_action
.sa_flags
= SA_RESTART
;
7116 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
7118 initialize_low_arch ();
7120 linux_check_ptrace_features ();