1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995-2021 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/rsp-low.h"
25 #include "gdbsupport/signals-state-save-restore.h"
26 #include "nat/linux-nat.h"
27 #include "nat/linux-waitpid.h"
28 #include "gdbsupport/gdb_wait.h"
29 #include "nat/gdb_ptrace.h"
30 #include "nat/linux-ptrace.h"
31 #include "nat/linux-procfs.h"
32 #include "nat/linux-personality.h"
34 #include <sys/ioctl.h>
37 #include <sys/syscall.h>
41 #include <sys/types.h>
46 #include "gdbsupport/filestuff.h"
47 #include "tracepoint.h"
49 #include "gdbsupport/common-inferior.h"
50 #include "nat/fork-inferior.h"
51 #include "gdbsupport/environ.h"
52 #include "gdbsupport/gdb-sigmask.h"
53 #include "gdbsupport/scoped_restore.h"
55 /* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
56 then ELFMAG0 will have been defined. If it didn't get included by
57 gdb_proc_service.h then including it will likely introduce a duplicate
58 definition of elf_fpregset_t. */
61 #include "nat/linux-namespaces.h"
63 #ifdef HAVE_PERSONALITY
64 # include <sys/personality.h>
65 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
66 # define ADDR_NO_RANDOMIZE 0x0040000
78 /* Some targets did not define these ptrace constants from the start,
79 so gdbserver defines them locally here. In the future, these may
80 be removed after they are added to asm/ptrace.h. */
81 #if !(defined(PT_TEXT_ADDR) \
82 || defined(PT_DATA_ADDR) \
83 || defined(PT_TEXT_END_ADDR))
84 #if defined(__mcoldfire__)
85 /* These are still undefined in 3.10 kernels. */
86 #define PT_TEXT_ADDR 49*4
87 #define PT_DATA_ADDR 50*4
88 #define PT_TEXT_END_ADDR 51*4
89 /* These are still undefined in 3.10 kernels. */
90 #elif defined(__TMS320C6X__)
91 #define PT_TEXT_ADDR (0x10000*4)
92 #define PT_DATA_ADDR (0x10004*4)
93 #define PT_TEXT_END_ADDR (0x10008*4)
97 #if (defined(__UCLIBC__) \
98 && defined(HAS_NOMMU) \
99 && defined(PT_TEXT_ADDR) \
100 && defined(PT_DATA_ADDR) \
101 && defined(PT_TEXT_END_ADDR))
102 #define SUPPORTS_READ_OFFSETS
105 #ifdef HAVE_LINUX_BTRACE
106 # include "nat/linux-btrace.h"
107 # include "gdbsupport/btrace-common.h"
110 #ifndef HAVE_ELF32_AUXV_T
111 /* Copied from glibc's elf.h. */
114 uint32_t a_type
; /* Entry type */
117 uint32_t a_val
; /* Integer value */
118 /* We use to have pointer elements added here. We cannot do that,
119 though, since it does not work when using 32-bit definitions
120 on 64-bit platforms and vice versa. */
125 #ifndef HAVE_ELF64_AUXV_T
126 /* Copied from glibc's elf.h. */
129 uint64_t a_type
; /* Entry type */
132 uint64_t a_val
; /* Integer value */
133 /* We use to have pointer elements added here. We cannot do that,
134 though, since it does not work when using 32-bit definitions
135 on 64-bit platforms and vice versa. */
140 /* Does the current host support PTRACE_GETREGSET? */
141 int have_ptrace_getregset
= -1;
145 /* See nat/linux-nat.h. */
148 ptid_of_lwp (struct lwp_info
*lwp
)
150 return ptid_of (get_lwp_thread (lwp
));
153 /* See nat/linux-nat.h. */
156 lwp_set_arch_private_info (struct lwp_info
*lwp
,
157 struct arch_lwp_info
*info
)
159 lwp
->arch_private
= info
;
162 /* See nat/linux-nat.h. */
164 struct arch_lwp_info
*
165 lwp_arch_private_info (struct lwp_info
*lwp
)
167 return lwp
->arch_private
;
170 /* See nat/linux-nat.h. */
173 lwp_is_stopped (struct lwp_info
*lwp
)
178 /* See nat/linux-nat.h. */
180 enum target_stop_reason
181 lwp_stop_reason (struct lwp_info
*lwp
)
183 return lwp
->stop_reason
;
186 /* See nat/linux-nat.h. */
189 lwp_is_stepping (struct lwp_info
*lwp
)
191 return lwp
->stepping
;
194 /* A list of all unknown processes which receive stop signals. Some
195 other process will presumably claim each of these as forked
196 children momentarily. */
198 struct simple_pid_list
200 /* The process ID. */
203 /* The status as reported by waitpid. */
207 struct simple_pid_list
*next
;
209 static struct simple_pid_list
*stopped_pids
;
211 /* Trivial list manipulation functions to keep track of a list of new
212 stopped processes. */
215 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
217 struct simple_pid_list
*new_pid
= XNEW (struct simple_pid_list
);
220 new_pid
->status
= status
;
221 new_pid
->next
= *listp
;
226 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
228 struct simple_pid_list
**p
;
230 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
231 if ((*p
)->pid
== pid
)
233 struct simple_pid_list
*next
= (*p
)->next
;
235 *statusp
= (*p
)->status
;
243 enum stopping_threads_kind
245 /* Not stopping threads presently. */
246 NOT_STOPPING_THREADS
,
248 /* Stopping threads. */
251 /* Stopping and suspending threads. */
252 STOPPING_AND_SUSPENDING_THREADS
255 /* This is set while stop_all_lwps is in effect. */
256 static stopping_threads_kind stopping_threads
= NOT_STOPPING_THREADS
;
258 /* FIXME make into a target method? */
259 int using_threads
= 1;
261 /* True if we're presently stabilizing threads (moving them out of
263 static int stabilizing_threads
;
265 static void unsuspend_all_lwps (struct lwp_info
*except
);
266 static void mark_lwp_dead (struct lwp_info
*lwp
, int wstat
);
267 static int lwp_is_marked_dead (struct lwp_info
*lwp
);
268 static int kill_lwp (unsigned long lwpid
, int signo
);
269 static void enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
);
270 static int linux_low_ptrace_options (int attached
);
271 static int check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
);
273 /* When the event-loop is doing a step-over, this points at the thread
275 static ptid_t step_over_bkpt
;
278 linux_process_target::low_supports_breakpoints ()
284 linux_process_target::low_get_pc (regcache
*regcache
)
290 linux_process_target::low_set_pc (regcache
*regcache
, CORE_ADDR newpc
)
292 gdb_assert_not_reached ("linux target op low_set_pc is not implemented");
295 std::vector
<CORE_ADDR
>
296 linux_process_target::low_get_next_pcs (regcache
*regcache
)
298 gdb_assert_not_reached ("linux target op low_get_next_pcs is not "
303 linux_process_target::low_decr_pc_after_break ()
308 /* True if LWP is stopped in its stepping range. */
311 lwp_in_step_range (struct lwp_info
*lwp
)
313 CORE_ADDR pc
= lwp
->stop_pc
;
315 return (pc
>= lwp
->step_range_start
&& pc
< lwp
->step_range_end
);
318 /* The read/write ends of the pipe registered as waitable file in the
320 static int linux_event_pipe
[2] = { -1, -1 };
322 /* True if we're currently in async mode. */
323 #define target_is_async_p() (linux_event_pipe[0] != -1)
325 static void send_sigstop (struct lwp_info
*lwp
);
327 /* Return non-zero if HEADER is a 64-bit ELF file. */
330 elf_64_header_p (const Elf64_Ehdr
*header
, unsigned int *machine
)
332 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
333 && header
->e_ident
[EI_MAG1
] == ELFMAG1
334 && header
->e_ident
[EI_MAG2
] == ELFMAG2
335 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
337 *machine
= header
->e_machine
;
338 return header
->e_ident
[EI_CLASS
] == ELFCLASS64
;
345 /* Return non-zero if FILE is a 64-bit ELF file,
346 zero if the file is not a 64-bit ELF file,
347 and -1 if the file is not accessible or doesn't exist. */
350 elf_64_file_p (const char *file
, unsigned int *machine
)
355 fd
= open (file
, O_RDONLY
);
359 if (read (fd
, &header
, sizeof (header
)) != sizeof (header
))
366 return elf_64_header_p (&header
, machine
);
369 /* Accepts an integer PID; Returns true if the executable PID is
370 running is a 64-bit ELF file.. */
373 linux_pid_exe_is_elf_64_file (int pid
, unsigned int *machine
)
377 sprintf (file
, "/proc/%d/exe", pid
);
378 return elf_64_file_p (file
, machine
);
382 linux_process_target::delete_lwp (lwp_info
*lwp
)
384 struct thread_info
*thr
= get_lwp_thread (lwp
);
387 debug_printf ("deleting %ld\n", lwpid_of (thr
));
391 low_delete_thread (lwp
->arch_private
);
397 linux_process_target::low_delete_thread (arch_lwp_info
*info
)
399 /* Default implementation should be overridden if architecture-specific
400 info is being used. */
401 gdb_assert (info
== nullptr);
405 linux_process_target::add_linux_process (int pid
, int attached
)
407 struct process_info
*proc
;
409 proc
= add_process (pid
, attached
);
410 proc
->priv
= XCNEW (struct process_info_private
);
412 proc
->priv
->arch_private
= low_new_process ();
418 linux_process_target::low_new_process ()
424 linux_process_target::low_delete_process (arch_process_info
*info
)
426 /* Default implementation must be overridden if architecture-specific
428 gdb_assert (info
== nullptr);
432 linux_process_target::low_new_fork (process_info
*parent
, process_info
*child
)
438 linux_process_target::arch_setup_thread (thread_info
*thread
)
440 struct thread_info
*saved_thread
;
442 saved_thread
= current_thread
;
443 current_thread
= thread
;
447 current_thread
= saved_thread
;
451 linux_process_target::handle_extended_wait (lwp_info
**orig_event_lwp
,
454 client_state
&cs
= get_client_state ();
455 struct lwp_info
*event_lwp
= *orig_event_lwp
;
456 int event
= linux_ptrace_get_extended_event (wstat
);
457 struct thread_info
*event_thr
= get_lwp_thread (event_lwp
);
458 struct lwp_info
*new_lwp
;
460 gdb_assert (event_lwp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
);
462 /* All extended events we currently use are mid-syscall. Only
463 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
464 you have to be using PTRACE_SEIZE to get that. */
465 event_lwp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
467 if ((event
== PTRACE_EVENT_FORK
) || (event
== PTRACE_EVENT_VFORK
)
468 || (event
== PTRACE_EVENT_CLONE
))
471 unsigned long new_pid
;
474 /* Get the pid of the new lwp. */
475 ptrace (PTRACE_GETEVENTMSG
, lwpid_of (event_thr
), (PTRACE_TYPE_ARG3
) 0,
478 /* If we haven't already seen the new PID stop, wait for it now. */
479 if (!pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
481 /* The new child has a pending SIGSTOP. We can't affect it until it
482 hits the SIGSTOP, but we're already attached. */
484 ret
= my_waitpid (new_pid
, &status
, __WALL
);
487 perror_with_name ("waiting for new child");
488 else if (ret
!= new_pid
)
489 warning ("wait returned unexpected PID %d", ret
);
490 else if (!WIFSTOPPED (status
))
491 warning ("wait returned unexpected status 0x%x", status
);
494 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
)
496 struct process_info
*parent_proc
;
497 struct process_info
*child_proc
;
498 struct lwp_info
*child_lwp
;
499 struct thread_info
*child_thr
;
501 ptid
= ptid_t (new_pid
, new_pid
, 0);
505 debug_printf ("HEW: Got fork event from LWP %ld, "
507 ptid_of (event_thr
).lwp (),
511 /* Add the new process to the tables and clone the breakpoint
512 lists of the parent. We need to do this even if the new process
513 will be detached, since we will need the process object and the
514 breakpoints to remove any breakpoints from memory when we
515 detach, and the client side will access registers. */
516 child_proc
= add_linux_process (new_pid
, 0);
517 gdb_assert (child_proc
!= NULL
);
518 child_lwp
= add_lwp (ptid
);
519 gdb_assert (child_lwp
!= NULL
);
520 child_lwp
->stopped
= 1;
521 child_lwp
->must_set_ptrace_flags
= 1;
522 child_lwp
->status_pending_p
= 0;
523 child_thr
= get_lwp_thread (child_lwp
);
524 child_thr
->last_resume_kind
= resume_stop
;
525 child_thr
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
527 /* If we're suspending all threads, leave this one suspended
528 too. If the fork/clone parent is stepping over a breakpoint,
529 all other threads have been suspended already. Leave the
530 child suspended too. */
531 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
532 || event_lwp
->bp_reinsert
!= 0)
535 debug_printf ("HEW: leaving child suspended\n");
536 child_lwp
->suspended
= 1;
539 parent_proc
= get_thread_process (event_thr
);
540 child_proc
->attached
= parent_proc
->attached
;
542 if (event_lwp
->bp_reinsert
!= 0
543 && supports_software_single_step ()
544 && event
== PTRACE_EVENT_VFORK
)
546 /* If we leave single-step breakpoints there, child will
547 hit it, so uninsert single-step breakpoints from parent
548 (and child). Once vfork child is done, reinsert
549 them back to parent. */
550 uninsert_single_step_breakpoints (event_thr
);
553 clone_all_breakpoints (child_thr
, event_thr
);
555 target_desc_up tdesc
= allocate_target_description ();
556 copy_target_description (tdesc
.get (), parent_proc
->tdesc
);
557 child_proc
->tdesc
= tdesc
.release ();
559 /* Clone arch-specific process data. */
560 low_new_fork (parent_proc
, child_proc
);
562 /* Save fork info in the parent thread. */
563 if (event
== PTRACE_EVENT_FORK
)
564 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_FORKED
;
565 else if (event
== PTRACE_EVENT_VFORK
)
566 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_VFORKED
;
568 event_lwp
->waitstatus
.value
.related_pid
= ptid
;
570 /* The status_pending field contains bits denoting the
571 extended event, so when the pending event is handled,
572 the handler will look at lwp->waitstatus. */
573 event_lwp
->status_pending_p
= 1;
574 event_lwp
->status_pending
= wstat
;
576 /* Link the threads until the parent event is passed on to
578 event_lwp
->fork_relative
= child_lwp
;
579 child_lwp
->fork_relative
= event_lwp
;
581 /* If the parent thread is doing step-over with single-step
582 breakpoints, the list of single-step breakpoints are cloned
583 from the parent's. Remove them from the child process.
584 In case of vfork, we'll reinsert them back once vforked
586 if (event_lwp
->bp_reinsert
!= 0
587 && supports_software_single_step ())
589 /* The child process is forked and stopped, so it is safe
590 to access its memory without stopping all other threads
591 from other processes. */
592 delete_single_step_breakpoints (child_thr
);
594 gdb_assert (has_single_step_breakpoints (event_thr
));
595 gdb_assert (!has_single_step_breakpoints (child_thr
));
598 /* Report the event. */
603 debug_printf ("HEW: Got clone event "
604 "from LWP %ld, new child is LWP %ld\n",
605 lwpid_of (event_thr
), new_pid
);
607 ptid
= ptid_t (pid_of (event_thr
), new_pid
, 0);
608 new_lwp
= add_lwp (ptid
);
610 /* Either we're going to immediately resume the new thread
611 or leave it stopped. resume_one_lwp is a nop if it
612 thinks the thread is currently running, so set this first
613 before calling resume_one_lwp. */
614 new_lwp
->stopped
= 1;
616 /* If we're suspending all threads, leave this one suspended
617 too. If the fork/clone parent is stepping over a breakpoint,
618 all other threads have been suspended already. Leave the
619 child suspended too. */
620 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
621 || event_lwp
->bp_reinsert
!= 0)
622 new_lwp
->suspended
= 1;
624 /* Normally we will get the pending SIGSTOP. But in some cases
625 we might get another signal delivered to the group first.
626 If we do get another signal, be sure not to lose it. */
627 if (WSTOPSIG (status
) != SIGSTOP
)
629 new_lwp
->stop_expected
= 1;
630 new_lwp
->status_pending_p
= 1;
631 new_lwp
->status_pending
= status
;
633 else if (cs
.report_thread_events
)
635 new_lwp
->waitstatus
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
636 new_lwp
->status_pending_p
= 1;
637 new_lwp
->status_pending
= status
;
641 thread_db_notice_clone (event_thr
, ptid
);
644 /* Don't report the event. */
647 else if (event
== PTRACE_EVENT_VFORK_DONE
)
649 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_VFORK_DONE
;
651 if (event_lwp
->bp_reinsert
!= 0 && supports_software_single_step ())
653 reinsert_single_step_breakpoints (event_thr
);
655 gdb_assert (has_single_step_breakpoints (event_thr
));
658 /* Report the event. */
661 else if (event
== PTRACE_EVENT_EXEC
&& cs
.report_exec_events
)
663 struct process_info
*proc
;
664 std::vector
<int> syscalls_to_catch
;
670 debug_printf ("HEW: Got exec event from LWP %ld\n",
671 lwpid_of (event_thr
));
674 /* Get the event ptid. */
675 event_ptid
= ptid_of (event_thr
);
676 event_pid
= event_ptid
.pid ();
678 /* Save the syscall list from the execing process. */
679 proc
= get_thread_process (event_thr
);
680 syscalls_to_catch
= std::move (proc
->syscalls_to_catch
);
682 /* Delete the execing process and all its threads. */
684 current_thread
= NULL
;
686 /* Create a new process/lwp/thread. */
687 proc
= add_linux_process (event_pid
, 0);
688 event_lwp
= add_lwp (event_ptid
);
689 event_thr
= get_lwp_thread (event_lwp
);
690 gdb_assert (current_thread
== event_thr
);
691 arch_setup_thread (event_thr
);
693 /* Set the event status. */
694 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_EXECD
;
695 event_lwp
->waitstatus
.value
.execd_pathname
696 = xstrdup (linux_proc_pid_to_exec_file (lwpid_of (event_thr
)));
698 /* Mark the exec status as pending. */
699 event_lwp
->stopped
= 1;
700 event_lwp
->status_pending_p
= 1;
701 event_lwp
->status_pending
= wstat
;
702 event_thr
->last_resume_kind
= resume_continue
;
703 event_thr
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
705 /* Update syscall state in the new lwp, effectively mid-syscall too. */
706 event_lwp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
708 /* Restore the list to catch. Don't rely on the client, which is free
709 to avoid sending a new list when the architecture doesn't change.
710 Also, for ANY_SYSCALL, the architecture doesn't really matter. */
711 proc
->syscalls_to_catch
= std::move (syscalls_to_catch
);
713 /* Report the event. */
714 *orig_event_lwp
= event_lwp
;
718 internal_error (__FILE__
, __LINE__
, _("unknown ptrace event %d"), event
);
722 linux_process_target::get_pc (lwp_info
*lwp
)
724 struct thread_info
*saved_thread
;
725 struct regcache
*regcache
;
728 if (!low_supports_breakpoints ())
731 saved_thread
= current_thread
;
732 current_thread
= get_lwp_thread (lwp
);
734 regcache
= get_thread_regcache (current_thread
, 1);
735 pc
= low_get_pc (regcache
);
738 debug_printf ("pc is 0x%lx\n", (long) pc
);
740 current_thread
= saved_thread
;
745 linux_process_target::get_syscall_trapinfo (lwp_info
*lwp
, int *sysno
)
747 struct thread_info
*saved_thread
;
748 struct regcache
*regcache
;
750 saved_thread
= current_thread
;
751 current_thread
= get_lwp_thread (lwp
);
753 regcache
= get_thread_regcache (current_thread
, 1);
754 low_get_syscall_trapinfo (regcache
, sysno
);
757 debug_printf ("get_syscall_trapinfo sysno %d\n", *sysno
);
759 current_thread
= saved_thread
;
763 linux_process_target::low_get_syscall_trapinfo (regcache
*regcache
, int *sysno
)
765 /* By default, report an unknown system call number. */
766 *sysno
= UNKNOWN_SYSCALL
;
770 linux_process_target::save_stop_reason (lwp_info
*lwp
)
773 CORE_ADDR sw_breakpoint_pc
;
774 struct thread_info
*saved_thread
;
775 #if USE_SIGTRAP_SIGINFO
779 if (!low_supports_breakpoints ())
783 sw_breakpoint_pc
= pc
- low_decr_pc_after_break ();
785 /* breakpoint_at reads from the current thread. */
786 saved_thread
= current_thread
;
787 current_thread
= get_lwp_thread (lwp
);
789 #if USE_SIGTRAP_SIGINFO
790 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
791 (PTRACE_TYPE_ARG3
) 0, &siginfo
) == 0)
793 if (siginfo
.si_signo
== SIGTRAP
)
795 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
)
796 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
798 /* The si_code is ambiguous on this arch -- check debug
800 if (!check_stopped_by_watchpoint (lwp
))
801 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
803 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
))
805 /* If we determine the LWP stopped for a SW breakpoint,
806 trust it. Particularly don't check watchpoint
807 registers, because at least on s390, we'd find
808 stopped-by-watchpoint as long as there's a watchpoint
810 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
812 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
814 /* This can indicate either a hardware breakpoint or
815 hardware watchpoint. Check debug registers. */
816 if (!check_stopped_by_watchpoint (lwp
))
817 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
819 else if (siginfo
.si_code
== TRAP_TRACE
)
821 /* We may have single stepped an instruction that
822 triggered a watchpoint. In that case, on some
823 architectures (such as x86), instead of TRAP_HWBKPT,
824 si_code indicates TRAP_TRACE, and we need to check
825 the debug registers separately. */
826 if (!check_stopped_by_watchpoint (lwp
))
827 lwp
->stop_reason
= TARGET_STOPPED_BY_SINGLE_STEP
;
832 /* We may have just stepped a breakpoint instruction. E.g., in
833 non-stop mode, GDB first tells the thread A to step a range, and
834 then the user inserts a breakpoint inside the range. In that
835 case we need to report the breakpoint PC. */
836 if ((!lwp
->stepping
|| lwp
->stop_pc
== sw_breakpoint_pc
)
837 && low_breakpoint_at (sw_breakpoint_pc
))
838 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
840 if (hardware_breakpoint_inserted_here (pc
))
841 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
843 if (lwp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
)
844 check_stopped_by_watchpoint (lwp
);
847 if (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
)
851 struct thread_info
*thr
= get_lwp_thread (lwp
);
853 debug_printf ("CSBB: %s stopped by software breakpoint\n",
854 target_pid_to_str (ptid_of (thr
)));
857 /* Back up the PC if necessary. */
858 if (pc
!= sw_breakpoint_pc
)
860 struct regcache
*regcache
861 = get_thread_regcache (current_thread
, 1);
862 low_set_pc (regcache
, sw_breakpoint_pc
);
865 /* Update this so we record the correct stop PC below. */
866 pc
= sw_breakpoint_pc
;
868 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
872 struct thread_info
*thr
= get_lwp_thread (lwp
);
874 debug_printf ("CSBB: %s stopped by hardware breakpoint\n",
875 target_pid_to_str (ptid_of (thr
)));
878 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
882 struct thread_info
*thr
= get_lwp_thread (lwp
);
884 debug_printf ("CSBB: %s stopped by hardware watchpoint\n",
885 target_pid_to_str (ptid_of (thr
)));
888 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
892 struct thread_info
*thr
= get_lwp_thread (lwp
);
894 debug_printf ("CSBB: %s stopped by trace\n",
895 target_pid_to_str (ptid_of (thr
)));
900 current_thread
= saved_thread
;
905 linux_process_target::add_lwp (ptid_t ptid
)
907 struct lwp_info
*lwp
;
909 lwp
= new lwp_info
{};
911 lwp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
913 lwp
->thread
= add_thread (ptid
, lwp
);
915 low_new_thread (lwp
);
921 linux_process_target::low_new_thread (lwp_info
*info
)
926 /* Callback to be used when calling fork_inferior, responsible for
927 actually initiating the tracing of the inferior. */
932 if (ptrace (PTRACE_TRACEME
, 0, (PTRACE_TYPE_ARG3
) 0,
933 (PTRACE_TYPE_ARG4
) 0) < 0)
934 trace_start_error_with_name ("ptrace");
936 if (setpgid (0, 0) < 0)
937 trace_start_error_with_name ("setpgid");
939 /* If GDBserver is connected to gdb via stdio, redirect the inferior's
940 stdout to stderr so that inferior i/o doesn't corrupt the connection.
941 Also, redirect stdin to /dev/null. */
942 if (remote_connection_is_stdio ())
945 trace_start_error_with_name ("close");
946 if (open ("/dev/null", O_RDONLY
) < 0)
947 trace_start_error_with_name ("open");
949 trace_start_error_with_name ("dup2");
950 if (write (2, "stdin/stdout redirected\n",
951 sizeof ("stdin/stdout redirected\n") - 1) < 0)
953 /* Errors ignored. */;
958 /* Start an inferior process and returns its pid.
959 PROGRAM is the name of the program to be started, and PROGRAM_ARGS
960 are its arguments. */
963 linux_process_target::create_inferior (const char *program
,
964 const std::vector
<char *> &program_args
)
966 client_state
&cs
= get_client_state ();
967 struct lwp_info
*new_lwp
;
972 maybe_disable_address_space_randomization restore_personality
973 (cs
.disable_randomization
);
974 std::string str_program_args
= construct_inferior_arguments (program_args
);
976 pid
= fork_inferior (program
,
977 str_program_args
.c_str (),
978 get_environ ()->envp (), linux_ptrace_fun
,
979 NULL
, NULL
, NULL
, NULL
);
982 add_linux_process (pid
, 0);
984 ptid
= ptid_t (pid
, pid
, 0);
985 new_lwp
= add_lwp (ptid
);
986 new_lwp
->must_set_ptrace_flags
= 1;
988 post_fork_inferior (pid
, program
);
993 /* Implement the post_create_inferior target_ops method. */
996 linux_process_target::post_create_inferior ()
998 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
1002 if (lwp
->must_set_ptrace_flags
)
1004 struct process_info
*proc
= current_process ();
1005 int options
= linux_low_ptrace_options (proc
->attached
);
1007 linux_enable_event_reporting (lwpid_of (current_thread
), options
);
1008 lwp
->must_set_ptrace_flags
= 0;
1013 linux_process_target::attach_lwp (ptid_t ptid
)
1015 struct lwp_info
*new_lwp
;
1016 int lwpid
= ptid
.lwp ();
1018 if (ptrace (PTRACE_ATTACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0)
1022 new_lwp
= add_lwp (ptid
);
1024 /* We need to wait for SIGSTOP before being able to make the next
1025 ptrace call on this LWP. */
1026 new_lwp
->must_set_ptrace_flags
= 1;
1028 if (linux_proc_pid_is_stopped (lwpid
))
1031 debug_printf ("Attached to a stopped process\n");
1033 /* The process is definitely stopped. It is in a job control
1034 stop, unless the kernel predates the TASK_STOPPED /
1035 TASK_TRACED distinction, in which case it might be in a
1036 ptrace stop. Make sure it is in a ptrace stop; from there we
1037 can kill it, signal it, et cetera.
1039 First make sure there is a pending SIGSTOP. Since we are
1040 already attached, the process can not transition from stopped
1041 to running without a PTRACE_CONT; so we know this signal will
1042 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1043 probably already in the queue (unless this kernel is old
1044 enough to use TASK_STOPPED for ptrace stops); but since
1045 SIGSTOP is not an RT signal, it can only be queued once. */
1046 kill_lwp (lwpid
, SIGSTOP
);
1048 /* Finally, resume the stopped process. This will deliver the
1049 SIGSTOP (or a higher priority signal, just like normal
1050 PTRACE_ATTACH), which we'll catch later on. */
1051 ptrace (PTRACE_CONT
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1054 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
1055 brings it to a halt.
1057 There are several cases to consider here:
1059 1) gdbserver has already attached to the process and is being notified
1060 of a new thread that is being created.
1061 In this case we should ignore that SIGSTOP and resume the
1062 process. This is handled below by setting stop_expected = 1,
1063 and the fact that add_thread sets last_resume_kind ==
1066 2) This is the first thread (the process thread), and we're attaching
1067 to it via attach_inferior.
1068 In this case we want the process thread to stop.
1069 This is handled by having linux_attach set last_resume_kind ==
1070 resume_stop after we return.
1072 If the pid we are attaching to is also the tgid, we attach to and
1073 stop all the existing threads. Otherwise, we attach to pid and
1074 ignore any other threads in the same group as this pid.
1076 3) GDB is connecting to gdbserver and is requesting an enumeration of all
1078 In this case we want the thread to stop.
1079 FIXME: This case is currently not properly handled.
1080 We should wait for the SIGSTOP but don't. Things work apparently
1081 because enough time passes between when we ptrace (ATTACH) and when
1082 gdb makes the next ptrace call on the thread.
1084 On the other hand, if we are currently trying to stop all threads, we
1085 should treat the new thread as if we had sent it a SIGSTOP. This works
1086 because we are guaranteed that the add_lwp call above added us to the
1087 end of the list, and so the new thread has not yet reached
1088 wait_for_sigstop (but will). */
1089 new_lwp
->stop_expected
= 1;
1094 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1095 already attached. Returns true if a new LWP is found, false
1099 attach_proc_task_lwp_callback (ptid_t ptid
)
1101 /* Is this a new thread? */
1102 if (find_thread_ptid (ptid
) == NULL
)
1104 int lwpid
= ptid
.lwp ();
1108 debug_printf ("Found new lwp %d\n", lwpid
);
1110 err
= the_linux_target
->attach_lwp (ptid
);
1112 /* Be quiet if we simply raced with the thread exiting. EPERM
1113 is returned if the thread's task still exists, and is marked
1114 as exited or zombie, as well as other conditions, so in that
1115 case, confirm the status in /proc/PID/status. */
1117 || (err
== EPERM
&& linux_proc_pid_is_gone (lwpid
)))
1121 debug_printf ("Cannot attach to lwp %d: "
1122 "thread is gone (%d: %s)\n",
1123 lwpid
, err
, safe_strerror (err
));
1129 = linux_ptrace_attach_fail_reason_string (ptid
, err
);
1131 warning (_("Cannot attach to lwp %d: %s"), lwpid
, reason
.c_str ());
1139 static void async_file_mark (void);
1141 /* Attach to PID. If PID is the tgid, attach to it and all
1145 linux_process_target::attach (unsigned long pid
)
1147 struct process_info
*proc
;
1148 struct thread_info
*initial_thread
;
1149 ptid_t ptid
= ptid_t (pid
, pid
, 0);
1152 proc
= add_linux_process (pid
, 1);
1154 /* Attach to PID. We will check for other threads
1156 err
= attach_lwp (ptid
);
1159 remove_process (proc
);
1161 std::string reason
= linux_ptrace_attach_fail_reason_string (ptid
, err
);
1162 error ("Cannot attach to process %ld: %s", pid
, reason
.c_str ());
1165 /* Don't ignore the initial SIGSTOP if we just attached to this
1166 process. It will be collected by wait shortly. */
1167 initial_thread
= find_thread_ptid (ptid_t (pid
, pid
, 0));
1168 initial_thread
->last_resume_kind
= resume_stop
;
1170 /* We must attach to every LWP. If /proc is mounted, use that to
1171 find them now. On the one hand, the inferior may be using raw
1172 clone instead of using pthreads. On the other hand, even if it
1173 is using pthreads, GDB may not be connected yet (thread_db needs
1174 to do symbol lookups, through qSymbol). Also, thread_db walks
1175 structures in the inferior's address space to find the list of
1176 threads/LWPs, and those structures may well be corrupted. Note
1177 that once thread_db is loaded, we'll still use it to list threads
1178 and associate pthread info with each LWP. */
1179 linux_proc_attach_tgid_threads (pid
, attach_proc_task_lwp_callback
);
1181 /* GDB will shortly read the xml target description for this
1182 process, to figure out the process' architecture. But the target
1183 description is only filled in when the first process/thread in
1184 the thread group reports its initial PTRACE_ATTACH SIGSTOP. Do
1185 that now, otherwise, if GDB is fast enough, it could read the
1186 target description _before_ that initial stop. */
1189 struct lwp_info
*lwp
;
1191 ptid_t pid_ptid
= ptid_t (pid
);
1193 lwpid
= wait_for_event_filtered (pid_ptid
, pid_ptid
, &wstat
, __WALL
);
1194 gdb_assert (lwpid
> 0);
1196 lwp
= find_lwp_pid (ptid_t (lwpid
));
1198 if (!WIFSTOPPED (wstat
) || WSTOPSIG (wstat
) != SIGSTOP
)
1200 lwp
->status_pending_p
= 1;
1201 lwp
->status_pending
= wstat
;
1204 initial_thread
->last_resume_kind
= resume_continue
;
1208 gdb_assert (proc
->tdesc
!= NULL
);
1215 last_thread_of_process_p (int pid
)
1217 bool seen_one
= false;
1219 thread_info
*thread
= find_thread (pid
, [&] (thread_info
*thr_arg
)
1223 /* This is the first thread of this process we see. */
1229 /* This is the second thread of this process we see. */
1234 return thread
== NULL
;
1240 linux_kill_one_lwp (struct lwp_info
*lwp
)
1242 struct thread_info
*thr
= get_lwp_thread (lwp
);
1243 int pid
= lwpid_of (thr
);
1245 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
1246 there is no signal context, and ptrace(PTRACE_KILL) (or
1247 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
1248 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
1249 alternative is to kill with SIGKILL. We only need one SIGKILL
1250 per process, not one for each thread. But since we still support
1251 support debugging programs using raw clone without CLONE_THREAD,
1252 we send one for each thread. For years, we used PTRACE_KILL
1253 only, so we're being a bit paranoid about some old kernels where
1254 PTRACE_KILL might work better (dubious if there are any such, but
1255 that's why it's paranoia), so we try SIGKILL first, PTRACE_KILL
1256 second, and so we're fine everywhere. */
1259 kill_lwp (pid
, SIGKILL
);
1262 int save_errno
= errno
;
1264 debug_printf ("LKL: kill_lwp (SIGKILL) %s, 0, 0 (%s)\n",
1265 target_pid_to_str (ptid_of (thr
)),
1266 save_errno
? safe_strerror (save_errno
) : "OK");
1270 ptrace (PTRACE_KILL
, pid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1273 int save_errno
= errno
;
1275 debug_printf ("LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
1276 target_pid_to_str (ptid_of (thr
)),
1277 save_errno
? safe_strerror (save_errno
) : "OK");
1281 /* Kill LWP and wait for it to die. */
1284 kill_wait_lwp (struct lwp_info
*lwp
)
1286 struct thread_info
*thr
= get_lwp_thread (lwp
);
1287 int pid
= ptid_of (thr
).pid ();
1288 int lwpid
= ptid_of (thr
).lwp ();
1293 debug_printf ("kwl: killing lwp %d, for pid: %d\n", lwpid
, pid
);
1297 linux_kill_one_lwp (lwp
);
1299 /* Make sure it died. Notes:
1301 - The loop is most likely unnecessary.
1303 - We don't use wait_for_event as that could delete lwps
1304 while we're iterating over them. We're not interested in
1305 any pending status at this point, only in making sure all
1306 wait status on the kernel side are collected until the
1309 - We don't use __WALL here as the __WALL emulation relies on
1310 SIGCHLD, and killing a stopped process doesn't generate
1311 one, nor an exit status.
1313 res
= my_waitpid (lwpid
, &wstat
, 0);
1314 if (res
== -1 && errno
== ECHILD
)
1315 res
= my_waitpid (lwpid
, &wstat
, __WCLONE
);
1316 } while (res
> 0 && WIFSTOPPED (wstat
));
1318 /* Even if it was stopped, the child may have already disappeared.
1319 E.g., if it was killed by SIGKILL. */
1320 if (res
< 0 && errno
!= ECHILD
)
1321 perror_with_name ("kill_wait_lwp");
1324 /* Callback for `for_each_thread'. Kills an lwp of a given process,
1325 except the leader. */
1328 kill_one_lwp_callback (thread_info
*thread
, int pid
)
1330 struct lwp_info
*lwp
= get_thread_lwp (thread
);
1332 /* We avoid killing the first thread here, because of a Linux kernel (at
1333 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
1334 the children get a chance to be reaped, it will remain a zombie
1337 if (lwpid_of (thread
) == pid
)
1340 debug_printf ("lkop: is last of process %s\n",
1341 target_pid_to_str (thread
->id
));
1345 kill_wait_lwp (lwp
);
1349 linux_process_target::kill (process_info
*process
)
1351 int pid
= process
->pid
;
1353 /* If we're killing a running inferior, make sure it is stopped
1354 first, as PTRACE_KILL will not work otherwise. */
1355 stop_all_lwps (0, NULL
);
1357 for_each_thread (pid
, [&] (thread_info
*thread
)
1359 kill_one_lwp_callback (thread
, pid
);
1362 /* See the comment in linux_kill_one_lwp. We did not kill the first
1363 thread in the list, so do so now. */
1364 lwp_info
*lwp
= find_lwp_pid (ptid_t (pid
));
1369 debug_printf ("lk_1: cannot find lwp for pid: %d\n",
1373 kill_wait_lwp (lwp
);
1377 /* Since we presently can only stop all lwps of all processes, we
1378 need to unstop lwps of other processes. */
1379 unstop_all_lwps (0, NULL
);
1383 /* Get pending signal of THREAD, for detaching purposes. This is the
1384 signal the thread last stopped for, which we need to deliver to the
1385 thread when detaching, otherwise, it'd be suppressed/lost. */
1388 get_detach_signal (struct thread_info
*thread
)
1390 client_state
&cs
= get_client_state ();
1391 enum gdb_signal signo
= GDB_SIGNAL_0
;
1393 struct lwp_info
*lp
= get_thread_lwp (thread
);
1395 if (lp
->status_pending_p
)
1396 status
= lp
->status_pending
;
1399 /* If the thread had been suspended by gdbserver, and it stopped
1400 cleanly, then it'll have stopped with SIGSTOP. But we don't
1401 want to deliver that SIGSTOP. */
1402 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
1403 || thread
->last_status
.value
.sig
== GDB_SIGNAL_0
)
1406 /* Otherwise, we may need to deliver the signal we
1408 status
= lp
->last_status
;
1411 if (!WIFSTOPPED (status
))
1414 debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n",
1415 target_pid_to_str (ptid_of (thread
)));
1419 /* Extended wait statuses aren't real SIGTRAPs. */
1420 if (WSTOPSIG (status
) == SIGTRAP
&& linux_is_extended_waitstatus (status
))
1423 debug_printf ("GPS: lwp %s had stopped with extended "
1424 "status: no pending signal\n",
1425 target_pid_to_str (ptid_of (thread
)));
1429 signo
= gdb_signal_from_host (WSTOPSIG (status
));
1431 if (cs
.program_signals_p
&& !cs
.program_signals
[signo
])
1434 debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
1435 target_pid_to_str (ptid_of (thread
)),
1436 gdb_signal_to_string (signo
));
1439 else if (!cs
.program_signals_p
1440 /* If we have no way to know which signals GDB does not
1441 want to have passed to the program, assume
1442 SIGTRAP/SIGINT, which is GDB's default. */
1443 && (signo
== GDB_SIGNAL_TRAP
|| signo
== GDB_SIGNAL_INT
))
1446 debug_printf ("GPS: lwp %s had signal %s, "
1447 "but we don't know if we should pass it. "
1448 "Default to not.\n",
1449 target_pid_to_str (ptid_of (thread
)),
1450 gdb_signal_to_string (signo
));
1456 debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n",
1457 target_pid_to_str (ptid_of (thread
)),
1458 gdb_signal_to_string (signo
));
1460 return WSTOPSIG (status
);
1465 linux_process_target::detach_one_lwp (lwp_info
*lwp
)
1467 struct thread_info
*thread
= get_lwp_thread (lwp
);
1471 /* If there is a pending SIGSTOP, get rid of it. */
1472 if (lwp
->stop_expected
)
1475 debug_printf ("Sending SIGCONT to %s\n",
1476 target_pid_to_str (ptid_of (thread
)));
1478 kill_lwp (lwpid_of (thread
), SIGCONT
);
1479 lwp
->stop_expected
= 0;
1482 /* Pass on any pending signal for this thread. */
1483 sig
= get_detach_signal (thread
);
1485 /* Preparing to resume may try to write registers, and fail if the
1486 lwp is zombie. If that happens, ignore the error. We'll handle
1487 it below, when detach fails with ESRCH. */
1490 /* Flush any pending changes to the process's registers. */
1491 regcache_invalidate_thread (thread
);
1493 /* Finally, let it resume. */
1494 low_prepare_to_resume (lwp
);
1496 catch (const gdb_exception_error
&ex
)
1498 if (!check_ptrace_stopped_lwp_gone (lwp
))
1502 lwpid
= lwpid_of (thread
);
1503 if (ptrace (PTRACE_DETACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0,
1504 (PTRACE_TYPE_ARG4
) (long) sig
) < 0)
1506 int save_errno
= errno
;
1508 /* We know the thread exists, so ESRCH must mean the lwp is
1509 zombie. This can happen if one of the already-detached
1510 threads exits the whole thread group. In that case we're
1511 still attached, and must reap the lwp. */
1512 if (save_errno
== ESRCH
)
1516 ret
= my_waitpid (lwpid
, &status
, __WALL
);
1519 warning (_("Couldn't reap LWP %d while detaching: %s"),
1520 lwpid
, safe_strerror (errno
));
1522 else if (!WIFEXITED (status
) && !WIFSIGNALED (status
))
1524 warning (_("Reaping LWP %d while detaching "
1525 "returned unexpected status 0x%x"),
1531 error (_("Can't detach %s: %s"),
1532 target_pid_to_str (ptid_of (thread
)),
1533 safe_strerror (save_errno
));
1536 else if (debug_threads
)
1538 debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)\n",
1539 target_pid_to_str (ptid_of (thread
)),
1547 linux_process_target::detach (process_info
*process
)
1549 struct lwp_info
*main_lwp
;
1551 /* As there's a step over already in progress, let it finish first,
1552 otherwise nesting a stabilize_threads operation on top gets real
1554 complete_ongoing_step_over ();
1556 /* Stop all threads before detaching. First, ptrace requires that
1557 the thread is stopped to successfully detach. Second, thread_db
1558 may need to uninstall thread event breakpoints from memory, which
1559 only works with a stopped process anyway. */
1560 stop_all_lwps (0, NULL
);
1562 #ifdef USE_THREAD_DB
1563 thread_db_detach (process
);
1566 /* Stabilize threads (move out of jump pads). */
1567 target_stabilize_threads ();
1569 /* Detach from the clone lwps first. If the thread group exits just
1570 while we're detaching, we must reap the clone lwps before we're
1571 able to reap the leader. */
1572 for_each_thread (process
->pid
, [this] (thread_info
*thread
)
1574 /* We don't actually detach from the thread group leader just yet.
1575 If the thread group exits, we must reap the zombie clone lwps
1576 before we're able to reap the leader. */
1577 if (thread
->id
.pid () == thread
->id
.lwp ())
1580 lwp_info
*lwp
= get_thread_lwp (thread
);
1581 detach_one_lwp (lwp
);
1584 main_lwp
= find_lwp_pid (ptid_t (process
->pid
));
1585 detach_one_lwp (main_lwp
);
1589 /* Since we presently can only stop all lwps of all processes, we
1590 need to unstop lwps of other processes. */
1591 unstop_all_lwps (0, NULL
);
1595 /* Remove all LWPs that belong to process PROC from the lwp list. */
1598 linux_process_target::mourn (process_info
*process
)
1600 struct process_info_private
*priv
;
1602 #ifdef USE_THREAD_DB
1603 thread_db_mourn (process
);
1606 for_each_thread (process
->pid
, [this] (thread_info
*thread
)
1608 delete_lwp (get_thread_lwp (thread
));
1611 /* Freeing all private data. */
1612 priv
= process
->priv
;
1613 low_delete_process (priv
->arch_private
);
1615 process
->priv
= NULL
;
1617 remove_process (process
);
1621 linux_process_target::join (int pid
)
1626 ret
= my_waitpid (pid
, &status
, 0);
1627 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1629 } while (ret
!= -1 || errno
!= ECHILD
);
1632 /* Return true if the given thread is still alive. */
1635 linux_process_target::thread_alive (ptid_t ptid
)
1637 struct lwp_info
*lwp
= find_lwp_pid (ptid
);
1639 /* We assume we always know if a thread exits. If a whole process
1640 exited but we still haven't been able to report it to GDB, we'll
1641 hold on to the last lwp of the dead process. */
1643 return !lwp_is_marked_dead (lwp
);
1649 linux_process_target::thread_still_has_status_pending (thread_info
*thread
)
1651 struct lwp_info
*lp
= get_thread_lwp (thread
);
1653 if (!lp
->status_pending_p
)
1656 if (thread
->last_resume_kind
!= resume_stop
1657 && (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1658 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
1660 struct thread_info
*saved_thread
;
1664 gdb_assert (lp
->last_status
!= 0);
1668 saved_thread
= current_thread
;
1669 current_thread
= thread
;
1671 if (pc
!= lp
->stop_pc
)
1674 debug_printf ("PC of %ld changed\n",
1679 #if !USE_SIGTRAP_SIGINFO
1680 else if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1681 && !low_breakpoint_at (pc
))
1684 debug_printf ("previous SW breakpoint of %ld gone\n",
1688 else if (lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
1689 && !hardware_breakpoint_inserted_here (pc
))
1692 debug_printf ("previous HW breakpoint of %ld gone\n",
1698 current_thread
= saved_thread
;
1703 debug_printf ("discarding pending breakpoint status\n");
1704 lp
->status_pending_p
= 0;
1712 /* Returns true if LWP is resumed from the client's perspective. */
1715 lwp_resumed (struct lwp_info
*lwp
)
1717 struct thread_info
*thread
= get_lwp_thread (lwp
);
1719 if (thread
->last_resume_kind
!= resume_stop
)
1722 /* Did gdb send us a `vCont;t', but we haven't reported the
1723 corresponding stop to gdb yet? If so, the thread is still
1724 resumed/running from gdb's perspective. */
1725 if (thread
->last_resume_kind
== resume_stop
1726 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
1733 linux_process_target::status_pending_p_callback (thread_info
*thread
,
1736 struct lwp_info
*lp
= get_thread_lwp (thread
);
1738 /* Check if we're only interested in events from a specific process
1739 or a specific LWP. */
1740 if (!thread
->id
.matches (ptid
))
1743 if (!lwp_resumed (lp
))
1746 if (lp
->status_pending_p
1747 && !thread_still_has_status_pending (thread
))
1749 resume_one_lwp (lp
, lp
->stepping
, GDB_SIGNAL_0
, NULL
);
1753 return lp
->status_pending_p
;
1757 find_lwp_pid (ptid_t ptid
)
1759 thread_info
*thread
= find_thread ([&] (thread_info
*thr_arg
)
1761 int lwp
= ptid
.lwp () != 0 ? ptid
.lwp () : ptid
.pid ();
1762 return thr_arg
->id
.lwp () == lwp
;
1768 return get_thread_lwp (thread
);
1771 /* Return the number of known LWPs in the tgid given by PID. */
1778 for_each_thread (pid
, [&] (thread_info
*thread
)
1786 /* See nat/linux-nat.h. */
1789 iterate_over_lwps (ptid_t filter
,
1790 gdb::function_view
<iterate_over_lwps_ftype
> callback
)
1792 thread_info
*thread
= find_thread (filter
, [&] (thread_info
*thr_arg
)
1794 lwp_info
*lwp
= get_thread_lwp (thr_arg
);
1796 return callback (lwp
);
1802 return get_thread_lwp (thread
);
1806 linux_process_target::check_zombie_leaders ()
1808 for_each_process ([this] (process_info
*proc
) {
1809 pid_t leader_pid
= pid_of (proc
);
1810 struct lwp_info
*leader_lp
;
1812 leader_lp
= find_lwp_pid (ptid_t (leader_pid
));
1815 debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
1816 "num_lwps=%d, zombie=%d\n",
1817 leader_pid
, leader_lp
!= NULL
, num_lwps (leader_pid
),
1818 linux_proc_pid_is_zombie (leader_pid
));
1820 if (leader_lp
!= NULL
&& !leader_lp
->stopped
1821 /* Check if there are other threads in the group, as we may
1822 have raced with the inferior simply exiting. */
1823 && !last_thread_of_process_p (leader_pid
)
1824 && linux_proc_pid_is_zombie (leader_pid
))
1826 /* A leader zombie can mean one of two things:
1828 - It exited, and there's an exit status pending
1829 available, or only the leader exited (not the whole
1830 program). In the latter case, we can't waitpid the
1831 leader's exit status until all other threads are gone.
1833 - There are 3 or more threads in the group, and a thread
1834 other than the leader exec'd. On an exec, the Linux
1835 kernel destroys all other threads (except the execing
1836 one) in the thread group, and resets the execing thread's
1837 tid to the tgid. No exit notification is sent for the
1838 execing thread -- from the ptracer's perspective, it
1839 appears as though the execing thread just vanishes.
1840 Until we reap all other threads except the leader and the
1841 execing thread, the leader will be zombie, and the
1842 execing thread will be in `D (disc sleep)'. As soon as
1843 all other threads are reaped, the execing thread changes
1844 it's tid to the tgid, and the previous (zombie) leader
1845 vanishes, giving place to the "new" leader. We could try
1846 distinguishing the exit and exec cases, by waiting once
1847 more, and seeing if something comes out, but it doesn't
1848 sound useful. The previous leader _does_ go away, and
1849 we'll re-add the new one once we see the exec event
1850 (which is just the same as what would happen if the
1851 previous leader did exit voluntarily before some other
1855 debug_printf ("CZL: Thread group leader %d zombie "
1856 "(it exited, or another thread execd).\n",
1859 delete_lwp (leader_lp
);
1864 /* Callback for `find_thread'. Returns the first LWP that is not
1868 not_stopped_callback (thread_info
*thread
, ptid_t filter
)
1870 if (!thread
->id
.matches (filter
))
1873 lwp_info
*lwp
= get_thread_lwp (thread
);
1875 return !lwp
->stopped
;
1878 /* Increment LWP's suspend count. */
1881 lwp_suspended_inc (struct lwp_info
*lwp
)
1885 if (debug_threads
&& lwp
->suspended
> 4)
1887 struct thread_info
*thread
= get_lwp_thread (lwp
);
1889 debug_printf ("LWP %ld has a suspiciously high suspend count,"
1890 " suspended=%d\n", lwpid_of (thread
), lwp
->suspended
);
1894 /* Decrement LWP's suspend count. */
1897 lwp_suspended_decr (struct lwp_info
*lwp
)
1901 if (lwp
->suspended
< 0)
1903 struct thread_info
*thread
= get_lwp_thread (lwp
);
1905 internal_error (__FILE__
, __LINE__
,
1906 "unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread
),
1911 /* This function should only be called if the LWP got a SIGTRAP.
1913 Handle any tracepoint steps or hits. Return true if a tracepoint
1914 event was handled, 0 otherwise. */
1917 handle_tracepoints (struct lwp_info
*lwp
)
1919 struct thread_info
*tinfo
= get_lwp_thread (lwp
);
1920 int tpoint_related_event
= 0;
1922 gdb_assert (lwp
->suspended
== 0);
1924 /* If this tracepoint hit causes a tracing stop, we'll immediately
1925 uninsert tracepoints. To do this, we temporarily pause all
1926 threads, unpatch away, and then unpause threads. We need to make
1927 sure the unpausing doesn't resume LWP too. */
1928 lwp_suspended_inc (lwp
);
1930 /* And we need to be sure that any all-threads-stopping doesn't try
1931 to move threads out of the jump pads, as it could deadlock the
1932 inferior (LWP could be in the jump pad, maybe even holding the
1935 /* Do any necessary step collect actions. */
1936 tpoint_related_event
|= tracepoint_finished_step (tinfo
, lwp
->stop_pc
);
1938 tpoint_related_event
|= handle_tracepoint_bkpts (tinfo
, lwp
->stop_pc
);
1940 /* See if we just hit a tracepoint and do its main collect
1942 tpoint_related_event
|= tracepoint_was_hit (tinfo
, lwp
->stop_pc
);
1944 lwp_suspended_decr (lwp
);
1946 gdb_assert (lwp
->suspended
== 0);
1947 gdb_assert (!stabilizing_threads
1948 || (lwp
->collecting_fast_tracepoint
1949 != fast_tpoint_collect_result::not_collecting
));
1951 if (tpoint_related_event
)
1954 debug_printf ("got a tracepoint event\n");
1961 fast_tpoint_collect_result
1962 linux_process_target::linux_fast_tracepoint_collecting
1963 (lwp_info
*lwp
, fast_tpoint_collect_status
*status
)
1965 CORE_ADDR thread_area
;
1966 struct thread_info
*thread
= get_lwp_thread (lwp
);
1968 /* Get the thread area address. This is used to recognize which
1969 thread is which when tracing with the in-process agent library.
1970 We don't read anything from the address, and treat it as opaque;
1971 it's the address itself that we assume is unique per-thread. */
1972 if (low_get_thread_area (lwpid_of (thread
), &thread_area
) == -1)
1973 return fast_tpoint_collect_result::not_collecting
;
1975 return fast_tracepoint_collecting (thread_area
, lwp
->stop_pc
, status
);
1979 linux_process_target::low_get_thread_area (int lwpid
, CORE_ADDR
*addrp
)
1985 linux_process_target::maybe_move_out_of_jump_pad (lwp_info
*lwp
, int *wstat
)
1987 struct thread_info
*saved_thread
;
1989 saved_thread
= current_thread
;
1990 current_thread
= get_lwp_thread (lwp
);
1993 || (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) != SIGTRAP
))
1994 && supports_fast_tracepoints ()
1995 && agent_loaded_p ())
1997 struct fast_tpoint_collect_status status
;
2000 debug_printf ("Checking whether LWP %ld needs to move out of the "
2002 lwpid_of (current_thread
));
2004 fast_tpoint_collect_result r
2005 = linux_fast_tracepoint_collecting (lwp
, &status
);
2008 || (WSTOPSIG (*wstat
) != SIGILL
2009 && WSTOPSIG (*wstat
) != SIGFPE
2010 && WSTOPSIG (*wstat
) != SIGSEGV
2011 && WSTOPSIG (*wstat
) != SIGBUS
))
2013 lwp
->collecting_fast_tracepoint
= r
;
2015 if (r
!= fast_tpoint_collect_result::not_collecting
)
2017 if (r
== fast_tpoint_collect_result::before_insn
2018 && lwp
->exit_jump_pad_bkpt
== NULL
)
2020 /* Haven't executed the original instruction yet.
2021 Set breakpoint there, and wait till it's hit,
2022 then single-step until exiting the jump pad. */
2023 lwp
->exit_jump_pad_bkpt
2024 = set_breakpoint_at (status
.adjusted_insn_addr
, NULL
);
2028 debug_printf ("Checking whether LWP %ld needs to move out of "
2029 "the jump pad...it does\n",
2030 lwpid_of (current_thread
));
2031 current_thread
= saved_thread
;
2038 /* If we get a synchronous signal while collecting, *and*
2039 while executing the (relocated) original instruction,
2040 reset the PC to point at the tpoint address, before
2041 reporting to GDB. Otherwise, it's an IPA lib bug: just
2042 report the signal to GDB, and pray for the best. */
2044 lwp
->collecting_fast_tracepoint
2045 = fast_tpoint_collect_result::not_collecting
;
2047 if (r
!= fast_tpoint_collect_result::not_collecting
2048 && (status
.adjusted_insn_addr
<= lwp
->stop_pc
2049 && lwp
->stop_pc
< status
.adjusted_insn_addr_end
))
2052 struct regcache
*regcache
;
2054 /* The si_addr on a few signals references the address
2055 of the faulting instruction. Adjust that as
2057 if ((WSTOPSIG (*wstat
) == SIGILL
2058 || WSTOPSIG (*wstat
) == SIGFPE
2059 || WSTOPSIG (*wstat
) == SIGBUS
2060 || WSTOPSIG (*wstat
) == SIGSEGV
)
2061 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
2062 (PTRACE_TYPE_ARG3
) 0, &info
) == 0
2063 /* Final check just to make sure we don't clobber
2064 the siginfo of non-kernel-sent signals. */
2065 && (uintptr_t) info
.si_addr
== lwp
->stop_pc
)
2067 info
.si_addr
= (void *) (uintptr_t) status
.tpoint_addr
;
2068 ptrace (PTRACE_SETSIGINFO
, lwpid_of (current_thread
),
2069 (PTRACE_TYPE_ARG3
) 0, &info
);
2072 regcache
= get_thread_regcache (current_thread
, 1);
2073 low_set_pc (regcache
, status
.tpoint_addr
);
2074 lwp
->stop_pc
= status
.tpoint_addr
;
2076 /* Cancel any fast tracepoint lock this thread was
2078 force_unlock_trace_buffer ();
2081 if (lwp
->exit_jump_pad_bkpt
!= NULL
)
2084 debug_printf ("Cancelling fast exit-jump-pad: removing bkpt. "
2085 "stopping all threads momentarily.\n");
2087 stop_all_lwps (1, lwp
);
2089 delete_breakpoint (lwp
->exit_jump_pad_bkpt
);
2090 lwp
->exit_jump_pad_bkpt
= NULL
;
2092 unstop_all_lwps (1, lwp
);
2094 gdb_assert (lwp
->suspended
>= 0);
2100 debug_printf ("Checking whether LWP %ld needs to move out of the "
2102 lwpid_of (current_thread
));
2104 current_thread
= saved_thread
;
2108 /* Enqueue one signal in the "signals to report later when out of the
2112 enqueue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2114 struct thread_info
*thread
= get_lwp_thread (lwp
);
2117 debug_printf ("Deferring signal %d for LWP %ld.\n",
2118 WSTOPSIG (*wstat
), lwpid_of (thread
));
2122 for (const auto &sig
: lwp
->pending_signals_to_report
)
2123 debug_printf (" Already queued %d\n",
2126 debug_printf (" (no more currently queued signals)\n");
2129 /* Don't enqueue non-RT signals if they are already in the deferred
2130 queue. (SIGSTOP being the easiest signal to see ending up here
2132 if (WSTOPSIG (*wstat
) < __SIGRTMIN
)
2134 for (const auto &sig
: lwp
->pending_signals_to_report
)
2136 if (sig
.signal
== WSTOPSIG (*wstat
))
2139 debug_printf ("Not requeuing already queued non-RT signal %d"
2148 lwp
->pending_signals_to_report
.emplace_back (WSTOPSIG (*wstat
));
2150 ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2151 &lwp
->pending_signals_to_report
.back ().info
);
2154 /* Dequeue one signal from the "signals to report later when out of
2155 the jump pad" list. */
2158 dequeue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2160 struct thread_info
*thread
= get_lwp_thread (lwp
);
2162 if (!lwp
->pending_signals_to_report
.empty ())
2164 const pending_signal
&p_sig
= lwp
->pending_signals_to_report
.front ();
2166 *wstat
= W_STOPCODE (p_sig
.signal
);
2167 if (p_sig
.info
.si_signo
!= 0)
2168 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2171 lwp
->pending_signals_to_report
.pop_front ();
2174 debug_printf ("Reporting deferred signal %d for LWP %ld.\n",
2175 WSTOPSIG (*wstat
), lwpid_of (thread
));
2179 for (const auto &sig
: lwp
->pending_signals_to_report
)
2180 debug_printf (" Still queued %d\n",
2183 debug_printf (" (no more queued signals)\n");
2193 linux_process_target::check_stopped_by_watchpoint (lwp_info
*child
)
2195 struct thread_info
*saved_thread
= current_thread
;
2196 current_thread
= get_lwp_thread (child
);
2198 if (low_stopped_by_watchpoint ())
2200 child
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
2201 child
->stopped_data_address
= low_stopped_data_address ();
2204 current_thread
= saved_thread
;
2206 return child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2210 linux_process_target::low_stopped_by_watchpoint ()
2216 linux_process_target::low_stopped_data_address ()
2221 /* Return the ptrace options that we want to try to enable. */
2224 linux_low_ptrace_options (int attached
)
2226 client_state
&cs
= get_client_state ();
2230 options
|= PTRACE_O_EXITKILL
;
2232 if (cs
.report_fork_events
)
2233 options
|= PTRACE_O_TRACEFORK
;
2235 if (cs
.report_vfork_events
)
2236 options
|= (PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEVFORKDONE
);
2238 if (cs
.report_exec_events
)
2239 options
|= PTRACE_O_TRACEEXEC
;
2241 options
|= PTRACE_O_TRACESYSGOOD
;
2247 linux_process_target::filter_event (int lwpid
, int wstat
)
2249 client_state
&cs
= get_client_state ();
2250 struct lwp_info
*child
;
2251 struct thread_info
*thread
;
2252 int have_stop_pc
= 0;
2254 child
= find_lwp_pid (ptid_t (lwpid
));
2256 /* Check for stop events reported by a process we didn't already
2257 know about - anything not already in our LWP list.
2259 If we're expecting to receive stopped processes after
2260 fork, vfork, and clone events, then we'll just add the
2261 new one to our list and go back to waiting for the event
2262 to be reported - the stopped process might be returned
2263 from waitpid before or after the event is.
2265 But note the case of a non-leader thread exec'ing after the
2266 leader having exited, and gone from our lists (because
2267 check_zombie_leaders deleted it). The non-leader thread
2268 changes its tid to the tgid. */
2270 if (WIFSTOPPED (wstat
) && child
== NULL
&& WSTOPSIG (wstat
) == SIGTRAP
2271 && linux_ptrace_get_extended_event (wstat
) == PTRACE_EVENT_EXEC
)
2275 /* A multi-thread exec after we had seen the leader exiting. */
2278 debug_printf ("LLW: Re-adding thread group leader LWP %d"
2279 "after exec.\n", lwpid
);
2282 child_ptid
= ptid_t (lwpid
, lwpid
, 0);
2283 child
= add_lwp (child_ptid
);
2285 current_thread
= child
->thread
;
2288 /* If we didn't find a process, one of two things presumably happened:
2289 - A process we started and then detached from has exited. Ignore it.
2290 - A process we are controlling has forked and the new child's stop
2291 was reported to us by the kernel. Save its PID. */
2292 if (child
== NULL
&& WIFSTOPPED (wstat
))
2294 add_to_pid_list (&stopped_pids
, lwpid
, wstat
);
2297 else if (child
== NULL
)
2300 thread
= get_lwp_thread (child
);
2304 child
->last_status
= wstat
;
2306 /* Check if the thread has exited. */
2307 if ((WIFEXITED (wstat
) || WIFSIGNALED (wstat
)))
2310 debug_printf ("LLFE: %d exited.\n", lwpid
);
2312 if (finish_step_over (child
))
2314 /* Unsuspend all other LWPs, and set them back running again. */
2315 unsuspend_all_lwps (child
);
2318 /* If there is at least one more LWP, then the exit signal was
2319 not the end of the debugged application and should be
2320 ignored, unless GDB wants to hear about thread exits. */
2321 if (cs
.report_thread_events
2322 || last_thread_of_process_p (pid_of (thread
)))
2324 /* Since events are serialized to GDB core, and we can't
2325 report this one right now. Leave the status pending for
2326 the next time we're able to report it. */
2327 mark_lwp_dead (child
, wstat
);
2337 gdb_assert (WIFSTOPPED (wstat
));
2339 if (WIFSTOPPED (wstat
))
2341 struct process_info
*proc
;
2343 /* Architecture-specific setup after inferior is running. */
2344 proc
= find_process_pid (pid_of (thread
));
2345 if (proc
->tdesc
== NULL
)
2349 /* This needs to happen after we have attached to the
2350 inferior and it is stopped for the first time, but
2351 before we access any inferior registers. */
2352 arch_setup_thread (thread
);
2356 /* The process is started, but GDBserver will do
2357 architecture-specific setup after the program stops at
2358 the first instruction. */
2359 child
->status_pending_p
= 1;
2360 child
->status_pending
= wstat
;
2366 if (WIFSTOPPED (wstat
) && child
->must_set_ptrace_flags
)
2368 struct process_info
*proc
= find_process_pid (pid_of (thread
));
2369 int options
= linux_low_ptrace_options (proc
->attached
);
2371 linux_enable_event_reporting (lwpid
, options
);
2372 child
->must_set_ptrace_flags
= 0;
2375 /* Always update syscall_state, even if it will be filtered later. */
2376 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SYSCALL_SIGTRAP
)
2378 child
->syscall_state
2379 = (child
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
2380 ? TARGET_WAITKIND_SYSCALL_RETURN
2381 : TARGET_WAITKIND_SYSCALL_ENTRY
);
2385 /* Almost all other ptrace-stops are known to be outside of system
2386 calls, with further exceptions in handle_extended_wait. */
2387 child
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2390 /* Be careful to not overwrite stop_pc until save_stop_reason is
2392 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGTRAP
2393 && linux_is_extended_waitstatus (wstat
))
2395 child
->stop_pc
= get_pc (child
);
2396 if (handle_extended_wait (&child
, wstat
))
2398 /* The event has been handled, so just return without
2404 if (linux_wstatus_maybe_breakpoint (wstat
))
2406 if (save_stop_reason (child
))
2411 child
->stop_pc
= get_pc (child
);
2413 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGSTOP
2414 && child
->stop_expected
)
2417 debug_printf ("Expected stop.\n");
2418 child
->stop_expected
= 0;
2420 if (thread
->last_resume_kind
== resume_stop
)
2422 /* We want to report the stop to the core. Treat the
2423 SIGSTOP as a normal event. */
2425 debug_printf ("LLW: resume_stop SIGSTOP caught for %s.\n",
2426 target_pid_to_str (ptid_of (thread
)));
2428 else if (stopping_threads
!= NOT_STOPPING_THREADS
)
2430 /* Stopping threads. We don't want this SIGSTOP to end up
2433 debug_printf ("LLW: SIGSTOP caught for %s "
2434 "while stopping threads.\n",
2435 target_pid_to_str (ptid_of (thread
)));
2440 /* This is a delayed SIGSTOP. Filter out the event. */
2442 debug_printf ("LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
2443 child
->stepping
? "step" : "continue",
2444 target_pid_to_str (ptid_of (thread
)));
2446 resume_one_lwp (child
, child
->stepping
, 0, NULL
);
2451 child
->status_pending_p
= 1;
2452 child
->status_pending
= wstat
;
2457 linux_process_target::maybe_hw_step (thread_info
*thread
)
2459 if (supports_hardware_single_step ())
2463 /* GDBserver must insert single-step breakpoint for software
2465 gdb_assert (has_single_step_breakpoints (thread
));
2471 linux_process_target::resume_stopped_resumed_lwps (thread_info
*thread
)
2473 struct lwp_info
*lp
= get_thread_lwp (thread
);
2477 && !lp
->status_pending_p
2478 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2482 if (thread
->last_resume_kind
== resume_step
)
2483 step
= maybe_hw_step (thread
);
2486 debug_printf ("RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
2487 target_pid_to_str (ptid_of (thread
)),
2488 paddress (lp
->stop_pc
),
2491 resume_one_lwp (lp
, step
, GDB_SIGNAL_0
, NULL
);
2496 linux_process_target::wait_for_event_filtered (ptid_t wait_ptid
,
2498 int *wstatp
, int options
)
2500 struct thread_info
*event_thread
;
2501 struct lwp_info
*event_child
, *requested_child
;
2502 sigset_t block_mask
, prev_mask
;
2505 /* N.B. event_thread points to the thread_info struct that contains
2506 event_child. Keep them in sync. */
2507 event_thread
= NULL
;
2509 requested_child
= NULL
;
2511 /* Check for a lwp with a pending status. */
2513 if (filter_ptid
== minus_one_ptid
|| filter_ptid
.is_pid ())
2515 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2517 return status_pending_p_callback (thread
, filter_ptid
);
2520 if (event_thread
!= NULL
)
2521 event_child
= get_thread_lwp (event_thread
);
2522 if (debug_threads
&& event_thread
)
2523 debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread
));
2525 else if (filter_ptid
!= null_ptid
)
2527 requested_child
= find_lwp_pid (filter_ptid
);
2529 if (stopping_threads
== NOT_STOPPING_THREADS
2530 && requested_child
->status_pending_p
2531 && (requested_child
->collecting_fast_tracepoint
2532 != fast_tpoint_collect_result::not_collecting
))
2534 enqueue_one_deferred_signal (requested_child
,
2535 &requested_child
->status_pending
);
2536 requested_child
->status_pending_p
= 0;
2537 requested_child
->status_pending
= 0;
2538 resume_one_lwp (requested_child
, 0, 0, NULL
);
2541 if (requested_child
->suspended
2542 && requested_child
->status_pending_p
)
2544 internal_error (__FILE__
, __LINE__
,
2545 "requesting an event out of a"
2546 " suspended child?");
2549 if (requested_child
->status_pending_p
)
2551 event_child
= requested_child
;
2552 event_thread
= get_lwp_thread (event_child
);
2556 if (event_child
!= NULL
)
2559 debug_printf ("Got an event from pending child %ld (%04x)\n",
2560 lwpid_of (event_thread
), event_child
->status_pending
);
2561 *wstatp
= event_child
->status_pending
;
2562 event_child
->status_pending_p
= 0;
2563 event_child
->status_pending
= 0;
2564 current_thread
= event_thread
;
2565 return lwpid_of (event_thread
);
2568 /* But if we don't find a pending event, we'll have to wait.
2570 We only enter this loop if no process has a pending wait status.
2571 Thus any action taken in response to a wait status inside this
2572 loop is responding as soon as we detect the status, not after any
2575 /* Make sure SIGCHLD is blocked until the sigsuspend below. Block
2576 all signals while here. */
2577 sigfillset (&block_mask
);
2578 gdb_sigmask (SIG_BLOCK
, &block_mask
, &prev_mask
);
2580 /* Always pull all events out of the kernel. We'll randomly select
2581 an event LWP out of all that have events, to prevent
2583 while (event_child
== NULL
)
2587 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
2590 - If the thread group leader exits while other threads in the
2591 thread group still exist, waitpid(TGID, ...) hangs. That
2592 waitpid won't return an exit status until the other threads
2593 in the group are reaped.
2595 - When a non-leader thread execs, that thread just vanishes
2596 without reporting an exit (so we'd hang if we waited for it
2597 explicitly in that case). The exec event is reported to
2600 ret
= my_waitpid (-1, wstatp
, options
| WNOHANG
);
2603 debug_printf ("LWFE: waitpid(-1, ...) returned %d, %s\n",
2604 ret
, errno
? safe_strerror (errno
) : "ERRNO-OK");
2610 debug_printf ("LLW: waitpid %ld received %s\n",
2611 (long) ret
, status_to_str (*wstatp
));
2614 /* Filter all events. IOW, leave all events pending. We'll
2615 randomly select an event LWP out of all that have events
2617 filter_event (ret
, *wstatp
);
2618 /* Retry until nothing comes out of waitpid. A single
2619 SIGCHLD can indicate more than one child stopped. */
2623 /* Now that we've pulled all events out of the kernel, resume
2624 LWPs that don't have an interesting event to report. */
2625 if (stopping_threads
== NOT_STOPPING_THREADS
)
2626 for_each_thread ([this] (thread_info
*thread
)
2628 resume_stopped_resumed_lwps (thread
);
2631 /* ... and find an LWP with a status to report to the core, if
2633 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2635 return status_pending_p_callback (thread
, filter_ptid
);
2638 if (event_thread
!= NULL
)
2640 event_child
= get_thread_lwp (event_thread
);
2641 *wstatp
= event_child
->status_pending
;
2642 event_child
->status_pending_p
= 0;
2643 event_child
->status_pending
= 0;
2647 /* Check for zombie thread group leaders. Those can't be reaped
2648 until all other threads in the thread group are. */
2649 check_zombie_leaders ();
2651 auto not_stopped
= [&] (thread_info
*thread
)
2653 return not_stopped_callback (thread
, wait_ptid
);
2656 /* If there are no resumed children left in the set of LWPs we
2657 want to wait for, bail. We can't just block in
2658 waitpid/sigsuspend, because lwps might have been left stopped
2659 in trace-stop state, and we'd be stuck forever waiting for
2660 their status to change (which would only happen if we resumed
2661 them). Even if WNOHANG is set, this return code is preferred
2662 over 0 (below), as it is more detailed. */
2663 if (find_thread (not_stopped
) == NULL
)
2666 debug_printf ("LLW: exit (no unwaited-for LWP)\n");
2667 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2671 /* No interesting event to report to the caller. */
2672 if ((options
& WNOHANG
))
2675 debug_printf ("WNOHANG set, no event found\n");
2677 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2681 /* Block until we get an event reported with SIGCHLD. */
2683 debug_printf ("sigsuspend'ing\n");
2685 sigsuspend (&prev_mask
);
2686 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2690 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2692 current_thread
= event_thread
;
2694 return lwpid_of (event_thread
);
2698 linux_process_target::wait_for_event (ptid_t ptid
, int *wstatp
, int options
)
2700 return wait_for_event_filtered (ptid
, ptid
, wstatp
, options
);
2703 /* Select one LWP out of those that have events pending. */
2706 select_event_lwp (struct lwp_info
**orig_lp
)
2708 struct thread_info
*event_thread
= NULL
;
2710 /* In all-stop, give preference to the LWP that is being
2711 single-stepped. There will be at most one, and it's the LWP that
2712 the core is most interested in. If we didn't do this, then we'd
2713 have to handle pending step SIGTRAPs somehow in case the core
2714 later continues the previously-stepped thread, otherwise we'd
2715 report the pending SIGTRAP, and the core, not having stepped the
2716 thread, wouldn't understand what the trap was for, and therefore
2717 would report it to the user as a random signal. */
2720 event_thread
= find_thread ([] (thread_info
*thread
)
2722 lwp_info
*lp
= get_thread_lwp (thread
);
2724 return (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2725 && thread
->last_resume_kind
== resume_step
2726 && lp
->status_pending_p
);
2729 if (event_thread
!= NULL
)
2732 debug_printf ("SEL: Select single-step %s\n",
2733 target_pid_to_str (ptid_of (event_thread
)));
2736 if (event_thread
== NULL
)
2738 /* No single-stepping LWP. Select one at random, out of those
2739 which have had events. */
2741 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2743 lwp_info
*lp
= get_thread_lwp (thread
);
2745 /* Only resumed LWPs that have an event pending. */
2746 return (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2747 && lp
->status_pending_p
);
2751 if (event_thread
!= NULL
)
2753 struct lwp_info
*event_lp
= get_thread_lwp (event_thread
);
2755 /* Switch the event LWP. */
2756 *orig_lp
= event_lp
;
2760 /* Decrement the suspend count of all LWPs, except EXCEPT, if non
2764 unsuspend_all_lwps (struct lwp_info
*except
)
2766 for_each_thread ([&] (thread_info
*thread
)
2768 lwp_info
*lwp
= get_thread_lwp (thread
);
2771 lwp_suspended_decr (lwp
);
2775 static bool lwp_running (thread_info
*thread
);
2777 /* Stabilize threads (move out of jump pads).
2779 If a thread is midway collecting a fast tracepoint, we need to
2780 finish the collection and move it out of the jump pad before
2781 reporting the signal.
2783 This avoids recursion while collecting (when a signal arrives
2784 midway, and the signal handler itself collects), which would trash
2785 the trace buffer. In case the user set a breakpoint in a signal
2786 handler, this avoids the backtrace showing the jump pad, etc..
2787 Most importantly, there are certain things we can't do safely if
2788 threads are stopped in a jump pad (or in its callee's). For
2791 - starting a new trace run. A thread still collecting the
2792 previous run, could trash the trace buffer when resumed. The trace
2793 buffer control structures would have been reset but the thread had
2794 no way to tell. The thread could even midway memcpy'ing to the
2795 buffer, which would mean that when resumed, it would clobber the
2796 trace buffer that had been set for a new run.
2798 - we can't rewrite/reuse the jump pads for new tracepoints
2799 safely. Say you do tstart while a thread is stopped midway while
2800 collecting. When the thread is later resumed, it finishes the
2801 collection, and returns to the jump pad, to execute the original
2802 instruction that was under the tracepoint jump at the time the
2803 older run had been started. If the jump pad had been rewritten
2804 since for something else in the new run, the thread would now
2805 execute the wrong / random instructions. */
2808 linux_process_target::stabilize_threads ()
2810 thread_info
*thread_stuck
= find_thread ([this] (thread_info
*thread
)
2812 return stuck_in_jump_pad (thread
);
2815 if (thread_stuck
!= NULL
)
2818 debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n",
2819 lwpid_of (thread_stuck
));
2823 thread_info
*saved_thread
= current_thread
;
2825 stabilizing_threads
= 1;
2828 for_each_thread ([this] (thread_info
*thread
)
2830 move_out_of_jump_pad (thread
);
2833 /* Loop until all are stopped out of the jump pads. */
2834 while (find_thread (lwp_running
) != NULL
)
2836 struct target_waitstatus ourstatus
;
2837 struct lwp_info
*lwp
;
2840 /* Note that we go through the full wait even loop. While
2841 moving threads out of jump pad, we need to be able to step
2842 over internal breakpoints and such. */
2843 wait_1 (minus_one_ptid
, &ourstatus
, 0);
2845 if (ourstatus
.kind
== TARGET_WAITKIND_STOPPED
)
2847 lwp
= get_thread_lwp (current_thread
);
2850 lwp_suspended_inc (lwp
);
2852 if (ourstatus
.value
.sig
!= GDB_SIGNAL_0
2853 || current_thread
->last_resume_kind
== resume_stop
)
2855 wstat
= W_STOPCODE (gdb_signal_to_host (ourstatus
.value
.sig
));
2856 enqueue_one_deferred_signal (lwp
, &wstat
);
2861 unsuspend_all_lwps (NULL
);
2863 stabilizing_threads
= 0;
2865 current_thread
= saved_thread
;
2869 thread_stuck
= find_thread ([this] (thread_info
*thread
)
2871 return stuck_in_jump_pad (thread
);
2874 if (thread_stuck
!= NULL
)
2875 debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
2876 lwpid_of (thread_stuck
));
2880 /* Convenience function that is called when the kernel reports an
2881 event that is not passed out to GDB. */
2884 ignore_event (struct target_waitstatus
*ourstatus
)
2886 /* If we got an event, there may still be others, as a single
2887 SIGCHLD can indicate more than one child stopped. This forces
2888 another target_wait call. */
2891 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2896 linux_process_target::filter_exit_event (lwp_info
*event_child
,
2897 target_waitstatus
*ourstatus
)
2899 client_state
&cs
= get_client_state ();
2900 struct thread_info
*thread
= get_lwp_thread (event_child
);
2901 ptid_t ptid
= ptid_of (thread
);
2903 if (!last_thread_of_process_p (pid_of (thread
)))
2905 if (cs
.report_thread_events
)
2906 ourstatus
->kind
= TARGET_WAITKIND_THREAD_EXITED
;
2908 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2910 delete_lwp (event_child
);
2915 /* Returns 1 if GDB is interested in any event_child syscalls. */
2918 gdb_catching_syscalls_p (struct lwp_info
*event_child
)
2920 struct thread_info
*thread
= get_lwp_thread (event_child
);
2921 struct process_info
*proc
= get_thread_process (thread
);
2923 return !proc
->syscalls_to_catch
.empty ();
2927 linux_process_target::gdb_catch_this_syscall (lwp_info
*event_child
)
2930 struct thread_info
*thread
= get_lwp_thread (event_child
);
2931 struct process_info
*proc
= get_thread_process (thread
);
2933 if (proc
->syscalls_to_catch
.empty ())
2936 if (proc
->syscalls_to_catch
[0] == ANY_SYSCALL
)
2939 get_syscall_trapinfo (event_child
, &sysno
);
2941 for (int iter
: proc
->syscalls_to_catch
)
2949 linux_process_target::wait_1 (ptid_t ptid
, target_waitstatus
*ourstatus
,
2950 target_wait_flags target_options
)
2952 client_state
&cs
= get_client_state ();
2954 struct lwp_info
*event_child
;
2957 int step_over_finished
;
2958 int bp_explains_trap
;
2959 int maybe_internal_trap
;
2968 debug_printf ("wait_1: [%s]\n", target_pid_to_str (ptid
));
2971 /* Translate generic target options into linux options. */
2973 if (target_options
& TARGET_WNOHANG
)
2976 bp_explains_trap
= 0;
2979 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2981 auto status_pending_p_any
= [&] (thread_info
*thread
)
2983 return status_pending_p_callback (thread
, minus_one_ptid
);
2986 auto not_stopped
= [&] (thread_info
*thread
)
2988 return not_stopped_callback (thread
, minus_one_ptid
);
2991 /* Find a resumed LWP, if any. */
2992 if (find_thread (status_pending_p_any
) != NULL
)
2994 else if (find_thread (not_stopped
) != NULL
)
2999 if (step_over_bkpt
== null_ptid
)
3000 pid
= wait_for_event (ptid
, &w
, options
);
3004 debug_printf ("step_over_bkpt set [%s], doing a blocking wait\n",
3005 target_pid_to_str (step_over_bkpt
));
3006 pid
= wait_for_event (step_over_bkpt
, &w
, options
& ~WNOHANG
);
3009 if (pid
== 0 || (pid
== -1 && !any_resumed
))
3011 gdb_assert (target_options
& TARGET_WNOHANG
);
3015 debug_printf ("wait_1 ret = null_ptid, "
3016 "TARGET_WAITKIND_IGNORE\n");
3020 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3027 debug_printf ("wait_1 ret = null_ptid, "
3028 "TARGET_WAITKIND_NO_RESUMED\n");
3032 ourstatus
->kind
= TARGET_WAITKIND_NO_RESUMED
;
3036 event_child
= get_thread_lwp (current_thread
);
3038 /* wait_for_event only returns an exit status for the last
3039 child of a process. Report it. */
3040 if (WIFEXITED (w
) || WIFSIGNALED (w
))
3044 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
3045 ourstatus
->value
.integer
= WEXITSTATUS (w
);
3049 debug_printf ("wait_1 ret = %s, exited with "
3051 target_pid_to_str (ptid_of (current_thread
)),
3058 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
3059 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (w
));
3063 debug_printf ("wait_1 ret = %s, terminated with "
3065 target_pid_to_str (ptid_of (current_thread
)),
3071 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
3072 return filter_exit_event (event_child
, ourstatus
);
3074 return ptid_of (current_thread
);
3077 /* If step-over executes a breakpoint instruction, in the case of a
3078 hardware single step it means a gdb/gdbserver breakpoint had been
3079 planted on top of a permanent breakpoint, in the case of a software
3080 single step it may just mean that gdbserver hit the reinsert breakpoint.
3081 The PC has been adjusted by save_stop_reason to point at
3082 the breakpoint address.
3083 So in the case of the hardware single step advance the PC manually
3084 past the breakpoint and in the case of software single step advance only
3085 if it's not the single_step_breakpoint we are hitting.
3086 This avoids that a program would keep trapping a permanent breakpoint
3088 if (step_over_bkpt
!= null_ptid
3089 && event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3090 && (event_child
->stepping
3091 || !single_step_breakpoint_inserted_here (event_child
->stop_pc
)))
3093 int increment_pc
= 0;
3094 int breakpoint_kind
= 0;
3095 CORE_ADDR stop_pc
= event_child
->stop_pc
;
3097 breakpoint_kind
= breakpoint_kind_from_current_state (&stop_pc
);
3098 sw_breakpoint_from_kind (breakpoint_kind
, &increment_pc
);
3102 debug_printf ("step-over for %s executed software breakpoint\n",
3103 target_pid_to_str (ptid_of (current_thread
)));
3106 if (increment_pc
!= 0)
3108 struct regcache
*regcache
3109 = get_thread_regcache (current_thread
, 1);
3111 event_child
->stop_pc
+= increment_pc
;
3112 low_set_pc (regcache
, event_child
->stop_pc
);
3114 if (!low_breakpoint_at (event_child
->stop_pc
))
3115 event_child
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3119 /* If this event was not handled before, and is not a SIGTRAP, we
3120 report it. SIGILL and SIGSEGV are also treated as traps in case
3121 a breakpoint is inserted at the current PC. If this target does
3122 not support internal breakpoints at all, we also report the
3123 SIGTRAP without further processing; it's of no concern to us. */
3125 = (low_supports_breakpoints ()
3126 && (WSTOPSIG (w
) == SIGTRAP
3127 || ((WSTOPSIG (w
) == SIGILL
3128 || WSTOPSIG (w
) == SIGSEGV
)
3129 && low_breakpoint_at (event_child
->stop_pc
))));
3131 if (maybe_internal_trap
)
3133 /* Handle anything that requires bookkeeping before deciding to
3134 report the event or continue waiting. */
3136 /* First check if we can explain the SIGTRAP with an internal
3137 breakpoint, or if we should possibly report the event to GDB.
3138 Do this before anything that may remove or insert a
3140 bp_explains_trap
= breakpoint_inserted_here (event_child
->stop_pc
);
3142 /* We have a SIGTRAP, possibly a step-over dance has just
3143 finished. If so, tweak the state machine accordingly,
3144 reinsert breakpoints and delete any single-step
3146 step_over_finished
= finish_step_over (event_child
);
3148 /* Now invoke the callbacks of any internal breakpoints there. */
3149 check_breakpoints (event_child
->stop_pc
);
3151 /* Handle tracepoint data collecting. This may overflow the
3152 trace buffer, and cause a tracing stop, removing
3154 trace_event
= handle_tracepoints (event_child
);
3156 if (bp_explains_trap
)
3159 debug_printf ("Hit a gdbserver breakpoint.\n");
3164 /* We have some other signal, possibly a step-over dance was in
3165 progress, and it should be cancelled too. */
3166 step_over_finished
= finish_step_over (event_child
);
3169 /* We have all the data we need. Either report the event to GDB, or
3170 resume threads and keep waiting for more. */
3172 /* If we're collecting a fast tracepoint, finish the collection and
3173 move out of the jump pad before delivering a signal. See
3174 linux_stabilize_threads. */
3177 && WSTOPSIG (w
) != SIGTRAP
3178 && supports_fast_tracepoints ()
3179 && agent_loaded_p ())
3182 debug_printf ("Got signal %d for LWP %ld. Check if we need "
3183 "to defer or adjust it.\n",
3184 WSTOPSIG (w
), lwpid_of (current_thread
));
3186 /* Allow debugging the jump pad itself. */
3187 if (current_thread
->last_resume_kind
!= resume_step
3188 && maybe_move_out_of_jump_pad (event_child
, &w
))
3190 enqueue_one_deferred_signal (event_child
, &w
);
3193 debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
3194 WSTOPSIG (w
), lwpid_of (current_thread
));
3196 resume_one_lwp (event_child
, 0, 0, NULL
);
3200 return ignore_event (ourstatus
);
3204 if (event_child
->collecting_fast_tracepoint
3205 != fast_tpoint_collect_result::not_collecting
)
3208 debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
3209 "Check if we're already there.\n",
3210 lwpid_of (current_thread
),
3211 (int) event_child
->collecting_fast_tracepoint
);
3215 event_child
->collecting_fast_tracepoint
3216 = linux_fast_tracepoint_collecting (event_child
, NULL
);
3218 if (event_child
->collecting_fast_tracepoint
3219 != fast_tpoint_collect_result::before_insn
)
3221 /* No longer need this breakpoint. */
3222 if (event_child
->exit_jump_pad_bkpt
!= NULL
)
3225 debug_printf ("No longer need exit-jump-pad bkpt; removing it."
3226 "stopping all threads momentarily.\n");
3228 /* Other running threads could hit this breakpoint.
3229 We don't handle moribund locations like GDB does,
3230 instead we always pause all threads when removing
3231 breakpoints, so that any step-over or
3232 decr_pc_after_break adjustment is always taken
3233 care of while the breakpoint is still
3235 stop_all_lwps (1, event_child
);
3237 delete_breakpoint (event_child
->exit_jump_pad_bkpt
);
3238 event_child
->exit_jump_pad_bkpt
= NULL
;
3240 unstop_all_lwps (1, event_child
);
3242 gdb_assert (event_child
->suspended
>= 0);
3246 if (event_child
->collecting_fast_tracepoint
3247 == fast_tpoint_collect_result::not_collecting
)
3250 debug_printf ("fast tracepoint finished "
3251 "collecting successfully.\n");
3253 /* We may have a deferred signal to report. */
3254 if (dequeue_one_deferred_signal (event_child
, &w
))
3257 debug_printf ("dequeued one signal.\n");
3262 debug_printf ("no deferred signals.\n");
3264 if (stabilizing_threads
)
3266 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3267 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3271 debug_printf ("wait_1 ret = %s, stopped "
3272 "while stabilizing threads\n",
3273 target_pid_to_str (ptid_of (current_thread
)));
3277 return ptid_of (current_thread
);
3283 /* Check whether GDB would be interested in this event. */
3285 /* Check if GDB is interested in this syscall. */
3287 && WSTOPSIG (w
) == SYSCALL_SIGTRAP
3288 && !gdb_catch_this_syscall (event_child
))
3292 debug_printf ("Ignored syscall for LWP %ld.\n",
3293 lwpid_of (current_thread
));
3296 resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
3300 return ignore_event (ourstatus
);
3303 /* If GDB is not interested in this signal, don't stop other
3304 threads, and don't report it to GDB. Just resume the inferior
3305 right away. We do this for threading-related signals as well as
3306 any that GDB specifically requested we ignore. But never ignore
3307 SIGSTOP if we sent it ourselves, and do not ignore signals when
3308 stepping - they may require special handling to skip the signal
3309 handler. Also never ignore signals that could be caused by a
3312 && current_thread
->last_resume_kind
!= resume_step
3314 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
3315 (current_process ()->priv
->thread_db
!= NULL
3316 && (WSTOPSIG (w
) == __SIGRTMIN
3317 || WSTOPSIG (w
) == __SIGRTMIN
+ 1))
3320 (cs
.pass_signals
[gdb_signal_from_host (WSTOPSIG (w
))]
3321 && !(WSTOPSIG (w
) == SIGSTOP
3322 && current_thread
->last_resume_kind
== resume_stop
)
3323 && !linux_wstatus_maybe_breakpoint (w
))))
3325 siginfo_t info
, *info_p
;
3328 debug_printf ("Ignored signal %d for LWP %ld.\n",
3329 WSTOPSIG (w
), lwpid_of (current_thread
));
3331 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
3332 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
3337 if (step_over_finished
)
3339 /* We cancelled this thread's step-over above. We still
3340 need to unsuspend all other LWPs, and set them back
3341 running again while the signal handler runs. */
3342 unsuspend_all_lwps (event_child
);
3344 /* Enqueue the pending signal info so that proceed_all_lwps
3346 enqueue_pending_signal (event_child
, WSTOPSIG (w
), info_p
);
3348 proceed_all_lwps ();
3352 resume_one_lwp (event_child
, event_child
->stepping
,
3353 WSTOPSIG (w
), info_p
);
3359 return ignore_event (ourstatus
);
3362 /* Note that all addresses are always "out of the step range" when
3363 there's no range to begin with. */
3364 in_step_range
= lwp_in_step_range (event_child
);
3366 /* If GDB wanted this thread to single step, and the thread is out
3367 of the step range, we always want to report the SIGTRAP, and let
3368 GDB handle it. Watchpoints should always be reported. So should
3369 signals we can't explain. A SIGTRAP we can't explain could be a
3370 GDB breakpoint --- we may or not support Z0 breakpoints. If we
3371 do, we're be able to handle GDB breakpoints on top of internal
3372 breakpoints, by handling the internal breakpoint and still
3373 reporting the event to GDB. If we don't, we're out of luck, GDB
3374 won't see the breakpoint hit. If we see a single-step event but
3375 the thread should be continuing, don't pass the trap to gdb.
3376 That indicates that we had previously finished a single-step but
3377 left the single-step pending -- see
3378 complete_ongoing_step_over. */
3379 report_to_gdb
= (!maybe_internal_trap
3380 || (current_thread
->last_resume_kind
== resume_step
3382 || event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3384 && !bp_explains_trap
3386 && !step_over_finished
3387 && !(current_thread
->last_resume_kind
== resume_continue
3388 && event_child
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
))
3389 || (gdb_breakpoint_here (event_child
->stop_pc
)
3390 && gdb_condition_true_at_breakpoint (event_child
->stop_pc
)
3391 && gdb_no_commands_at_breakpoint (event_child
->stop_pc
))
3392 || event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
);
3394 run_breakpoint_commands (event_child
->stop_pc
);
3396 /* We found no reason GDB would want us to stop. We either hit one
3397 of our own breakpoints, or finished an internal step GDB
3398 shouldn't know about. */
3403 if (bp_explains_trap
)
3404 debug_printf ("Hit a gdbserver breakpoint.\n");
3405 if (step_over_finished
)
3406 debug_printf ("Step-over finished.\n");
3408 debug_printf ("Tracepoint event.\n");
3409 if (lwp_in_step_range (event_child
))
3410 debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).\n",
3411 paddress (event_child
->stop_pc
),
3412 paddress (event_child
->step_range_start
),
3413 paddress (event_child
->step_range_end
));
3416 /* We're not reporting this breakpoint to GDB, so apply the
3417 decr_pc_after_break adjustment to the inferior's regcache
3420 if (low_supports_breakpoints ())
3422 struct regcache
*regcache
3423 = get_thread_regcache (current_thread
, 1);
3424 low_set_pc (regcache
, event_child
->stop_pc
);
3427 if (step_over_finished
)
3429 /* If we have finished stepping over a breakpoint, we've
3430 stopped and suspended all LWPs momentarily except the
3431 stepping one. This is where we resume them all again.
3432 We're going to keep waiting, so use proceed, which
3433 handles stepping over the next breakpoint. */
3434 unsuspend_all_lwps (event_child
);
3438 /* Remove the single-step breakpoints if any. Note that
3439 there isn't single-step breakpoint if we finished stepping
3441 if (supports_software_single_step ()
3442 && has_single_step_breakpoints (current_thread
))
3444 stop_all_lwps (0, event_child
);
3445 delete_single_step_breakpoints (current_thread
);
3446 unstop_all_lwps (0, event_child
);
3451 debug_printf ("proceeding all threads.\n");
3452 proceed_all_lwps ();
3457 return ignore_event (ourstatus
);
3462 if (event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3465 = target_waitstatus_to_string (&event_child
->waitstatus
);
3467 debug_printf ("LWP %ld: extended event with waitstatus %s\n",
3468 lwpid_of (get_lwp_thread (event_child
)), str
.c_str ());
3470 if (current_thread
->last_resume_kind
== resume_step
)
3472 if (event_child
->step_range_start
== event_child
->step_range_end
)
3473 debug_printf ("GDB wanted to single-step, reporting event.\n");
3474 else if (!lwp_in_step_range (event_child
))
3475 debug_printf ("Out of step range, reporting event.\n");
3477 if (event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
3478 debug_printf ("Stopped by watchpoint.\n");
3479 else if (gdb_breakpoint_here (event_child
->stop_pc
))
3480 debug_printf ("Stopped by GDB breakpoint.\n");
3482 debug_printf ("Hit a non-gdbserver trap event.\n");
3485 /* Alright, we're going to report a stop. */
3487 /* Remove single-step breakpoints. */
3488 if (supports_software_single_step ())
3490 /* Remove single-step breakpoints or not. It it is true, stop all
3491 lwps, so that other threads won't hit the breakpoint in the
3493 int remove_single_step_breakpoints_p
= 0;
3497 remove_single_step_breakpoints_p
3498 = has_single_step_breakpoints (current_thread
);
3502 /* In all-stop, a stop reply cancels all previous resume
3503 requests. Delete all single-step breakpoints. */
3505 find_thread ([&] (thread_info
*thread
) {
3506 if (has_single_step_breakpoints (thread
))
3508 remove_single_step_breakpoints_p
= 1;
3516 if (remove_single_step_breakpoints_p
)
3518 /* If we remove single-step breakpoints from memory, stop all lwps,
3519 so that other threads won't hit the breakpoint in the staled
3521 stop_all_lwps (0, event_child
);
3525 gdb_assert (has_single_step_breakpoints (current_thread
));
3526 delete_single_step_breakpoints (current_thread
);
3530 for_each_thread ([] (thread_info
*thread
){
3531 if (has_single_step_breakpoints (thread
))
3532 delete_single_step_breakpoints (thread
);
3536 unstop_all_lwps (0, event_child
);
3540 if (!stabilizing_threads
)
3542 /* In all-stop, stop all threads. */
3544 stop_all_lwps (0, NULL
);
3546 if (step_over_finished
)
3550 /* If we were doing a step-over, all other threads but
3551 the stepping one had been paused in start_step_over,
3552 with their suspend counts incremented. We don't want
3553 to do a full unstop/unpause, because we're in
3554 all-stop mode (so we want threads stopped), but we
3555 still need to unsuspend the other threads, to
3556 decrement their `suspended' count back. */
3557 unsuspend_all_lwps (event_child
);
3561 /* If we just finished a step-over, then all threads had
3562 been momentarily paused. In all-stop, that's fine,
3563 we want threads stopped by now anyway. In non-stop,
3564 we need to re-resume threads that GDB wanted to be
3566 unstop_all_lwps (1, event_child
);
3570 /* If we're not waiting for a specific LWP, choose an event LWP
3571 from among those that have had events. Giving equal priority
3572 to all LWPs that have had events helps prevent
3574 if (ptid
== minus_one_ptid
)
3576 event_child
->status_pending_p
= 1;
3577 event_child
->status_pending
= w
;
3579 select_event_lwp (&event_child
);
3581 /* current_thread and event_child must stay in sync. */
3582 current_thread
= get_lwp_thread (event_child
);
3584 event_child
->status_pending_p
= 0;
3585 w
= event_child
->status_pending
;
3589 /* Stabilize threads (move out of jump pads). */
3591 target_stabilize_threads ();
3595 /* If we just finished a step-over, then all threads had been
3596 momentarily paused. In all-stop, that's fine, we want
3597 threads stopped by now anyway. In non-stop, we need to
3598 re-resume threads that GDB wanted to be running. */
3599 if (step_over_finished
)
3600 unstop_all_lwps (1, event_child
);
3603 if (event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3605 /* If the reported event is an exit, fork, vfork or exec, let
3608 /* Break the unreported fork relationship chain. */
3609 if (event_child
->waitstatus
.kind
== TARGET_WAITKIND_FORKED
3610 || event_child
->waitstatus
.kind
== TARGET_WAITKIND_VFORKED
)
3612 event_child
->fork_relative
->fork_relative
= NULL
;
3613 event_child
->fork_relative
= NULL
;
3616 *ourstatus
= event_child
->waitstatus
;
3617 /* Clear the event lwp's waitstatus since we handled it already. */
3618 event_child
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
3621 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3623 /* Now that we've selected our final event LWP, un-adjust its PC if
3624 it was a software breakpoint, and the client doesn't know we can
3625 adjust the breakpoint ourselves. */
3626 if (event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3627 && !cs
.swbreak_feature
)
3629 int decr_pc
= low_decr_pc_after_break ();
3633 struct regcache
*regcache
3634 = get_thread_regcache (current_thread
, 1);
3635 low_set_pc (regcache
, event_child
->stop_pc
+ decr_pc
);
3639 if (WSTOPSIG (w
) == SYSCALL_SIGTRAP
)
3641 get_syscall_trapinfo (event_child
,
3642 &ourstatus
->value
.syscall_number
);
3643 ourstatus
->kind
= event_child
->syscall_state
;
3645 else if (current_thread
->last_resume_kind
== resume_stop
3646 && WSTOPSIG (w
) == SIGSTOP
)
3648 /* A thread that has been requested to stop by GDB with vCont;t,
3649 and it stopped cleanly, so report as SIG0. The use of
3650 SIGSTOP is an implementation detail. */
3651 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3653 else if (current_thread
->last_resume_kind
== resume_stop
3654 && WSTOPSIG (w
) != SIGSTOP
)
3656 /* A thread that has been requested to stop by GDB with vCont;t,
3657 but, it stopped for other reasons. */
3658 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
3660 else if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
3662 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
3665 gdb_assert (step_over_bkpt
== null_ptid
);
3669 debug_printf ("wait_1 ret = %s, %d, %d\n",
3670 target_pid_to_str (ptid_of (current_thread
)),
3671 ourstatus
->kind
, ourstatus
->value
.sig
);
3675 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
3676 return filter_exit_event (event_child
, ourstatus
);
3678 return ptid_of (current_thread
);
3681 /* Get rid of any pending event in the pipe. */
3683 async_file_flush (void)
3689 ret
= read (linux_event_pipe
[0], &buf
, 1);
3690 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
3693 /* Put something in the pipe, so the event loop wakes up. */
3695 async_file_mark (void)
3699 async_file_flush ();
3702 ret
= write (linux_event_pipe
[1], "+", 1);
3703 while (ret
== 0 || (ret
== -1 && errno
== EINTR
));
3705 /* Ignore EAGAIN. If the pipe is full, the event loop will already
3706 be awakened anyway. */
3710 linux_process_target::wait (ptid_t ptid
,
3711 target_waitstatus
*ourstatus
,
3712 target_wait_flags target_options
)
3716 /* Flush the async file first. */
3717 if (target_is_async_p ())
3718 async_file_flush ();
3722 event_ptid
= wait_1 (ptid
, ourstatus
, target_options
);
3724 while ((target_options
& TARGET_WNOHANG
) == 0
3725 && event_ptid
== null_ptid
3726 && ourstatus
->kind
== TARGET_WAITKIND_IGNORE
);
3728 /* If at least one stop was reported, there may be more. A single
3729 SIGCHLD can signal more than one child stop. */
3730 if (target_is_async_p ()
3731 && (target_options
& TARGET_WNOHANG
) != 0
3732 && event_ptid
!= null_ptid
)
3738 /* Send a signal to an LWP. */
3741 kill_lwp (unsigned long lwpid
, int signo
)
3746 ret
= syscall (__NR_tkill
, lwpid
, signo
);
3747 if (errno
== ENOSYS
)
3749 /* If tkill fails, then we are not using nptl threads, a
3750 configuration we no longer support. */
3751 perror_with_name (("tkill"));
3757 linux_stop_lwp (struct lwp_info
*lwp
)
3763 send_sigstop (struct lwp_info
*lwp
)
3767 pid
= lwpid_of (get_lwp_thread (lwp
));
3769 /* If we already have a pending stop signal for this process, don't
3771 if (lwp
->stop_expected
)
3774 debug_printf ("Have pending sigstop for lwp %d\n", pid
);
3780 debug_printf ("Sending sigstop to lwp %d\n", pid
);
3782 lwp
->stop_expected
= 1;
3783 kill_lwp (pid
, SIGSTOP
);
3787 send_sigstop (thread_info
*thread
, lwp_info
*except
)
3789 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3791 /* Ignore EXCEPT. */
3801 /* Increment the suspend count of an LWP, and stop it, if not stopped
3804 suspend_and_send_sigstop (thread_info
*thread
, lwp_info
*except
)
3806 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3808 /* Ignore EXCEPT. */
3812 lwp_suspended_inc (lwp
);
3814 send_sigstop (thread
, except
);
3818 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
3820 /* Store the exit status for later. */
3821 lwp
->status_pending_p
= 1;
3822 lwp
->status_pending
= wstat
;
3824 /* Store in waitstatus as well, as there's nothing else to process
3826 if (WIFEXITED (wstat
))
3828 lwp
->waitstatus
.kind
= TARGET_WAITKIND_EXITED
;
3829 lwp
->waitstatus
.value
.integer
= WEXITSTATUS (wstat
);
3831 else if (WIFSIGNALED (wstat
))
3833 lwp
->waitstatus
.kind
= TARGET_WAITKIND_SIGNALLED
;
3834 lwp
->waitstatus
.value
.sig
= gdb_signal_from_host (WTERMSIG (wstat
));
3837 /* Prevent trying to stop it. */
3840 /* No further stops are expected from a dead lwp. */
3841 lwp
->stop_expected
= 0;
3844 /* Return true if LWP has exited already, and has a pending exit event
3845 to report to GDB. */
3848 lwp_is_marked_dead (struct lwp_info
*lwp
)
3850 return (lwp
->status_pending_p
3851 && (WIFEXITED (lwp
->status_pending
)
3852 || WIFSIGNALED (lwp
->status_pending
)));
3856 linux_process_target::wait_for_sigstop ()
3858 struct thread_info
*saved_thread
;
3863 saved_thread
= current_thread
;
3864 if (saved_thread
!= NULL
)
3865 saved_tid
= saved_thread
->id
;
3867 saved_tid
= null_ptid
; /* avoid bogus unused warning */
3870 debug_printf ("wait_for_sigstop: pulling events\n");
3872 /* Passing NULL_PTID as filter indicates we want all events to be
3873 left pending. Eventually this returns when there are no
3874 unwaited-for children left. */
3875 ret
= wait_for_event_filtered (minus_one_ptid
, null_ptid
, &wstat
, __WALL
);
3876 gdb_assert (ret
== -1);
3878 if (saved_thread
== NULL
|| mythread_alive (saved_tid
))
3879 current_thread
= saved_thread
;
3883 debug_printf ("Previously current thread died.\n");
3885 /* We can't change the current inferior behind GDB's back,
3886 otherwise, a subsequent command may apply to the wrong
3888 current_thread
= NULL
;
3893 linux_process_target::stuck_in_jump_pad (thread_info
*thread
)
3895 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3897 if (lwp
->suspended
!= 0)
3899 internal_error (__FILE__
, __LINE__
,
3900 "LWP %ld is suspended, suspended=%d\n",
3901 lwpid_of (thread
), lwp
->suspended
);
3903 gdb_assert (lwp
->stopped
);
3905 /* Allow debugging the jump pad, gdb_collect, etc.. */
3906 return (supports_fast_tracepoints ()
3907 && agent_loaded_p ()
3908 && (gdb_breakpoint_here (lwp
->stop_pc
)
3909 || lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3910 || thread
->last_resume_kind
== resume_step
)
3911 && (linux_fast_tracepoint_collecting (lwp
, NULL
)
3912 != fast_tpoint_collect_result::not_collecting
));
3916 linux_process_target::move_out_of_jump_pad (thread_info
*thread
)
3918 struct thread_info
*saved_thread
;
3919 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3922 if (lwp
->suspended
!= 0)
3924 internal_error (__FILE__
, __LINE__
,
3925 "LWP %ld is suspended, suspended=%d\n",
3926 lwpid_of (thread
), lwp
->suspended
);
3928 gdb_assert (lwp
->stopped
);
3930 /* For gdb_breakpoint_here. */
3931 saved_thread
= current_thread
;
3932 current_thread
= thread
;
3934 wstat
= lwp
->status_pending_p
? &lwp
->status_pending
: NULL
;
3936 /* Allow debugging the jump pad, gdb_collect, etc. */
3937 if (!gdb_breakpoint_here (lwp
->stop_pc
)
3938 && lwp
->stop_reason
!= TARGET_STOPPED_BY_WATCHPOINT
3939 && thread
->last_resume_kind
!= resume_step
3940 && maybe_move_out_of_jump_pad (lwp
, wstat
))
3943 debug_printf ("LWP %ld needs stabilizing (in jump pad)\n",
3948 lwp
->status_pending_p
= 0;
3949 enqueue_one_deferred_signal (lwp
, wstat
);
3952 debug_printf ("Signal %d for LWP %ld deferred "
3954 WSTOPSIG (*wstat
), lwpid_of (thread
));
3957 resume_one_lwp (lwp
, 0, 0, NULL
);
3960 lwp_suspended_inc (lwp
);
3962 current_thread
= saved_thread
;
3966 lwp_running (thread_info
*thread
)
3968 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3970 if (lwp_is_marked_dead (lwp
))
3973 return !lwp
->stopped
;
3977 linux_process_target::stop_all_lwps (int suspend
, lwp_info
*except
)
3979 /* Should not be called recursively. */
3980 gdb_assert (stopping_threads
== NOT_STOPPING_THREADS
);
3985 debug_printf ("stop_all_lwps (%s, except=%s)\n",
3986 suspend
? "stop-and-suspend" : "stop",
3988 ? target_pid_to_str (ptid_of (get_lwp_thread (except
)))
3992 stopping_threads
= (suspend
3993 ? STOPPING_AND_SUSPENDING_THREADS
3994 : STOPPING_THREADS
);
3997 for_each_thread ([&] (thread_info
*thread
)
3999 suspend_and_send_sigstop (thread
, except
);
4002 for_each_thread ([&] (thread_info
*thread
)
4004 send_sigstop (thread
, except
);
4007 wait_for_sigstop ();
4008 stopping_threads
= NOT_STOPPING_THREADS
;
4012 debug_printf ("stop_all_lwps done, setting stopping_threads "
4013 "back to !stopping\n");
4018 /* Enqueue one signal in the chain of signals which need to be
4019 delivered to this process on next resume. */
4022 enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
)
4024 lwp
->pending_signals
.emplace_back (signal
);
4025 if (info
== nullptr)
4026 memset (&lwp
->pending_signals
.back ().info
, 0, sizeof (siginfo_t
));
4028 lwp
->pending_signals
.back ().info
= *info
;
4032 linux_process_target::install_software_single_step_breakpoints (lwp_info
*lwp
)
4034 struct thread_info
*thread
= get_lwp_thread (lwp
);
4035 struct regcache
*regcache
= get_thread_regcache (thread
, 1);
4037 scoped_restore save_current_thread
= make_scoped_restore (¤t_thread
);
4039 current_thread
= thread
;
4040 std::vector
<CORE_ADDR
> next_pcs
= low_get_next_pcs (regcache
);
4042 for (CORE_ADDR pc
: next_pcs
)
4043 set_single_step_breakpoint (pc
, current_ptid
);
4047 linux_process_target::single_step (lwp_info
* lwp
)
4051 if (supports_hardware_single_step ())
4055 else if (supports_software_single_step ())
4057 install_software_single_step_breakpoints (lwp
);
4063 debug_printf ("stepping is not implemented on this target");
4069 /* The signal can be delivered to the inferior if we are not trying to
4070 finish a fast tracepoint collect. Since signal can be delivered in
4071 the step-over, the program may go to signal handler and trap again
4072 after return from the signal handler. We can live with the spurious
4076 lwp_signal_can_be_delivered (struct lwp_info
*lwp
)
4078 return (lwp
->collecting_fast_tracepoint
4079 == fast_tpoint_collect_result::not_collecting
);
4083 linux_process_target::resume_one_lwp_throw (lwp_info
*lwp
, int step
,
4084 int signal
, siginfo_t
*info
)
4086 struct thread_info
*thread
= get_lwp_thread (lwp
);
4087 struct thread_info
*saved_thread
;
4089 struct process_info
*proc
= get_thread_process (thread
);
4091 /* Note that target description may not be initialised
4092 (proc->tdesc == NULL) at this point because the program hasn't
4093 stopped at the first instruction yet. It means GDBserver skips
4094 the extra traps from the wrapper program (see option --wrapper).
4095 Code in this function that requires register access should be
4096 guarded by proc->tdesc == NULL or something else. */
4098 if (lwp
->stopped
== 0)
4101 gdb_assert (lwp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
);
4103 fast_tpoint_collect_result fast_tp_collecting
4104 = lwp
->collecting_fast_tracepoint
;
4106 gdb_assert (!stabilizing_threads
4107 || (fast_tp_collecting
4108 != fast_tpoint_collect_result::not_collecting
));
4110 /* Cancel actions that rely on GDB not changing the PC (e.g., the
4111 user used the "jump" command, or "set $pc = foo"). */
4112 if (thread
->while_stepping
!= NULL
&& lwp
->stop_pc
!= get_pc (lwp
))
4114 /* Collecting 'while-stepping' actions doesn't make sense
4116 release_while_stepping_state_list (thread
);
4119 /* If we have pending signals or status, and a new signal, enqueue the
4120 signal. Also enqueue the signal if it can't be delivered to the
4121 inferior right now. */
4123 && (lwp
->status_pending_p
4124 || !lwp
->pending_signals
.empty ()
4125 || !lwp_signal_can_be_delivered (lwp
)))
4127 enqueue_pending_signal (lwp
, signal
, info
);
4129 /* Postpone any pending signal. It was enqueued above. */
4133 if (lwp
->status_pending_p
)
4136 debug_printf ("Not resuming lwp %ld (%s, stop %s);"
4137 " has pending status\n",
4138 lwpid_of (thread
), step
? "step" : "continue",
4139 lwp
->stop_expected
? "expected" : "not expected");
4143 saved_thread
= current_thread
;
4144 current_thread
= thread
;
4146 /* This bit needs some thinking about. If we get a signal that
4147 we must report while a single-step reinsert is still pending,
4148 we often end up resuming the thread. It might be better to
4149 (ew) allow a stack of pending events; then we could be sure that
4150 the reinsert happened right away and not lose any signals.
4152 Making this stack would also shrink the window in which breakpoints are
4153 uninserted (see comment in linux_wait_for_lwp) but not enough for
4154 complete correctness, so it won't solve that problem. It may be
4155 worthwhile just to solve this one, however. */
4156 if (lwp
->bp_reinsert
!= 0)
4159 debug_printf (" pending reinsert at 0x%s\n",
4160 paddress (lwp
->bp_reinsert
));
4162 if (supports_hardware_single_step ())
4164 if (fast_tp_collecting
== fast_tpoint_collect_result::not_collecting
)
4167 warning ("BAD - reinserting but not stepping.");
4169 warning ("BAD - reinserting and suspended(%d).",
4174 step
= maybe_hw_step (thread
);
4177 if (fast_tp_collecting
== fast_tpoint_collect_result::before_insn
)
4180 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
4181 " (exit-jump-pad-bkpt)\n",
4184 else if (fast_tp_collecting
== fast_tpoint_collect_result::at_insn
)
4187 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
4188 " single-stepping\n",
4191 if (supports_hardware_single_step ())
4195 internal_error (__FILE__
, __LINE__
,
4196 "moving out of jump pad single-stepping"
4197 " not implemented on this target");
4201 /* If we have while-stepping actions in this thread set it stepping.
4202 If we have a signal to deliver, it may or may not be set to
4203 SIG_IGN, we don't know. Assume so, and allow collecting
4204 while-stepping into a signal handler. A possible smart thing to
4205 do would be to set an internal breakpoint at the signal return
4206 address, continue, and carry on catching this while-stepping
4207 action only when that breakpoint is hit. A future
4209 if (thread
->while_stepping
!= NULL
)
4212 debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n",
4215 step
= single_step (lwp
);
4218 if (proc
->tdesc
!= NULL
&& low_supports_breakpoints ())
4220 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
4222 lwp
->stop_pc
= low_get_pc (regcache
);
4226 debug_printf (" %s from pc 0x%lx\n", step
? "step" : "continue",
4227 (long) lwp
->stop_pc
);
4231 /* If we have pending signals, consume one if it can be delivered to
4233 if (!lwp
->pending_signals
.empty () && lwp_signal_can_be_delivered (lwp
))
4235 const pending_signal
&p_sig
= lwp
->pending_signals
.front ();
4237 signal
= p_sig
.signal
;
4238 if (p_sig
.info
.si_signo
!= 0)
4239 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
4242 lwp
->pending_signals
.pop_front ();
4246 debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
4247 lwpid_of (thread
), step
? "step" : "continue", signal
,
4248 lwp
->stop_expected
? "expected" : "not expected");
4250 low_prepare_to_resume (lwp
);
4252 regcache_invalidate_thread (thread
);
4254 lwp
->stepping
= step
;
4256 ptrace_request
= PTRACE_SINGLESTEP
;
4257 else if (gdb_catching_syscalls_p (lwp
))
4258 ptrace_request
= PTRACE_SYSCALL
;
4260 ptrace_request
= PTRACE_CONT
;
4261 ptrace (ptrace_request
,
4263 (PTRACE_TYPE_ARG3
) 0,
4264 /* Coerce to a uintptr_t first to avoid potential gcc warning
4265 of coercing an 8 byte integer to a 4 byte pointer. */
4266 (PTRACE_TYPE_ARG4
) (uintptr_t) signal
);
4268 current_thread
= saved_thread
;
4270 perror_with_name ("resuming thread");
4272 /* Successfully resumed. Clear state that no longer makes sense,
4273 and mark the LWP as running. Must not do this before resuming
4274 otherwise if that fails other code will be confused. E.g., we'd
4275 later try to stop the LWP and hang forever waiting for a stop
4276 status. Note that we must not throw after this is cleared,
4277 otherwise handle_zombie_lwp_error would get confused. */
4279 lwp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4283 linux_process_target::low_prepare_to_resume (lwp_info
*lwp
)
4288 /* Called when we try to resume a stopped LWP and that errors out. If
4289 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
4290 or about to become), discard the error, clear any pending status
4291 the LWP may have, and return true (we'll collect the exit status
4292 soon enough). Otherwise, return false. */
4295 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
4297 struct thread_info
*thread
= get_lwp_thread (lp
);
4299 /* If we get an error after resuming the LWP successfully, we'd
4300 confuse !T state for the LWP being gone. */
4301 gdb_assert (lp
->stopped
);
4303 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
4304 because even if ptrace failed with ESRCH, the tracee may be "not
4305 yet fully dead", but already refusing ptrace requests. In that
4306 case the tracee has 'R (Running)' state for a little bit
4307 (observed in Linux 3.18). See also the note on ESRCH in the
4308 ptrace(2) man page. Instead, check whether the LWP has any state
4309 other than ptrace-stopped. */
4311 /* Don't assume anything if /proc/PID/status can't be read. */
4312 if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread
)) == 0)
4314 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4315 lp
->status_pending_p
= 0;
4322 linux_process_target::resume_one_lwp (lwp_info
*lwp
, int step
, int signal
,
4327 resume_one_lwp_throw (lwp
, step
, signal
, info
);
4329 catch (const gdb_exception_error
&ex
)
4331 if (!check_ptrace_stopped_lwp_gone (lwp
))
4336 /* This function is called once per thread via for_each_thread.
4337 We look up which resume request applies to THREAD and mark it with a
4338 pointer to the appropriate resume request.
4340 This algorithm is O(threads * resume elements), but resume elements
4341 is small (and will remain small at least until GDB supports thread
4345 linux_set_resume_request (thread_info
*thread
, thread_resume
*resume
, size_t n
)
4347 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4349 for (int ndx
= 0; ndx
< n
; ndx
++)
4351 ptid_t ptid
= resume
[ndx
].thread
;
4352 if (ptid
== minus_one_ptid
4353 || ptid
== thread
->id
4354 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
4356 || (ptid
.pid () == pid_of (thread
)
4358 || ptid
.lwp () == -1)))
4360 if (resume
[ndx
].kind
== resume_stop
4361 && thread
->last_resume_kind
== resume_stop
)
4364 debug_printf ("already %s LWP %ld at GDB's request\n",
4365 (thread
->last_status
.kind
4366 == TARGET_WAITKIND_STOPPED
)
4374 /* Ignore (wildcard) resume requests for already-resumed
4376 if (resume
[ndx
].kind
!= resume_stop
4377 && thread
->last_resume_kind
!= resume_stop
)
4380 debug_printf ("already %s LWP %ld at GDB's request\n",
4381 (thread
->last_resume_kind
4389 /* Don't let wildcard resumes resume fork children that GDB
4390 does not yet know are new fork children. */
4391 if (lwp
->fork_relative
!= NULL
)
4393 struct lwp_info
*rel
= lwp
->fork_relative
;
4395 if (rel
->status_pending_p
4396 && (rel
->waitstatus
.kind
== TARGET_WAITKIND_FORKED
4397 || rel
->waitstatus
.kind
== TARGET_WAITKIND_VFORKED
))
4400 debug_printf ("not resuming LWP %ld: has queued stop reply\n",
4406 /* If the thread has a pending event that has already been
4407 reported to GDBserver core, but GDB has not pulled the
4408 event out of the vStopped queue yet, likewise, ignore the
4409 (wildcard) resume request. */
4410 if (in_queued_stop_replies (thread
->id
))
4413 debug_printf ("not resuming LWP %ld: has queued stop reply\n",
4418 lwp
->resume
= &resume
[ndx
];
4419 thread
->last_resume_kind
= lwp
->resume
->kind
;
4421 lwp
->step_range_start
= lwp
->resume
->step_range_start
;
4422 lwp
->step_range_end
= lwp
->resume
->step_range_end
;
4424 /* If we had a deferred signal to report, dequeue one now.
4425 This can happen if LWP gets more than one signal while
4426 trying to get out of a jump pad. */
4428 && !lwp
->status_pending_p
4429 && dequeue_one_deferred_signal (lwp
, &lwp
->status_pending
))
4431 lwp
->status_pending_p
= 1;
4434 debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
4435 "leaving status pending.\n",
4436 WSTOPSIG (lwp
->status_pending
),
4444 /* No resume action for this thread. */
4449 linux_process_target::resume_status_pending (thread_info
*thread
)
4451 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4453 /* LWPs which will not be resumed are not interesting, because
4454 we might not wait for them next time through linux_wait. */
4455 if (lwp
->resume
== NULL
)
4458 return thread_still_has_status_pending (thread
);
4462 linux_process_target::thread_needs_step_over (thread_info
*thread
)
4464 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4465 struct thread_info
*saved_thread
;
4467 struct process_info
*proc
= get_thread_process (thread
);
4469 /* GDBserver is skipping the extra traps from the wrapper program,
4470 don't have to do step over. */
4471 if (proc
->tdesc
== NULL
)
4474 /* LWPs which will not be resumed are not interesting, because we
4475 might not wait for them next time through linux_wait. */
4480 debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n",
4485 if (thread
->last_resume_kind
== resume_stop
)
4488 debug_printf ("Need step over [LWP %ld]? Ignoring, should remain"
4494 gdb_assert (lwp
->suspended
>= 0);
4499 debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n",
4504 if (lwp
->status_pending_p
)
4507 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4513 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
4517 /* If the PC has changed since we stopped, then don't do anything,
4518 and let the breakpoint/tracepoint be hit. This happens if, for
4519 instance, GDB handled the decr_pc_after_break subtraction itself,
4520 GDB is OOL stepping this thread, or the user has issued a "jump"
4521 command, or poked thread's registers herself. */
4522 if (pc
!= lwp
->stop_pc
)
4525 debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. "
4526 "Old stop_pc was 0x%s, PC is now 0x%s\n",
4528 paddress (lwp
->stop_pc
), paddress (pc
));
4532 /* On software single step target, resume the inferior with signal
4533 rather than stepping over. */
4534 if (supports_software_single_step ()
4535 && !lwp
->pending_signals
.empty ()
4536 && lwp_signal_can_be_delivered (lwp
))
4539 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4546 saved_thread
= current_thread
;
4547 current_thread
= thread
;
4549 /* We can only step over breakpoints we know about. */
4550 if (breakpoint_here (pc
) || fast_tracepoint_jump_here (pc
))
4552 /* Don't step over a breakpoint that GDB expects to hit
4553 though. If the condition is being evaluated on the target's side
4554 and it evaluate to false, step over this breakpoint as well. */
4555 if (gdb_breakpoint_here (pc
)
4556 && gdb_condition_true_at_breakpoint (pc
)
4557 && gdb_no_commands_at_breakpoint (pc
))
4560 debug_printf ("Need step over [LWP %ld]? yes, but found"
4561 " GDB breakpoint at 0x%s; skipping step over\n",
4562 lwpid_of (thread
), paddress (pc
));
4564 current_thread
= saved_thread
;
4570 debug_printf ("Need step over [LWP %ld]? yes, "
4571 "found breakpoint at 0x%s\n",
4572 lwpid_of (thread
), paddress (pc
));
4574 /* We've found an lwp that needs stepping over --- return 1 so
4575 that find_thread stops looking. */
4576 current_thread
= saved_thread
;
4582 current_thread
= saved_thread
;
4585 debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
4587 lwpid_of (thread
), paddress (pc
));
4593 linux_process_target::start_step_over (lwp_info
*lwp
)
4595 struct thread_info
*thread
= get_lwp_thread (lwp
);
4596 struct thread_info
*saved_thread
;
4601 debug_printf ("Starting step-over on LWP %ld. Stopping all threads\n",
4604 stop_all_lwps (1, lwp
);
4606 if (lwp
->suspended
!= 0)
4608 internal_error (__FILE__
, __LINE__
,
4609 "LWP %ld suspended=%d\n", lwpid_of (thread
),
4614 debug_printf ("Done stopping all threads for step-over.\n");
4616 /* Note, we should always reach here with an already adjusted PC,
4617 either by GDB (if we're resuming due to GDB's request), or by our
4618 caller, if we just finished handling an internal breakpoint GDB
4619 shouldn't care about. */
4622 saved_thread
= current_thread
;
4623 current_thread
= thread
;
4625 lwp
->bp_reinsert
= pc
;
4626 uninsert_breakpoints_at (pc
);
4627 uninsert_fast_tracepoint_jumps_at (pc
);
4629 step
= single_step (lwp
);
4631 current_thread
= saved_thread
;
4633 resume_one_lwp (lwp
, step
, 0, NULL
);
4635 /* Require next event from this LWP. */
4636 step_over_bkpt
= thread
->id
;
4640 linux_process_target::finish_step_over (lwp_info
*lwp
)
4642 if (lwp
->bp_reinsert
!= 0)
4644 struct thread_info
*saved_thread
= current_thread
;
4647 debug_printf ("Finished step over.\n");
4649 current_thread
= get_lwp_thread (lwp
);
4651 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
4652 may be no breakpoint to reinsert there by now. */
4653 reinsert_breakpoints_at (lwp
->bp_reinsert
);
4654 reinsert_fast_tracepoint_jumps_at (lwp
->bp_reinsert
);
4656 lwp
->bp_reinsert
= 0;
4658 /* Delete any single-step breakpoints. No longer needed. We
4659 don't have to worry about other threads hitting this trap,
4660 and later not being able to explain it, because we were
4661 stepping over a breakpoint, and we hold all threads but
4662 LWP stopped while doing that. */
4663 if (!supports_hardware_single_step ())
4665 gdb_assert (has_single_step_breakpoints (current_thread
));
4666 delete_single_step_breakpoints (current_thread
);
4669 step_over_bkpt
= null_ptid
;
4670 current_thread
= saved_thread
;
4678 linux_process_target::complete_ongoing_step_over ()
4680 if (step_over_bkpt
!= null_ptid
)
4682 struct lwp_info
*lwp
;
4687 debug_printf ("detach: step over in progress, finish it first\n");
4689 /* Passing NULL_PTID as filter indicates we want all events to
4690 be left pending. Eventually this returns when there are no
4691 unwaited-for children left. */
4692 ret
= wait_for_event_filtered (minus_one_ptid
, null_ptid
, &wstat
,
4694 gdb_assert (ret
== -1);
4696 lwp
= find_lwp_pid (step_over_bkpt
);
4699 finish_step_over (lwp
);
4701 /* If we got our step SIGTRAP, don't leave it pending,
4702 otherwise we would report it to GDB as a spurious
4704 gdb_assert (lwp
->status_pending_p
);
4705 if (WIFSTOPPED (lwp
->status_pending
)
4706 && WSTOPSIG (lwp
->status_pending
) == SIGTRAP
)
4708 thread_info
*thread
= get_lwp_thread (lwp
);
4709 if (thread
->last_resume_kind
!= resume_step
)
4712 debug_printf ("detach: discard step-over SIGTRAP\n");
4714 lwp
->status_pending_p
= 0;
4715 lwp
->status_pending
= 0;
4716 resume_one_lwp (lwp
, lwp
->stepping
, 0, NULL
);
4721 debug_printf ("detach: resume_step, "
4722 "not discarding step-over SIGTRAP\n");
4726 step_over_bkpt
= null_ptid
;
4727 unsuspend_all_lwps (lwp
);
4732 linux_process_target::resume_one_thread (thread_info
*thread
,
4733 bool leave_all_stopped
)
4735 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4738 if (lwp
->resume
== NULL
)
4741 if (lwp
->resume
->kind
== resume_stop
)
4744 debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread
));
4749 debug_printf ("stopping LWP %ld\n", lwpid_of (thread
));
4751 /* Stop the thread, and wait for the event asynchronously,
4752 through the event loop. */
4758 debug_printf ("already stopped LWP %ld\n",
4761 /* The LWP may have been stopped in an internal event that
4762 was not meant to be notified back to GDB (e.g., gdbserver
4763 breakpoint), so we should be reporting a stop event in
4766 /* If the thread already has a pending SIGSTOP, this is a
4767 no-op. Otherwise, something later will presumably resume
4768 the thread and this will cause it to cancel any pending
4769 operation, due to last_resume_kind == resume_stop. If
4770 the thread already has a pending status to report, we
4771 will still report it the next time we wait - see
4772 status_pending_p_callback. */
4774 /* If we already have a pending signal to report, then
4775 there's no need to queue a SIGSTOP, as this means we're
4776 midway through moving the LWP out of the jumppad, and we
4777 will report the pending signal as soon as that is
4779 if (lwp
->pending_signals_to_report
.empty ())
4783 /* For stop requests, we're done. */
4785 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
4789 /* If this thread which is about to be resumed has a pending status,
4790 then don't resume it - we can just report the pending status.
4791 Likewise if it is suspended, because e.g., another thread is
4792 stepping past a breakpoint. Make sure to queue any signals that
4793 would otherwise be sent. In all-stop mode, we do this decision
4794 based on if *any* thread has a pending status. If there's a
4795 thread that needs the step-over-breakpoint dance, then don't
4796 resume any other thread but that particular one. */
4797 leave_pending
= (lwp
->suspended
4798 || lwp
->status_pending_p
4799 || leave_all_stopped
);
4801 /* If we have a new signal, enqueue the signal. */
4802 if (lwp
->resume
->sig
!= 0)
4804 siginfo_t info
, *info_p
;
4806 /* If this is the same signal we were previously stopped by,
4807 make sure to queue its siginfo. */
4808 if (WIFSTOPPED (lwp
->last_status
)
4809 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
4810 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
),
4811 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
4816 enqueue_pending_signal (lwp
, lwp
->resume
->sig
, info_p
);
4822 debug_printf ("resuming LWP %ld\n", lwpid_of (thread
));
4824 proceed_one_lwp (thread
, NULL
);
4829 debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread
));
4832 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
4837 linux_process_target::resume (thread_resume
*resume_info
, size_t n
)
4839 struct thread_info
*need_step_over
= NULL
;
4844 debug_printf ("linux_resume:\n");
4847 for_each_thread ([&] (thread_info
*thread
)
4849 linux_set_resume_request (thread
, resume_info
, n
);
4852 /* If there is a thread which would otherwise be resumed, which has
4853 a pending status, then don't resume any threads - we can just
4854 report the pending status. Make sure to queue any signals that
4855 would otherwise be sent. In non-stop mode, we'll apply this
4856 logic to each thread individually. We consume all pending events
4857 before considering to start a step-over (in all-stop). */
4858 bool any_pending
= false;
4860 any_pending
= find_thread ([this] (thread_info
*thread
)
4862 return resume_status_pending (thread
);
4865 /* If there is a thread which would otherwise be resumed, which is
4866 stopped at a breakpoint that needs stepping over, then don't
4867 resume any threads - have it step over the breakpoint with all
4868 other threads stopped, then resume all threads again. Make sure
4869 to queue any signals that would otherwise be delivered or
4871 if (!any_pending
&& low_supports_breakpoints ())
4872 need_step_over
= find_thread ([this] (thread_info
*thread
)
4874 return thread_needs_step_over (thread
);
4877 bool leave_all_stopped
= (need_step_over
!= NULL
|| any_pending
);
4881 if (need_step_over
!= NULL
)
4882 debug_printf ("Not resuming all, need step over\n");
4883 else if (any_pending
)
4884 debug_printf ("Not resuming, all-stop and found "
4885 "an LWP with pending status\n");
4887 debug_printf ("Resuming, no pending status or step over needed\n");
4890 /* Even if we're leaving threads stopped, queue all signals we'd
4891 otherwise deliver. */
4892 for_each_thread ([&] (thread_info
*thread
)
4894 resume_one_thread (thread
, leave_all_stopped
);
4898 start_step_over (get_thread_lwp (need_step_over
));
4902 debug_printf ("linux_resume done\n");
4906 /* We may have events that were pending that can/should be sent to
4907 the client now. Trigger a linux_wait call. */
4908 if (target_is_async_p ())
4913 linux_process_target::proceed_one_lwp (thread_info
*thread
, lwp_info
*except
)
4915 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4922 debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread
));
4927 debug_printf (" LWP %ld already running\n", lwpid_of (thread
));
4931 if (thread
->last_resume_kind
== resume_stop
4932 && thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4935 debug_printf (" client wants LWP to remain %ld stopped\n",
4940 if (lwp
->status_pending_p
)
4943 debug_printf (" LWP %ld has pending status, leaving stopped\n",
4948 gdb_assert (lwp
->suspended
>= 0);
4953 debug_printf (" LWP %ld is suspended\n", lwpid_of (thread
));
4957 if (thread
->last_resume_kind
== resume_stop
4958 && lwp
->pending_signals_to_report
.empty ()
4959 && (lwp
->collecting_fast_tracepoint
4960 == fast_tpoint_collect_result::not_collecting
))
4962 /* We haven't reported this LWP as stopped yet (otherwise, the
4963 last_status.kind check above would catch it, and we wouldn't
4964 reach here. This LWP may have been momentarily paused by a
4965 stop_all_lwps call while handling for example, another LWP's
4966 step-over. In that case, the pending expected SIGSTOP signal
4967 that was queued at vCont;t handling time will have already
4968 been consumed by wait_for_sigstop, and so we need to requeue
4969 another one here. Note that if the LWP already has a SIGSTOP
4970 pending, this is a no-op. */
4973 debug_printf ("Client wants LWP %ld to stop. "
4974 "Making sure it has a SIGSTOP pending\n",
4980 if (thread
->last_resume_kind
== resume_step
)
4983 debug_printf (" stepping LWP %ld, client wants it stepping\n",
4986 /* If resume_step is requested by GDB, install single-step
4987 breakpoints when the thread is about to be actually resumed if
4988 the single-step breakpoints weren't removed. */
4989 if (supports_software_single_step ()
4990 && !has_single_step_breakpoints (thread
))
4991 install_software_single_step_breakpoints (lwp
);
4993 step
= maybe_hw_step (thread
);
4995 else if (lwp
->bp_reinsert
!= 0)
4998 debug_printf (" stepping LWP %ld, reinsert set\n",
5001 step
= maybe_hw_step (thread
);
5006 resume_one_lwp (lwp
, step
, 0, NULL
);
5010 linux_process_target::unsuspend_and_proceed_one_lwp (thread_info
*thread
,
5013 struct lwp_info
*lwp
= get_thread_lwp (thread
);
5018 lwp_suspended_decr (lwp
);
5020 proceed_one_lwp (thread
, except
);
5024 linux_process_target::proceed_all_lwps ()
5026 struct thread_info
*need_step_over
;
5028 /* If there is a thread which would otherwise be resumed, which is
5029 stopped at a breakpoint that needs stepping over, then don't
5030 resume any threads - have it step over the breakpoint with all
5031 other threads stopped, then resume all threads again. */
5033 if (low_supports_breakpoints ())
5035 need_step_over
= find_thread ([this] (thread_info
*thread
)
5037 return thread_needs_step_over (thread
);
5040 if (need_step_over
!= NULL
)
5043 debug_printf ("proceed_all_lwps: found "
5044 "thread %ld needing a step-over\n",
5045 lwpid_of (need_step_over
));
5047 start_step_over (get_thread_lwp (need_step_over
));
5053 debug_printf ("Proceeding, no step-over needed\n");
5055 for_each_thread ([this] (thread_info
*thread
)
5057 proceed_one_lwp (thread
, NULL
);
5062 linux_process_target::unstop_all_lwps (int unsuspend
, lwp_info
*except
)
5068 debug_printf ("unstopping all lwps, except=(LWP %ld)\n",
5069 lwpid_of (get_lwp_thread (except
)));
5071 debug_printf ("unstopping all lwps\n");
5075 for_each_thread ([&] (thread_info
*thread
)
5077 unsuspend_and_proceed_one_lwp (thread
, except
);
5080 for_each_thread ([&] (thread_info
*thread
)
5082 proceed_one_lwp (thread
, except
);
5087 debug_printf ("unstop_all_lwps done\n");
5093 #ifdef HAVE_LINUX_REGSETS
5095 #define use_linux_regsets 1
5097 /* Returns true if REGSET has been disabled. */
5100 regset_disabled (struct regsets_info
*info
, struct regset_info
*regset
)
5102 return (info
->disabled_regsets
!= NULL
5103 && info
->disabled_regsets
[regset
- info
->regsets
]);
5106 /* Disable REGSET. */
5109 disable_regset (struct regsets_info
*info
, struct regset_info
*regset
)
5113 dr_offset
= regset
- info
->regsets
;
5114 if (info
->disabled_regsets
== NULL
)
5115 info
->disabled_regsets
= (char *) xcalloc (1, info
->num_regsets
);
5116 info
->disabled_regsets
[dr_offset
] = 1;
5120 regsets_fetch_inferior_registers (struct regsets_info
*regsets_info
,
5121 struct regcache
*regcache
)
5123 struct regset_info
*regset
;
5124 int saw_general_regs
= 0;
5128 pid
= lwpid_of (current_thread
);
5129 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
5134 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
))
5137 buf
= xmalloc (regset
->size
);
5139 nt_type
= regset
->nt_type
;
5143 iov
.iov_len
= regset
->size
;
5144 data
= (void *) &iov
;
5150 res
= ptrace (regset
->get_request
, pid
,
5151 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5153 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
5158 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5160 /* If we get EIO on a regset, or an EINVAL and the regset is
5161 optional, do not try it again for this process mode. */
5162 disable_regset (regsets_info
, regset
);
5164 else if (errno
== ENODATA
)
5166 /* ENODATA may be returned if the regset is currently
5167 not "active". This can happen in normal operation,
5168 so suppress the warning in this case. */
5170 else if (errno
== ESRCH
)
5172 /* At this point, ESRCH should mean the process is
5173 already gone, in which case we simply ignore attempts
5174 to read its registers. */
5179 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
5186 if (regset
->type
== GENERAL_REGS
)
5187 saw_general_regs
= 1;
5188 regset
->store_function (regcache
, buf
);
5192 if (saw_general_regs
)
5199 regsets_store_inferior_registers (struct regsets_info
*regsets_info
,
5200 struct regcache
*regcache
)
5202 struct regset_info
*regset
;
5203 int saw_general_regs
= 0;
5207 pid
= lwpid_of (current_thread
);
5208 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
5213 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
)
5214 || regset
->fill_function
== NULL
)
5217 buf
= xmalloc (regset
->size
);
5219 /* First fill the buffer with the current register set contents,
5220 in case there are any items in the kernel's regset that are
5221 not in gdbserver's regcache. */
5223 nt_type
= regset
->nt_type
;
5227 iov
.iov_len
= regset
->size
;
5228 data
= (void *) &iov
;
5234 res
= ptrace (regset
->get_request
, pid
,
5235 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5237 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
5242 /* Then overlay our cached registers on that. */
5243 regset
->fill_function (regcache
, buf
);
5245 /* Only now do we write the register set. */
5247 res
= ptrace (regset
->set_request
, pid
,
5248 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5250 res
= ptrace (regset
->set_request
, pid
, data
, nt_type
);
5257 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5259 /* If we get EIO on a regset, or an EINVAL and the regset is
5260 optional, do not try it again for this process mode. */
5261 disable_regset (regsets_info
, regset
);
5263 else if (errno
== ESRCH
)
5265 /* At this point, ESRCH should mean the process is
5266 already gone, in which case we simply ignore attempts
5267 to change its registers. See also the related
5268 comment in resume_one_lwp. */
5274 perror ("Warning: ptrace(regsets_store_inferior_registers)");
5277 else if (regset
->type
== GENERAL_REGS
)
5278 saw_general_regs
= 1;
5281 if (saw_general_regs
)
5287 #else /* !HAVE_LINUX_REGSETS */
5289 #define use_linux_regsets 0
5290 #define regsets_fetch_inferior_registers(regsets_info, regcache) 1
5291 #define regsets_store_inferior_registers(regsets_info, regcache) 1
5295 /* Return 1 if register REGNO is supported by one of the regset ptrace
5296 calls or 0 if it has to be transferred individually. */
5299 linux_register_in_regsets (const struct regs_info
*regs_info
, int regno
)
5301 unsigned char mask
= 1 << (regno
% 8);
5302 size_t index
= regno
/ 8;
5304 return (use_linux_regsets
5305 && (regs_info
->regset_bitmap
== NULL
5306 || (regs_info
->regset_bitmap
[index
] & mask
) != 0));
5309 #ifdef HAVE_LINUX_USRREGS
5312 register_addr (const struct usrregs_info
*usrregs
, int regnum
)
5316 if (regnum
< 0 || regnum
>= usrregs
->num_regs
)
5317 error ("Invalid register number %d.", regnum
);
5319 addr
= usrregs
->regmap
[regnum
];
5326 linux_process_target::fetch_register (const usrregs_info
*usrregs
,
5327 regcache
*regcache
, int regno
)
5334 if (regno
>= usrregs
->num_regs
)
5336 if (low_cannot_fetch_register (regno
))
5339 regaddr
= register_addr (usrregs
, regno
);
5343 size
= ((register_size (regcache
->tdesc
, regno
)
5344 + sizeof (PTRACE_XFER_TYPE
) - 1)
5345 & -sizeof (PTRACE_XFER_TYPE
));
5346 buf
= (char *) alloca (size
);
5348 pid
= lwpid_of (current_thread
);
5349 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5352 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
5353 ptrace (PTRACE_PEEKUSER
, pid
,
5354 /* Coerce to a uintptr_t first to avoid potential gcc warning
5355 of coercing an 8 byte integer to a 4 byte pointer. */
5356 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
, (PTRACE_TYPE_ARG4
) 0);
5357 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5360 /* Mark register REGNO unavailable. */
5361 supply_register (regcache
, regno
, NULL
);
5366 low_supply_ptrace_register (regcache
, regno
, buf
);
5370 linux_process_target::store_register (const usrregs_info
*usrregs
,
5371 regcache
*regcache
, int regno
)
5378 if (regno
>= usrregs
->num_regs
)
5380 if (low_cannot_store_register (regno
))
5383 regaddr
= register_addr (usrregs
, regno
);
5387 size
= ((register_size (regcache
->tdesc
, regno
)
5388 + sizeof (PTRACE_XFER_TYPE
) - 1)
5389 & -sizeof (PTRACE_XFER_TYPE
));
5390 buf
= (char *) alloca (size
);
5391 memset (buf
, 0, size
);
5393 low_collect_ptrace_register (regcache
, regno
, buf
);
5395 pid
= lwpid_of (current_thread
);
5396 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5399 ptrace (PTRACE_POKEUSER
, pid
,
5400 /* Coerce to a uintptr_t first to avoid potential gcc warning
5401 about coercing an 8 byte integer to a 4 byte pointer. */
5402 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
,
5403 (PTRACE_TYPE_ARG4
) *(PTRACE_XFER_TYPE
*) (buf
+ i
));
5406 /* At this point, ESRCH should mean the process is
5407 already gone, in which case we simply ignore attempts
5408 to change its registers. See also the related
5409 comment in resume_one_lwp. */
5414 if (!low_cannot_store_register (regno
))
5415 error ("writing register %d: %s", regno
, safe_strerror (errno
));
5417 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5420 #endif /* HAVE_LINUX_USRREGS */
5423 linux_process_target::low_collect_ptrace_register (regcache
*regcache
,
5424 int regno
, char *buf
)
5426 collect_register (regcache
, regno
, buf
);
5430 linux_process_target::low_supply_ptrace_register (regcache
*regcache
,
5431 int regno
, const char *buf
)
5433 supply_register (regcache
, regno
, buf
);
5437 linux_process_target::usr_fetch_inferior_registers (const regs_info
*regs_info
,
5441 #ifdef HAVE_LINUX_USRREGS
5442 struct usrregs_info
*usr
= regs_info
->usrregs
;
5446 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5447 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5448 fetch_register (usr
, regcache
, regno
);
5451 fetch_register (usr
, regcache
, regno
);
5456 linux_process_target::usr_store_inferior_registers (const regs_info
*regs_info
,
5460 #ifdef HAVE_LINUX_USRREGS
5461 struct usrregs_info
*usr
= regs_info
->usrregs
;
5465 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5466 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5467 store_register (usr
, regcache
, regno
);
5470 store_register (usr
, regcache
, regno
);
5475 linux_process_target::fetch_registers (regcache
*regcache
, int regno
)
5479 const regs_info
*regs_info
= get_regs_info ();
5483 if (regs_info
->usrregs
!= NULL
)
5484 for (regno
= 0; regno
< regs_info
->usrregs
->num_regs
; regno
++)
5485 low_fetch_register (regcache
, regno
);
5487 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
, regcache
);
5488 if (regs_info
->usrregs
!= NULL
)
5489 usr_fetch_inferior_registers (regs_info
, regcache
, -1, all
);
5493 if (low_fetch_register (regcache
, regno
))
5496 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5498 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
,
5500 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5501 usr_fetch_inferior_registers (regs_info
, regcache
, regno
, 1);
5506 linux_process_target::store_registers (regcache
*regcache
, int regno
)
5510 const regs_info
*regs_info
= get_regs_info ();
5514 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5516 if (regs_info
->usrregs
!= NULL
)
5517 usr_store_inferior_registers (regs_info
, regcache
, regno
, all
);
5521 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5523 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5525 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5526 usr_store_inferior_registers (regs_info
, regcache
, regno
, 1);
5531 linux_process_target::low_fetch_register (regcache
*regcache
, int regno
)
5536 /* A wrapper for the read_memory target op. */
5539 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
5541 return the_target
->read_memory (memaddr
, myaddr
, len
);
5544 /* Copy LEN bytes from inferior's memory starting at MEMADDR
5545 to debugger memory starting at MYADDR. */
5548 linux_process_target::read_memory (CORE_ADDR memaddr
,
5549 unsigned char *myaddr
, int len
)
5551 int pid
= lwpid_of (current_thread
);
5552 PTRACE_XFER_TYPE
*buffer
;
5560 /* Try using /proc. Don't bother for one word. */
5561 if (len
>= 3 * sizeof (long))
5565 /* We could keep this file open and cache it - possibly one per
5566 thread. That requires some juggling, but is even faster. */
5567 sprintf (filename
, "/proc/%d/mem", pid
);
5568 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
5572 /* If pread64 is available, use it. It's faster if the kernel
5573 supports it (only one syscall), and it's 64-bit safe even on
5574 32-bit platforms (for instance, SPARC debugging a SPARC64
5577 bytes
= pread64 (fd
, myaddr
, len
, memaddr
);
5580 if (lseek (fd
, memaddr
, SEEK_SET
) != -1)
5581 bytes
= read (fd
, myaddr
, len
);
5588 /* Some data was read, we'll try to get the rest with ptrace. */
5598 /* Round starting address down to longword boundary. */
5599 addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
5600 /* Round ending address up; get number of longwords that makes. */
5601 count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
5602 / sizeof (PTRACE_XFER_TYPE
));
5603 /* Allocate buffer of that many longwords. */
5604 buffer
= XALLOCAVEC (PTRACE_XFER_TYPE
, count
);
5606 /* Read all the longwords */
5608 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
5610 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5611 about coercing an 8 byte integer to a 4 byte pointer. */
5612 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, pid
,
5613 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5614 (PTRACE_TYPE_ARG4
) 0);
5620 /* Copy appropriate bytes out of the buffer. */
5623 i
*= sizeof (PTRACE_XFER_TYPE
);
5624 i
-= memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1);
5626 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
5633 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
5634 memory at MEMADDR. On failure (cannot write to the inferior)
5635 returns the value of errno. Always succeeds if LEN is zero. */
5638 linux_process_target::write_memory (CORE_ADDR memaddr
,
5639 const unsigned char *myaddr
, int len
)
5642 /* Round starting address down to longword boundary. */
5643 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
5644 /* Round ending address up; get number of longwords that makes. */
5646 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
5647 / sizeof (PTRACE_XFER_TYPE
);
5649 /* Allocate buffer of that many longwords. */
5650 PTRACE_XFER_TYPE
*buffer
= XALLOCAVEC (PTRACE_XFER_TYPE
, count
);
5652 int pid
= lwpid_of (current_thread
);
5656 /* Zero length write always succeeds. */
5662 /* Dump up to four bytes. */
5663 char str
[4 * 2 + 1];
5665 int dump
= len
< 4 ? len
: 4;
5667 for (i
= 0; i
< dump
; i
++)
5669 sprintf (p
, "%02x", myaddr
[i
]);
5674 debug_printf ("Writing %s to 0x%08lx in process %d\n",
5675 str
, (long) memaddr
, pid
);
5678 /* Fill start and end extra bytes of buffer with existing memory data. */
5681 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5682 about coercing an 8 byte integer to a 4 byte pointer. */
5683 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, pid
,
5684 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5685 (PTRACE_TYPE_ARG4
) 0);
5693 = ptrace (PTRACE_PEEKTEXT
, pid
,
5694 /* Coerce to a uintptr_t first to avoid potential gcc warning
5695 about coercing an 8 byte integer to a 4 byte pointer. */
5696 (PTRACE_TYPE_ARG3
) (uintptr_t) (addr
+ (count
- 1)
5697 * sizeof (PTRACE_XFER_TYPE
)),
5698 (PTRACE_TYPE_ARG4
) 0);
5703 /* Copy data to be written over corresponding part of buffer. */
5705 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
5708 /* Write the entire buffer. */
5710 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
5713 ptrace (PTRACE_POKETEXT
, pid
,
5714 /* Coerce to a uintptr_t first to avoid potential gcc warning
5715 about coercing an 8 byte integer to a 4 byte pointer. */
5716 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5717 (PTRACE_TYPE_ARG4
) buffer
[i
]);
5726 linux_process_target::look_up_symbols ()
5728 #ifdef USE_THREAD_DB
5729 struct process_info
*proc
= current_process ();
5731 if (proc
->priv
->thread_db
!= NULL
)
5739 linux_process_target::request_interrupt ()
5741 /* Send a SIGINT to the process group. This acts just like the user
5742 typed a ^C on the controlling terminal. */
5743 ::kill (-signal_pid
, SIGINT
);
5747 linux_process_target::supports_read_auxv ()
5752 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
5753 to debugger memory starting at MYADDR. */
5756 linux_process_target::read_auxv (CORE_ADDR offset
, unsigned char *myaddr
,
5759 char filename
[PATH_MAX
];
5761 int pid
= lwpid_of (current_thread
);
5763 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
5765 fd
= open (filename
, O_RDONLY
);
5769 if (offset
!= (CORE_ADDR
) 0
5770 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5773 n
= read (fd
, myaddr
, len
);
5781 linux_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5782 int size
, raw_breakpoint
*bp
)
5784 if (type
== raw_bkpt_type_sw
)
5785 return insert_memory_breakpoint (bp
);
5787 return low_insert_point (type
, addr
, size
, bp
);
5791 linux_process_target::low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
5792 int size
, raw_breakpoint
*bp
)
5794 /* Unsupported (see target.h). */
5799 linux_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5800 int size
, raw_breakpoint
*bp
)
5802 if (type
== raw_bkpt_type_sw
)
5803 return remove_memory_breakpoint (bp
);
5805 return low_remove_point (type
, addr
, size
, bp
);
5809 linux_process_target::low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
5810 int size
, raw_breakpoint
*bp
)
5812 /* Unsupported (see target.h). */
5816 /* Implement the stopped_by_sw_breakpoint target_ops
5820 linux_process_target::stopped_by_sw_breakpoint ()
5822 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5824 return (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
5827 /* Implement the supports_stopped_by_sw_breakpoint target_ops
5831 linux_process_target::supports_stopped_by_sw_breakpoint ()
5833 return USE_SIGTRAP_SIGINFO
;
5836 /* Implement the stopped_by_hw_breakpoint target_ops
5840 linux_process_target::stopped_by_hw_breakpoint ()
5842 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5844 return (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
5847 /* Implement the supports_stopped_by_hw_breakpoint target_ops
5851 linux_process_target::supports_stopped_by_hw_breakpoint ()
5853 return USE_SIGTRAP_SIGINFO
;
5856 /* Implement the supports_hardware_single_step target_ops method. */
5859 linux_process_target::supports_hardware_single_step ()
5865 linux_process_target::stopped_by_watchpoint ()
5867 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5869 return lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
5873 linux_process_target::stopped_data_address ()
5875 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5877 return lwp
->stopped_data_address
;
5880 /* This is only used for targets that define PT_TEXT_ADDR,
5881 PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
5882 the target has different ways of acquiring this information, like
5886 linux_process_target::supports_read_offsets ()
5888 #ifdef SUPPORTS_READ_OFFSETS
5895 /* Under uClinux, programs are loaded at non-zero offsets, which we need
5896 to tell gdb about. */
5899 linux_process_target::read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
5901 #ifdef SUPPORTS_READ_OFFSETS
5902 unsigned long text
, text_end
, data
;
5903 int pid
= lwpid_of (current_thread
);
5907 text
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_ADDR
,
5908 (PTRACE_TYPE_ARG4
) 0);
5909 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_END_ADDR
,
5910 (PTRACE_TYPE_ARG4
) 0);
5911 data
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_DATA_ADDR
,
5912 (PTRACE_TYPE_ARG4
) 0);
5916 /* Both text and data offsets produced at compile-time (and so
5917 used by gdb) are relative to the beginning of the program,
5918 with the data segment immediately following the text segment.
5919 However, the actual runtime layout in memory may put the data
5920 somewhere else, so when we send gdb a data base-address, we
5921 use the real data base address and subtract the compile-time
5922 data base-address from it (which is just the length of the
5923 text segment). BSS immediately follows data in both
5926 *data_p
= data
- (text_end
- text
);
5932 gdb_assert_not_reached ("target op read_offsets not supported");
5937 linux_process_target::supports_get_tls_address ()
5939 #ifdef USE_THREAD_DB
5947 linux_process_target::get_tls_address (thread_info
*thread
,
5949 CORE_ADDR load_module
,
5952 #ifdef USE_THREAD_DB
5953 return thread_db_get_tls_address (thread
, offset
, load_module
, address
);
5960 linux_process_target::supports_qxfer_osdata ()
5966 linux_process_target::qxfer_osdata (const char *annex
,
5967 unsigned char *readbuf
,
5968 unsigned const char *writebuf
,
5969 CORE_ADDR offset
, int len
)
5971 return linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
5975 linux_process_target::siginfo_fixup (siginfo_t
*siginfo
,
5976 gdb_byte
*inf_siginfo
, int direction
)
5978 bool done
= low_siginfo_fixup (siginfo
, inf_siginfo
, direction
);
5980 /* If there was no callback, or the callback didn't do anything,
5981 then just do a straight memcpy. */
5985 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
5987 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
5992 linux_process_target::low_siginfo_fixup (siginfo_t
*native
, gdb_byte
*inf
,
5999 linux_process_target::supports_qxfer_siginfo ()
6005 linux_process_target::qxfer_siginfo (const char *annex
,
6006 unsigned char *readbuf
,
6007 unsigned const char *writebuf
,
6008 CORE_ADDR offset
, int len
)
6012 gdb_byte inf_siginfo
[sizeof (siginfo_t
)];
6014 if (current_thread
== NULL
)
6017 pid
= lwpid_of (current_thread
);
6020 debug_printf ("%s siginfo for lwp %d.\n",
6021 readbuf
!= NULL
? "Reading" : "Writing",
6024 if (offset
>= sizeof (siginfo
))
6027 if (ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
6030 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
6031 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
6032 inferior with a 64-bit GDBSERVER should look the same as debugging it
6033 with a 32-bit GDBSERVER, we need to convert it. */
6034 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
6036 if (offset
+ len
> sizeof (siginfo
))
6037 len
= sizeof (siginfo
) - offset
;
6039 if (readbuf
!= NULL
)
6040 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
6043 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
6045 /* Convert back to ptrace layout before flushing it out. */
6046 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
6048 if (ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
6055 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
6056 so we notice when children change state; as the handler for the
6057 sigsuspend in my_waitpid. */
6060 sigchld_handler (int signo
)
6062 int old_errno
= errno
;
6068 /* Use the async signal safe debug function. */
6069 if (debug_write ("sigchld_handler\n",
6070 sizeof ("sigchld_handler\n") - 1) < 0)
6071 break; /* just ignore */
6075 if (target_is_async_p ())
6076 async_file_mark (); /* trigger a linux_wait */
6082 linux_process_target::supports_non_stop ()
6088 linux_process_target::async (bool enable
)
6090 bool previous
= target_is_async_p ();
6093 debug_printf ("linux_async (%d), previous=%d\n",
6096 if (previous
!= enable
)
6099 sigemptyset (&mask
);
6100 sigaddset (&mask
, SIGCHLD
);
6102 gdb_sigmask (SIG_BLOCK
, &mask
, NULL
);
6106 if (pipe (linux_event_pipe
) == -1)
6108 linux_event_pipe
[0] = -1;
6109 linux_event_pipe
[1] = -1;
6110 gdb_sigmask (SIG_UNBLOCK
, &mask
, NULL
);
6112 warning ("creating event pipe failed.");
6116 fcntl (linux_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
6117 fcntl (linux_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
6119 /* Register the event loop handler. */
6120 add_file_handler (linux_event_pipe
[0],
6121 handle_target_event
, NULL
,
6124 /* Always trigger a linux_wait. */
6129 delete_file_handler (linux_event_pipe
[0]);
6131 close (linux_event_pipe
[0]);
6132 close (linux_event_pipe
[1]);
6133 linux_event_pipe
[0] = -1;
6134 linux_event_pipe
[1] = -1;
6137 gdb_sigmask (SIG_UNBLOCK
, &mask
, NULL
);
6144 linux_process_target::start_non_stop (bool nonstop
)
6146 /* Register or unregister from event-loop accordingly. */
6147 target_async (nonstop
);
6149 if (target_is_async_p () != (nonstop
!= false))
6156 linux_process_target::supports_multi_process ()
6161 /* Check if fork events are supported. */
6164 linux_process_target::supports_fork_events ()
6166 return linux_supports_tracefork ();
6169 /* Check if vfork events are supported. */
6172 linux_process_target::supports_vfork_events ()
6174 return linux_supports_tracefork ();
6177 /* Check if exec events are supported. */
6180 linux_process_target::supports_exec_events ()
6182 return linux_supports_traceexec ();
6185 /* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
6186 ptrace flags for all inferiors. This is in case the new GDB connection
6187 doesn't support the same set of events that the previous one did. */
6190 linux_process_target::handle_new_gdb_connection ()
6192 /* Request that all the lwps reset their ptrace options. */
6193 for_each_thread ([] (thread_info
*thread
)
6195 struct lwp_info
*lwp
= get_thread_lwp (thread
);
6199 /* Stop the lwp so we can modify its ptrace options. */
6200 lwp
->must_set_ptrace_flags
= 1;
6201 linux_stop_lwp (lwp
);
6205 /* Already stopped; go ahead and set the ptrace options. */
6206 struct process_info
*proc
= find_process_pid (pid_of (thread
));
6207 int options
= linux_low_ptrace_options (proc
->attached
);
6209 linux_enable_event_reporting (lwpid_of (thread
), options
);
6210 lwp
->must_set_ptrace_flags
= 0;
6216 linux_process_target::handle_monitor_command (char *mon
)
6218 #ifdef USE_THREAD_DB
6219 return thread_db_handle_monitor_command (mon
);
6226 linux_process_target::core_of_thread (ptid_t ptid
)
6228 return linux_common_core_of_thread (ptid
);
6232 linux_process_target::supports_disable_randomization ()
6234 #ifdef HAVE_PERSONALITY
6242 linux_process_target::supports_agent ()
6248 linux_process_target::supports_range_stepping ()
6250 if (supports_software_single_step ())
6253 return low_supports_range_stepping ();
6257 linux_process_target::low_supports_range_stepping ()
6263 linux_process_target::supports_pid_to_exec_file ()
6269 linux_process_target::pid_to_exec_file (int pid
)
6271 return linux_proc_pid_to_exec_file (pid
);
6275 linux_process_target::supports_multifs ()
6281 linux_process_target::multifs_open (int pid
, const char *filename
,
6282 int flags
, mode_t mode
)
6284 return linux_mntns_open_cloexec (pid
, filename
, flags
, mode
);
6288 linux_process_target::multifs_unlink (int pid
, const char *filename
)
6290 return linux_mntns_unlink (pid
, filename
);
6294 linux_process_target::multifs_readlink (int pid
, const char *filename
,
6295 char *buf
, size_t bufsiz
)
6297 return linux_mntns_readlink (pid
, filename
, buf
, bufsiz
);
6300 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
6301 struct target_loadseg
6303 /* Core address to which the segment is mapped. */
6305 /* VMA recorded in the program header. */
6307 /* Size of this segment in memory. */
6311 # if defined PT_GETDSBT
6312 struct target_loadmap
6314 /* Protocol version number, must be zero. */
6316 /* Pointer to the DSBT table, its size, and the DSBT index. */
6317 unsigned *dsbt_table
;
6318 unsigned dsbt_size
, dsbt_index
;
6319 /* Number of segments in this map. */
6321 /* The actual memory map. */
6322 struct target_loadseg segs
[/*nsegs*/];
6324 # define LINUX_LOADMAP PT_GETDSBT
6325 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
6326 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
6328 struct target_loadmap
6330 /* Protocol version number, must be zero. */
6332 /* Number of segments in this map. */
6334 /* The actual memory map. */
6335 struct target_loadseg segs
[/*nsegs*/];
6337 # define LINUX_LOADMAP PTRACE_GETFDPIC
6338 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
6339 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
6343 linux_process_target::supports_read_loadmap ()
6349 linux_process_target::read_loadmap (const char *annex
, CORE_ADDR offset
,
6350 unsigned char *myaddr
, unsigned int len
)
6352 int pid
= lwpid_of (current_thread
);
6354 struct target_loadmap
*data
= NULL
;
6355 unsigned int actual_length
, copy_length
;
6357 if (strcmp (annex
, "exec") == 0)
6358 addr
= (int) LINUX_LOADMAP_EXEC
;
6359 else if (strcmp (annex
, "interp") == 0)
6360 addr
= (int) LINUX_LOADMAP_INTERP
;
6364 if (ptrace (LINUX_LOADMAP
, pid
, addr
, &data
) != 0)
6370 actual_length
= sizeof (struct target_loadmap
)
6371 + sizeof (struct target_loadseg
) * data
->nsegs
;
6373 if (offset
< 0 || offset
> actual_length
)
6376 copy_length
= actual_length
- offset
< len
? actual_length
- offset
: len
;
6377 memcpy (myaddr
, (char *) data
+ offset
, copy_length
);
6380 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
6383 linux_process_target::supports_catch_syscall ()
6385 return (low_supports_catch_syscall ()
6386 && linux_supports_tracesysgood ());
6390 linux_process_target::low_supports_catch_syscall ()
6396 linux_process_target::read_pc (regcache
*regcache
)
6398 if (!low_supports_breakpoints ())
6401 return low_get_pc (regcache
);
6405 linux_process_target::write_pc (regcache
*regcache
, CORE_ADDR pc
)
6407 gdb_assert (low_supports_breakpoints ());
6409 low_set_pc (regcache
, pc
);
6413 linux_process_target::supports_thread_stopped ()
6419 linux_process_target::thread_stopped (thread_info
*thread
)
6421 return get_thread_lwp (thread
)->stopped
;
6424 /* This exposes stop-all-threads functionality to other modules. */
6427 linux_process_target::pause_all (bool freeze
)
6429 stop_all_lwps (freeze
, NULL
);
6432 /* This exposes unstop-all-threads functionality to other gdbserver
6436 linux_process_target::unpause_all (bool unfreeze
)
6438 unstop_all_lwps (unfreeze
, NULL
);
6442 linux_process_target::prepare_to_access_memory ()
6444 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6447 target_pause_all (true);
6452 linux_process_target::done_accessing_memory ()
6454 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6457 target_unpause_all (true);
6460 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
6463 get_phdr_phnum_from_proc_auxv (const int pid
, const int is_elf64
,
6464 CORE_ADDR
*phdr_memaddr
, int *num_phdr
)
6466 char filename
[PATH_MAX
];
6468 const int auxv_size
= is_elf64
6469 ? sizeof (Elf64_auxv_t
) : sizeof (Elf32_auxv_t
);
6470 char buf
[sizeof (Elf64_auxv_t
)]; /* The larger of the two. */
6472 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
6474 fd
= open (filename
, O_RDONLY
);
6480 while (read (fd
, buf
, auxv_size
) == auxv_size
6481 && (*phdr_memaddr
== 0 || *num_phdr
== 0))
6485 Elf64_auxv_t
*const aux
= (Elf64_auxv_t
*) buf
;
6487 switch (aux
->a_type
)
6490 *phdr_memaddr
= aux
->a_un
.a_val
;
6493 *num_phdr
= aux
->a_un
.a_val
;
6499 Elf32_auxv_t
*const aux
= (Elf32_auxv_t
*) buf
;
6501 switch (aux
->a_type
)
6504 *phdr_memaddr
= aux
->a_un
.a_val
;
6507 *num_phdr
= aux
->a_un
.a_val
;
6515 if (*phdr_memaddr
== 0 || *num_phdr
== 0)
6517 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
6518 "phdr_memaddr = %ld, phdr_num = %d",
6519 (long) *phdr_memaddr
, *num_phdr
);
6526 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
6529 get_dynamic (const int pid
, const int is_elf64
)
6531 CORE_ADDR phdr_memaddr
, relocation
;
6533 unsigned char *phdr_buf
;
6534 const int phdr_size
= is_elf64
? sizeof (Elf64_Phdr
) : sizeof (Elf32_Phdr
);
6536 if (get_phdr_phnum_from_proc_auxv (pid
, is_elf64
, &phdr_memaddr
, &num_phdr
))
6539 gdb_assert (num_phdr
< 100); /* Basic sanity check. */
6540 phdr_buf
= (unsigned char *) alloca (num_phdr
* phdr_size
);
6542 if (linux_read_memory (phdr_memaddr
, phdr_buf
, num_phdr
* phdr_size
))
6545 /* Compute relocation: it is expected to be 0 for "regular" executables,
6546 non-zero for PIE ones. */
6548 for (i
= 0; relocation
== -1 && i
< num_phdr
; i
++)
6551 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6553 if (p
->p_type
== PT_PHDR
)
6554 relocation
= phdr_memaddr
- p
->p_vaddr
;
6558 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6560 if (p
->p_type
== PT_PHDR
)
6561 relocation
= phdr_memaddr
- p
->p_vaddr
;
6564 if (relocation
== -1)
6566 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
6567 any real world executables, including PIE executables, have always
6568 PT_PHDR present. PT_PHDR is not present in some shared libraries or
6569 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
6570 or present DT_DEBUG anyway (fpc binaries are statically linked).
6572 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
6574 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
6579 for (i
= 0; i
< num_phdr
; i
++)
6583 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6585 if (p
->p_type
== PT_DYNAMIC
)
6586 return p
->p_vaddr
+ relocation
;
6590 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6592 if (p
->p_type
== PT_DYNAMIC
)
6593 return p
->p_vaddr
+ relocation
;
6600 /* Return &_r_debug in the inferior, or -1 if not present. Return value
6601 can be 0 if the inferior does not yet have the library list initialized.
6602 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
6603 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
6606 get_r_debug (const int pid
, const int is_elf64
)
6608 CORE_ADDR dynamic_memaddr
;
6609 const int dyn_size
= is_elf64
? sizeof (Elf64_Dyn
) : sizeof (Elf32_Dyn
);
6610 unsigned char buf
[sizeof (Elf64_Dyn
)]; /* The larger of the two. */
6613 dynamic_memaddr
= get_dynamic (pid
, is_elf64
);
6614 if (dynamic_memaddr
== 0)
6617 while (linux_read_memory (dynamic_memaddr
, buf
, dyn_size
) == 0)
6621 Elf64_Dyn
*const dyn
= (Elf64_Dyn
*) buf
;
6622 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6626 unsigned char buf
[sizeof (Elf64_Xword
)];
6630 #ifdef DT_MIPS_RLD_MAP
6631 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6633 if (linux_read_memory (dyn
->d_un
.d_val
,
6634 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6639 #endif /* DT_MIPS_RLD_MAP */
6640 #ifdef DT_MIPS_RLD_MAP_REL
6641 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6643 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6644 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6649 #endif /* DT_MIPS_RLD_MAP_REL */
6651 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6652 map
= dyn
->d_un
.d_val
;
6654 if (dyn
->d_tag
== DT_NULL
)
6659 Elf32_Dyn
*const dyn
= (Elf32_Dyn
*) buf
;
6660 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6664 unsigned char buf
[sizeof (Elf32_Word
)];
6668 #ifdef DT_MIPS_RLD_MAP
6669 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6671 if (linux_read_memory (dyn
->d_un
.d_val
,
6672 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6677 #endif /* DT_MIPS_RLD_MAP */
6678 #ifdef DT_MIPS_RLD_MAP_REL
6679 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6681 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6682 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6687 #endif /* DT_MIPS_RLD_MAP_REL */
6689 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6690 map
= dyn
->d_un
.d_val
;
6692 if (dyn
->d_tag
== DT_NULL
)
6696 dynamic_memaddr
+= dyn_size
;
6702 /* Read one pointer from MEMADDR in the inferior. */
6705 read_one_ptr (CORE_ADDR memaddr
, CORE_ADDR
*ptr
, int ptr_size
)
6709 /* Go through a union so this works on either big or little endian
6710 hosts, when the inferior's pointer size is smaller than the size
6711 of CORE_ADDR. It is assumed the inferior's endianness is the
6712 same of the superior's. */
6715 CORE_ADDR core_addr
;
6720 ret
= linux_read_memory (memaddr
, &addr
.uc
, ptr_size
);
6723 if (ptr_size
== sizeof (CORE_ADDR
))
6724 *ptr
= addr
.core_addr
;
6725 else if (ptr_size
== sizeof (unsigned int))
6728 gdb_assert_not_reached ("unhandled pointer size");
6734 linux_process_target::supports_qxfer_libraries_svr4 ()
6739 struct link_map_offsets
6741 /* Offset and size of r_debug.r_version. */
6742 int r_version_offset
;
6744 /* Offset and size of r_debug.r_map. */
6747 /* Offset to l_addr field in struct link_map. */
6750 /* Offset to l_name field in struct link_map. */
6753 /* Offset to l_ld field in struct link_map. */
6756 /* Offset to l_next field in struct link_map. */
6759 /* Offset to l_prev field in struct link_map. */
6763 /* Construct qXfer:libraries-svr4:read reply. */
6766 linux_process_target::qxfer_libraries_svr4 (const char *annex
,
6767 unsigned char *readbuf
,
6768 unsigned const char *writebuf
,
6769 CORE_ADDR offset
, int len
)
6771 struct process_info_private
*const priv
= current_process ()->priv
;
6772 char filename
[PATH_MAX
];
6775 static const struct link_map_offsets lmo_32bit_offsets
=
6777 0, /* r_version offset. */
6778 4, /* r_debug.r_map offset. */
6779 0, /* l_addr offset in link_map. */
6780 4, /* l_name offset in link_map. */
6781 8, /* l_ld offset in link_map. */
6782 12, /* l_next offset in link_map. */
6783 16 /* l_prev offset in link_map. */
6786 static const struct link_map_offsets lmo_64bit_offsets
=
6788 0, /* r_version offset. */
6789 8, /* r_debug.r_map offset. */
6790 0, /* l_addr offset in link_map. */
6791 8, /* l_name offset in link_map. */
6792 16, /* l_ld offset in link_map. */
6793 24, /* l_next offset in link_map. */
6794 32 /* l_prev offset in link_map. */
6796 const struct link_map_offsets
*lmo
;
6797 unsigned int machine
;
6799 CORE_ADDR lm_addr
= 0, lm_prev
= 0;
6800 CORE_ADDR l_name
, l_addr
, l_ld
, l_next
, l_prev
;
6801 int header_done
= 0;
6803 if (writebuf
!= NULL
)
6805 if (readbuf
== NULL
)
6808 pid
= lwpid_of (current_thread
);
6809 xsnprintf (filename
, sizeof filename
, "/proc/%d/exe", pid
);
6810 is_elf64
= elf_64_file_p (filename
, &machine
);
6811 lmo
= is_elf64
? &lmo_64bit_offsets
: &lmo_32bit_offsets
;
6812 ptr_size
= is_elf64
? 8 : 4;
6814 while (annex
[0] != '\0')
6820 sep
= strchr (annex
, '=');
6824 name_len
= sep
- annex
;
6825 if (name_len
== 5 && startswith (annex
, "start"))
6827 else if (name_len
== 4 && startswith (annex
, "prev"))
6831 annex
= strchr (sep
, ';');
6838 annex
= decode_address_to_semicolon (addrp
, sep
+ 1);
6845 if (priv
->r_debug
== 0)
6846 priv
->r_debug
= get_r_debug (pid
, is_elf64
);
6848 /* We failed to find DT_DEBUG. Such situation will not change
6849 for this inferior - do not retry it. Report it to GDB as
6850 E01, see for the reasons at the GDB solib-svr4.c side. */
6851 if (priv
->r_debug
== (CORE_ADDR
) -1)
6854 if (priv
->r_debug
!= 0)
6856 if (linux_read_memory (priv
->r_debug
+ lmo
->r_version_offset
,
6857 (unsigned char *) &r_version
,
6858 sizeof (r_version
)) != 0
6861 warning ("unexpected r_debug version %d", r_version
);
6863 else if (read_one_ptr (priv
->r_debug
+ lmo
->r_map_offset
,
6864 &lm_addr
, ptr_size
) != 0)
6866 warning ("unable to read r_map from 0x%lx",
6867 (long) priv
->r_debug
+ lmo
->r_map_offset
);
6872 std::string document
= "<library-list-svr4 version=\"1.0\"";
6875 && read_one_ptr (lm_addr
+ lmo
->l_name_offset
,
6876 &l_name
, ptr_size
) == 0
6877 && read_one_ptr (lm_addr
+ lmo
->l_addr_offset
,
6878 &l_addr
, ptr_size
) == 0
6879 && read_one_ptr (lm_addr
+ lmo
->l_ld_offset
,
6880 &l_ld
, ptr_size
) == 0
6881 && read_one_ptr (lm_addr
+ lmo
->l_prev_offset
,
6882 &l_prev
, ptr_size
) == 0
6883 && read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
6884 &l_next
, ptr_size
) == 0)
6886 unsigned char libname
[PATH_MAX
];
6888 if (lm_prev
!= l_prev
)
6890 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
6891 (long) lm_prev
, (long) l_prev
);
6895 /* Ignore the first entry even if it has valid name as the first entry
6896 corresponds to the main executable. The first entry should not be
6897 skipped if the dynamic loader was loaded late by a static executable
6898 (see solib-svr4.c parameter ignore_first). But in such case the main
6899 executable does not have PT_DYNAMIC present and this function already
6900 exited above due to failed get_r_debug. */
6902 string_appendf (document
, " main-lm=\"0x%lx\"", (unsigned long) lm_addr
);
6905 /* Not checking for error because reading may stop before
6906 we've got PATH_MAX worth of characters. */
6908 linux_read_memory (l_name
, libname
, sizeof (libname
) - 1);
6909 libname
[sizeof (libname
) - 1] = '\0';
6910 if (libname
[0] != '\0')
6914 /* Terminate `<library-list-svr4'. */
6919 string_appendf (document
, "<library name=\"");
6920 xml_escape_text_append (&document
, (char *) libname
);
6921 string_appendf (document
, "\" lm=\"0x%lx\" "
6922 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
6923 (unsigned long) lm_addr
, (unsigned long) l_addr
,
6924 (unsigned long) l_ld
);
6934 /* Empty list; terminate `<library-list-svr4'. */
6938 document
+= "</library-list-svr4>";
6940 int document_len
= document
.length ();
6941 if (offset
< document_len
)
6942 document_len
-= offset
;
6945 if (len
> document_len
)
6948 memcpy (readbuf
, document
.data () + offset
, len
);
6953 #ifdef HAVE_LINUX_BTRACE
6955 btrace_target_info
*
6956 linux_process_target::enable_btrace (ptid_t ptid
,
6957 const btrace_config
*conf
)
6959 return linux_enable_btrace (ptid
, conf
);
6962 /* See to_disable_btrace target method. */
6965 linux_process_target::disable_btrace (btrace_target_info
*tinfo
)
6967 enum btrace_error err
;
6969 err
= linux_disable_btrace (tinfo
);
6970 return (err
== BTRACE_ERR_NONE
? 0 : -1);
6973 /* Encode an Intel Processor Trace configuration. */
6976 linux_low_encode_pt_config (struct buffer
*buffer
,
6977 const struct btrace_data_pt_config
*config
)
6979 buffer_grow_str (buffer
, "<pt-config>\n");
6981 switch (config
->cpu
.vendor
)
6984 buffer_xml_printf (buffer
, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
6985 "model=\"%u\" stepping=\"%u\"/>\n",
6986 config
->cpu
.family
, config
->cpu
.model
,
6987 config
->cpu
.stepping
);
6994 buffer_grow_str (buffer
, "</pt-config>\n");
6997 /* Encode a raw buffer. */
7000 linux_low_encode_raw (struct buffer
*buffer
, const gdb_byte
*data
,
7006 /* We use hex encoding - see gdbsupport/rsp-low.h. */
7007 buffer_grow_str (buffer
, "<raw>\n");
7013 elem
[0] = tohex ((*data
>> 4) & 0xf);
7014 elem
[1] = tohex (*data
++ & 0xf);
7016 buffer_grow (buffer
, elem
, 2);
7019 buffer_grow_str (buffer
, "</raw>\n");
7022 /* See to_read_btrace target method. */
7025 linux_process_target::read_btrace (btrace_target_info
*tinfo
,
7027 enum btrace_read_type type
)
7029 struct btrace_data btrace
;
7030 enum btrace_error err
;
7032 err
= linux_read_btrace (&btrace
, tinfo
, type
);
7033 if (err
!= BTRACE_ERR_NONE
)
7035 if (err
== BTRACE_ERR_OVERFLOW
)
7036 buffer_grow_str0 (buffer
, "E.Overflow.");
7038 buffer_grow_str0 (buffer
, "E.Generic Error.");
7043 switch (btrace
.format
)
7045 case BTRACE_FORMAT_NONE
:
7046 buffer_grow_str0 (buffer
, "E.No Trace.");
7049 case BTRACE_FORMAT_BTS
:
7050 buffer_grow_str (buffer
, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
7051 buffer_grow_str (buffer
, "<btrace version=\"1.0\">\n");
7053 for (const btrace_block
&block
: *btrace
.variant
.bts
.blocks
)
7054 buffer_xml_printf (buffer
, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
7055 paddress (block
.begin
), paddress (block
.end
));
7057 buffer_grow_str0 (buffer
, "</btrace>\n");
7060 case BTRACE_FORMAT_PT
:
7061 buffer_grow_str (buffer
, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
7062 buffer_grow_str (buffer
, "<btrace version=\"1.0\">\n");
7063 buffer_grow_str (buffer
, "<pt>\n");
7065 linux_low_encode_pt_config (buffer
, &btrace
.variant
.pt
.config
);
7067 linux_low_encode_raw (buffer
, btrace
.variant
.pt
.data
,
7068 btrace
.variant
.pt
.size
);
7070 buffer_grow_str (buffer
, "</pt>\n");
7071 buffer_grow_str0 (buffer
, "</btrace>\n");
7075 buffer_grow_str0 (buffer
, "E.Unsupported Trace Format.");
7082 /* See to_btrace_conf target method. */
7085 linux_process_target::read_btrace_conf (const btrace_target_info
*tinfo
,
7088 const struct btrace_config
*conf
;
7090 buffer_grow_str (buffer
, "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n");
7091 buffer_grow_str (buffer
, "<btrace-conf version=\"1.0\">\n");
7093 conf
= linux_btrace_conf (tinfo
);
7096 switch (conf
->format
)
7098 case BTRACE_FORMAT_NONE
:
7101 case BTRACE_FORMAT_BTS
:
7102 buffer_xml_printf (buffer
, "<bts");
7103 buffer_xml_printf (buffer
, " size=\"0x%x\"", conf
->bts
.size
);
7104 buffer_xml_printf (buffer
, " />\n");
7107 case BTRACE_FORMAT_PT
:
7108 buffer_xml_printf (buffer
, "<pt");
7109 buffer_xml_printf (buffer
, " size=\"0x%x\"", conf
->pt
.size
);
7110 buffer_xml_printf (buffer
, "/>\n");
7115 buffer_grow_str0 (buffer
, "</btrace-conf>\n");
7118 #endif /* HAVE_LINUX_BTRACE */
7120 /* See nat/linux-nat.h. */
7123 current_lwp_ptid (void)
7125 return ptid_of (current_thread
);
7129 linux_process_target::thread_name (ptid_t thread
)
7131 return linux_proc_tid_get_name (thread
);
7136 linux_process_target::thread_handle (ptid_t ptid
, gdb_byte
**handle
,
7139 return thread_db_thread_handle (ptid
, handle
, handle_len
);
7143 /* Default implementation of linux_target_ops method "set_pc" for
7144 32-bit pc register which is literally named "pc". */
7147 linux_set_pc_32bit (struct regcache
*regcache
, CORE_ADDR pc
)
7149 uint32_t newpc
= pc
;
7151 supply_register_by_name (regcache
, "pc", &newpc
);
7154 /* Default implementation of linux_target_ops method "get_pc" for
7155 32-bit pc register which is literally named "pc". */
7158 linux_get_pc_32bit (struct regcache
*regcache
)
7162 collect_register_by_name (regcache
, "pc", &pc
);
7164 debug_printf ("stop pc is 0x%" PRIx32
"\n", pc
);
7168 /* Default implementation of linux_target_ops method "set_pc" for
7169 64-bit pc register which is literally named "pc". */
7172 linux_set_pc_64bit (struct regcache
*regcache
, CORE_ADDR pc
)
7174 uint64_t newpc
= pc
;
7176 supply_register_by_name (regcache
, "pc", &newpc
);
7179 /* Default implementation of linux_target_ops method "get_pc" for
7180 64-bit pc register which is literally named "pc". */
7183 linux_get_pc_64bit (struct regcache
*regcache
)
7187 collect_register_by_name (regcache
, "pc", &pc
);
7189 debug_printf ("stop pc is 0x%" PRIx64
"\n", pc
);
7193 /* See linux-low.h. */
7196 linux_get_auxv (int wordsize
, CORE_ADDR match
, CORE_ADDR
*valp
)
7198 gdb_byte
*data
= (gdb_byte
*) alloca (2 * wordsize
);
7201 gdb_assert (wordsize
== 4 || wordsize
== 8);
7203 while (the_target
->read_auxv (offset
, data
, 2 * wordsize
) == 2 * wordsize
)
7207 uint32_t *data_p
= (uint32_t *) data
;
7208 if (data_p
[0] == match
)
7216 uint64_t *data_p
= (uint64_t *) data
;
7217 if (data_p
[0] == match
)
7224 offset
+= 2 * wordsize
;
7230 /* See linux-low.h. */
7233 linux_get_hwcap (int wordsize
)
7235 CORE_ADDR hwcap
= 0;
7236 linux_get_auxv (wordsize
, AT_HWCAP
, &hwcap
);
7240 /* See linux-low.h. */
7243 linux_get_hwcap2 (int wordsize
)
7245 CORE_ADDR hwcap2
= 0;
7246 linux_get_auxv (wordsize
, AT_HWCAP2
, &hwcap2
);
7250 #ifdef HAVE_LINUX_REGSETS
7252 initialize_regsets_info (struct regsets_info
*info
)
7254 for (info
->num_regsets
= 0;
7255 info
->regsets
[info
->num_regsets
].size
>= 0;
7256 info
->num_regsets
++)
7262 initialize_low (void)
7264 struct sigaction sigchld_action
;
7266 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
7267 set_target_ops (the_linux_target
);
7269 linux_ptrace_init_warnings ();
7270 linux_proc_init_warnings ();
7272 sigchld_action
.sa_handler
= sigchld_handler
;
7273 sigemptyset (&sigchld_action
.sa_mask
);
7274 sigchld_action
.sa_flags
= SA_RESTART
;
7275 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
7277 initialize_low_arch ();
7279 linux_check_ptrace_features ();