1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995-2020 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 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 enum 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 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 struct pending_signals
322 struct pending_signals
*prev
;
325 /* The read/write ends of the pipe registered as waitable file in the
327 static int linux_event_pipe
[2] = { -1, -1 };
329 /* True if we're currently in async mode. */
330 #define target_is_async_p() (linux_event_pipe[0] != -1)
332 static void send_sigstop (struct lwp_info
*lwp
);
334 /* Return non-zero if HEADER is a 64-bit ELF file. */
337 elf_64_header_p (const Elf64_Ehdr
*header
, unsigned int *machine
)
339 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
340 && header
->e_ident
[EI_MAG1
] == ELFMAG1
341 && header
->e_ident
[EI_MAG2
] == ELFMAG2
342 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
344 *machine
= header
->e_machine
;
345 return header
->e_ident
[EI_CLASS
] == ELFCLASS64
;
352 /* Return non-zero if FILE is a 64-bit ELF file,
353 zero if the file is not a 64-bit ELF file,
354 and -1 if the file is not accessible or doesn't exist. */
357 elf_64_file_p (const char *file
, unsigned int *machine
)
362 fd
= open (file
, O_RDONLY
);
366 if (read (fd
, &header
, sizeof (header
)) != sizeof (header
))
373 return elf_64_header_p (&header
, machine
);
376 /* Accepts an integer PID; Returns true if the executable PID is
377 running is a 64-bit ELF file.. */
380 linux_pid_exe_is_elf_64_file (int pid
, unsigned int *machine
)
384 sprintf (file
, "/proc/%d/exe", pid
);
385 return elf_64_file_p (file
, machine
);
389 linux_process_target::delete_lwp (lwp_info
*lwp
)
391 struct thread_info
*thr
= get_lwp_thread (lwp
);
394 debug_printf ("deleting %ld\n", lwpid_of (thr
));
398 low_delete_thread (lwp
->arch_private
);
404 linux_process_target::low_delete_thread (arch_lwp_info
*info
)
406 /* Default implementation should be overridden if architecture-specific
407 info is being used. */
408 gdb_assert (info
== nullptr);
412 linux_process_target::add_linux_process (int pid
, int attached
)
414 struct process_info
*proc
;
416 proc
= add_process (pid
, attached
);
417 proc
->priv
= XCNEW (struct process_info_private
);
419 proc
->priv
->arch_private
= low_new_process ();
425 linux_process_target::low_new_process ()
431 linux_process_target::low_delete_process (arch_process_info
*info
)
433 /* Default implementation must be overridden if architecture-specific
435 gdb_assert (info
== nullptr);
439 linux_process_target::low_new_fork (process_info
*parent
, process_info
*child
)
445 linux_process_target::arch_setup_thread (thread_info
*thread
)
447 struct thread_info
*saved_thread
;
449 saved_thread
= current_thread
;
450 current_thread
= thread
;
454 current_thread
= saved_thread
;
458 linux_process_target::handle_extended_wait (lwp_info
**orig_event_lwp
,
461 client_state
&cs
= get_client_state ();
462 struct lwp_info
*event_lwp
= *orig_event_lwp
;
463 int event
= linux_ptrace_get_extended_event (wstat
);
464 struct thread_info
*event_thr
= get_lwp_thread (event_lwp
);
465 struct lwp_info
*new_lwp
;
467 gdb_assert (event_lwp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
);
469 /* All extended events we currently use are mid-syscall. Only
470 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
471 you have to be using PTRACE_SEIZE to get that. */
472 event_lwp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
474 if ((event
== PTRACE_EVENT_FORK
) || (event
== PTRACE_EVENT_VFORK
)
475 || (event
== PTRACE_EVENT_CLONE
))
478 unsigned long new_pid
;
481 /* Get the pid of the new lwp. */
482 ptrace (PTRACE_GETEVENTMSG
, lwpid_of (event_thr
), (PTRACE_TYPE_ARG3
) 0,
485 /* If we haven't already seen the new PID stop, wait for it now. */
486 if (!pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
488 /* The new child has a pending SIGSTOP. We can't affect it until it
489 hits the SIGSTOP, but we're already attached. */
491 ret
= my_waitpid (new_pid
, &status
, __WALL
);
494 perror_with_name ("waiting for new child");
495 else if (ret
!= new_pid
)
496 warning ("wait returned unexpected PID %d", ret
);
497 else if (!WIFSTOPPED (status
))
498 warning ("wait returned unexpected status 0x%x", status
);
501 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
)
503 struct process_info
*parent_proc
;
504 struct process_info
*child_proc
;
505 struct lwp_info
*child_lwp
;
506 struct thread_info
*child_thr
;
507 struct target_desc
*tdesc
;
509 ptid
= ptid_t (new_pid
, new_pid
, 0);
513 debug_printf ("HEW: Got fork event from LWP %ld, "
515 ptid_of (event_thr
).lwp (),
519 /* Add the new process to the tables and clone the breakpoint
520 lists of the parent. We need to do this even if the new process
521 will be detached, since we will need the process object and the
522 breakpoints to remove any breakpoints from memory when we
523 detach, and the client side will access registers. */
524 child_proc
= add_linux_process (new_pid
, 0);
525 gdb_assert (child_proc
!= NULL
);
526 child_lwp
= add_lwp (ptid
);
527 gdb_assert (child_lwp
!= NULL
);
528 child_lwp
->stopped
= 1;
529 child_lwp
->must_set_ptrace_flags
= 1;
530 child_lwp
->status_pending_p
= 0;
531 child_thr
= get_lwp_thread (child_lwp
);
532 child_thr
->last_resume_kind
= resume_stop
;
533 child_thr
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
535 /* If we're suspending all threads, leave this one suspended
536 too. If the fork/clone parent is stepping over a breakpoint,
537 all other threads have been suspended already. Leave the
538 child suspended too. */
539 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
540 || event_lwp
->bp_reinsert
!= 0)
543 debug_printf ("HEW: leaving child suspended\n");
544 child_lwp
->suspended
= 1;
547 parent_proc
= get_thread_process (event_thr
);
548 child_proc
->attached
= parent_proc
->attached
;
550 if (event_lwp
->bp_reinsert
!= 0
551 && supports_software_single_step ()
552 && event
== PTRACE_EVENT_VFORK
)
554 /* If we leave single-step breakpoints there, child will
555 hit it, so uninsert single-step breakpoints from parent
556 (and child). Once vfork child is done, reinsert
557 them back to parent. */
558 uninsert_single_step_breakpoints (event_thr
);
561 clone_all_breakpoints (child_thr
, event_thr
);
563 tdesc
= allocate_target_description ();
564 copy_target_description (tdesc
, parent_proc
->tdesc
);
565 child_proc
->tdesc
= tdesc
;
567 /* Clone arch-specific process data. */
568 low_new_fork (parent_proc
, child_proc
);
570 /* Save fork info in the parent thread. */
571 if (event
== PTRACE_EVENT_FORK
)
572 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_FORKED
;
573 else if (event
== PTRACE_EVENT_VFORK
)
574 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_VFORKED
;
576 event_lwp
->waitstatus
.value
.related_pid
= ptid
;
578 /* The status_pending field contains bits denoting the
579 extended event, so when the pending event is handled,
580 the handler will look at lwp->waitstatus. */
581 event_lwp
->status_pending_p
= 1;
582 event_lwp
->status_pending
= wstat
;
584 /* Link the threads until the parent event is passed on to
586 event_lwp
->fork_relative
= child_lwp
;
587 child_lwp
->fork_relative
= event_lwp
;
589 /* If the parent thread is doing step-over with single-step
590 breakpoints, the list of single-step breakpoints are cloned
591 from the parent's. Remove them from the child process.
592 In case of vfork, we'll reinsert them back once vforked
594 if (event_lwp
->bp_reinsert
!= 0
595 && supports_software_single_step ())
597 /* The child process is forked and stopped, so it is safe
598 to access its memory without stopping all other threads
599 from other processes. */
600 delete_single_step_breakpoints (child_thr
);
602 gdb_assert (has_single_step_breakpoints (event_thr
));
603 gdb_assert (!has_single_step_breakpoints (child_thr
));
606 /* Report the event. */
611 debug_printf ("HEW: Got clone event "
612 "from LWP %ld, new child is LWP %ld\n",
613 lwpid_of (event_thr
), new_pid
);
615 ptid
= ptid_t (pid_of (event_thr
), new_pid
, 0);
616 new_lwp
= add_lwp (ptid
);
618 /* Either we're going to immediately resume the new thread
619 or leave it stopped. resume_one_lwp is a nop if it
620 thinks the thread is currently running, so set this first
621 before calling resume_one_lwp. */
622 new_lwp
->stopped
= 1;
624 /* If we're suspending all threads, leave this one suspended
625 too. If the fork/clone parent is stepping over a breakpoint,
626 all other threads have been suspended already. Leave the
627 child suspended too. */
628 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
629 || event_lwp
->bp_reinsert
!= 0)
630 new_lwp
->suspended
= 1;
632 /* Normally we will get the pending SIGSTOP. But in some cases
633 we might get another signal delivered to the group first.
634 If we do get another signal, be sure not to lose it. */
635 if (WSTOPSIG (status
) != SIGSTOP
)
637 new_lwp
->stop_expected
= 1;
638 new_lwp
->status_pending_p
= 1;
639 new_lwp
->status_pending
= status
;
641 else if (cs
.report_thread_events
)
643 new_lwp
->waitstatus
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
644 new_lwp
->status_pending_p
= 1;
645 new_lwp
->status_pending
= status
;
649 thread_db_notice_clone (event_thr
, ptid
);
652 /* Don't report the event. */
655 else if (event
== PTRACE_EVENT_VFORK_DONE
)
657 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_VFORK_DONE
;
659 if (event_lwp
->bp_reinsert
!= 0 && supports_software_single_step ())
661 reinsert_single_step_breakpoints (event_thr
);
663 gdb_assert (has_single_step_breakpoints (event_thr
));
666 /* Report the event. */
669 else if (event
== PTRACE_EVENT_EXEC
&& cs
.report_exec_events
)
671 struct process_info
*proc
;
672 std::vector
<int> syscalls_to_catch
;
678 debug_printf ("HEW: Got exec event from LWP %ld\n",
679 lwpid_of (event_thr
));
682 /* Get the event ptid. */
683 event_ptid
= ptid_of (event_thr
);
684 event_pid
= event_ptid
.pid ();
686 /* Save the syscall list from the execing process. */
687 proc
= get_thread_process (event_thr
);
688 syscalls_to_catch
= std::move (proc
->syscalls_to_catch
);
690 /* Delete the execing process and all its threads. */
692 current_thread
= NULL
;
694 /* Create a new process/lwp/thread. */
695 proc
= add_linux_process (event_pid
, 0);
696 event_lwp
= add_lwp (event_ptid
);
697 event_thr
= get_lwp_thread (event_lwp
);
698 gdb_assert (current_thread
== event_thr
);
699 arch_setup_thread (event_thr
);
701 /* Set the event status. */
702 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_EXECD
;
703 event_lwp
->waitstatus
.value
.execd_pathname
704 = xstrdup (linux_proc_pid_to_exec_file (lwpid_of (event_thr
)));
706 /* Mark the exec status as pending. */
707 event_lwp
->stopped
= 1;
708 event_lwp
->status_pending_p
= 1;
709 event_lwp
->status_pending
= wstat
;
710 event_thr
->last_resume_kind
= resume_continue
;
711 event_thr
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
713 /* Update syscall state in the new lwp, effectively mid-syscall too. */
714 event_lwp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
716 /* Restore the list to catch. Don't rely on the client, which is free
717 to avoid sending a new list when the architecture doesn't change.
718 Also, for ANY_SYSCALL, the architecture doesn't really matter. */
719 proc
->syscalls_to_catch
= std::move (syscalls_to_catch
);
721 /* Report the event. */
722 *orig_event_lwp
= event_lwp
;
726 internal_error (__FILE__
, __LINE__
, _("unknown ptrace event %d"), event
);
730 linux_process_target::get_pc (lwp_info
*lwp
)
732 struct thread_info
*saved_thread
;
733 struct regcache
*regcache
;
736 if (!low_supports_breakpoints ())
739 saved_thread
= current_thread
;
740 current_thread
= get_lwp_thread (lwp
);
742 regcache
= get_thread_regcache (current_thread
, 1);
743 pc
= low_get_pc (regcache
);
746 debug_printf ("pc is 0x%lx\n", (long) pc
);
748 current_thread
= saved_thread
;
753 linux_process_target::get_syscall_trapinfo (lwp_info
*lwp
, int *sysno
)
755 struct thread_info
*saved_thread
;
756 struct regcache
*regcache
;
758 saved_thread
= current_thread
;
759 current_thread
= get_lwp_thread (lwp
);
761 regcache
= get_thread_regcache (current_thread
, 1);
762 low_get_syscall_trapinfo (regcache
, sysno
);
765 debug_printf ("get_syscall_trapinfo sysno %d\n", *sysno
);
767 current_thread
= saved_thread
;
771 linux_process_target::low_get_syscall_trapinfo (regcache
*regcache
, int *sysno
)
773 /* By default, report an unknown system call number. */
774 *sysno
= UNKNOWN_SYSCALL
;
778 linux_process_target::save_stop_reason (lwp_info
*lwp
)
781 CORE_ADDR sw_breakpoint_pc
;
782 struct thread_info
*saved_thread
;
783 #if USE_SIGTRAP_SIGINFO
787 if (!low_supports_breakpoints ())
791 sw_breakpoint_pc
= pc
- low_decr_pc_after_break ();
793 /* breakpoint_at reads from the current thread. */
794 saved_thread
= current_thread
;
795 current_thread
= get_lwp_thread (lwp
);
797 #if USE_SIGTRAP_SIGINFO
798 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
799 (PTRACE_TYPE_ARG3
) 0, &siginfo
) == 0)
801 if (siginfo
.si_signo
== SIGTRAP
)
803 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
)
804 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
806 /* The si_code is ambiguous on this arch -- check debug
808 if (!check_stopped_by_watchpoint (lwp
))
809 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
811 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
))
813 /* If we determine the LWP stopped for a SW breakpoint,
814 trust it. Particularly don't check watchpoint
815 registers, because at least on s390, we'd find
816 stopped-by-watchpoint as long as there's a watchpoint
818 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
820 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
822 /* This can indicate either a hardware breakpoint or
823 hardware watchpoint. Check debug registers. */
824 if (!check_stopped_by_watchpoint (lwp
))
825 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
827 else if (siginfo
.si_code
== TRAP_TRACE
)
829 /* We may have single stepped an instruction that
830 triggered a watchpoint. In that case, on some
831 architectures (such as x86), instead of TRAP_HWBKPT,
832 si_code indicates TRAP_TRACE, and we need to check
833 the debug registers separately. */
834 if (!check_stopped_by_watchpoint (lwp
))
835 lwp
->stop_reason
= TARGET_STOPPED_BY_SINGLE_STEP
;
840 /* We may have just stepped a breakpoint instruction. E.g., in
841 non-stop mode, GDB first tells the thread A to step a range, and
842 then the user inserts a breakpoint inside the range. In that
843 case we need to report the breakpoint PC. */
844 if ((!lwp
->stepping
|| lwp
->stop_pc
== sw_breakpoint_pc
)
845 && low_breakpoint_at (sw_breakpoint_pc
))
846 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
848 if (hardware_breakpoint_inserted_here (pc
))
849 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
851 if (lwp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
)
852 check_stopped_by_watchpoint (lwp
);
855 if (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
)
859 struct thread_info
*thr
= get_lwp_thread (lwp
);
861 debug_printf ("CSBB: %s stopped by software breakpoint\n",
862 target_pid_to_str (ptid_of (thr
)));
865 /* Back up the PC if necessary. */
866 if (pc
!= sw_breakpoint_pc
)
868 struct regcache
*regcache
869 = get_thread_regcache (current_thread
, 1);
870 low_set_pc (regcache
, sw_breakpoint_pc
);
873 /* Update this so we record the correct stop PC below. */
874 pc
= sw_breakpoint_pc
;
876 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
880 struct thread_info
*thr
= get_lwp_thread (lwp
);
882 debug_printf ("CSBB: %s stopped by hardware breakpoint\n",
883 target_pid_to_str (ptid_of (thr
)));
886 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
890 struct thread_info
*thr
= get_lwp_thread (lwp
);
892 debug_printf ("CSBB: %s stopped by hardware watchpoint\n",
893 target_pid_to_str (ptid_of (thr
)));
896 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
900 struct thread_info
*thr
= get_lwp_thread (lwp
);
902 debug_printf ("CSBB: %s stopped by trace\n",
903 target_pid_to_str (ptid_of (thr
)));
908 current_thread
= saved_thread
;
913 linux_process_target::add_lwp (ptid_t ptid
)
915 struct lwp_info
*lwp
;
917 lwp
= XCNEW (struct lwp_info
);
919 lwp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
921 lwp
->thread
= add_thread (ptid
, lwp
);
923 low_new_thread (lwp
);
929 linux_process_target::low_new_thread (lwp_info
*info
)
934 /* Callback to be used when calling fork_inferior, responsible for
935 actually initiating the tracing of the inferior. */
940 if (ptrace (PTRACE_TRACEME
, 0, (PTRACE_TYPE_ARG3
) 0,
941 (PTRACE_TYPE_ARG4
) 0) < 0)
942 trace_start_error_with_name ("ptrace");
944 if (setpgid (0, 0) < 0)
945 trace_start_error_with_name ("setpgid");
947 /* If GDBserver is connected to gdb via stdio, redirect the inferior's
948 stdout to stderr so that inferior i/o doesn't corrupt the connection.
949 Also, redirect stdin to /dev/null. */
950 if (remote_connection_is_stdio ())
953 trace_start_error_with_name ("close");
954 if (open ("/dev/null", O_RDONLY
) < 0)
955 trace_start_error_with_name ("open");
957 trace_start_error_with_name ("dup2");
958 if (write (2, "stdin/stdout redirected\n",
959 sizeof ("stdin/stdout redirected\n") - 1) < 0)
961 /* Errors ignored. */;
966 /* Start an inferior process and returns its pid.
967 PROGRAM is the name of the program to be started, and PROGRAM_ARGS
968 are its arguments. */
971 linux_process_target::create_inferior (const char *program
,
972 const std::vector
<char *> &program_args
)
974 client_state
&cs
= get_client_state ();
975 struct lwp_info
*new_lwp
;
980 maybe_disable_address_space_randomization restore_personality
981 (cs
.disable_randomization
);
982 std::string str_program_args
= construct_inferior_arguments (program_args
);
984 pid
= fork_inferior (program
,
985 str_program_args
.c_str (),
986 get_environ ()->envp (), linux_ptrace_fun
,
987 NULL
, NULL
, NULL
, NULL
);
990 add_linux_process (pid
, 0);
992 ptid
= ptid_t (pid
, pid
, 0);
993 new_lwp
= add_lwp (ptid
);
994 new_lwp
->must_set_ptrace_flags
= 1;
996 post_fork_inferior (pid
, program
);
1001 /* Implement the post_create_inferior target_ops method. */
1004 linux_process_target::post_create_inferior ()
1006 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
1010 if (lwp
->must_set_ptrace_flags
)
1012 struct process_info
*proc
= current_process ();
1013 int options
= linux_low_ptrace_options (proc
->attached
);
1015 linux_enable_event_reporting (lwpid_of (current_thread
), options
);
1016 lwp
->must_set_ptrace_flags
= 0;
1021 linux_process_target::attach_lwp (ptid_t ptid
)
1023 struct lwp_info
*new_lwp
;
1024 int lwpid
= ptid
.lwp ();
1026 if (ptrace (PTRACE_ATTACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0)
1030 new_lwp
= add_lwp (ptid
);
1032 /* We need to wait for SIGSTOP before being able to make the next
1033 ptrace call on this LWP. */
1034 new_lwp
->must_set_ptrace_flags
= 1;
1036 if (linux_proc_pid_is_stopped (lwpid
))
1039 debug_printf ("Attached to a stopped process\n");
1041 /* The process is definitely stopped. It is in a job control
1042 stop, unless the kernel predates the TASK_STOPPED /
1043 TASK_TRACED distinction, in which case it might be in a
1044 ptrace stop. Make sure it is in a ptrace stop; from there we
1045 can kill it, signal it, et cetera.
1047 First make sure there is a pending SIGSTOP. Since we are
1048 already attached, the process can not transition from stopped
1049 to running without a PTRACE_CONT; so we know this signal will
1050 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1051 probably already in the queue (unless this kernel is old
1052 enough to use TASK_STOPPED for ptrace stops); but since
1053 SIGSTOP is not an RT signal, it can only be queued once. */
1054 kill_lwp (lwpid
, SIGSTOP
);
1056 /* Finally, resume the stopped process. This will deliver the
1057 SIGSTOP (or a higher priority signal, just like normal
1058 PTRACE_ATTACH), which we'll catch later on. */
1059 ptrace (PTRACE_CONT
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1062 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
1063 brings it to a halt.
1065 There are several cases to consider here:
1067 1) gdbserver has already attached to the process and is being notified
1068 of a new thread that is being created.
1069 In this case we should ignore that SIGSTOP and resume the
1070 process. This is handled below by setting stop_expected = 1,
1071 and the fact that add_thread sets last_resume_kind ==
1074 2) This is the first thread (the process thread), and we're attaching
1075 to it via attach_inferior.
1076 In this case we want the process thread to stop.
1077 This is handled by having linux_attach set last_resume_kind ==
1078 resume_stop after we return.
1080 If the pid we are attaching to is also the tgid, we attach to and
1081 stop all the existing threads. Otherwise, we attach to pid and
1082 ignore any other threads in the same group as this pid.
1084 3) GDB is connecting to gdbserver and is requesting an enumeration of all
1086 In this case we want the thread to stop.
1087 FIXME: This case is currently not properly handled.
1088 We should wait for the SIGSTOP but don't. Things work apparently
1089 because enough time passes between when we ptrace (ATTACH) and when
1090 gdb makes the next ptrace call on the thread.
1092 On the other hand, if we are currently trying to stop all threads, we
1093 should treat the new thread as if we had sent it a SIGSTOP. This works
1094 because we are guaranteed that the add_lwp call above added us to the
1095 end of the list, and so the new thread has not yet reached
1096 wait_for_sigstop (but will). */
1097 new_lwp
->stop_expected
= 1;
1102 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1103 already attached. Returns true if a new LWP is found, false
1107 attach_proc_task_lwp_callback (ptid_t ptid
)
1109 /* Is this a new thread? */
1110 if (find_thread_ptid (ptid
) == NULL
)
1112 int lwpid
= ptid
.lwp ();
1116 debug_printf ("Found new lwp %d\n", lwpid
);
1118 err
= the_linux_target
->attach_lwp (ptid
);
1120 /* Be quiet if we simply raced with the thread exiting. EPERM
1121 is returned if the thread's task still exists, and is marked
1122 as exited or zombie, as well as other conditions, so in that
1123 case, confirm the status in /proc/PID/status. */
1125 || (err
== EPERM
&& linux_proc_pid_is_gone (lwpid
)))
1129 debug_printf ("Cannot attach to lwp %d: "
1130 "thread is gone (%d: %s)\n",
1131 lwpid
, err
, safe_strerror (err
));
1137 = linux_ptrace_attach_fail_reason_string (ptid
, err
);
1139 warning (_("Cannot attach to lwp %d: %s"), lwpid
, reason
.c_str ());
1147 static void async_file_mark (void);
1149 /* Attach to PID. If PID is the tgid, attach to it and all
1153 linux_process_target::attach (unsigned long pid
)
1155 struct process_info
*proc
;
1156 struct thread_info
*initial_thread
;
1157 ptid_t ptid
= ptid_t (pid
, pid
, 0);
1160 proc
= add_linux_process (pid
, 1);
1162 /* Attach to PID. We will check for other threads
1164 err
= attach_lwp (ptid
);
1167 remove_process (proc
);
1169 std::string reason
= linux_ptrace_attach_fail_reason_string (ptid
, err
);
1170 error ("Cannot attach to process %ld: %s", pid
, reason
.c_str ());
1173 /* Don't ignore the initial SIGSTOP if we just attached to this
1174 process. It will be collected by wait shortly. */
1175 initial_thread
= find_thread_ptid (ptid_t (pid
, pid
, 0));
1176 initial_thread
->last_resume_kind
= resume_stop
;
1178 /* We must attach to every LWP. If /proc is mounted, use that to
1179 find them now. On the one hand, the inferior may be using raw
1180 clone instead of using pthreads. On the other hand, even if it
1181 is using pthreads, GDB may not be connected yet (thread_db needs
1182 to do symbol lookups, through qSymbol). Also, thread_db walks
1183 structures in the inferior's address space to find the list of
1184 threads/LWPs, and those structures may well be corrupted. Note
1185 that once thread_db is loaded, we'll still use it to list threads
1186 and associate pthread info with each LWP. */
1187 linux_proc_attach_tgid_threads (pid
, attach_proc_task_lwp_callback
);
1189 /* GDB will shortly read the xml target description for this
1190 process, to figure out the process' architecture. But the target
1191 description is only filled in when the first process/thread in
1192 the thread group reports its initial PTRACE_ATTACH SIGSTOP. Do
1193 that now, otherwise, if GDB is fast enough, it could read the
1194 target description _before_ that initial stop. */
1197 struct lwp_info
*lwp
;
1199 ptid_t pid_ptid
= ptid_t (pid
);
1201 lwpid
= wait_for_event_filtered (pid_ptid
, pid_ptid
, &wstat
, __WALL
);
1202 gdb_assert (lwpid
> 0);
1204 lwp
= find_lwp_pid (ptid_t (lwpid
));
1206 if (!WIFSTOPPED (wstat
) || WSTOPSIG (wstat
) != SIGSTOP
)
1208 lwp
->status_pending_p
= 1;
1209 lwp
->status_pending
= wstat
;
1212 initial_thread
->last_resume_kind
= resume_continue
;
1216 gdb_assert (proc
->tdesc
!= NULL
);
1223 last_thread_of_process_p (int pid
)
1225 bool seen_one
= false;
1227 thread_info
*thread
= find_thread (pid
, [&] (thread_info
*thr_arg
)
1231 /* This is the first thread of this process we see. */
1237 /* This is the second thread of this process we see. */
1242 return thread
== NULL
;
1248 linux_kill_one_lwp (struct lwp_info
*lwp
)
1250 struct thread_info
*thr
= get_lwp_thread (lwp
);
1251 int pid
= lwpid_of (thr
);
1253 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
1254 there is no signal context, and ptrace(PTRACE_KILL) (or
1255 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
1256 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
1257 alternative is to kill with SIGKILL. We only need one SIGKILL
1258 per process, not one for each thread. But since we still support
1259 support debugging programs using raw clone without CLONE_THREAD,
1260 we send one for each thread. For years, we used PTRACE_KILL
1261 only, so we're being a bit paranoid about some old kernels where
1262 PTRACE_KILL might work better (dubious if there are any such, but
1263 that's why it's paranoia), so we try SIGKILL first, PTRACE_KILL
1264 second, and so we're fine everywhere. */
1267 kill_lwp (pid
, SIGKILL
);
1270 int save_errno
= errno
;
1272 debug_printf ("LKL: kill_lwp (SIGKILL) %s, 0, 0 (%s)\n",
1273 target_pid_to_str (ptid_of (thr
)),
1274 save_errno
? safe_strerror (save_errno
) : "OK");
1278 ptrace (PTRACE_KILL
, pid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1281 int save_errno
= errno
;
1283 debug_printf ("LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
1284 target_pid_to_str (ptid_of (thr
)),
1285 save_errno
? safe_strerror (save_errno
) : "OK");
1289 /* Kill LWP and wait for it to die. */
1292 kill_wait_lwp (struct lwp_info
*lwp
)
1294 struct thread_info
*thr
= get_lwp_thread (lwp
);
1295 int pid
= ptid_of (thr
).pid ();
1296 int lwpid
= ptid_of (thr
).lwp ();
1301 debug_printf ("kwl: killing lwp %d, for pid: %d\n", lwpid
, pid
);
1305 linux_kill_one_lwp (lwp
);
1307 /* Make sure it died. Notes:
1309 - The loop is most likely unnecessary.
1311 - We don't use wait_for_event as that could delete lwps
1312 while we're iterating over them. We're not interested in
1313 any pending status at this point, only in making sure all
1314 wait status on the kernel side are collected until the
1317 - We don't use __WALL here as the __WALL emulation relies on
1318 SIGCHLD, and killing a stopped process doesn't generate
1319 one, nor an exit status.
1321 res
= my_waitpid (lwpid
, &wstat
, 0);
1322 if (res
== -1 && errno
== ECHILD
)
1323 res
= my_waitpid (lwpid
, &wstat
, __WCLONE
);
1324 } while (res
> 0 && WIFSTOPPED (wstat
));
1326 /* Even if it was stopped, the child may have already disappeared.
1327 E.g., if it was killed by SIGKILL. */
1328 if (res
< 0 && errno
!= ECHILD
)
1329 perror_with_name ("kill_wait_lwp");
1332 /* Callback for `for_each_thread'. Kills an lwp of a given process,
1333 except the leader. */
1336 kill_one_lwp_callback (thread_info
*thread
, int pid
)
1338 struct lwp_info
*lwp
= get_thread_lwp (thread
);
1340 /* We avoid killing the first thread here, because of a Linux kernel (at
1341 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
1342 the children get a chance to be reaped, it will remain a zombie
1345 if (lwpid_of (thread
) == pid
)
1348 debug_printf ("lkop: is last of process %s\n",
1349 target_pid_to_str (thread
->id
));
1353 kill_wait_lwp (lwp
);
1357 linux_process_target::kill (process_info
*process
)
1359 int pid
= process
->pid
;
1361 /* If we're killing a running inferior, make sure it is stopped
1362 first, as PTRACE_KILL will not work otherwise. */
1363 stop_all_lwps (0, NULL
);
1365 for_each_thread (pid
, [&] (thread_info
*thread
)
1367 kill_one_lwp_callback (thread
, pid
);
1370 /* See the comment in linux_kill_one_lwp. We did not kill the first
1371 thread in the list, so do so now. */
1372 lwp_info
*lwp
= find_lwp_pid (ptid_t (pid
));
1377 debug_printf ("lk_1: cannot find lwp for pid: %d\n",
1381 kill_wait_lwp (lwp
);
1385 /* Since we presently can only stop all lwps of all processes, we
1386 need to unstop lwps of other processes. */
1387 unstop_all_lwps (0, NULL
);
1391 /* Get pending signal of THREAD, for detaching purposes. This is the
1392 signal the thread last stopped for, which we need to deliver to the
1393 thread when detaching, otherwise, it'd be suppressed/lost. */
1396 get_detach_signal (struct thread_info
*thread
)
1398 client_state
&cs
= get_client_state ();
1399 enum gdb_signal signo
= GDB_SIGNAL_0
;
1401 struct lwp_info
*lp
= get_thread_lwp (thread
);
1403 if (lp
->status_pending_p
)
1404 status
= lp
->status_pending
;
1407 /* If the thread had been suspended by gdbserver, and it stopped
1408 cleanly, then it'll have stopped with SIGSTOP. But we don't
1409 want to deliver that SIGSTOP. */
1410 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
1411 || thread
->last_status
.value
.sig
== GDB_SIGNAL_0
)
1414 /* Otherwise, we may need to deliver the signal we
1416 status
= lp
->last_status
;
1419 if (!WIFSTOPPED (status
))
1422 debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n",
1423 target_pid_to_str (ptid_of (thread
)));
1427 /* Extended wait statuses aren't real SIGTRAPs. */
1428 if (WSTOPSIG (status
) == SIGTRAP
&& linux_is_extended_waitstatus (status
))
1431 debug_printf ("GPS: lwp %s had stopped with extended "
1432 "status: no pending signal\n",
1433 target_pid_to_str (ptid_of (thread
)));
1437 signo
= gdb_signal_from_host (WSTOPSIG (status
));
1439 if (cs
.program_signals_p
&& !cs
.program_signals
[signo
])
1442 debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
1443 target_pid_to_str (ptid_of (thread
)),
1444 gdb_signal_to_string (signo
));
1447 else if (!cs
.program_signals_p
1448 /* If we have no way to know which signals GDB does not
1449 want to have passed to the program, assume
1450 SIGTRAP/SIGINT, which is GDB's default. */
1451 && (signo
== GDB_SIGNAL_TRAP
|| signo
== GDB_SIGNAL_INT
))
1454 debug_printf ("GPS: lwp %s had signal %s, "
1455 "but we don't know if we should pass it. "
1456 "Default to not.\n",
1457 target_pid_to_str (ptid_of (thread
)),
1458 gdb_signal_to_string (signo
));
1464 debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n",
1465 target_pid_to_str (ptid_of (thread
)),
1466 gdb_signal_to_string (signo
));
1468 return WSTOPSIG (status
);
1473 linux_process_target::detach_one_lwp (lwp_info
*lwp
)
1475 struct thread_info
*thread
= get_lwp_thread (lwp
);
1479 /* If there is a pending SIGSTOP, get rid of it. */
1480 if (lwp
->stop_expected
)
1483 debug_printf ("Sending SIGCONT to %s\n",
1484 target_pid_to_str (ptid_of (thread
)));
1486 kill_lwp (lwpid_of (thread
), SIGCONT
);
1487 lwp
->stop_expected
= 0;
1490 /* Pass on any pending signal for this thread. */
1491 sig
= get_detach_signal (thread
);
1493 /* Preparing to resume may try to write registers, and fail if the
1494 lwp is zombie. If that happens, ignore the error. We'll handle
1495 it below, when detach fails with ESRCH. */
1498 /* Flush any pending changes to the process's registers. */
1499 regcache_invalidate_thread (thread
);
1501 /* Finally, let it resume. */
1502 low_prepare_to_resume (lwp
);
1504 catch (const gdb_exception_error
&ex
)
1506 if (!check_ptrace_stopped_lwp_gone (lwp
))
1510 lwpid
= lwpid_of (thread
);
1511 if (ptrace (PTRACE_DETACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0,
1512 (PTRACE_TYPE_ARG4
) (long) sig
) < 0)
1514 int save_errno
= errno
;
1516 /* We know the thread exists, so ESRCH must mean the lwp is
1517 zombie. This can happen if one of the already-detached
1518 threads exits the whole thread group. In that case we're
1519 still attached, and must reap the lwp. */
1520 if (save_errno
== ESRCH
)
1524 ret
= my_waitpid (lwpid
, &status
, __WALL
);
1527 warning (_("Couldn't reap LWP %d while detaching: %s"),
1528 lwpid
, safe_strerror (errno
));
1530 else if (!WIFEXITED (status
) && !WIFSIGNALED (status
))
1532 warning (_("Reaping LWP %d while detaching "
1533 "returned unexpected status 0x%x"),
1539 error (_("Can't detach %s: %s"),
1540 target_pid_to_str (ptid_of (thread
)),
1541 safe_strerror (save_errno
));
1544 else if (debug_threads
)
1546 debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)\n",
1547 target_pid_to_str (ptid_of (thread
)),
1555 linux_process_target::detach (process_info
*process
)
1557 struct lwp_info
*main_lwp
;
1559 /* As there's a step over already in progress, let it finish first,
1560 otherwise nesting a stabilize_threads operation on top gets real
1562 complete_ongoing_step_over ();
1564 /* Stop all threads before detaching. First, ptrace requires that
1565 the thread is stopped to successfully detach. Second, thread_db
1566 may need to uninstall thread event breakpoints from memory, which
1567 only works with a stopped process anyway. */
1568 stop_all_lwps (0, NULL
);
1570 #ifdef USE_THREAD_DB
1571 thread_db_detach (process
);
1574 /* Stabilize threads (move out of jump pads). */
1575 target_stabilize_threads ();
1577 /* Detach from the clone lwps first. If the thread group exits just
1578 while we're detaching, we must reap the clone lwps before we're
1579 able to reap the leader. */
1580 for_each_thread (process
->pid
, [this] (thread_info
*thread
)
1582 /* We don't actually detach from the thread group leader just yet.
1583 If the thread group exits, we must reap the zombie clone lwps
1584 before we're able to reap the leader. */
1585 if (thread
->id
.pid () == thread
->id
.lwp ())
1588 lwp_info
*lwp
= get_thread_lwp (thread
);
1589 detach_one_lwp (lwp
);
1592 main_lwp
= find_lwp_pid (ptid_t (process
->pid
));
1593 detach_one_lwp (main_lwp
);
1597 /* Since we presently can only stop all lwps of all processes, we
1598 need to unstop lwps of other processes. */
1599 unstop_all_lwps (0, NULL
);
1603 /* Remove all LWPs that belong to process PROC from the lwp list. */
1606 linux_process_target::mourn (process_info
*process
)
1608 struct process_info_private
*priv
;
1610 #ifdef USE_THREAD_DB
1611 thread_db_mourn (process
);
1614 for_each_thread (process
->pid
, [this] (thread_info
*thread
)
1616 delete_lwp (get_thread_lwp (thread
));
1619 /* Freeing all private data. */
1620 priv
= process
->priv
;
1621 low_delete_process (priv
->arch_private
);
1623 process
->priv
= NULL
;
1625 remove_process (process
);
1629 linux_process_target::join (int pid
)
1634 ret
= my_waitpid (pid
, &status
, 0);
1635 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1637 } while (ret
!= -1 || errno
!= ECHILD
);
1640 /* Return true if the given thread is still alive. */
1643 linux_process_target::thread_alive (ptid_t ptid
)
1645 struct lwp_info
*lwp
= find_lwp_pid (ptid
);
1647 /* We assume we always know if a thread exits. If a whole process
1648 exited but we still haven't been able to report it to GDB, we'll
1649 hold on to the last lwp of the dead process. */
1651 return !lwp_is_marked_dead (lwp
);
1657 linux_process_target::thread_still_has_status_pending (thread_info
*thread
)
1659 struct lwp_info
*lp
= get_thread_lwp (thread
);
1661 if (!lp
->status_pending_p
)
1664 if (thread
->last_resume_kind
!= resume_stop
1665 && (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1666 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
1668 struct thread_info
*saved_thread
;
1672 gdb_assert (lp
->last_status
!= 0);
1676 saved_thread
= current_thread
;
1677 current_thread
= thread
;
1679 if (pc
!= lp
->stop_pc
)
1682 debug_printf ("PC of %ld changed\n",
1687 #if !USE_SIGTRAP_SIGINFO
1688 else if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1689 && !low_breakpoint_at (pc
))
1692 debug_printf ("previous SW breakpoint of %ld gone\n",
1696 else if (lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
1697 && !hardware_breakpoint_inserted_here (pc
))
1700 debug_printf ("previous HW breakpoint of %ld gone\n",
1706 current_thread
= saved_thread
;
1711 debug_printf ("discarding pending breakpoint status\n");
1712 lp
->status_pending_p
= 0;
1720 /* Returns true if LWP is resumed from the client's perspective. */
1723 lwp_resumed (struct lwp_info
*lwp
)
1725 struct thread_info
*thread
= get_lwp_thread (lwp
);
1727 if (thread
->last_resume_kind
!= resume_stop
)
1730 /* Did gdb send us a `vCont;t', but we haven't reported the
1731 corresponding stop to gdb yet? If so, the thread is still
1732 resumed/running from gdb's perspective. */
1733 if (thread
->last_resume_kind
== resume_stop
1734 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
1741 linux_process_target::status_pending_p_callback (thread_info
*thread
,
1744 struct lwp_info
*lp
= get_thread_lwp (thread
);
1746 /* Check if we're only interested in events from a specific process
1747 or a specific LWP. */
1748 if (!thread
->id
.matches (ptid
))
1751 if (!lwp_resumed (lp
))
1754 if (lp
->status_pending_p
1755 && !thread_still_has_status_pending (thread
))
1757 resume_one_lwp (lp
, lp
->stepping
, GDB_SIGNAL_0
, NULL
);
1761 return lp
->status_pending_p
;
1765 find_lwp_pid (ptid_t ptid
)
1767 thread_info
*thread
= find_thread ([&] (thread_info
*thr_arg
)
1769 int lwp
= ptid
.lwp () != 0 ? ptid
.lwp () : ptid
.pid ();
1770 return thr_arg
->id
.lwp () == lwp
;
1776 return get_thread_lwp (thread
);
1779 /* Return the number of known LWPs in the tgid given by PID. */
1786 for_each_thread (pid
, [&] (thread_info
*thread
)
1794 /* See nat/linux-nat.h. */
1797 iterate_over_lwps (ptid_t filter
,
1798 gdb::function_view
<iterate_over_lwps_ftype
> callback
)
1800 thread_info
*thread
= find_thread (filter
, [&] (thread_info
*thr_arg
)
1802 lwp_info
*lwp
= get_thread_lwp (thr_arg
);
1804 return callback (lwp
);
1810 return get_thread_lwp (thread
);
1814 linux_process_target::check_zombie_leaders ()
1816 for_each_process ([this] (process_info
*proc
) {
1817 pid_t leader_pid
= pid_of (proc
);
1818 struct lwp_info
*leader_lp
;
1820 leader_lp
= find_lwp_pid (ptid_t (leader_pid
));
1823 debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
1824 "num_lwps=%d, zombie=%d\n",
1825 leader_pid
, leader_lp
!= NULL
, num_lwps (leader_pid
),
1826 linux_proc_pid_is_zombie (leader_pid
));
1828 if (leader_lp
!= NULL
&& !leader_lp
->stopped
1829 /* Check if there are other threads in the group, as we may
1830 have raced with the inferior simply exiting. */
1831 && !last_thread_of_process_p (leader_pid
)
1832 && linux_proc_pid_is_zombie (leader_pid
))
1834 /* A leader zombie can mean one of two things:
1836 - It exited, and there's an exit status pending
1837 available, or only the leader exited (not the whole
1838 program). In the latter case, we can't waitpid the
1839 leader's exit status until all other threads are gone.
1841 - There are 3 or more threads in the group, and a thread
1842 other than the leader exec'd. On an exec, the Linux
1843 kernel destroys all other threads (except the execing
1844 one) in the thread group, and resets the execing thread's
1845 tid to the tgid. No exit notification is sent for the
1846 execing thread -- from the ptracer's perspective, it
1847 appears as though the execing thread just vanishes.
1848 Until we reap all other threads except the leader and the
1849 execing thread, the leader will be zombie, and the
1850 execing thread will be in `D (disc sleep)'. As soon as
1851 all other threads are reaped, the execing thread changes
1852 it's tid to the tgid, and the previous (zombie) leader
1853 vanishes, giving place to the "new" leader. We could try
1854 distinguishing the exit and exec cases, by waiting once
1855 more, and seeing if something comes out, but it doesn't
1856 sound useful. The previous leader _does_ go away, and
1857 we'll re-add the new one once we see the exec event
1858 (which is just the same as what would happen if the
1859 previous leader did exit voluntarily before some other
1863 debug_printf ("CZL: Thread group leader %d zombie "
1864 "(it exited, or another thread execd).\n",
1867 delete_lwp (leader_lp
);
1872 /* Callback for `find_thread'. Returns the first LWP that is not
1876 not_stopped_callback (thread_info
*thread
, ptid_t filter
)
1878 if (!thread
->id
.matches (filter
))
1881 lwp_info
*lwp
= get_thread_lwp (thread
);
1883 return !lwp
->stopped
;
1886 /* Increment LWP's suspend count. */
1889 lwp_suspended_inc (struct lwp_info
*lwp
)
1893 if (debug_threads
&& lwp
->suspended
> 4)
1895 struct thread_info
*thread
= get_lwp_thread (lwp
);
1897 debug_printf ("LWP %ld has a suspiciously high suspend count,"
1898 " suspended=%d\n", lwpid_of (thread
), lwp
->suspended
);
1902 /* Decrement LWP's suspend count. */
1905 lwp_suspended_decr (struct lwp_info
*lwp
)
1909 if (lwp
->suspended
< 0)
1911 struct thread_info
*thread
= get_lwp_thread (lwp
);
1913 internal_error (__FILE__
, __LINE__
,
1914 "unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread
),
1919 /* This function should only be called if the LWP got a SIGTRAP.
1921 Handle any tracepoint steps or hits. Return true if a tracepoint
1922 event was handled, 0 otherwise. */
1925 handle_tracepoints (struct lwp_info
*lwp
)
1927 struct thread_info
*tinfo
= get_lwp_thread (lwp
);
1928 int tpoint_related_event
= 0;
1930 gdb_assert (lwp
->suspended
== 0);
1932 /* If this tracepoint hit causes a tracing stop, we'll immediately
1933 uninsert tracepoints. To do this, we temporarily pause all
1934 threads, unpatch away, and then unpause threads. We need to make
1935 sure the unpausing doesn't resume LWP too. */
1936 lwp_suspended_inc (lwp
);
1938 /* And we need to be sure that any all-threads-stopping doesn't try
1939 to move threads out of the jump pads, as it could deadlock the
1940 inferior (LWP could be in the jump pad, maybe even holding the
1943 /* Do any necessary step collect actions. */
1944 tpoint_related_event
|= tracepoint_finished_step (tinfo
, lwp
->stop_pc
);
1946 tpoint_related_event
|= handle_tracepoint_bkpts (tinfo
, lwp
->stop_pc
);
1948 /* See if we just hit a tracepoint and do its main collect
1950 tpoint_related_event
|= tracepoint_was_hit (tinfo
, lwp
->stop_pc
);
1952 lwp_suspended_decr (lwp
);
1954 gdb_assert (lwp
->suspended
== 0);
1955 gdb_assert (!stabilizing_threads
1956 || (lwp
->collecting_fast_tracepoint
1957 != fast_tpoint_collect_result::not_collecting
));
1959 if (tpoint_related_event
)
1962 debug_printf ("got a tracepoint event\n");
1969 fast_tpoint_collect_result
1970 linux_process_target::linux_fast_tracepoint_collecting
1971 (lwp_info
*lwp
, fast_tpoint_collect_status
*status
)
1973 CORE_ADDR thread_area
;
1974 struct thread_info
*thread
= get_lwp_thread (lwp
);
1976 /* Get the thread area address. This is used to recognize which
1977 thread is which when tracing with the in-process agent library.
1978 We don't read anything from the address, and treat it as opaque;
1979 it's the address itself that we assume is unique per-thread. */
1980 if (low_get_thread_area (lwpid_of (thread
), &thread_area
) == -1)
1981 return fast_tpoint_collect_result::not_collecting
;
1983 return fast_tracepoint_collecting (thread_area
, lwp
->stop_pc
, status
);
1987 linux_process_target::low_get_thread_area (int lwpid
, CORE_ADDR
*addrp
)
1993 linux_process_target::maybe_move_out_of_jump_pad (lwp_info
*lwp
, int *wstat
)
1995 struct thread_info
*saved_thread
;
1997 saved_thread
= current_thread
;
1998 current_thread
= get_lwp_thread (lwp
);
2001 || (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) != SIGTRAP
))
2002 && supports_fast_tracepoints ()
2003 && agent_loaded_p ())
2005 struct fast_tpoint_collect_status status
;
2008 debug_printf ("Checking whether LWP %ld needs to move out of the "
2010 lwpid_of (current_thread
));
2012 fast_tpoint_collect_result r
2013 = linux_fast_tracepoint_collecting (lwp
, &status
);
2016 || (WSTOPSIG (*wstat
) != SIGILL
2017 && WSTOPSIG (*wstat
) != SIGFPE
2018 && WSTOPSIG (*wstat
) != SIGSEGV
2019 && WSTOPSIG (*wstat
) != SIGBUS
))
2021 lwp
->collecting_fast_tracepoint
= r
;
2023 if (r
!= fast_tpoint_collect_result::not_collecting
)
2025 if (r
== fast_tpoint_collect_result::before_insn
2026 && lwp
->exit_jump_pad_bkpt
== NULL
)
2028 /* Haven't executed the original instruction yet.
2029 Set breakpoint there, and wait till it's hit,
2030 then single-step until exiting the jump pad. */
2031 lwp
->exit_jump_pad_bkpt
2032 = set_breakpoint_at (status
.adjusted_insn_addr
, NULL
);
2036 debug_printf ("Checking whether LWP %ld needs to move out of "
2037 "the jump pad...it does\n",
2038 lwpid_of (current_thread
));
2039 current_thread
= saved_thread
;
2046 /* If we get a synchronous signal while collecting, *and*
2047 while executing the (relocated) original instruction,
2048 reset the PC to point at the tpoint address, before
2049 reporting to GDB. Otherwise, it's an IPA lib bug: just
2050 report the signal to GDB, and pray for the best. */
2052 lwp
->collecting_fast_tracepoint
2053 = fast_tpoint_collect_result::not_collecting
;
2055 if (r
!= fast_tpoint_collect_result::not_collecting
2056 && (status
.adjusted_insn_addr
<= lwp
->stop_pc
2057 && lwp
->stop_pc
< status
.adjusted_insn_addr_end
))
2060 struct regcache
*regcache
;
2062 /* The si_addr on a few signals references the address
2063 of the faulting instruction. Adjust that as
2065 if ((WSTOPSIG (*wstat
) == SIGILL
2066 || WSTOPSIG (*wstat
) == SIGFPE
2067 || WSTOPSIG (*wstat
) == SIGBUS
2068 || WSTOPSIG (*wstat
) == SIGSEGV
)
2069 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
2070 (PTRACE_TYPE_ARG3
) 0, &info
) == 0
2071 /* Final check just to make sure we don't clobber
2072 the siginfo of non-kernel-sent signals. */
2073 && (uintptr_t) info
.si_addr
== lwp
->stop_pc
)
2075 info
.si_addr
= (void *) (uintptr_t) status
.tpoint_addr
;
2076 ptrace (PTRACE_SETSIGINFO
, lwpid_of (current_thread
),
2077 (PTRACE_TYPE_ARG3
) 0, &info
);
2080 regcache
= get_thread_regcache (current_thread
, 1);
2081 low_set_pc (regcache
, status
.tpoint_addr
);
2082 lwp
->stop_pc
= status
.tpoint_addr
;
2084 /* Cancel any fast tracepoint lock this thread was
2086 force_unlock_trace_buffer ();
2089 if (lwp
->exit_jump_pad_bkpt
!= NULL
)
2092 debug_printf ("Cancelling fast exit-jump-pad: removing bkpt. "
2093 "stopping all threads momentarily.\n");
2095 stop_all_lwps (1, lwp
);
2097 delete_breakpoint (lwp
->exit_jump_pad_bkpt
);
2098 lwp
->exit_jump_pad_bkpt
= NULL
;
2100 unstop_all_lwps (1, lwp
);
2102 gdb_assert (lwp
->suspended
>= 0);
2108 debug_printf ("Checking whether LWP %ld needs to move out of the "
2110 lwpid_of (current_thread
));
2112 current_thread
= saved_thread
;
2116 /* Enqueue one signal in the "signals to report later when out of the
2120 enqueue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2122 struct pending_signals
*p_sig
;
2123 struct thread_info
*thread
= get_lwp_thread (lwp
);
2126 debug_printf ("Deferring signal %d for LWP %ld.\n",
2127 WSTOPSIG (*wstat
), lwpid_of (thread
));
2131 struct pending_signals
*sig
;
2133 for (sig
= lwp
->pending_signals_to_report
;
2136 debug_printf (" Already queued %d\n",
2139 debug_printf (" (no more currently queued signals)\n");
2142 /* Don't enqueue non-RT signals if they are already in the deferred
2143 queue. (SIGSTOP being the easiest signal to see ending up here
2145 if (WSTOPSIG (*wstat
) < __SIGRTMIN
)
2147 struct pending_signals
*sig
;
2149 for (sig
= lwp
->pending_signals_to_report
;
2153 if (sig
->signal
== WSTOPSIG (*wstat
))
2156 debug_printf ("Not requeuing already queued non-RT signal %d"
2165 p_sig
= XCNEW (struct pending_signals
);
2166 p_sig
->prev
= lwp
->pending_signals_to_report
;
2167 p_sig
->signal
= WSTOPSIG (*wstat
);
2169 ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2172 lwp
->pending_signals_to_report
= p_sig
;
2175 /* Dequeue one signal from the "signals to report later when out of
2176 the jump pad" list. */
2179 dequeue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2181 struct thread_info
*thread
= get_lwp_thread (lwp
);
2183 if (lwp
->pending_signals_to_report
!= NULL
)
2185 struct pending_signals
**p_sig
;
2187 p_sig
= &lwp
->pending_signals_to_report
;
2188 while ((*p_sig
)->prev
!= NULL
)
2189 p_sig
= &(*p_sig
)->prev
;
2191 *wstat
= W_STOPCODE ((*p_sig
)->signal
);
2192 if ((*p_sig
)->info
.si_signo
!= 0)
2193 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2199 debug_printf ("Reporting deferred signal %d for LWP %ld.\n",
2200 WSTOPSIG (*wstat
), lwpid_of (thread
));
2204 struct pending_signals
*sig
;
2206 for (sig
= lwp
->pending_signals_to_report
;
2209 debug_printf (" Still queued %d\n",
2212 debug_printf (" (no more queued signals)\n");
2222 linux_process_target::check_stopped_by_watchpoint (lwp_info
*child
)
2224 struct thread_info
*saved_thread
= current_thread
;
2225 current_thread
= get_lwp_thread (child
);
2227 if (low_stopped_by_watchpoint ())
2229 child
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
2230 child
->stopped_data_address
= low_stopped_data_address ();
2233 current_thread
= saved_thread
;
2235 return child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2239 linux_process_target::low_stopped_by_watchpoint ()
2245 linux_process_target::low_stopped_data_address ()
2250 /* Return the ptrace options that we want to try to enable. */
2253 linux_low_ptrace_options (int attached
)
2255 client_state
&cs
= get_client_state ();
2259 options
|= PTRACE_O_EXITKILL
;
2261 if (cs
.report_fork_events
)
2262 options
|= PTRACE_O_TRACEFORK
;
2264 if (cs
.report_vfork_events
)
2265 options
|= (PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEVFORKDONE
);
2267 if (cs
.report_exec_events
)
2268 options
|= PTRACE_O_TRACEEXEC
;
2270 options
|= PTRACE_O_TRACESYSGOOD
;
2276 linux_process_target::filter_event (int lwpid
, int wstat
)
2278 client_state
&cs
= get_client_state ();
2279 struct lwp_info
*child
;
2280 struct thread_info
*thread
;
2281 int have_stop_pc
= 0;
2283 child
= find_lwp_pid (ptid_t (lwpid
));
2285 /* Check for stop events reported by a process we didn't already
2286 know about - anything not already in our LWP list.
2288 If we're expecting to receive stopped processes after
2289 fork, vfork, and clone events, then we'll just add the
2290 new one to our list and go back to waiting for the event
2291 to be reported - the stopped process might be returned
2292 from waitpid before or after the event is.
2294 But note the case of a non-leader thread exec'ing after the
2295 leader having exited, and gone from our lists (because
2296 check_zombie_leaders deleted it). The non-leader thread
2297 changes its tid to the tgid. */
2299 if (WIFSTOPPED (wstat
) && child
== NULL
&& WSTOPSIG (wstat
) == SIGTRAP
2300 && linux_ptrace_get_extended_event (wstat
) == PTRACE_EVENT_EXEC
)
2304 /* A multi-thread exec after we had seen the leader exiting. */
2307 debug_printf ("LLW: Re-adding thread group leader LWP %d"
2308 "after exec.\n", lwpid
);
2311 child_ptid
= ptid_t (lwpid
, lwpid
, 0);
2312 child
= add_lwp (child_ptid
);
2314 current_thread
= child
->thread
;
2317 /* If we didn't find a process, one of two things presumably happened:
2318 - A process we started and then detached from has exited. Ignore it.
2319 - A process we are controlling has forked and the new child's stop
2320 was reported to us by the kernel. Save its PID. */
2321 if (child
== NULL
&& WIFSTOPPED (wstat
))
2323 add_to_pid_list (&stopped_pids
, lwpid
, wstat
);
2326 else if (child
== NULL
)
2329 thread
= get_lwp_thread (child
);
2333 child
->last_status
= wstat
;
2335 /* Check if the thread has exited. */
2336 if ((WIFEXITED (wstat
) || WIFSIGNALED (wstat
)))
2339 debug_printf ("LLFE: %d exited.\n", lwpid
);
2341 if (finish_step_over (child
))
2343 /* Unsuspend all other LWPs, and set them back running again. */
2344 unsuspend_all_lwps (child
);
2347 /* If there is at least one more LWP, then the exit signal was
2348 not the end of the debugged application and should be
2349 ignored, unless GDB wants to hear about thread exits. */
2350 if (cs
.report_thread_events
2351 || last_thread_of_process_p (pid_of (thread
)))
2353 /* Since events are serialized to GDB core, and we can't
2354 report this one right now. Leave the status pending for
2355 the next time we're able to report it. */
2356 mark_lwp_dead (child
, wstat
);
2366 gdb_assert (WIFSTOPPED (wstat
));
2368 if (WIFSTOPPED (wstat
))
2370 struct process_info
*proc
;
2372 /* Architecture-specific setup after inferior is running. */
2373 proc
= find_process_pid (pid_of (thread
));
2374 if (proc
->tdesc
== NULL
)
2378 /* This needs to happen after we have attached to the
2379 inferior and it is stopped for the first time, but
2380 before we access any inferior registers. */
2381 arch_setup_thread (thread
);
2385 /* The process is started, but GDBserver will do
2386 architecture-specific setup after the program stops at
2387 the first instruction. */
2388 child
->status_pending_p
= 1;
2389 child
->status_pending
= wstat
;
2395 if (WIFSTOPPED (wstat
) && child
->must_set_ptrace_flags
)
2397 struct process_info
*proc
= find_process_pid (pid_of (thread
));
2398 int options
= linux_low_ptrace_options (proc
->attached
);
2400 linux_enable_event_reporting (lwpid
, options
);
2401 child
->must_set_ptrace_flags
= 0;
2404 /* Always update syscall_state, even if it will be filtered later. */
2405 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SYSCALL_SIGTRAP
)
2407 child
->syscall_state
2408 = (child
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
2409 ? TARGET_WAITKIND_SYSCALL_RETURN
2410 : TARGET_WAITKIND_SYSCALL_ENTRY
);
2414 /* Almost all other ptrace-stops are known to be outside of system
2415 calls, with further exceptions in handle_extended_wait. */
2416 child
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2419 /* Be careful to not overwrite stop_pc until save_stop_reason is
2421 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGTRAP
2422 && linux_is_extended_waitstatus (wstat
))
2424 child
->stop_pc
= get_pc (child
);
2425 if (handle_extended_wait (&child
, wstat
))
2427 /* The event has been handled, so just return without
2433 if (linux_wstatus_maybe_breakpoint (wstat
))
2435 if (save_stop_reason (child
))
2440 child
->stop_pc
= get_pc (child
);
2442 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGSTOP
2443 && child
->stop_expected
)
2446 debug_printf ("Expected stop.\n");
2447 child
->stop_expected
= 0;
2449 if (thread
->last_resume_kind
== resume_stop
)
2451 /* We want to report the stop to the core. Treat the
2452 SIGSTOP as a normal event. */
2454 debug_printf ("LLW: resume_stop SIGSTOP caught for %s.\n",
2455 target_pid_to_str (ptid_of (thread
)));
2457 else if (stopping_threads
!= NOT_STOPPING_THREADS
)
2459 /* Stopping threads. We don't want this SIGSTOP to end up
2462 debug_printf ("LLW: SIGSTOP caught for %s "
2463 "while stopping threads.\n",
2464 target_pid_to_str (ptid_of (thread
)));
2469 /* This is a delayed SIGSTOP. Filter out the event. */
2471 debug_printf ("LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
2472 child
->stepping
? "step" : "continue",
2473 target_pid_to_str (ptid_of (thread
)));
2475 resume_one_lwp (child
, child
->stepping
, 0, NULL
);
2480 child
->status_pending_p
= 1;
2481 child
->status_pending
= wstat
;
2486 linux_process_target::maybe_hw_step (thread_info
*thread
)
2488 if (supports_hardware_single_step ())
2492 /* GDBserver must insert single-step breakpoint for software
2494 gdb_assert (has_single_step_breakpoints (thread
));
2500 linux_process_target::resume_stopped_resumed_lwps (thread_info
*thread
)
2502 struct lwp_info
*lp
= get_thread_lwp (thread
);
2506 && !lp
->status_pending_p
2507 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2511 if (thread
->last_resume_kind
== resume_step
)
2512 step
= maybe_hw_step (thread
);
2515 debug_printf ("RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
2516 target_pid_to_str (ptid_of (thread
)),
2517 paddress (lp
->stop_pc
),
2520 resume_one_lwp (lp
, step
, GDB_SIGNAL_0
, NULL
);
2525 linux_process_target::wait_for_event_filtered (ptid_t wait_ptid
,
2527 int *wstatp
, int options
)
2529 struct thread_info
*event_thread
;
2530 struct lwp_info
*event_child
, *requested_child
;
2531 sigset_t block_mask
, prev_mask
;
2534 /* N.B. event_thread points to the thread_info struct that contains
2535 event_child. Keep them in sync. */
2536 event_thread
= NULL
;
2538 requested_child
= NULL
;
2540 /* Check for a lwp with a pending status. */
2542 if (filter_ptid
== minus_one_ptid
|| filter_ptid
.is_pid ())
2544 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2546 return status_pending_p_callback (thread
, filter_ptid
);
2549 if (event_thread
!= NULL
)
2550 event_child
= get_thread_lwp (event_thread
);
2551 if (debug_threads
&& event_thread
)
2552 debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread
));
2554 else if (filter_ptid
!= null_ptid
)
2556 requested_child
= find_lwp_pid (filter_ptid
);
2558 if (stopping_threads
== NOT_STOPPING_THREADS
2559 && requested_child
->status_pending_p
2560 && (requested_child
->collecting_fast_tracepoint
2561 != fast_tpoint_collect_result::not_collecting
))
2563 enqueue_one_deferred_signal (requested_child
,
2564 &requested_child
->status_pending
);
2565 requested_child
->status_pending_p
= 0;
2566 requested_child
->status_pending
= 0;
2567 resume_one_lwp (requested_child
, 0, 0, NULL
);
2570 if (requested_child
->suspended
2571 && requested_child
->status_pending_p
)
2573 internal_error (__FILE__
, __LINE__
,
2574 "requesting an event out of a"
2575 " suspended child?");
2578 if (requested_child
->status_pending_p
)
2580 event_child
= requested_child
;
2581 event_thread
= get_lwp_thread (event_child
);
2585 if (event_child
!= NULL
)
2588 debug_printf ("Got an event from pending child %ld (%04x)\n",
2589 lwpid_of (event_thread
), event_child
->status_pending
);
2590 *wstatp
= event_child
->status_pending
;
2591 event_child
->status_pending_p
= 0;
2592 event_child
->status_pending
= 0;
2593 current_thread
= event_thread
;
2594 return lwpid_of (event_thread
);
2597 /* But if we don't find a pending event, we'll have to wait.
2599 We only enter this loop if no process has a pending wait status.
2600 Thus any action taken in response to a wait status inside this
2601 loop is responding as soon as we detect the status, not after any
2604 /* Make sure SIGCHLD is blocked until the sigsuspend below. Block
2605 all signals while here. */
2606 sigfillset (&block_mask
);
2607 gdb_sigmask (SIG_BLOCK
, &block_mask
, &prev_mask
);
2609 /* Always pull all events out of the kernel. We'll randomly select
2610 an event LWP out of all that have events, to prevent
2612 while (event_child
== NULL
)
2616 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
2619 - If the thread group leader exits while other threads in the
2620 thread group still exist, waitpid(TGID, ...) hangs. That
2621 waitpid won't return an exit status until the other threads
2622 in the group are reaped.
2624 - When a non-leader thread execs, that thread just vanishes
2625 without reporting an exit (so we'd hang if we waited for it
2626 explicitly in that case). The exec event is reported to
2629 ret
= my_waitpid (-1, wstatp
, options
| WNOHANG
);
2632 debug_printf ("LWFE: waitpid(-1, ...) returned %d, %s\n",
2633 ret
, errno
? safe_strerror (errno
) : "ERRNO-OK");
2639 debug_printf ("LLW: waitpid %ld received %s\n",
2640 (long) ret
, status_to_str (*wstatp
));
2643 /* Filter all events. IOW, leave all events pending. We'll
2644 randomly select an event LWP out of all that have events
2646 filter_event (ret
, *wstatp
);
2647 /* Retry until nothing comes out of waitpid. A single
2648 SIGCHLD can indicate more than one child stopped. */
2652 /* Now that we've pulled all events out of the kernel, resume
2653 LWPs that don't have an interesting event to report. */
2654 if (stopping_threads
== NOT_STOPPING_THREADS
)
2655 for_each_thread ([this] (thread_info
*thread
)
2657 resume_stopped_resumed_lwps (thread
);
2660 /* ... and find an LWP with a status to report to the core, if
2662 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2664 return status_pending_p_callback (thread
, filter_ptid
);
2667 if (event_thread
!= NULL
)
2669 event_child
= get_thread_lwp (event_thread
);
2670 *wstatp
= event_child
->status_pending
;
2671 event_child
->status_pending_p
= 0;
2672 event_child
->status_pending
= 0;
2676 /* Check for zombie thread group leaders. Those can't be reaped
2677 until all other threads in the thread group are. */
2678 check_zombie_leaders ();
2680 auto not_stopped
= [&] (thread_info
*thread
)
2682 return not_stopped_callback (thread
, wait_ptid
);
2685 /* If there are no resumed children left in the set of LWPs we
2686 want to wait for, bail. We can't just block in
2687 waitpid/sigsuspend, because lwps might have been left stopped
2688 in trace-stop state, and we'd be stuck forever waiting for
2689 their status to change (which would only happen if we resumed
2690 them). Even if WNOHANG is set, this return code is preferred
2691 over 0 (below), as it is more detailed. */
2692 if (find_thread (not_stopped
) == NULL
)
2695 debug_printf ("LLW: exit (no unwaited-for LWP)\n");
2696 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2700 /* No interesting event to report to the caller. */
2701 if ((options
& WNOHANG
))
2704 debug_printf ("WNOHANG set, no event found\n");
2706 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2710 /* Block until we get an event reported with SIGCHLD. */
2712 debug_printf ("sigsuspend'ing\n");
2714 sigsuspend (&prev_mask
);
2715 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2719 gdb_sigmask (SIG_SETMASK
, &prev_mask
, NULL
);
2721 current_thread
= event_thread
;
2723 return lwpid_of (event_thread
);
2727 linux_process_target::wait_for_event (ptid_t ptid
, int *wstatp
, int options
)
2729 return wait_for_event_filtered (ptid
, ptid
, wstatp
, options
);
2732 /* Select one LWP out of those that have events pending. */
2735 select_event_lwp (struct lwp_info
**orig_lp
)
2737 struct thread_info
*event_thread
= NULL
;
2739 /* In all-stop, give preference to the LWP that is being
2740 single-stepped. There will be at most one, and it's the LWP that
2741 the core is most interested in. If we didn't do this, then we'd
2742 have to handle pending step SIGTRAPs somehow in case the core
2743 later continues the previously-stepped thread, otherwise we'd
2744 report the pending SIGTRAP, and the core, not having stepped the
2745 thread, wouldn't understand what the trap was for, and therefore
2746 would report it to the user as a random signal. */
2749 event_thread
= find_thread ([] (thread_info
*thread
)
2751 lwp_info
*lp
= get_thread_lwp (thread
);
2753 return (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2754 && thread
->last_resume_kind
== resume_step
2755 && lp
->status_pending_p
);
2758 if (event_thread
!= NULL
)
2761 debug_printf ("SEL: Select single-step %s\n",
2762 target_pid_to_str (ptid_of (event_thread
)));
2765 if (event_thread
== NULL
)
2767 /* No single-stepping LWP. Select one at random, out of those
2768 which have had events. */
2770 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2772 lwp_info
*lp
= get_thread_lwp (thread
);
2774 /* Only resumed LWPs that have an event pending. */
2775 return (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2776 && lp
->status_pending_p
);
2780 if (event_thread
!= NULL
)
2782 struct lwp_info
*event_lp
= get_thread_lwp (event_thread
);
2784 /* Switch the event LWP. */
2785 *orig_lp
= event_lp
;
2789 /* Decrement the suspend count of all LWPs, except EXCEPT, if non
2793 unsuspend_all_lwps (struct lwp_info
*except
)
2795 for_each_thread ([&] (thread_info
*thread
)
2797 lwp_info
*lwp
= get_thread_lwp (thread
);
2800 lwp_suspended_decr (lwp
);
2804 static bool lwp_running (thread_info
*thread
);
2806 /* Stabilize threads (move out of jump pads).
2808 If a thread is midway collecting a fast tracepoint, we need to
2809 finish the collection and move it out of the jump pad before
2810 reporting the signal.
2812 This avoids recursion while collecting (when a signal arrives
2813 midway, and the signal handler itself collects), which would trash
2814 the trace buffer. In case the user set a breakpoint in a signal
2815 handler, this avoids the backtrace showing the jump pad, etc..
2816 Most importantly, there are certain things we can't do safely if
2817 threads are stopped in a jump pad (or in its callee's). For
2820 - starting a new trace run. A thread still collecting the
2821 previous run, could trash the trace buffer when resumed. The trace
2822 buffer control structures would have been reset but the thread had
2823 no way to tell. The thread could even midway memcpy'ing to the
2824 buffer, which would mean that when resumed, it would clobber the
2825 trace buffer that had been set for a new run.
2827 - we can't rewrite/reuse the jump pads for new tracepoints
2828 safely. Say you do tstart while a thread is stopped midway while
2829 collecting. When the thread is later resumed, it finishes the
2830 collection, and returns to the jump pad, to execute the original
2831 instruction that was under the tracepoint jump at the time the
2832 older run had been started. If the jump pad had been rewritten
2833 since for something else in the new run, the thread would now
2834 execute the wrong / random instructions. */
2837 linux_process_target::stabilize_threads ()
2839 thread_info
*thread_stuck
= find_thread ([this] (thread_info
*thread
)
2841 return stuck_in_jump_pad (thread
);
2844 if (thread_stuck
!= NULL
)
2847 debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n",
2848 lwpid_of (thread_stuck
));
2852 thread_info
*saved_thread
= current_thread
;
2854 stabilizing_threads
= 1;
2857 for_each_thread ([this] (thread_info
*thread
)
2859 move_out_of_jump_pad (thread
);
2862 /* Loop until all are stopped out of the jump pads. */
2863 while (find_thread (lwp_running
) != NULL
)
2865 struct target_waitstatus ourstatus
;
2866 struct lwp_info
*lwp
;
2869 /* Note that we go through the full wait even loop. While
2870 moving threads out of jump pad, we need to be able to step
2871 over internal breakpoints and such. */
2872 wait_1 (minus_one_ptid
, &ourstatus
, 0);
2874 if (ourstatus
.kind
== TARGET_WAITKIND_STOPPED
)
2876 lwp
= get_thread_lwp (current_thread
);
2879 lwp_suspended_inc (lwp
);
2881 if (ourstatus
.value
.sig
!= GDB_SIGNAL_0
2882 || current_thread
->last_resume_kind
== resume_stop
)
2884 wstat
= W_STOPCODE (gdb_signal_to_host (ourstatus
.value
.sig
));
2885 enqueue_one_deferred_signal (lwp
, &wstat
);
2890 unsuspend_all_lwps (NULL
);
2892 stabilizing_threads
= 0;
2894 current_thread
= saved_thread
;
2898 thread_stuck
= find_thread ([this] (thread_info
*thread
)
2900 return stuck_in_jump_pad (thread
);
2903 if (thread_stuck
!= NULL
)
2904 debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
2905 lwpid_of (thread_stuck
));
2909 /* Convenience function that is called when the kernel reports an
2910 event that is not passed out to GDB. */
2913 ignore_event (struct target_waitstatus
*ourstatus
)
2915 /* If we got an event, there may still be others, as a single
2916 SIGCHLD can indicate more than one child stopped. This forces
2917 another target_wait call. */
2920 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2925 linux_process_target::filter_exit_event (lwp_info
*event_child
,
2926 target_waitstatus
*ourstatus
)
2928 client_state
&cs
= get_client_state ();
2929 struct thread_info
*thread
= get_lwp_thread (event_child
);
2930 ptid_t ptid
= ptid_of (thread
);
2932 if (!last_thread_of_process_p (pid_of (thread
)))
2934 if (cs
.report_thread_events
)
2935 ourstatus
->kind
= TARGET_WAITKIND_THREAD_EXITED
;
2937 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2939 delete_lwp (event_child
);
2944 /* Returns 1 if GDB is interested in any event_child syscalls. */
2947 gdb_catching_syscalls_p (struct lwp_info
*event_child
)
2949 struct thread_info
*thread
= get_lwp_thread (event_child
);
2950 struct process_info
*proc
= get_thread_process (thread
);
2952 return !proc
->syscalls_to_catch
.empty ();
2956 linux_process_target::gdb_catch_this_syscall (lwp_info
*event_child
)
2959 struct thread_info
*thread
= get_lwp_thread (event_child
);
2960 struct process_info
*proc
= get_thread_process (thread
);
2962 if (proc
->syscalls_to_catch
.empty ())
2965 if (proc
->syscalls_to_catch
[0] == ANY_SYSCALL
)
2968 get_syscall_trapinfo (event_child
, &sysno
);
2970 for (int iter
: proc
->syscalls_to_catch
)
2978 linux_process_target::wait_1 (ptid_t ptid
, target_waitstatus
*ourstatus
,
2981 client_state
&cs
= get_client_state ();
2983 struct lwp_info
*event_child
;
2986 int step_over_finished
;
2987 int bp_explains_trap
;
2988 int maybe_internal_trap
;
2997 debug_printf ("wait_1: [%s]\n", target_pid_to_str (ptid
));
3000 /* Translate generic target options into linux options. */
3002 if (target_options
& TARGET_WNOHANG
)
3005 bp_explains_trap
= 0;
3008 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3010 auto status_pending_p_any
= [&] (thread_info
*thread
)
3012 return status_pending_p_callback (thread
, minus_one_ptid
);
3015 auto not_stopped
= [&] (thread_info
*thread
)
3017 return not_stopped_callback (thread
, minus_one_ptid
);
3020 /* Find a resumed LWP, if any. */
3021 if (find_thread (status_pending_p_any
) != NULL
)
3023 else if (find_thread (not_stopped
) != NULL
)
3028 if (step_over_bkpt
== null_ptid
)
3029 pid
= wait_for_event (ptid
, &w
, options
);
3033 debug_printf ("step_over_bkpt set [%s], doing a blocking wait\n",
3034 target_pid_to_str (step_over_bkpt
));
3035 pid
= wait_for_event (step_over_bkpt
, &w
, options
& ~WNOHANG
);
3038 if (pid
== 0 || (pid
== -1 && !any_resumed
))
3040 gdb_assert (target_options
& TARGET_WNOHANG
);
3044 debug_printf ("wait_1 ret = null_ptid, "
3045 "TARGET_WAITKIND_IGNORE\n");
3049 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3056 debug_printf ("wait_1 ret = null_ptid, "
3057 "TARGET_WAITKIND_NO_RESUMED\n");
3061 ourstatus
->kind
= TARGET_WAITKIND_NO_RESUMED
;
3065 event_child
= get_thread_lwp (current_thread
);
3067 /* wait_for_event only returns an exit status for the last
3068 child of a process. Report it. */
3069 if (WIFEXITED (w
) || WIFSIGNALED (w
))
3073 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
3074 ourstatus
->value
.integer
= WEXITSTATUS (w
);
3078 debug_printf ("wait_1 ret = %s, exited with "
3080 target_pid_to_str (ptid_of (current_thread
)),
3087 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
3088 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (w
));
3092 debug_printf ("wait_1 ret = %s, terminated with "
3094 target_pid_to_str (ptid_of (current_thread
)),
3100 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
3101 return filter_exit_event (event_child
, ourstatus
);
3103 return ptid_of (current_thread
);
3106 /* If step-over executes a breakpoint instruction, in the case of a
3107 hardware single step it means a gdb/gdbserver breakpoint had been
3108 planted on top of a permanent breakpoint, in the case of a software
3109 single step it may just mean that gdbserver hit the reinsert breakpoint.
3110 The PC has been adjusted by save_stop_reason to point at
3111 the breakpoint address.
3112 So in the case of the hardware single step advance the PC manually
3113 past the breakpoint and in the case of software single step advance only
3114 if it's not the single_step_breakpoint we are hitting.
3115 This avoids that a program would keep trapping a permanent breakpoint
3117 if (step_over_bkpt
!= null_ptid
3118 && event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3119 && (event_child
->stepping
3120 || !single_step_breakpoint_inserted_here (event_child
->stop_pc
)))
3122 int increment_pc
= 0;
3123 int breakpoint_kind
= 0;
3124 CORE_ADDR stop_pc
= event_child
->stop_pc
;
3126 breakpoint_kind
= breakpoint_kind_from_current_state (&stop_pc
);
3127 sw_breakpoint_from_kind (breakpoint_kind
, &increment_pc
);
3131 debug_printf ("step-over for %s executed software breakpoint\n",
3132 target_pid_to_str (ptid_of (current_thread
)));
3135 if (increment_pc
!= 0)
3137 struct regcache
*regcache
3138 = get_thread_regcache (current_thread
, 1);
3140 event_child
->stop_pc
+= increment_pc
;
3141 low_set_pc (regcache
, event_child
->stop_pc
);
3143 if (!low_breakpoint_at (event_child
->stop_pc
))
3144 event_child
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3148 /* If this event was not handled before, and is not a SIGTRAP, we
3149 report it. SIGILL and SIGSEGV are also treated as traps in case
3150 a breakpoint is inserted at the current PC. If this target does
3151 not support internal breakpoints at all, we also report the
3152 SIGTRAP without further processing; it's of no concern to us. */
3154 = (low_supports_breakpoints ()
3155 && (WSTOPSIG (w
) == SIGTRAP
3156 || ((WSTOPSIG (w
) == SIGILL
3157 || WSTOPSIG (w
) == SIGSEGV
)
3158 && low_breakpoint_at (event_child
->stop_pc
))));
3160 if (maybe_internal_trap
)
3162 /* Handle anything that requires bookkeeping before deciding to
3163 report the event or continue waiting. */
3165 /* First check if we can explain the SIGTRAP with an internal
3166 breakpoint, or if we should possibly report the event to GDB.
3167 Do this before anything that may remove or insert a
3169 bp_explains_trap
= breakpoint_inserted_here (event_child
->stop_pc
);
3171 /* We have a SIGTRAP, possibly a step-over dance has just
3172 finished. If so, tweak the state machine accordingly,
3173 reinsert breakpoints and delete any single-step
3175 step_over_finished
= finish_step_over (event_child
);
3177 /* Now invoke the callbacks of any internal breakpoints there. */
3178 check_breakpoints (event_child
->stop_pc
);
3180 /* Handle tracepoint data collecting. This may overflow the
3181 trace buffer, and cause a tracing stop, removing
3183 trace_event
= handle_tracepoints (event_child
);
3185 if (bp_explains_trap
)
3188 debug_printf ("Hit a gdbserver breakpoint.\n");
3193 /* We have some other signal, possibly a step-over dance was in
3194 progress, and it should be cancelled too. */
3195 step_over_finished
= finish_step_over (event_child
);
3198 /* We have all the data we need. Either report the event to GDB, or
3199 resume threads and keep waiting for more. */
3201 /* If we're collecting a fast tracepoint, finish the collection and
3202 move out of the jump pad before delivering a signal. See
3203 linux_stabilize_threads. */
3206 && WSTOPSIG (w
) != SIGTRAP
3207 && supports_fast_tracepoints ()
3208 && agent_loaded_p ())
3211 debug_printf ("Got signal %d for LWP %ld. Check if we need "
3212 "to defer or adjust it.\n",
3213 WSTOPSIG (w
), lwpid_of (current_thread
));
3215 /* Allow debugging the jump pad itself. */
3216 if (current_thread
->last_resume_kind
!= resume_step
3217 && maybe_move_out_of_jump_pad (event_child
, &w
))
3219 enqueue_one_deferred_signal (event_child
, &w
);
3222 debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
3223 WSTOPSIG (w
), lwpid_of (current_thread
));
3225 resume_one_lwp (event_child
, 0, 0, NULL
);
3229 return ignore_event (ourstatus
);
3233 if (event_child
->collecting_fast_tracepoint
3234 != fast_tpoint_collect_result::not_collecting
)
3237 debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
3238 "Check if we're already there.\n",
3239 lwpid_of (current_thread
),
3240 (int) event_child
->collecting_fast_tracepoint
);
3244 event_child
->collecting_fast_tracepoint
3245 = linux_fast_tracepoint_collecting (event_child
, NULL
);
3247 if (event_child
->collecting_fast_tracepoint
3248 != fast_tpoint_collect_result::before_insn
)
3250 /* No longer need this breakpoint. */
3251 if (event_child
->exit_jump_pad_bkpt
!= NULL
)
3254 debug_printf ("No longer need exit-jump-pad bkpt; removing it."
3255 "stopping all threads momentarily.\n");
3257 /* Other running threads could hit this breakpoint.
3258 We don't handle moribund locations like GDB does,
3259 instead we always pause all threads when removing
3260 breakpoints, so that any step-over or
3261 decr_pc_after_break adjustment is always taken
3262 care of while the breakpoint is still
3264 stop_all_lwps (1, event_child
);
3266 delete_breakpoint (event_child
->exit_jump_pad_bkpt
);
3267 event_child
->exit_jump_pad_bkpt
= NULL
;
3269 unstop_all_lwps (1, event_child
);
3271 gdb_assert (event_child
->suspended
>= 0);
3275 if (event_child
->collecting_fast_tracepoint
3276 == fast_tpoint_collect_result::not_collecting
)
3279 debug_printf ("fast tracepoint finished "
3280 "collecting successfully.\n");
3282 /* We may have a deferred signal to report. */
3283 if (dequeue_one_deferred_signal (event_child
, &w
))
3286 debug_printf ("dequeued one signal.\n");
3291 debug_printf ("no deferred signals.\n");
3293 if (stabilizing_threads
)
3295 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3296 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3300 debug_printf ("wait_1 ret = %s, stopped "
3301 "while stabilizing threads\n",
3302 target_pid_to_str (ptid_of (current_thread
)));
3306 return ptid_of (current_thread
);
3312 /* Check whether GDB would be interested in this event. */
3314 /* Check if GDB is interested in this syscall. */
3316 && WSTOPSIG (w
) == SYSCALL_SIGTRAP
3317 && !gdb_catch_this_syscall (event_child
))
3321 debug_printf ("Ignored syscall for LWP %ld.\n",
3322 lwpid_of (current_thread
));
3325 resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
3329 return ignore_event (ourstatus
);
3332 /* If GDB is not interested in this signal, don't stop other
3333 threads, and don't report it to GDB. Just resume the inferior
3334 right away. We do this for threading-related signals as well as
3335 any that GDB specifically requested we ignore. But never ignore
3336 SIGSTOP if we sent it ourselves, and do not ignore signals when
3337 stepping - they may require special handling to skip the signal
3338 handler. Also never ignore signals that could be caused by a
3341 && current_thread
->last_resume_kind
!= resume_step
3343 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
3344 (current_process ()->priv
->thread_db
!= NULL
3345 && (WSTOPSIG (w
) == __SIGRTMIN
3346 || WSTOPSIG (w
) == __SIGRTMIN
+ 1))
3349 (cs
.pass_signals
[gdb_signal_from_host (WSTOPSIG (w
))]
3350 && !(WSTOPSIG (w
) == SIGSTOP
3351 && current_thread
->last_resume_kind
== resume_stop
)
3352 && !linux_wstatus_maybe_breakpoint (w
))))
3354 siginfo_t info
, *info_p
;
3357 debug_printf ("Ignored signal %d for LWP %ld.\n",
3358 WSTOPSIG (w
), lwpid_of (current_thread
));
3360 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
3361 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
3366 if (step_over_finished
)
3368 /* We cancelled this thread's step-over above. We still
3369 need to unsuspend all other LWPs, and set them back
3370 running again while the signal handler runs. */
3371 unsuspend_all_lwps (event_child
);
3373 /* Enqueue the pending signal info so that proceed_all_lwps
3375 enqueue_pending_signal (event_child
, WSTOPSIG (w
), info_p
);
3377 proceed_all_lwps ();
3381 resume_one_lwp (event_child
, event_child
->stepping
,
3382 WSTOPSIG (w
), info_p
);
3388 return ignore_event (ourstatus
);
3391 /* Note that all addresses are always "out of the step range" when
3392 there's no range to begin with. */
3393 in_step_range
= lwp_in_step_range (event_child
);
3395 /* If GDB wanted this thread to single step, and the thread is out
3396 of the step range, we always want to report the SIGTRAP, and let
3397 GDB handle it. Watchpoints should always be reported. So should
3398 signals we can't explain. A SIGTRAP we can't explain could be a
3399 GDB breakpoint --- we may or not support Z0 breakpoints. If we
3400 do, we're be able to handle GDB breakpoints on top of internal
3401 breakpoints, by handling the internal breakpoint and still
3402 reporting the event to GDB. If we don't, we're out of luck, GDB
3403 won't see the breakpoint hit. If we see a single-step event but
3404 the thread should be continuing, don't pass the trap to gdb.
3405 That indicates that we had previously finished a single-step but
3406 left the single-step pending -- see
3407 complete_ongoing_step_over. */
3408 report_to_gdb
= (!maybe_internal_trap
3409 || (current_thread
->last_resume_kind
== resume_step
3411 || event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3413 && !bp_explains_trap
3415 && !step_over_finished
3416 && !(current_thread
->last_resume_kind
== resume_continue
3417 && event_child
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
))
3418 || (gdb_breakpoint_here (event_child
->stop_pc
)
3419 && gdb_condition_true_at_breakpoint (event_child
->stop_pc
)
3420 && gdb_no_commands_at_breakpoint (event_child
->stop_pc
))
3421 || event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
);
3423 run_breakpoint_commands (event_child
->stop_pc
);
3425 /* We found no reason GDB would want us to stop. We either hit one
3426 of our own breakpoints, or finished an internal step GDB
3427 shouldn't know about. */
3432 if (bp_explains_trap
)
3433 debug_printf ("Hit a gdbserver breakpoint.\n");
3434 if (step_over_finished
)
3435 debug_printf ("Step-over finished.\n");
3437 debug_printf ("Tracepoint event.\n");
3438 if (lwp_in_step_range (event_child
))
3439 debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).\n",
3440 paddress (event_child
->stop_pc
),
3441 paddress (event_child
->step_range_start
),
3442 paddress (event_child
->step_range_end
));
3445 /* We're not reporting this breakpoint to GDB, so apply the
3446 decr_pc_after_break adjustment to the inferior's regcache
3449 if (low_supports_breakpoints ())
3451 struct regcache
*regcache
3452 = get_thread_regcache (current_thread
, 1);
3453 low_set_pc (regcache
, event_child
->stop_pc
);
3456 if (step_over_finished
)
3458 /* If we have finished stepping over a breakpoint, we've
3459 stopped and suspended all LWPs momentarily except the
3460 stepping one. This is where we resume them all again.
3461 We're going to keep waiting, so use proceed, which
3462 handles stepping over the next breakpoint. */
3463 unsuspend_all_lwps (event_child
);
3467 /* Remove the single-step breakpoints if any. Note that
3468 there isn't single-step breakpoint if we finished stepping
3470 if (supports_software_single_step ()
3471 && has_single_step_breakpoints (current_thread
))
3473 stop_all_lwps (0, event_child
);
3474 delete_single_step_breakpoints (current_thread
);
3475 unstop_all_lwps (0, event_child
);
3480 debug_printf ("proceeding all threads.\n");
3481 proceed_all_lwps ();
3486 return ignore_event (ourstatus
);
3491 if (event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3494 = target_waitstatus_to_string (&event_child
->waitstatus
);
3496 debug_printf ("LWP %ld: extended event with waitstatus %s\n",
3497 lwpid_of (get_lwp_thread (event_child
)), str
.c_str ());
3499 if (current_thread
->last_resume_kind
== resume_step
)
3501 if (event_child
->step_range_start
== event_child
->step_range_end
)
3502 debug_printf ("GDB wanted to single-step, reporting event.\n");
3503 else if (!lwp_in_step_range (event_child
))
3504 debug_printf ("Out of step range, reporting event.\n");
3506 if (event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
3507 debug_printf ("Stopped by watchpoint.\n");
3508 else if (gdb_breakpoint_here (event_child
->stop_pc
))
3509 debug_printf ("Stopped by GDB breakpoint.\n");
3511 debug_printf ("Hit a non-gdbserver trap event.\n");
3514 /* Alright, we're going to report a stop. */
3516 /* Remove single-step breakpoints. */
3517 if (supports_software_single_step ())
3519 /* Remove single-step breakpoints or not. It it is true, stop all
3520 lwps, so that other threads won't hit the breakpoint in the
3522 int remove_single_step_breakpoints_p
= 0;
3526 remove_single_step_breakpoints_p
3527 = has_single_step_breakpoints (current_thread
);
3531 /* In all-stop, a stop reply cancels all previous resume
3532 requests. Delete all single-step breakpoints. */
3534 find_thread ([&] (thread_info
*thread
) {
3535 if (has_single_step_breakpoints (thread
))
3537 remove_single_step_breakpoints_p
= 1;
3545 if (remove_single_step_breakpoints_p
)
3547 /* If we remove single-step breakpoints from memory, stop all lwps,
3548 so that other threads won't hit the breakpoint in the staled
3550 stop_all_lwps (0, event_child
);
3554 gdb_assert (has_single_step_breakpoints (current_thread
));
3555 delete_single_step_breakpoints (current_thread
);
3559 for_each_thread ([] (thread_info
*thread
){
3560 if (has_single_step_breakpoints (thread
))
3561 delete_single_step_breakpoints (thread
);
3565 unstop_all_lwps (0, event_child
);
3569 if (!stabilizing_threads
)
3571 /* In all-stop, stop all threads. */
3573 stop_all_lwps (0, NULL
);
3575 if (step_over_finished
)
3579 /* If we were doing a step-over, all other threads but
3580 the stepping one had been paused in start_step_over,
3581 with their suspend counts incremented. We don't want
3582 to do a full unstop/unpause, because we're in
3583 all-stop mode (so we want threads stopped), but we
3584 still need to unsuspend the other threads, to
3585 decrement their `suspended' count back. */
3586 unsuspend_all_lwps (event_child
);
3590 /* If we just finished a step-over, then all threads had
3591 been momentarily paused. In all-stop, that's fine,
3592 we want threads stopped by now anyway. In non-stop,
3593 we need to re-resume threads that GDB wanted to be
3595 unstop_all_lwps (1, event_child
);
3599 /* If we're not waiting for a specific LWP, choose an event LWP
3600 from among those that have had events. Giving equal priority
3601 to all LWPs that have had events helps prevent
3603 if (ptid
== minus_one_ptid
)
3605 event_child
->status_pending_p
= 1;
3606 event_child
->status_pending
= w
;
3608 select_event_lwp (&event_child
);
3610 /* current_thread and event_child must stay in sync. */
3611 current_thread
= get_lwp_thread (event_child
);
3613 event_child
->status_pending_p
= 0;
3614 w
= event_child
->status_pending
;
3618 /* Stabilize threads (move out of jump pads). */
3620 target_stabilize_threads ();
3624 /* If we just finished a step-over, then all threads had been
3625 momentarily paused. In all-stop, that's fine, we want
3626 threads stopped by now anyway. In non-stop, we need to
3627 re-resume threads that GDB wanted to be running. */
3628 if (step_over_finished
)
3629 unstop_all_lwps (1, event_child
);
3632 if (event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3634 /* If the reported event is an exit, fork, vfork or exec, let
3637 /* Break the unreported fork relationship chain. */
3638 if (event_child
->waitstatus
.kind
== TARGET_WAITKIND_FORKED
3639 || event_child
->waitstatus
.kind
== TARGET_WAITKIND_VFORKED
)
3641 event_child
->fork_relative
->fork_relative
= NULL
;
3642 event_child
->fork_relative
= NULL
;
3645 *ourstatus
= event_child
->waitstatus
;
3646 /* Clear the event lwp's waitstatus since we handled it already. */
3647 event_child
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
3650 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3652 /* Now that we've selected our final event LWP, un-adjust its PC if
3653 it was a software breakpoint, and the client doesn't know we can
3654 adjust the breakpoint ourselves. */
3655 if (event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3656 && !cs
.swbreak_feature
)
3658 int decr_pc
= low_decr_pc_after_break ();
3662 struct regcache
*regcache
3663 = get_thread_regcache (current_thread
, 1);
3664 low_set_pc (regcache
, event_child
->stop_pc
+ decr_pc
);
3668 if (WSTOPSIG (w
) == SYSCALL_SIGTRAP
)
3670 get_syscall_trapinfo (event_child
,
3671 &ourstatus
->value
.syscall_number
);
3672 ourstatus
->kind
= event_child
->syscall_state
;
3674 else if (current_thread
->last_resume_kind
== resume_stop
3675 && WSTOPSIG (w
) == SIGSTOP
)
3677 /* A thread that has been requested to stop by GDB with vCont;t,
3678 and it stopped cleanly, so report as SIG0. The use of
3679 SIGSTOP is an implementation detail. */
3680 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3682 else if (current_thread
->last_resume_kind
== resume_stop
3683 && WSTOPSIG (w
) != SIGSTOP
)
3685 /* A thread that has been requested to stop by GDB with vCont;t,
3686 but, it stopped for other reasons. */
3687 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
3689 else if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
3691 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
3694 gdb_assert (step_over_bkpt
== null_ptid
);
3698 debug_printf ("wait_1 ret = %s, %d, %d\n",
3699 target_pid_to_str (ptid_of (current_thread
)),
3700 ourstatus
->kind
, ourstatus
->value
.sig
);
3704 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
3705 return filter_exit_event (event_child
, ourstatus
);
3707 return ptid_of (current_thread
);
3710 /* Get rid of any pending event in the pipe. */
3712 async_file_flush (void)
3718 ret
= read (linux_event_pipe
[0], &buf
, 1);
3719 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
3722 /* Put something in the pipe, so the event loop wakes up. */
3724 async_file_mark (void)
3728 async_file_flush ();
3731 ret
= write (linux_event_pipe
[1], "+", 1);
3732 while (ret
== 0 || (ret
== -1 && errno
== EINTR
));
3734 /* Ignore EAGAIN. If the pipe is full, the event loop will already
3735 be awakened anyway. */
3739 linux_process_target::wait (ptid_t ptid
,
3740 target_waitstatus
*ourstatus
,
3745 /* Flush the async file first. */
3746 if (target_is_async_p ())
3747 async_file_flush ();
3751 event_ptid
= wait_1 (ptid
, ourstatus
, target_options
);
3753 while ((target_options
& TARGET_WNOHANG
) == 0
3754 && event_ptid
== null_ptid
3755 && ourstatus
->kind
== TARGET_WAITKIND_IGNORE
);
3757 /* If at least one stop was reported, there may be more. A single
3758 SIGCHLD can signal more than one child stop. */
3759 if (target_is_async_p ()
3760 && (target_options
& TARGET_WNOHANG
) != 0
3761 && event_ptid
!= null_ptid
)
3767 /* Send a signal to an LWP. */
3770 kill_lwp (unsigned long lwpid
, int signo
)
3775 ret
= syscall (__NR_tkill
, lwpid
, signo
);
3776 if (errno
== ENOSYS
)
3778 /* If tkill fails, then we are not using nptl threads, a
3779 configuration we no longer support. */
3780 perror_with_name (("tkill"));
3786 linux_stop_lwp (struct lwp_info
*lwp
)
3792 send_sigstop (struct lwp_info
*lwp
)
3796 pid
= lwpid_of (get_lwp_thread (lwp
));
3798 /* If we already have a pending stop signal for this process, don't
3800 if (lwp
->stop_expected
)
3803 debug_printf ("Have pending sigstop for lwp %d\n", pid
);
3809 debug_printf ("Sending sigstop to lwp %d\n", pid
);
3811 lwp
->stop_expected
= 1;
3812 kill_lwp (pid
, SIGSTOP
);
3816 send_sigstop (thread_info
*thread
, lwp_info
*except
)
3818 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3820 /* Ignore EXCEPT. */
3830 /* Increment the suspend count of an LWP, and stop it, if not stopped
3833 suspend_and_send_sigstop (thread_info
*thread
, lwp_info
*except
)
3835 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3837 /* Ignore EXCEPT. */
3841 lwp_suspended_inc (lwp
);
3843 send_sigstop (thread
, except
);
3847 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
3849 /* Store the exit status for later. */
3850 lwp
->status_pending_p
= 1;
3851 lwp
->status_pending
= wstat
;
3853 /* Store in waitstatus as well, as there's nothing else to process
3855 if (WIFEXITED (wstat
))
3857 lwp
->waitstatus
.kind
= TARGET_WAITKIND_EXITED
;
3858 lwp
->waitstatus
.value
.integer
= WEXITSTATUS (wstat
);
3860 else if (WIFSIGNALED (wstat
))
3862 lwp
->waitstatus
.kind
= TARGET_WAITKIND_SIGNALLED
;
3863 lwp
->waitstatus
.value
.sig
= gdb_signal_from_host (WTERMSIG (wstat
));
3866 /* Prevent trying to stop it. */
3869 /* No further stops are expected from a dead lwp. */
3870 lwp
->stop_expected
= 0;
3873 /* Return true if LWP has exited already, and has a pending exit event
3874 to report to GDB. */
3877 lwp_is_marked_dead (struct lwp_info
*lwp
)
3879 return (lwp
->status_pending_p
3880 && (WIFEXITED (lwp
->status_pending
)
3881 || WIFSIGNALED (lwp
->status_pending
)));
3885 linux_process_target::wait_for_sigstop ()
3887 struct thread_info
*saved_thread
;
3892 saved_thread
= current_thread
;
3893 if (saved_thread
!= NULL
)
3894 saved_tid
= saved_thread
->id
;
3896 saved_tid
= null_ptid
; /* avoid bogus unused warning */
3899 debug_printf ("wait_for_sigstop: pulling events\n");
3901 /* Passing NULL_PTID as filter indicates we want all events to be
3902 left pending. Eventually this returns when there are no
3903 unwaited-for children left. */
3904 ret
= wait_for_event_filtered (minus_one_ptid
, null_ptid
, &wstat
, __WALL
);
3905 gdb_assert (ret
== -1);
3907 if (saved_thread
== NULL
|| mythread_alive (saved_tid
))
3908 current_thread
= saved_thread
;
3912 debug_printf ("Previously current thread died.\n");
3914 /* We can't change the current inferior behind GDB's back,
3915 otherwise, a subsequent command may apply to the wrong
3917 current_thread
= NULL
;
3922 linux_process_target::stuck_in_jump_pad (thread_info
*thread
)
3924 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3926 if (lwp
->suspended
!= 0)
3928 internal_error (__FILE__
, __LINE__
,
3929 "LWP %ld is suspended, suspended=%d\n",
3930 lwpid_of (thread
), lwp
->suspended
);
3932 gdb_assert (lwp
->stopped
);
3934 /* Allow debugging the jump pad, gdb_collect, etc.. */
3935 return (supports_fast_tracepoints ()
3936 && agent_loaded_p ()
3937 && (gdb_breakpoint_here (lwp
->stop_pc
)
3938 || lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3939 || thread
->last_resume_kind
== resume_step
)
3940 && (linux_fast_tracepoint_collecting (lwp
, NULL
)
3941 != fast_tpoint_collect_result::not_collecting
));
3945 linux_process_target::move_out_of_jump_pad (thread_info
*thread
)
3947 struct thread_info
*saved_thread
;
3948 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3951 if (lwp
->suspended
!= 0)
3953 internal_error (__FILE__
, __LINE__
,
3954 "LWP %ld is suspended, suspended=%d\n",
3955 lwpid_of (thread
), lwp
->suspended
);
3957 gdb_assert (lwp
->stopped
);
3959 /* For gdb_breakpoint_here. */
3960 saved_thread
= current_thread
;
3961 current_thread
= thread
;
3963 wstat
= lwp
->status_pending_p
? &lwp
->status_pending
: NULL
;
3965 /* Allow debugging the jump pad, gdb_collect, etc. */
3966 if (!gdb_breakpoint_here (lwp
->stop_pc
)
3967 && lwp
->stop_reason
!= TARGET_STOPPED_BY_WATCHPOINT
3968 && thread
->last_resume_kind
!= resume_step
3969 && maybe_move_out_of_jump_pad (lwp
, wstat
))
3972 debug_printf ("LWP %ld needs stabilizing (in jump pad)\n",
3977 lwp
->status_pending_p
= 0;
3978 enqueue_one_deferred_signal (lwp
, wstat
);
3981 debug_printf ("Signal %d for LWP %ld deferred "
3983 WSTOPSIG (*wstat
), lwpid_of (thread
));
3986 resume_one_lwp (lwp
, 0, 0, NULL
);
3989 lwp_suspended_inc (lwp
);
3991 current_thread
= saved_thread
;
3995 lwp_running (thread_info
*thread
)
3997 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3999 if (lwp_is_marked_dead (lwp
))
4002 return !lwp
->stopped
;
4006 linux_process_target::stop_all_lwps (int suspend
, lwp_info
*except
)
4008 /* Should not be called recursively. */
4009 gdb_assert (stopping_threads
== NOT_STOPPING_THREADS
);
4014 debug_printf ("stop_all_lwps (%s, except=%s)\n",
4015 suspend
? "stop-and-suspend" : "stop",
4017 ? target_pid_to_str (ptid_of (get_lwp_thread (except
)))
4021 stopping_threads
= (suspend
4022 ? STOPPING_AND_SUSPENDING_THREADS
4023 : STOPPING_THREADS
);
4026 for_each_thread ([&] (thread_info
*thread
)
4028 suspend_and_send_sigstop (thread
, except
);
4031 for_each_thread ([&] (thread_info
*thread
)
4033 send_sigstop (thread
, except
);
4036 wait_for_sigstop ();
4037 stopping_threads
= NOT_STOPPING_THREADS
;
4041 debug_printf ("stop_all_lwps done, setting stopping_threads "
4042 "back to !stopping\n");
4047 /* Enqueue one signal in the chain of signals which need to be
4048 delivered to this process on next resume. */
4051 enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
)
4053 struct pending_signals
*p_sig
= XNEW (struct pending_signals
);
4055 p_sig
->prev
= lwp
->pending_signals
;
4056 p_sig
->signal
= signal
;
4058 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
4060 memcpy (&p_sig
->info
, info
, sizeof (siginfo_t
));
4061 lwp
->pending_signals
= p_sig
;
4065 linux_process_target::install_software_single_step_breakpoints (lwp_info
*lwp
)
4067 struct thread_info
*thread
= get_lwp_thread (lwp
);
4068 struct regcache
*regcache
= get_thread_regcache (thread
, 1);
4070 scoped_restore save_current_thread
= make_scoped_restore (¤t_thread
);
4072 current_thread
= thread
;
4073 std::vector
<CORE_ADDR
> next_pcs
= low_get_next_pcs (regcache
);
4075 for (CORE_ADDR pc
: next_pcs
)
4076 set_single_step_breakpoint (pc
, current_ptid
);
4080 linux_process_target::single_step (lwp_info
* lwp
)
4084 if (supports_hardware_single_step ())
4088 else if (supports_software_single_step ())
4090 install_software_single_step_breakpoints (lwp
);
4096 debug_printf ("stepping is not implemented on this target");
4102 /* The signal can be delivered to the inferior if we are not trying to
4103 finish a fast tracepoint collect. Since signal can be delivered in
4104 the step-over, the program may go to signal handler and trap again
4105 after return from the signal handler. We can live with the spurious
4109 lwp_signal_can_be_delivered (struct lwp_info
*lwp
)
4111 return (lwp
->collecting_fast_tracepoint
4112 == fast_tpoint_collect_result::not_collecting
);
4116 linux_process_target::resume_one_lwp_throw (lwp_info
*lwp
, int step
,
4117 int signal
, siginfo_t
*info
)
4119 struct thread_info
*thread
= get_lwp_thread (lwp
);
4120 struct thread_info
*saved_thread
;
4122 struct process_info
*proc
= get_thread_process (thread
);
4124 /* Note that target description may not be initialised
4125 (proc->tdesc == NULL) at this point because the program hasn't
4126 stopped at the first instruction yet. It means GDBserver skips
4127 the extra traps from the wrapper program (see option --wrapper).
4128 Code in this function that requires register access should be
4129 guarded by proc->tdesc == NULL or something else. */
4131 if (lwp
->stopped
== 0)
4134 gdb_assert (lwp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
);
4136 fast_tpoint_collect_result fast_tp_collecting
4137 = lwp
->collecting_fast_tracepoint
;
4139 gdb_assert (!stabilizing_threads
4140 || (fast_tp_collecting
4141 != fast_tpoint_collect_result::not_collecting
));
4143 /* Cancel actions that rely on GDB not changing the PC (e.g., the
4144 user used the "jump" command, or "set $pc = foo"). */
4145 if (thread
->while_stepping
!= NULL
&& lwp
->stop_pc
!= get_pc (lwp
))
4147 /* Collecting 'while-stepping' actions doesn't make sense
4149 release_while_stepping_state_list (thread
);
4152 /* If we have pending signals or status, and a new signal, enqueue the
4153 signal. Also enqueue the signal if it can't be delivered to the
4154 inferior right now. */
4156 && (lwp
->status_pending_p
4157 || lwp
->pending_signals
!= NULL
4158 || !lwp_signal_can_be_delivered (lwp
)))
4160 enqueue_pending_signal (lwp
, signal
, info
);
4162 /* Postpone any pending signal. It was enqueued above. */
4166 if (lwp
->status_pending_p
)
4169 debug_printf ("Not resuming lwp %ld (%s, stop %s);"
4170 " has pending status\n",
4171 lwpid_of (thread
), step
? "step" : "continue",
4172 lwp
->stop_expected
? "expected" : "not expected");
4176 saved_thread
= current_thread
;
4177 current_thread
= thread
;
4179 /* This bit needs some thinking about. If we get a signal that
4180 we must report while a single-step reinsert is still pending,
4181 we often end up resuming the thread. It might be better to
4182 (ew) allow a stack of pending events; then we could be sure that
4183 the reinsert happened right away and not lose any signals.
4185 Making this stack would also shrink the window in which breakpoints are
4186 uninserted (see comment in linux_wait_for_lwp) but not enough for
4187 complete correctness, so it won't solve that problem. It may be
4188 worthwhile just to solve this one, however. */
4189 if (lwp
->bp_reinsert
!= 0)
4192 debug_printf (" pending reinsert at 0x%s\n",
4193 paddress (lwp
->bp_reinsert
));
4195 if (supports_hardware_single_step ())
4197 if (fast_tp_collecting
== fast_tpoint_collect_result::not_collecting
)
4200 warning ("BAD - reinserting but not stepping.");
4202 warning ("BAD - reinserting and suspended(%d).",
4207 step
= maybe_hw_step (thread
);
4210 if (fast_tp_collecting
== fast_tpoint_collect_result::before_insn
)
4213 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
4214 " (exit-jump-pad-bkpt)\n",
4217 else if (fast_tp_collecting
== fast_tpoint_collect_result::at_insn
)
4220 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
4221 " single-stepping\n",
4224 if (supports_hardware_single_step ())
4228 internal_error (__FILE__
, __LINE__
,
4229 "moving out of jump pad single-stepping"
4230 " not implemented on this target");
4234 /* If we have while-stepping actions in this thread set it stepping.
4235 If we have a signal to deliver, it may or may not be set to
4236 SIG_IGN, we don't know. Assume so, and allow collecting
4237 while-stepping into a signal handler. A possible smart thing to
4238 do would be to set an internal breakpoint at the signal return
4239 address, continue, and carry on catching this while-stepping
4240 action only when that breakpoint is hit. A future
4242 if (thread
->while_stepping
!= NULL
)
4245 debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n",
4248 step
= single_step (lwp
);
4251 if (proc
->tdesc
!= NULL
&& low_supports_breakpoints ())
4253 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
4255 lwp
->stop_pc
= low_get_pc (regcache
);
4259 debug_printf (" %s from pc 0x%lx\n", step
? "step" : "continue",
4260 (long) lwp
->stop_pc
);
4264 /* If we have pending signals, consume one if it can be delivered to
4266 if (lwp
->pending_signals
!= NULL
&& lwp_signal_can_be_delivered (lwp
))
4268 struct pending_signals
**p_sig
;
4270 p_sig
= &lwp
->pending_signals
;
4271 while ((*p_sig
)->prev
!= NULL
)
4272 p_sig
= &(*p_sig
)->prev
;
4274 signal
= (*p_sig
)->signal
;
4275 if ((*p_sig
)->info
.si_signo
!= 0)
4276 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
4284 debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
4285 lwpid_of (thread
), step
? "step" : "continue", signal
,
4286 lwp
->stop_expected
? "expected" : "not expected");
4288 low_prepare_to_resume (lwp
);
4290 regcache_invalidate_thread (thread
);
4292 lwp
->stepping
= step
;
4294 ptrace_request
= PTRACE_SINGLESTEP
;
4295 else if (gdb_catching_syscalls_p (lwp
))
4296 ptrace_request
= PTRACE_SYSCALL
;
4298 ptrace_request
= PTRACE_CONT
;
4299 ptrace (ptrace_request
,
4301 (PTRACE_TYPE_ARG3
) 0,
4302 /* Coerce to a uintptr_t first to avoid potential gcc warning
4303 of coercing an 8 byte integer to a 4 byte pointer. */
4304 (PTRACE_TYPE_ARG4
) (uintptr_t) signal
);
4306 current_thread
= saved_thread
;
4308 perror_with_name ("resuming thread");
4310 /* Successfully resumed. Clear state that no longer makes sense,
4311 and mark the LWP as running. Must not do this before resuming
4312 otherwise if that fails other code will be confused. E.g., we'd
4313 later try to stop the LWP and hang forever waiting for a stop
4314 status. Note that we must not throw after this is cleared,
4315 otherwise handle_zombie_lwp_error would get confused. */
4317 lwp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4321 linux_process_target::low_prepare_to_resume (lwp_info
*lwp
)
4326 /* Called when we try to resume a stopped LWP and that errors out. If
4327 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
4328 or about to become), discard the error, clear any pending status
4329 the LWP may have, and return true (we'll collect the exit status
4330 soon enough). Otherwise, return false. */
4333 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
4335 struct thread_info
*thread
= get_lwp_thread (lp
);
4337 /* If we get an error after resuming the LWP successfully, we'd
4338 confuse !T state for the LWP being gone. */
4339 gdb_assert (lp
->stopped
);
4341 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
4342 because even if ptrace failed with ESRCH, the tracee may be "not
4343 yet fully dead", but already refusing ptrace requests. In that
4344 case the tracee has 'R (Running)' state for a little bit
4345 (observed in Linux 3.18). See also the note on ESRCH in the
4346 ptrace(2) man page. Instead, check whether the LWP has any state
4347 other than ptrace-stopped. */
4349 /* Don't assume anything if /proc/PID/status can't be read. */
4350 if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread
)) == 0)
4352 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4353 lp
->status_pending_p
= 0;
4360 linux_process_target::resume_one_lwp (lwp_info
*lwp
, int step
, int signal
,
4365 resume_one_lwp_throw (lwp
, step
, signal
, info
);
4367 catch (const gdb_exception_error
&ex
)
4369 if (!check_ptrace_stopped_lwp_gone (lwp
))
4374 /* This function is called once per thread via for_each_thread.
4375 We look up which resume request applies to THREAD and mark it with a
4376 pointer to the appropriate resume request.
4378 This algorithm is O(threads * resume elements), but resume elements
4379 is small (and will remain small at least until GDB supports thread
4383 linux_set_resume_request (thread_info
*thread
, thread_resume
*resume
, size_t n
)
4385 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4387 for (int ndx
= 0; ndx
< n
; ndx
++)
4389 ptid_t ptid
= resume
[ndx
].thread
;
4390 if (ptid
== minus_one_ptid
4391 || ptid
== thread
->id
4392 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
4394 || (ptid
.pid () == pid_of (thread
)
4396 || ptid
.lwp () == -1)))
4398 if (resume
[ndx
].kind
== resume_stop
4399 && thread
->last_resume_kind
== resume_stop
)
4402 debug_printf ("already %s LWP %ld at GDB's request\n",
4403 (thread
->last_status
.kind
4404 == TARGET_WAITKIND_STOPPED
)
4412 /* Ignore (wildcard) resume requests for already-resumed
4414 if (resume
[ndx
].kind
!= resume_stop
4415 && thread
->last_resume_kind
!= resume_stop
)
4418 debug_printf ("already %s LWP %ld at GDB's request\n",
4419 (thread
->last_resume_kind
4427 /* Don't let wildcard resumes resume fork children that GDB
4428 does not yet know are new fork children. */
4429 if (lwp
->fork_relative
!= NULL
)
4431 struct lwp_info
*rel
= lwp
->fork_relative
;
4433 if (rel
->status_pending_p
4434 && (rel
->waitstatus
.kind
== TARGET_WAITKIND_FORKED
4435 || rel
->waitstatus
.kind
== TARGET_WAITKIND_VFORKED
))
4438 debug_printf ("not resuming LWP %ld: has queued stop reply\n",
4444 /* If the thread has a pending event that has already been
4445 reported to GDBserver core, but GDB has not pulled the
4446 event out of the vStopped queue yet, likewise, ignore the
4447 (wildcard) resume request. */
4448 if (in_queued_stop_replies (thread
->id
))
4451 debug_printf ("not resuming LWP %ld: has queued stop reply\n",
4456 lwp
->resume
= &resume
[ndx
];
4457 thread
->last_resume_kind
= lwp
->resume
->kind
;
4459 lwp
->step_range_start
= lwp
->resume
->step_range_start
;
4460 lwp
->step_range_end
= lwp
->resume
->step_range_end
;
4462 /* If we had a deferred signal to report, dequeue one now.
4463 This can happen if LWP gets more than one signal while
4464 trying to get out of a jump pad. */
4466 && !lwp
->status_pending_p
4467 && dequeue_one_deferred_signal (lwp
, &lwp
->status_pending
))
4469 lwp
->status_pending_p
= 1;
4472 debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
4473 "leaving status pending.\n",
4474 WSTOPSIG (lwp
->status_pending
),
4482 /* No resume action for this thread. */
4487 linux_process_target::resume_status_pending (thread_info
*thread
)
4489 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4491 /* LWPs which will not be resumed are not interesting, because
4492 we might not wait for them next time through linux_wait. */
4493 if (lwp
->resume
== NULL
)
4496 return thread_still_has_status_pending (thread
);
4500 linux_process_target::thread_needs_step_over (thread_info
*thread
)
4502 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4503 struct thread_info
*saved_thread
;
4505 struct process_info
*proc
= get_thread_process (thread
);
4507 /* GDBserver is skipping the extra traps from the wrapper program,
4508 don't have to do step over. */
4509 if (proc
->tdesc
== NULL
)
4512 /* LWPs which will not be resumed are not interesting, because we
4513 might not wait for them next time through linux_wait. */
4518 debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n",
4523 if (thread
->last_resume_kind
== resume_stop
)
4526 debug_printf ("Need step over [LWP %ld]? Ignoring, should remain"
4532 gdb_assert (lwp
->suspended
>= 0);
4537 debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n",
4542 if (lwp
->status_pending_p
)
4545 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4551 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
4555 /* If the PC has changed since we stopped, then don't do anything,
4556 and let the breakpoint/tracepoint be hit. This happens if, for
4557 instance, GDB handled the decr_pc_after_break subtraction itself,
4558 GDB is OOL stepping this thread, or the user has issued a "jump"
4559 command, or poked thread's registers herself. */
4560 if (pc
!= lwp
->stop_pc
)
4563 debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. "
4564 "Old stop_pc was 0x%s, PC is now 0x%s\n",
4566 paddress (lwp
->stop_pc
), paddress (pc
));
4570 /* On software single step target, resume the inferior with signal
4571 rather than stepping over. */
4572 if (supports_software_single_step ()
4573 && lwp
->pending_signals
!= NULL
4574 && lwp_signal_can_be_delivered (lwp
))
4577 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4584 saved_thread
= current_thread
;
4585 current_thread
= thread
;
4587 /* We can only step over breakpoints we know about. */
4588 if (breakpoint_here (pc
) || fast_tracepoint_jump_here (pc
))
4590 /* Don't step over a breakpoint that GDB expects to hit
4591 though. If the condition is being evaluated on the target's side
4592 and it evaluate to false, step over this breakpoint as well. */
4593 if (gdb_breakpoint_here (pc
)
4594 && gdb_condition_true_at_breakpoint (pc
)
4595 && gdb_no_commands_at_breakpoint (pc
))
4598 debug_printf ("Need step over [LWP %ld]? yes, but found"
4599 " GDB breakpoint at 0x%s; skipping step over\n",
4600 lwpid_of (thread
), paddress (pc
));
4602 current_thread
= saved_thread
;
4608 debug_printf ("Need step over [LWP %ld]? yes, "
4609 "found breakpoint at 0x%s\n",
4610 lwpid_of (thread
), paddress (pc
));
4612 /* We've found an lwp that needs stepping over --- return 1 so
4613 that find_thread stops looking. */
4614 current_thread
= saved_thread
;
4620 current_thread
= saved_thread
;
4623 debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
4625 lwpid_of (thread
), paddress (pc
));
4631 linux_process_target::start_step_over (lwp_info
*lwp
)
4633 struct thread_info
*thread
= get_lwp_thread (lwp
);
4634 struct thread_info
*saved_thread
;
4639 debug_printf ("Starting step-over on LWP %ld. Stopping all threads\n",
4642 stop_all_lwps (1, lwp
);
4644 if (lwp
->suspended
!= 0)
4646 internal_error (__FILE__
, __LINE__
,
4647 "LWP %ld suspended=%d\n", lwpid_of (thread
),
4652 debug_printf ("Done stopping all threads for step-over.\n");
4654 /* Note, we should always reach here with an already adjusted PC,
4655 either by GDB (if we're resuming due to GDB's request), or by our
4656 caller, if we just finished handling an internal breakpoint GDB
4657 shouldn't care about. */
4660 saved_thread
= current_thread
;
4661 current_thread
= thread
;
4663 lwp
->bp_reinsert
= pc
;
4664 uninsert_breakpoints_at (pc
);
4665 uninsert_fast_tracepoint_jumps_at (pc
);
4667 step
= single_step (lwp
);
4669 current_thread
= saved_thread
;
4671 resume_one_lwp (lwp
, step
, 0, NULL
);
4673 /* Require next event from this LWP. */
4674 step_over_bkpt
= thread
->id
;
4678 linux_process_target::finish_step_over (lwp_info
*lwp
)
4680 if (lwp
->bp_reinsert
!= 0)
4682 struct thread_info
*saved_thread
= current_thread
;
4685 debug_printf ("Finished step over.\n");
4687 current_thread
= get_lwp_thread (lwp
);
4689 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
4690 may be no breakpoint to reinsert there by now. */
4691 reinsert_breakpoints_at (lwp
->bp_reinsert
);
4692 reinsert_fast_tracepoint_jumps_at (lwp
->bp_reinsert
);
4694 lwp
->bp_reinsert
= 0;
4696 /* Delete any single-step breakpoints. No longer needed. We
4697 don't have to worry about other threads hitting this trap,
4698 and later not being able to explain it, because we were
4699 stepping over a breakpoint, and we hold all threads but
4700 LWP stopped while doing that. */
4701 if (!supports_hardware_single_step ())
4703 gdb_assert (has_single_step_breakpoints (current_thread
));
4704 delete_single_step_breakpoints (current_thread
);
4707 step_over_bkpt
= null_ptid
;
4708 current_thread
= saved_thread
;
4716 linux_process_target::complete_ongoing_step_over ()
4718 if (step_over_bkpt
!= null_ptid
)
4720 struct lwp_info
*lwp
;
4725 debug_printf ("detach: step over in progress, finish it first\n");
4727 /* Passing NULL_PTID as filter indicates we want all events to
4728 be left pending. Eventually this returns when there are no
4729 unwaited-for children left. */
4730 ret
= wait_for_event_filtered (minus_one_ptid
, null_ptid
, &wstat
,
4732 gdb_assert (ret
== -1);
4734 lwp
= find_lwp_pid (step_over_bkpt
);
4736 finish_step_over (lwp
);
4737 step_over_bkpt
= null_ptid
;
4738 unsuspend_all_lwps (lwp
);
4743 linux_process_target::resume_one_thread (thread_info
*thread
,
4744 bool leave_all_stopped
)
4746 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4749 if (lwp
->resume
== NULL
)
4752 if (lwp
->resume
->kind
== resume_stop
)
4755 debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread
));
4760 debug_printf ("stopping LWP %ld\n", lwpid_of (thread
));
4762 /* Stop the thread, and wait for the event asynchronously,
4763 through the event loop. */
4769 debug_printf ("already stopped LWP %ld\n",
4772 /* The LWP may have been stopped in an internal event that
4773 was not meant to be notified back to GDB (e.g., gdbserver
4774 breakpoint), so we should be reporting a stop event in
4777 /* If the thread already has a pending SIGSTOP, this is a
4778 no-op. Otherwise, something later will presumably resume
4779 the thread and this will cause it to cancel any pending
4780 operation, due to last_resume_kind == resume_stop. If
4781 the thread already has a pending status to report, we
4782 will still report it the next time we wait - see
4783 status_pending_p_callback. */
4785 /* If we already have a pending signal to report, then
4786 there's no need to queue a SIGSTOP, as this means we're
4787 midway through moving the LWP out of the jumppad, and we
4788 will report the pending signal as soon as that is
4790 if (lwp
->pending_signals_to_report
== NULL
)
4794 /* For stop requests, we're done. */
4796 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
4800 /* If this thread which is about to be resumed has a pending status,
4801 then don't resume it - we can just report the pending status.
4802 Likewise if it is suspended, because e.g., another thread is
4803 stepping past a breakpoint. Make sure to queue any signals that
4804 would otherwise be sent. In all-stop mode, we do this decision
4805 based on if *any* thread has a pending status. If there's a
4806 thread that needs the step-over-breakpoint dance, then don't
4807 resume any other thread but that particular one. */
4808 leave_pending
= (lwp
->suspended
4809 || lwp
->status_pending_p
4810 || leave_all_stopped
);
4812 /* If we have a new signal, enqueue the signal. */
4813 if (lwp
->resume
->sig
!= 0)
4815 siginfo_t info
, *info_p
;
4817 /* If this is the same signal we were previously stopped by,
4818 make sure to queue its siginfo. */
4819 if (WIFSTOPPED (lwp
->last_status
)
4820 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
4821 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
),
4822 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
4827 enqueue_pending_signal (lwp
, lwp
->resume
->sig
, info_p
);
4833 debug_printf ("resuming LWP %ld\n", lwpid_of (thread
));
4835 proceed_one_lwp (thread
, NULL
);
4840 debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread
));
4843 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
4848 linux_process_target::resume (thread_resume
*resume_info
, size_t n
)
4850 struct thread_info
*need_step_over
= NULL
;
4855 debug_printf ("linux_resume:\n");
4858 for_each_thread ([&] (thread_info
*thread
)
4860 linux_set_resume_request (thread
, resume_info
, n
);
4863 /* If there is a thread which would otherwise be resumed, which has
4864 a pending status, then don't resume any threads - we can just
4865 report the pending status. Make sure to queue any signals that
4866 would otherwise be sent. In non-stop mode, we'll apply this
4867 logic to each thread individually. We consume all pending events
4868 before considering to start a step-over (in all-stop). */
4869 bool any_pending
= false;
4871 any_pending
= find_thread ([this] (thread_info
*thread
)
4873 return resume_status_pending (thread
);
4876 /* If there is a thread which would otherwise be resumed, which is
4877 stopped at a breakpoint that needs stepping over, then don't
4878 resume any threads - have it step over the breakpoint with all
4879 other threads stopped, then resume all threads again. Make sure
4880 to queue any signals that would otherwise be delivered or
4882 if (!any_pending
&& low_supports_breakpoints ())
4883 need_step_over
= find_thread ([this] (thread_info
*thread
)
4885 return thread_needs_step_over (thread
);
4888 bool leave_all_stopped
= (need_step_over
!= NULL
|| any_pending
);
4892 if (need_step_over
!= NULL
)
4893 debug_printf ("Not resuming all, need step over\n");
4894 else if (any_pending
)
4895 debug_printf ("Not resuming, all-stop and found "
4896 "an LWP with pending status\n");
4898 debug_printf ("Resuming, no pending status or step over needed\n");
4901 /* Even if we're leaving threads stopped, queue all signals we'd
4902 otherwise deliver. */
4903 for_each_thread ([&] (thread_info
*thread
)
4905 resume_one_thread (thread
, leave_all_stopped
);
4909 start_step_over (get_thread_lwp (need_step_over
));
4913 debug_printf ("linux_resume done\n");
4917 /* We may have events that were pending that can/should be sent to
4918 the client now. Trigger a linux_wait call. */
4919 if (target_is_async_p ())
4924 linux_process_target::proceed_one_lwp (thread_info
*thread
, lwp_info
*except
)
4926 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4933 debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread
));
4938 debug_printf (" LWP %ld already running\n", lwpid_of (thread
));
4942 if (thread
->last_resume_kind
== resume_stop
4943 && thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4946 debug_printf (" client wants LWP to remain %ld stopped\n",
4951 if (lwp
->status_pending_p
)
4954 debug_printf (" LWP %ld has pending status, leaving stopped\n",
4959 gdb_assert (lwp
->suspended
>= 0);
4964 debug_printf (" LWP %ld is suspended\n", lwpid_of (thread
));
4968 if (thread
->last_resume_kind
== resume_stop
4969 && lwp
->pending_signals_to_report
== NULL
4970 && (lwp
->collecting_fast_tracepoint
4971 == fast_tpoint_collect_result::not_collecting
))
4973 /* We haven't reported this LWP as stopped yet (otherwise, the
4974 last_status.kind check above would catch it, and we wouldn't
4975 reach here. This LWP may have been momentarily paused by a
4976 stop_all_lwps call while handling for example, another LWP's
4977 step-over. In that case, the pending expected SIGSTOP signal
4978 that was queued at vCont;t handling time will have already
4979 been consumed by wait_for_sigstop, and so we need to requeue
4980 another one here. Note that if the LWP already has a SIGSTOP
4981 pending, this is a no-op. */
4984 debug_printf ("Client wants LWP %ld to stop. "
4985 "Making sure it has a SIGSTOP pending\n",
4991 if (thread
->last_resume_kind
== resume_step
)
4994 debug_printf (" stepping LWP %ld, client wants it stepping\n",
4997 /* If resume_step is requested by GDB, install single-step
4998 breakpoints when the thread is about to be actually resumed if
4999 the single-step breakpoints weren't removed. */
5000 if (supports_software_single_step ()
5001 && !has_single_step_breakpoints (thread
))
5002 install_software_single_step_breakpoints (lwp
);
5004 step
= maybe_hw_step (thread
);
5006 else if (lwp
->bp_reinsert
!= 0)
5009 debug_printf (" stepping LWP %ld, reinsert set\n",
5012 step
= maybe_hw_step (thread
);
5017 resume_one_lwp (lwp
, step
, 0, NULL
);
5021 linux_process_target::unsuspend_and_proceed_one_lwp (thread_info
*thread
,
5024 struct lwp_info
*lwp
= get_thread_lwp (thread
);
5029 lwp_suspended_decr (lwp
);
5031 proceed_one_lwp (thread
, except
);
5035 linux_process_target::proceed_all_lwps ()
5037 struct thread_info
*need_step_over
;
5039 /* If there is a thread which would otherwise be resumed, which is
5040 stopped at a breakpoint that needs stepping over, then don't
5041 resume any threads - have it step over the breakpoint with all
5042 other threads stopped, then resume all threads again. */
5044 if (low_supports_breakpoints ())
5046 need_step_over
= find_thread ([this] (thread_info
*thread
)
5048 return thread_needs_step_over (thread
);
5051 if (need_step_over
!= NULL
)
5054 debug_printf ("proceed_all_lwps: found "
5055 "thread %ld needing a step-over\n",
5056 lwpid_of (need_step_over
));
5058 start_step_over (get_thread_lwp (need_step_over
));
5064 debug_printf ("Proceeding, no step-over needed\n");
5066 for_each_thread ([this] (thread_info
*thread
)
5068 proceed_one_lwp (thread
, NULL
);
5073 linux_process_target::unstop_all_lwps (int unsuspend
, lwp_info
*except
)
5079 debug_printf ("unstopping all lwps, except=(LWP %ld)\n",
5080 lwpid_of (get_lwp_thread (except
)));
5082 debug_printf ("unstopping all lwps\n");
5086 for_each_thread ([&] (thread_info
*thread
)
5088 unsuspend_and_proceed_one_lwp (thread
, except
);
5091 for_each_thread ([&] (thread_info
*thread
)
5093 proceed_one_lwp (thread
, except
);
5098 debug_printf ("unstop_all_lwps done\n");
5104 #ifdef HAVE_LINUX_REGSETS
5106 #define use_linux_regsets 1
5108 /* Returns true if REGSET has been disabled. */
5111 regset_disabled (struct regsets_info
*info
, struct regset_info
*regset
)
5113 return (info
->disabled_regsets
!= NULL
5114 && info
->disabled_regsets
[regset
- info
->regsets
]);
5117 /* Disable REGSET. */
5120 disable_regset (struct regsets_info
*info
, struct regset_info
*regset
)
5124 dr_offset
= regset
- info
->regsets
;
5125 if (info
->disabled_regsets
== NULL
)
5126 info
->disabled_regsets
= (char *) xcalloc (1, info
->num_regsets
);
5127 info
->disabled_regsets
[dr_offset
] = 1;
5131 regsets_fetch_inferior_registers (struct regsets_info
*regsets_info
,
5132 struct regcache
*regcache
)
5134 struct regset_info
*regset
;
5135 int saw_general_regs
= 0;
5139 pid
= lwpid_of (current_thread
);
5140 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
5145 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
))
5148 buf
= xmalloc (regset
->size
);
5150 nt_type
= regset
->nt_type
;
5154 iov
.iov_len
= regset
->size
;
5155 data
= (void *) &iov
;
5161 res
= ptrace (regset
->get_request
, pid
,
5162 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5164 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
5169 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5171 /* If we get EIO on a regset, or an EINVAL and the regset is
5172 optional, do not try it again for this process mode. */
5173 disable_regset (regsets_info
, regset
);
5175 else if (errno
== ENODATA
)
5177 /* ENODATA may be returned if the regset is currently
5178 not "active". This can happen in normal operation,
5179 so suppress the warning in this case. */
5181 else if (errno
== ESRCH
)
5183 /* At this point, ESRCH should mean the process is
5184 already gone, in which case we simply ignore attempts
5185 to read its registers. */
5190 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
5197 if (regset
->type
== GENERAL_REGS
)
5198 saw_general_regs
= 1;
5199 regset
->store_function (regcache
, buf
);
5203 if (saw_general_regs
)
5210 regsets_store_inferior_registers (struct regsets_info
*regsets_info
,
5211 struct regcache
*regcache
)
5213 struct regset_info
*regset
;
5214 int saw_general_regs
= 0;
5218 pid
= lwpid_of (current_thread
);
5219 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
5224 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
)
5225 || regset
->fill_function
== NULL
)
5228 buf
= xmalloc (regset
->size
);
5230 /* First fill the buffer with the current register set contents,
5231 in case there are any items in the kernel's regset that are
5232 not in gdbserver's regcache. */
5234 nt_type
= regset
->nt_type
;
5238 iov
.iov_len
= regset
->size
;
5239 data
= (void *) &iov
;
5245 res
= ptrace (regset
->get_request
, pid
,
5246 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5248 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
5253 /* Then overlay our cached registers on that. */
5254 regset
->fill_function (regcache
, buf
);
5256 /* Only now do we write the register set. */
5258 res
= ptrace (regset
->set_request
, pid
,
5259 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5261 res
= ptrace (regset
->set_request
, pid
, data
, nt_type
);
5268 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5270 /* If we get EIO on a regset, or an EINVAL and the regset is
5271 optional, do not try it again for this process mode. */
5272 disable_regset (regsets_info
, regset
);
5274 else if (errno
== ESRCH
)
5276 /* At this point, ESRCH should mean the process is
5277 already gone, in which case we simply ignore attempts
5278 to change its registers. See also the related
5279 comment in resume_one_lwp. */
5285 perror ("Warning: ptrace(regsets_store_inferior_registers)");
5288 else if (regset
->type
== GENERAL_REGS
)
5289 saw_general_regs
= 1;
5292 if (saw_general_regs
)
5298 #else /* !HAVE_LINUX_REGSETS */
5300 #define use_linux_regsets 0
5301 #define regsets_fetch_inferior_registers(regsets_info, regcache) 1
5302 #define regsets_store_inferior_registers(regsets_info, regcache) 1
5306 /* Return 1 if register REGNO is supported by one of the regset ptrace
5307 calls or 0 if it has to be transferred individually. */
5310 linux_register_in_regsets (const struct regs_info
*regs_info
, int regno
)
5312 unsigned char mask
= 1 << (regno
% 8);
5313 size_t index
= regno
/ 8;
5315 return (use_linux_regsets
5316 && (regs_info
->regset_bitmap
== NULL
5317 || (regs_info
->regset_bitmap
[index
] & mask
) != 0));
5320 #ifdef HAVE_LINUX_USRREGS
5323 register_addr (const struct usrregs_info
*usrregs
, int regnum
)
5327 if (regnum
< 0 || regnum
>= usrregs
->num_regs
)
5328 error ("Invalid register number %d.", regnum
);
5330 addr
= usrregs
->regmap
[regnum
];
5337 linux_process_target::fetch_register (const usrregs_info
*usrregs
,
5338 regcache
*regcache
, int regno
)
5345 if (regno
>= usrregs
->num_regs
)
5347 if (low_cannot_fetch_register (regno
))
5350 regaddr
= register_addr (usrregs
, regno
);
5354 size
= ((register_size (regcache
->tdesc
, regno
)
5355 + sizeof (PTRACE_XFER_TYPE
) - 1)
5356 & -sizeof (PTRACE_XFER_TYPE
));
5357 buf
= (char *) alloca (size
);
5359 pid
= lwpid_of (current_thread
);
5360 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5363 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
5364 ptrace (PTRACE_PEEKUSER
, pid
,
5365 /* Coerce to a uintptr_t first to avoid potential gcc warning
5366 of coercing an 8 byte integer to a 4 byte pointer. */
5367 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
, (PTRACE_TYPE_ARG4
) 0);
5368 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5371 /* Mark register REGNO unavailable. */
5372 supply_register (regcache
, regno
, NULL
);
5377 low_supply_ptrace_register (regcache
, regno
, buf
);
5381 linux_process_target::store_register (const usrregs_info
*usrregs
,
5382 regcache
*regcache
, int regno
)
5389 if (regno
>= usrregs
->num_regs
)
5391 if (low_cannot_store_register (regno
))
5394 regaddr
= register_addr (usrregs
, regno
);
5398 size
= ((register_size (regcache
->tdesc
, regno
)
5399 + sizeof (PTRACE_XFER_TYPE
) - 1)
5400 & -sizeof (PTRACE_XFER_TYPE
));
5401 buf
= (char *) alloca (size
);
5402 memset (buf
, 0, size
);
5404 low_collect_ptrace_register (regcache
, regno
, buf
);
5406 pid
= lwpid_of (current_thread
);
5407 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5410 ptrace (PTRACE_POKEUSER
, pid
,
5411 /* Coerce to a uintptr_t first to avoid potential gcc warning
5412 about coercing an 8 byte integer to a 4 byte pointer. */
5413 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
,
5414 (PTRACE_TYPE_ARG4
) *(PTRACE_XFER_TYPE
*) (buf
+ i
));
5417 /* At this point, ESRCH should mean the process is
5418 already gone, in which case we simply ignore attempts
5419 to change its registers. See also the related
5420 comment in resume_one_lwp. */
5425 if (!low_cannot_store_register (regno
))
5426 error ("writing register %d: %s", regno
, safe_strerror (errno
));
5428 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5431 #endif /* HAVE_LINUX_USRREGS */
5434 linux_process_target::low_collect_ptrace_register (regcache
*regcache
,
5435 int regno
, char *buf
)
5437 collect_register (regcache
, regno
, buf
);
5441 linux_process_target::low_supply_ptrace_register (regcache
*regcache
,
5442 int regno
, const char *buf
)
5444 supply_register (regcache
, regno
, buf
);
5448 linux_process_target::usr_fetch_inferior_registers (const regs_info
*regs_info
,
5452 #ifdef HAVE_LINUX_USRREGS
5453 struct usrregs_info
*usr
= regs_info
->usrregs
;
5457 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5458 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5459 fetch_register (usr
, regcache
, regno
);
5462 fetch_register (usr
, regcache
, regno
);
5467 linux_process_target::usr_store_inferior_registers (const regs_info
*regs_info
,
5471 #ifdef HAVE_LINUX_USRREGS
5472 struct usrregs_info
*usr
= regs_info
->usrregs
;
5476 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5477 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5478 store_register (usr
, regcache
, regno
);
5481 store_register (usr
, regcache
, regno
);
5486 linux_process_target::fetch_registers (regcache
*regcache
, int regno
)
5490 const regs_info
*regs_info
= get_regs_info ();
5494 if (regs_info
->usrregs
!= NULL
)
5495 for (regno
= 0; regno
< regs_info
->usrregs
->num_regs
; regno
++)
5496 low_fetch_register (regcache
, regno
);
5498 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
, regcache
);
5499 if (regs_info
->usrregs
!= NULL
)
5500 usr_fetch_inferior_registers (regs_info
, regcache
, -1, all
);
5504 if (low_fetch_register (regcache
, regno
))
5507 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5509 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
,
5511 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5512 usr_fetch_inferior_registers (regs_info
, regcache
, regno
, 1);
5517 linux_process_target::store_registers (regcache
*regcache
, int regno
)
5521 const regs_info
*regs_info
= get_regs_info ();
5525 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5527 if (regs_info
->usrregs
!= NULL
)
5528 usr_store_inferior_registers (regs_info
, regcache
, regno
, all
);
5532 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5534 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5536 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5537 usr_store_inferior_registers (regs_info
, regcache
, regno
, 1);
5542 linux_process_target::low_fetch_register (regcache
*regcache
, int regno
)
5547 /* A wrapper for the read_memory target op. */
5550 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
5552 return the_target
->read_memory (memaddr
, myaddr
, len
);
5555 /* Copy LEN bytes from inferior's memory starting at MEMADDR
5556 to debugger memory starting at MYADDR. */
5559 linux_process_target::read_memory (CORE_ADDR memaddr
,
5560 unsigned char *myaddr
, int len
)
5562 int pid
= lwpid_of (current_thread
);
5563 PTRACE_XFER_TYPE
*buffer
;
5571 /* Try using /proc. Don't bother for one word. */
5572 if (len
>= 3 * sizeof (long))
5576 /* We could keep this file open and cache it - possibly one per
5577 thread. That requires some juggling, but is even faster. */
5578 sprintf (filename
, "/proc/%d/mem", pid
);
5579 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
5583 /* If pread64 is available, use it. It's faster if the kernel
5584 supports it (only one syscall), and it's 64-bit safe even on
5585 32-bit platforms (for instance, SPARC debugging a SPARC64
5588 bytes
= pread64 (fd
, myaddr
, len
, memaddr
);
5591 if (lseek (fd
, memaddr
, SEEK_SET
) != -1)
5592 bytes
= read (fd
, myaddr
, len
);
5599 /* Some data was read, we'll try to get the rest with ptrace. */
5609 /* Round starting address down to longword boundary. */
5610 addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
5611 /* Round ending address up; get number of longwords that makes. */
5612 count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
5613 / sizeof (PTRACE_XFER_TYPE
));
5614 /* Allocate buffer of that many longwords. */
5615 buffer
= XALLOCAVEC (PTRACE_XFER_TYPE
, count
);
5617 /* Read all the longwords */
5619 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
5621 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5622 about coercing an 8 byte integer to a 4 byte pointer. */
5623 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, pid
,
5624 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5625 (PTRACE_TYPE_ARG4
) 0);
5631 /* Copy appropriate bytes out of the buffer. */
5634 i
*= sizeof (PTRACE_XFER_TYPE
);
5635 i
-= memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1);
5637 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
5644 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
5645 memory at MEMADDR. On failure (cannot write to the inferior)
5646 returns the value of errno. Always succeeds if LEN is zero. */
5649 linux_process_target::write_memory (CORE_ADDR memaddr
,
5650 const unsigned char *myaddr
, int len
)
5653 /* Round starting address down to longword boundary. */
5654 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
5655 /* Round ending address up; get number of longwords that makes. */
5657 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
5658 / sizeof (PTRACE_XFER_TYPE
);
5660 /* Allocate buffer of that many longwords. */
5661 PTRACE_XFER_TYPE
*buffer
= XALLOCAVEC (PTRACE_XFER_TYPE
, count
);
5663 int pid
= lwpid_of (current_thread
);
5667 /* Zero length write always succeeds. */
5673 /* Dump up to four bytes. */
5674 char str
[4 * 2 + 1];
5676 int dump
= len
< 4 ? len
: 4;
5678 for (i
= 0; i
< dump
; i
++)
5680 sprintf (p
, "%02x", myaddr
[i
]);
5685 debug_printf ("Writing %s to 0x%08lx in process %d\n",
5686 str
, (long) memaddr
, pid
);
5689 /* Fill start and end extra bytes of buffer with existing memory data. */
5692 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5693 about coercing an 8 byte integer to a 4 byte pointer. */
5694 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, pid
,
5695 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5696 (PTRACE_TYPE_ARG4
) 0);
5704 = ptrace (PTRACE_PEEKTEXT
, pid
,
5705 /* Coerce to a uintptr_t first to avoid potential gcc warning
5706 about coercing an 8 byte integer to a 4 byte pointer. */
5707 (PTRACE_TYPE_ARG3
) (uintptr_t) (addr
+ (count
- 1)
5708 * sizeof (PTRACE_XFER_TYPE
)),
5709 (PTRACE_TYPE_ARG4
) 0);
5714 /* Copy data to be written over corresponding part of buffer. */
5716 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
5719 /* Write the entire buffer. */
5721 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
5724 ptrace (PTRACE_POKETEXT
, pid
,
5725 /* Coerce to a uintptr_t first to avoid potential gcc warning
5726 about coercing an 8 byte integer to a 4 byte pointer. */
5727 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5728 (PTRACE_TYPE_ARG4
) buffer
[i
]);
5737 linux_process_target::look_up_symbols ()
5739 #ifdef USE_THREAD_DB
5740 struct process_info
*proc
= current_process ();
5742 if (proc
->priv
->thread_db
!= NULL
)
5750 linux_process_target::request_interrupt ()
5752 /* Send a SIGINT to the process group. This acts just like the user
5753 typed a ^C on the controlling terminal. */
5754 ::kill (-signal_pid
, SIGINT
);
5758 linux_process_target::supports_read_auxv ()
5763 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
5764 to debugger memory starting at MYADDR. */
5767 linux_process_target::read_auxv (CORE_ADDR offset
, unsigned char *myaddr
,
5770 char filename
[PATH_MAX
];
5772 int pid
= lwpid_of (current_thread
);
5774 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
5776 fd
= open (filename
, O_RDONLY
);
5780 if (offset
!= (CORE_ADDR
) 0
5781 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5784 n
= read (fd
, myaddr
, len
);
5792 linux_process_target::insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5793 int size
, raw_breakpoint
*bp
)
5795 if (type
== raw_bkpt_type_sw
)
5796 return insert_memory_breakpoint (bp
);
5798 return low_insert_point (type
, addr
, size
, bp
);
5802 linux_process_target::low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
5803 int size
, raw_breakpoint
*bp
)
5805 /* Unsupported (see target.h). */
5810 linux_process_target::remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5811 int size
, raw_breakpoint
*bp
)
5813 if (type
== raw_bkpt_type_sw
)
5814 return remove_memory_breakpoint (bp
);
5816 return low_remove_point (type
, addr
, size
, bp
);
5820 linux_process_target::low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
5821 int size
, raw_breakpoint
*bp
)
5823 /* Unsupported (see target.h). */
5827 /* Implement the stopped_by_sw_breakpoint target_ops
5831 linux_process_target::stopped_by_sw_breakpoint ()
5833 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5835 return (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
5838 /* Implement the supports_stopped_by_sw_breakpoint target_ops
5842 linux_process_target::supports_stopped_by_sw_breakpoint ()
5844 return USE_SIGTRAP_SIGINFO
;
5847 /* Implement the stopped_by_hw_breakpoint target_ops
5851 linux_process_target::stopped_by_hw_breakpoint ()
5853 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5855 return (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
5858 /* Implement the supports_stopped_by_hw_breakpoint target_ops
5862 linux_process_target::supports_stopped_by_hw_breakpoint ()
5864 return USE_SIGTRAP_SIGINFO
;
5867 /* Implement the supports_hardware_single_step target_ops method. */
5870 linux_process_target::supports_hardware_single_step ()
5876 linux_process_target::stopped_by_watchpoint ()
5878 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5880 return lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
5884 linux_process_target::stopped_data_address ()
5886 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5888 return lwp
->stopped_data_address
;
5891 /* This is only used for targets that define PT_TEXT_ADDR,
5892 PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
5893 the target has different ways of acquiring this information, like
5897 linux_process_target::supports_read_offsets ()
5899 #ifdef SUPPORTS_READ_OFFSETS
5906 /* Under uClinux, programs are loaded at non-zero offsets, which we need
5907 to tell gdb about. */
5910 linux_process_target::read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
5912 #ifdef SUPPORTS_READ_OFFSETS
5913 unsigned long text
, text_end
, data
;
5914 int pid
= lwpid_of (current_thread
);
5918 text
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_ADDR
,
5919 (PTRACE_TYPE_ARG4
) 0);
5920 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_END_ADDR
,
5921 (PTRACE_TYPE_ARG4
) 0);
5922 data
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_DATA_ADDR
,
5923 (PTRACE_TYPE_ARG4
) 0);
5927 /* Both text and data offsets produced at compile-time (and so
5928 used by gdb) are relative to the beginning of the program,
5929 with the data segment immediately following the text segment.
5930 However, the actual runtime layout in memory may put the data
5931 somewhere else, so when we send gdb a data base-address, we
5932 use the real data base address and subtract the compile-time
5933 data base-address from it (which is just the length of the
5934 text segment). BSS immediately follows data in both
5937 *data_p
= data
- (text_end
- text
);
5943 gdb_assert_not_reached ("target op read_offsets not supported");
5948 linux_process_target::supports_get_tls_address ()
5950 #ifdef USE_THREAD_DB
5958 linux_process_target::get_tls_address (thread_info
*thread
,
5960 CORE_ADDR load_module
,
5963 #ifdef USE_THREAD_DB
5964 return thread_db_get_tls_address (thread
, offset
, load_module
, address
);
5971 linux_process_target::supports_qxfer_osdata ()
5977 linux_process_target::qxfer_osdata (const char *annex
,
5978 unsigned char *readbuf
,
5979 unsigned const char *writebuf
,
5980 CORE_ADDR offset
, int len
)
5982 return linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
5986 linux_process_target::siginfo_fixup (siginfo_t
*siginfo
,
5987 gdb_byte
*inf_siginfo
, int direction
)
5989 bool done
= low_siginfo_fixup (siginfo
, inf_siginfo
, direction
);
5991 /* If there was no callback, or the callback didn't do anything,
5992 then just do a straight memcpy. */
5996 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
5998 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
6003 linux_process_target::low_siginfo_fixup (siginfo_t
*native
, gdb_byte
*inf
,
6010 linux_process_target::supports_qxfer_siginfo ()
6016 linux_process_target::qxfer_siginfo (const char *annex
,
6017 unsigned char *readbuf
,
6018 unsigned const char *writebuf
,
6019 CORE_ADDR offset
, int len
)
6023 gdb_byte inf_siginfo
[sizeof (siginfo_t
)];
6025 if (current_thread
== NULL
)
6028 pid
= lwpid_of (current_thread
);
6031 debug_printf ("%s siginfo for lwp %d.\n",
6032 readbuf
!= NULL
? "Reading" : "Writing",
6035 if (offset
>= sizeof (siginfo
))
6038 if (ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
6041 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
6042 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
6043 inferior with a 64-bit GDBSERVER should look the same as debugging it
6044 with a 32-bit GDBSERVER, we need to convert it. */
6045 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
6047 if (offset
+ len
> sizeof (siginfo
))
6048 len
= sizeof (siginfo
) - offset
;
6050 if (readbuf
!= NULL
)
6051 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
6054 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
6056 /* Convert back to ptrace layout before flushing it out. */
6057 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
6059 if (ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
6066 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
6067 so we notice when children change state; as the handler for the
6068 sigsuspend in my_waitpid. */
6071 sigchld_handler (int signo
)
6073 int old_errno
= errno
;
6079 /* Use the async signal safe debug function. */
6080 if (debug_write ("sigchld_handler\n",
6081 sizeof ("sigchld_handler\n") - 1) < 0)
6082 break; /* just ignore */
6086 if (target_is_async_p ())
6087 async_file_mark (); /* trigger a linux_wait */
6093 linux_process_target::supports_non_stop ()
6099 linux_process_target::async (bool enable
)
6101 bool previous
= target_is_async_p ();
6104 debug_printf ("linux_async (%d), previous=%d\n",
6107 if (previous
!= enable
)
6110 sigemptyset (&mask
);
6111 sigaddset (&mask
, SIGCHLD
);
6113 gdb_sigmask (SIG_BLOCK
, &mask
, NULL
);
6117 if (pipe (linux_event_pipe
) == -1)
6119 linux_event_pipe
[0] = -1;
6120 linux_event_pipe
[1] = -1;
6121 gdb_sigmask (SIG_UNBLOCK
, &mask
, NULL
);
6123 warning ("creating event pipe failed.");
6127 fcntl (linux_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
6128 fcntl (linux_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
6130 /* Register the event loop handler. */
6131 add_file_handler (linux_event_pipe
[0],
6132 handle_target_event
, NULL
);
6134 /* Always trigger a linux_wait. */
6139 delete_file_handler (linux_event_pipe
[0]);
6141 close (linux_event_pipe
[0]);
6142 close (linux_event_pipe
[1]);
6143 linux_event_pipe
[0] = -1;
6144 linux_event_pipe
[1] = -1;
6147 gdb_sigmask (SIG_UNBLOCK
, &mask
, NULL
);
6154 linux_process_target::start_non_stop (bool nonstop
)
6156 /* Register or unregister from event-loop accordingly. */
6157 target_async (nonstop
);
6159 if (target_is_async_p () != (nonstop
!= false))
6166 linux_process_target::supports_multi_process ()
6171 /* Check if fork events are supported. */
6174 linux_process_target::supports_fork_events ()
6176 return linux_supports_tracefork ();
6179 /* Check if vfork events are supported. */
6182 linux_process_target::supports_vfork_events ()
6184 return linux_supports_tracefork ();
6187 /* Check if exec events are supported. */
6190 linux_process_target::supports_exec_events ()
6192 return linux_supports_traceexec ();
6195 /* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
6196 ptrace flags for all inferiors. This is in case the new GDB connection
6197 doesn't support the same set of events that the previous one did. */
6200 linux_process_target::handle_new_gdb_connection ()
6202 /* Request that all the lwps reset their ptrace options. */
6203 for_each_thread ([] (thread_info
*thread
)
6205 struct lwp_info
*lwp
= get_thread_lwp (thread
);
6209 /* Stop the lwp so we can modify its ptrace options. */
6210 lwp
->must_set_ptrace_flags
= 1;
6211 linux_stop_lwp (lwp
);
6215 /* Already stopped; go ahead and set the ptrace options. */
6216 struct process_info
*proc
= find_process_pid (pid_of (thread
));
6217 int options
= linux_low_ptrace_options (proc
->attached
);
6219 linux_enable_event_reporting (lwpid_of (thread
), options
);
6220 lwp
->must_set_ptrace_flags
= 0;
6226 linux_process_target::handle_monitor_command (char *mon
)
6228 #ifdef USE_THREAD_DB
6229 return thread_db_handle_monitor_command (mon
);
6236 linux_process_target::core_of_thread (ptid_t ptid
)
6238 return linux_common_core_of_thread (ptid
);
6242 linux_process_target::supports_disable_randomization ()
6244 #ifdef HAVE_PERSONALITY
6252 linux_process_target::supports_agent ()
6258 linux_process_target::supports_range_stepping ()
6260 if (supports_software_single_step ())
6263 return low_supports_range_stepping ();
6267 linux_process_target::low_supports_range_stepping ()
6273 linux_process_target::supports_pid_to_exec_file ()
6279 linux_process_target::pid_to_exec_file (int pid
)
6281 return linux_proc_pid_to_exec_file (pid
);
6285 linux_process_target::supports_multifs ()
6291 linux_process_target::multifs_open (int pid
, const char *filename
,
6292 int flags
, mode_t mode
)
6294 return linux_mntns_open_cloexec (pid
, filename
, flags
, mode
);
6298 linux_process_target::multifs_unlink (int pid
, const char *filename
)
6300 return linux_mntns_unlink (pid
, filename
);
6304 linux_process_target::multifs_readlink (int pid
, const char *filename
,
6305 char *buf
, size_t bufsiz
)
6307 return linux_mntns_readlink (pid
, filename
, buf
, bufsiz
);
6310 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
6311 struct target_loadseg
6313 /* Core address to which the segment is mapped. */
6315 /* VMA recorded in the program header. */
6317 /* Size of this segment in memory. */
6321 # if defined PT_GETDSBT
6322 struct target_loadmap
6324 /* Protocol version number, must be zero. */
6326 /* Pointer to the DSBT table, its size, and the DSBT index. */
6327 unsigned *dsbt_table
;
6328 unsigned dsbt_size
, dsbt_index
;
6329 /* Number of segments in this map. */
6331 /* The actual memory map. */
6332 struct target_loadseg segs
[/*nsegs*/];
6334 # define LINUX_LOADMAP PT_GETDSBT
6335 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
6336 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
6338 struct target_loadmap
6340 /* Protocol version number, must be zero. */
6342 /* Number of segments in this map. */
6344 /* The actual memory map. */
6345 struct target_loadseg segs
[/*nsegs*/];
6347 # define LINUX_LOADMAP PTRACE_GETFDPIC
6348 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
6349 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
6353 linux_process_target::supports_read_loadmap ()
6359 linux_process_target::read_loadmap (const char *annex
, CORE_ADDR offset
,
6360 unsigned char *myaddr
, unsigned int len
)
6362 int pid
= lwpid_of (current_thread
);
6364 struct target_loadmap
*data
= NULL
;
6365 unsigned int actual_length
, copy_length
;
6367 if (strcmp (annex
, "exec") == 0)
6368 addr
= (int) LINUX_LOADMAP_EXEC
;
6369 else if (strcmp (annex
, "interp") == 0)
6370 addr
= (int) LINUX_LOADMAP_INTERP
;
6374 if (ptrace (LINUX_LOADMAP
, pid
, addr
, &data
) != 0)
6380 actual_length
= sizeof (struct target_loadmap
)
6381 + sizeof (struct target_loadseg
) * data
->nsegs
;
6383 if (offset
< 0 || offset
> actual_length
)
6386 copy_length
= actual_length
- offset
< len
? actual_length
- offset
: len
;
6387 memcpy (myaddr
, (char *) data
+ offset
, copy_length
);
6390 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
6393 linux_process_target::supports_catch_syscall ()
6395 return (low_supports_catch_syscall ()
6396 && linux_supports_tracesysgood ());
6400 linux_process_target::low_supports_catch_syscall ()
6406 linux_process_target::read_pc (regcache
*regcache
)
6408 if (!low_supports_breakpoints ())
6411 return low_get_pc (regcache
);
6415 linux_process_target::write_pc (regcache
*regcache
, CORE_ADDR pc
)
6417 gdb_assert (low_supports_breakpoints ());
6419 low_set_pc (regcache
, pc
);
6423 linux_process_target::supports_thread_stopped ()
6429 linux_process_target::thread_stopped (thread_info
*thread
)
6431 return get_thread_lwp (thread
)->stopped
;
6434 /* This exposes stop-all-threads functionality to other modules. */
6437 linux_process_target::pause_all (bool freeze
)
6439 stop_all_lwps (freeze
, NULL
);
6442 /* This exposes unstop-all-threads functionality to other gdbserver
6446 linux_process_target::unpause_all (bool unfreeze
)
6448 unstop_all_lwps (unfreeze
, NULL
);
6452 linux_process_target::prepare_to_access_memory ()
6454 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6457 target_pause_all (true);
6462 linux_process_target::done_accessing_memory ()
6464 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6467 target_unpause_all (true);
6470 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
6473 get_phdr_phnum_from_proc_auxv (const int pid
, const int is_elf64
,
6474 CORE_ADDR
*phdr_memaddr
, int *num_phdr
)
6476 char filename
[PATH_MAX
];
6478 const int auxv_size
= is_elf64
6479 ? sizeof (Elf64_auxv_t
) : sizeof (Elf32_auxv_t
);
6480 char buf
[sizeof (Elf64_auxv_t
)]; /* The larger of the two. */
6482 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
6484 fd
= open (filename
, O_RDONLY
);
6490 while (read (fd
, buf
, auxv_size
) == auxv_size
6491 && (*phdr_memaddr
== 0 || *num_phdr
== 0))
6495 Elf64_auxv_t
*const aux
= (Elf64_auxv_t
*) buf
;
6497 switch (aux
->a_type
)
6500 *phdr_memaddr
= aux
->a_un
.a_val
;
6503 *num_phdr
= aux
->a_un
.a_val
;
6509 Elf32_auxv_t
*const aux
= (Elf32_auxv_t
*) buf
;
6511 switch (aux
->a_type
)
6514 *phdr_memaddr
= aux
->a_un
.a_val
;
6517 *num_phdr
= aux
->a_un
.a_val
;
6525 if (*phdr_memaddr
== 0 || *num_phdr
== 0)
6527 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
6528 "phdr_memaddr = %ld, phdr_num = %d",
6529 (long) *phdr_memaddr
, *num_phdr
);
6536 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
6539 get_dynamic (const int pid
, const int is_elf64
)
6541 CORE_ADDR phdr_memaddr
, relocation
;
6543 unsigned char *phdr_buf
;
6544 const int phdr_size
= is_elf64
? sizeof (Elf64_Phdr
) : sizeof (Elf32_Phdr
);
6546 if (get_phdr_phnum_from_proc_auxv (pid
, is_elf64
, &phdr_memaddr
, &num_phdr
))
6549 gdb_assert (num_phdr
< 100); /* Basic sanity check. */
6550 phdr_buf
= (unsigned char *) alloca (num_phdr
* phdr_size
);
6552 if (linux_read_memory (phdr_memaddr
, phdr_buf
, num_phdr
* phdr_size
))
6555 /* Compute relocation: it is expected to be 0 for "regular" executables,
6556 non-zero for PIE ones. */
6558 for (i
= 0; relocation
== -1 && i
< num_phdr
; i
++)
6561 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6563 if (p
->p_type
== PT_PHDR
)
6564 relocation
= phdr_memaddr
- p
->p_vaddr
;
6568 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6570 if (p
->p_type
== PT_PHDR
)
6571 relocation
= phdr_memaddr
- p
->p_vaddr
;
6574 if (relocation
== -1)
6576 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
6577 any real world executables, including PIE executables, have always
6578 PT_PHDR present. PT_PHDR is not present in some shared libraries or
6579 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
6580 or present DT_DEBUG anyway (fpc binaries are statically linked).
6582 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
6584 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
6589 for (i
= 0; i
< num_phdr
; i
++)
6593 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6595 if (p
->p_type
== PT_DYNAMIC
)
6596 return p
->p_vaddr
+ relocation
;
6600 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6602 if (p
->p_type
== PT_DYNAMIC
)
6603 return p
->p_vaddr
+ relocation
;
6610 /* Return &_r_debug in the inferior, or -1 if not present. Return value
6611 can be 0 if the inferior does not yet have the library list initialized.
6612 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
6613 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
6616 get_r_debug (const int pid
, const int is_elf64
)
6618 CORE_ADDR dynamic_memaddr
;
6619 const int dyn_size
= is_elf64
? sizeof (Elf64_Dyn
) : sizeof (Elf32_Dyn
);
6620 unsigned char buf
[sizeof (Elf64_Dyn
)]; /* The larger of the two. */
6623 dynamic_memaddr
= get_dynamic (pid
, is_elf64
);
6624 if (dynamic_memaddr
== 0)
6627 while (linux_read_memory (dynamic_memaddr
, buf
, dyn_size
) == 0)
6631 Elf64_Dyn
*const dyn
= (Elf64_Dyn
*) buf
;
6632 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6636 unsigned char buf
[sizeof (Elf64_Xword
)];
6640 #ifdef DT_MIPS_RLD_MAP
6641 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6643 if (linux_read_memory (dyn
->d_un
.d_val
,
6644 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6649 #endif /* DT_MIPS_RLD_MAP */
6650 #ifdef DT_MIPS_RLD_MAP_REL
6651 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6653 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6654 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6659 #endif /* DT_MIPS_RLD_MAP_REL */
6661 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6662 map
= dyn
->d_un
.d_val
;
6664 if (dyn
->d_tag
== DT_NULL
)
6669 Elf32_Dyn
*const dyn
= (Elf32_Dyn
*) buf
;
6670 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6674 unsigned char buf
[sizeof (Elf32_Word
)];
6678 #ifdef DT_MIPS_RLD_MAP
6679 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6681 if (linux_read_memory (dyn
->d_un
.d_val
,
6682 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6687 #endif /* DT_MIPS_RLD_MAP */
6688 #ifdef DT_MIPS_RLD_MAP_REL
6689 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6691 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6692 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6697 #endif /* DT_MIPS_RLD_MAP_REL */
6699 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6700 map
= dyn
->d_un
.d_val
;
6702 if (dyn
->d_tag
== DT_NULL
)
6706 dynamic_memaddr
+= dyn_size
;
6712 /* Read one pointer from MEMADDR in the inferior. */
6715 read_one_ptr (CORE_ADDR memaddr
, CORE_ADDR
*ptr
, int ptr_size
)
6719 /* Go through a union so this works on either big or little endian
6720 hosts, when the inferior's pointer size is smaller than the size
6721 of CORE_ADDR. It is assumed the inferior's endianness is the
6722 same of the superior's. */
6725 CORE_ADDR core_addr
;
6730 ret
= linux_read_memory (memaddr
, &addr
.uc
, ptr_size
);
6733 if (ptr_size
== sizeof (CORE_ADDR
))
6734 *ptr
= addr
.core_addr
;
6735 else if (ptr_size
== sizeof (unsigned int))
6738 gdb_assert_not_reached ("unhandled pointer size");
6744 linux_process_target::supports_qxfer_libraries_svr4 ()
6749 struct link_map_offsets
6751 /* Offset and size of r_debug.r_version. */
6752 int r_version_offset
;
6754 /* Offset and size of r_debug.r_map. */
6757 /* Offset to l_addr field in struct link_map. */
6760 /* Offset to l_name field in struct link_map. */
6763 /* Offset to l_ld field in struct link_map. */
6766 /* Offset to l_next field in struct link_map. */
6769 /* Offset to l_prev field in struct link_map. */
6773 /* Construct qXfer:libraries-svr4:read reply. */
6776 linux_process_target::qxfer_libraries_svr4 (const char *annex
,
6777 unsigned char *readbuf
,
6778 unsigned const char *writebuf
,
6779 CORE_ADDR offset
, int len
)
6781 struct process_info_private
*const priv
= current_process ()->priv
;
6782 char filename
[PATH_MAX
];
6785 static const struct link_map_offsets lmo_32bit_offsets
=
6787 0, /* r_version offset. */
6788 4, /* r_debug.r_map offset. */
6789 0, /* l_addr offset in link_map. */
6790 4, /* l_name offset in link_map. */
6791 8, /* l_ld offset in link_map. */
6792 12, /* l_next offset in link_map. */
6793 16 /* l_prev offset in link_map. */
6796 static const struct link_map_offsets lmo_64bit_offsets
=
6798 0, /* r_version offset. */
6799 8, /* r_debug.r_map offset. */
6800 0, /* l_addr offset in link_map. */
6801 8, /* l_name offset in link_map. */
6802 16, /* l_ld offset in link_map. */
6803 24, /* l_next offset in link_map. */
6804 32 /* l_prev offset in link_map. */
6806 const struct link_map_offsets
*lmo
;
6807 unsigned int machine
;
6809 CORE_ADDR lm_addr
= 0, lm_prev
= 0;
6810 CORE_ADDR l_name
, l_addr
, l_ld
, l_next
, l_prev
;
6811 int header_done
= 0;
6813 if (writebuf
!= NULL
)
6815 if (readbuf
== NULL
)
6818 pid
= lwpid_of (current_thread
);
6819 xsnprintf (filename
, sizeof filename
, "/proc/%d/exe", pid
);
6820 is_elf64
= elf_64_file_p (filename
, &machine
);
6821 lmo
= is_elf64
? &lmo_64bit_offsets
: &lmo_32bit_offsets
;
6822 ptr_size
= is_elf64
? 8 : 4;
6824 while (annex
[0] != '\0')
6830 sep
= strchr (annex
, '=');
6834 name_len
= sep
- annex
;
6835 if (name_len
== 5 && startswith (annex
, "start"))
6837 else if (name_len
== 4 && startswith (annex
, "prev"))
6841 annex
= strchr (sep
, ';');
6848 annex
= decode_address_to_semicolon (addrp
, sep
+ 1);
6855 if (priv
->r_debug
== 0)
6856 priv
->r_debug
= get_r_debug (pid
, is_elf64
);
6858 /* We failed to find DT_DEBUG. Such situation will not change
6859 for this inferior - do not retry it. Report it to GDB as
6860 E01, see for the reasons at the GDB solib-svr4.c side. */
6861 if (priv
->r_debug
== (CORE_ADDR
) -1)
6864 if (priv
->r_debug
!= 0)
6866 if (linux_read_memory (priv
->r_debug
+ lmo
->r_version_offset
,
6867 (unsigned char *) &r_version
,
6868 sizeof (r_version
)) != 0
6871 warning ("unexpected r_debug version %d", r_version
);
6873 else if (read_one_ptr (priv
->r_debug
+ lmo
->r_map_offset
,
6874 &lm_addr
, ptr_size
) != 0)
6876 warning ("unable to read r_map from 0x%lx",
6877 (long) priv
->r_debug
+ lmo
->r_map_offset
);
6882 std::string document
= "<library-list-svr4 version=\"1.0\"";
6885 && read_one_ptr (lm_addr
+ lmo
->l_name_offset
,
6886 &l_name
, ptr_size
) == 0
6887 && read_one_ptr (lm_addr
+ lmo
->l_addr_offset
,
6888 &l_addr
, ptr_size
) == 0
6889 && read_one_ptr (lm_addr
+ lmo
->l_ld_offset
,
6890 &l_ld
, ptr_size
) == 0
6891 && read_one_ptr (lm_addr
+ lmo
->l_prev_offset
,
6892 &l_prev
, ptr_size
) == 0
6893 && read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
6894 &l_next
, ptr_size
) == 0)
6896 unsigned char libname
[PATH_MAX
];
6898 if (lm_prev
!= l_prev
)
6900 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
6901 (long) lm_prev
, (long) l_prev
);
6905 /* Ignore the first entry even if it has valid name as the first entry
6906 corresponds to the main executable. The first entry should not be
6907 skipped if the dynamic loader was loaded late by a static executable
6908 (see solib-svr4.c parameter ignore_first). But in such case the main
6909 executable does not have PT_DYNAMIC present and this function already
6910 exited above due to failed get_r_debug. */
6912 string_appendf (document
, " main-lm=\"0x%lx\"", (unsigned long) lm_addr
);
6915 /* Not checking for error because reading may stop before
6916 we've got PATH_MAX worth of characters. */
6918 linux_read_memory (l_name
, libname
, sizeof (libname
) - 1);
6919 libname
[sizeof (libname
) - 1] = '\0';
6920 if (libname
[0] != '\0')
6924 /* Terminate `<library-list-svr4'. */
6929 string_appendf (document
, "<library name=\"");
6930 xml_escape_text_append (&document
, (char *) libname
);
6931 string_appendf (document
, "\" lm=\"0x%lx\" "
6932 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
6933 (unsigned long) lm_addr
, (unsigned long) l_addr
,
6934 (unsigned long) l_ld
);
6944 /* Empty list; terminate `<library-list-svr4'. */
6948 document
+= "</library-list-svr4>";
6950 int document_len
= document
.length ();
6951 if (offset
< document_len
)
6952 document_len
-= offset
;
6955 if (len
> document_len
)
6958 memcpy (readbuf
, document
.data () + offset
, len
);
6963 #ifdef HAVE_LINUX_BTRACE
6965 btrace_target_info
*
6966 linux_process_target::enable_btrace (ptid_t ptid
,
6967 const btrace_config
*conf
)
6969 return linux_enable_btrace (ptid
, conf
);
6972 /* See to_disable_btrace target method. */
6975 linux_process_target::disable_btrace (btrace_target_info
*tinfo
)
6977 enum btrace_error err
;
6979 err
= linux_disable_btrace (tinfo
);
6980 return (err
== BTRACE_ERR_NONE
? 0 : -1);
6983 /* Encode an Intel Processor Trace configuration. */
6986 linux_low_encode_pt_config (struct buffer
*buffer
,
6987 const struct btrace_data_pt_config
*config
)
6989 buffer_grow_str (buffer
, "<pt-config>\n");
6991 switch (config
->cpu
.vendor
)
6994 buffer_xml_printf (buffer
, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
6995 "model=\"%u\" stepping=\"%u\"/>\n",
6996 config
->cpu
.family
, config
->cpu
.model
,
6997 config
->cpu
.stepping
);
7004 buffer_grow_str (buffer
, "</pt-config>\n");
7007 /* Encode a raw buffer. */
7010 linux_low_encode_raw (struct buffer
*buffer
, const gdb_byte
*data
,
7016 /* We use hex encoding - see gdbsupport/rsp-low.h. */
7017 buffer_grow_str (buffer
, "<raw>\n");
7023 elem
[0] = tohex ((*data
>> 4) & 0xf);
7024 elem
[1] = tohex (*data
++ & 0xf);
7026 buffer_grow (buffer
, elem
, 2);
7029 buffer_grow_str (buffer
, "</raw>\n");
7032 /* See to_read_btrace target method. */
7035 linux_process_target::read_btrace (btrace_target_info
*tinfo
,
7037 enum btrace_read_type type
)
7039 struct btrace_data btrace
;
7040 enum btrace_error err
;
7042 err
= linux_read_btrace (&btrace
, tinfo
, type
);
7043 if (err
!= BTRACE_ERR_NONE
)
7045 if (err
== BTRACE_ERR_OVERFLOW
)
7046 buffer_grow_str0 (buffer
, "E.Overflow.");
7048 buffer_grow_str0 (buffer
, "E.Generic Error.");
7053 switch (btrace
.format
)
7055 case BTRACE_FORMAT_NONE
:
7056 buffer_grow_str0 (buffer
, "E.No Trace.");
7059 case BTRACE_FORMAT_BTS
:
7060 buffer_grow_str (buffer
, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
7061 buffer_grow_str (buffer
, "<btrace version=\"1.0\">\n");
7063 for (const btrace_block
&block
: *btrace
.variant
.bts
.blocks
)
7064 buffer_xml_printf (buffer
, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
7065 paddress (block
.begin
), paddress (block
.end
));
7067 buffer_grow_str0 (buffer
, "</btrace>\n");
7070 case BTRACE_FORMAT_PT
:
7071 buffer_grow_str (buffer
, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
7072 buffer_grow_str (buffer
, "<btrace version=\"1.0\">\n");
7073 buffer_grow_str (buffer
, "<pt>\n");
7075 linux_low_encode_pt_config (buffer
, &btrace
.variant
.pt
.config
);
7077 linux_low_encode_raw (buffer
, btrace
.variant
.pt
.data
,
7078 btrace
.variant
.pt
.size
);
7080 buffer_grow_str (buffer
, "</pt>\n");
7081 buffer_grow_str0 (buffer
, "</btrace>\n");
7085 buffer_grow_str0 (buffer
, "E.Unsupported Trace Format.");
7092 /* See to_btrace_conf target method. */
7095 linux_process_target::read_btrace_conf (const btrace_target_info
*tinfo
,
7098 const struct btrace_config
*conf
;
7100 buffer_grow_str (buffer
, "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n");
7101 buffer_grow_str (buffer
, "<btrace-conf version=\"1.0\">\n");
7103 conf
= linux_btrace_conf (tinfo
);
7106 switch (conf
->format
)
7108 case BTRACE_FORMAT_NONE
:
7111 case BTRACE_FORMAT_BTS
:
7112 buffer_xml_printf (buffer
, "<bts");
7113 buffer_xml_printf (buffer
, " size=\"0x%x\"", conf
->bts
.size
);
7114 buffer_xml_printf (buffer
, " />\n");
7117 case BTRACE_FORMAT_PT
:
7118 buffer_xml_printf (buffer
, "<pt");
7119 buffer_xml_printf (buffer
, " size=\"0x%x\"", conf
->pt
.size
);
7120 buffer_xml_printf (buffer
, "/>\n");
7125 buffer_grow_str0 (buffer
, "</btrace-conf>\n");
7128 #endif /* HAVE_LINUX_BTRACE */
7130 /* See nat/linux-nat.h. */
7133 current_lwp_ptid (void)
7135 return ptid_of (current_thread
);
7139 linux_process_target::thread_name (ptid_t thread
)
7141 return linux_proc_tid_get_name (thread
);
7146 linux_process_target::thread_handle (ptid_t ptid
, gdb_byte
**handle
,
7149 return thread_db_thread_handle (ptid
, handle
, handle_len
);
7153 /* Default implementation of linux_target_ops method "set_pc" for
7154 32-bit pc register which is literally named "pc". */
7157 linux_set_pc_32bit (struct regcache
*regcache
, CORE_ADDR pc
)
7159 uint32_t newpc
= pc
;
7161 supply_register_by_name (regcache
, "pc", &newpc
);
7164 /* Default implementation of linux_target_ops method "get_pc" for
7165 32-bit pc register which is literally named "pc". */
7168 linux_get_pc_32bit (struct regcache
*regcache
)
7172 collect_register_by_name (regcache
, "pc", &pc
);
7174 debug_printf ("stop pc is 0x%" PRIx32
"\n", pc
);
7178 /* Default implementation of linux_target_ops method "set_pc" for
7179 64-bit pc register which is literally named "pc". */
7182 linux_set_pc_64bit (struct regcache
*regcache
, CORE_ADDR pc
)
7184 uint64_t newpc
= pc
;
7186 supply_register_by_name (regcache
, "pc", &newpc
);
7189 /* Default implementation of linux_target_ops method "get_pc" for
7190 64-bit pc register which is literally named "pc". */
7193 linux_get_pc_64bit (struct regcache
*regcache
)
7197 collect_register_by_name (regcache
, "pc", &pc
);
7199 debug_printf ("stop pc is 0x%" PRIx64
"\n", pc
);
7203 /* See linux-low.h. */
7206 linux_get_auxv (int wordsize
, CORE_ADDR match
, CORE_ADDR
*valp
)
7208 gdb_byte
*data
= (gdb_byte
*) alloca (2 * wordsize
);
7211 gdb_assert (wordsize
== 4 || wordsize
== 8);
7213 while (the_target
->read_auxv (offset
, data
, 2 * wordsize
) == 2 * wordsize
)
7217 uint32_t *data_p
= (uint32_t *) data
;
7218 if (data_p
[0] == match
)
7226 uint64_t *data_p
= (uint64_t *) data
;
7227 if (data_p
[0] == match
)
7234 offset
+= 2 * wordsize
;
7240 /* See linux-low.h. */
7243 linux_get_hwcap (int wordsize
)
7245 CORE_ADDR hwcap
= 0;
7246 linux_get_auxv (wordsize
, AT_HWCAP
, &hwcap
);
7250 /* See linux-low.h. */
7253 linux_get_hwcap2 (int wordsize
)
7255 CORE_ADDR hwcap2
= 0;
7256 linux_get_auxv (wordsize
, AT_HWCAP2
, &hwcap2
);
7260 #ifdef HAVE_LINUX_REGSETS
7262 initialize_regsets_info (struct regsets_info
*info
)
7264 for (info
->num_regsets
= 0;
7265 info
->regsets
[info
->num_regsets
].size
>= 0;
7266 info
->num_regsets
++)
7272 initialize_low (void)
7274 struct sigaction sigchld_action
;
7276 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
7277 set_target_ops (the_linux_target
);
7279 linux_ptrace_init_warnings ();
7280 linux_proc_init_warnings ();
7282 sigchld_action
.sa_handler
= sigchld_handler
;
7283 sigemptyset (&sigchld_action
.sa_mask
);
7284 sigchld_action
.sa_flags
= SA_RESTART
;
7285 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
7287 initialize_low_arch ();
7289 linux_check_ptrace_features ();