1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995-2019 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"
50 #include "gdbsupport/common-inferior.h"
51 #include "nat/fork-inferior.h"
52 #include "gdbsupport/environ.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 /* BFIN already defines these since at least 2.6.32 kernels. */
91 #define PT_TEXT_ADDR 220
92 #define PT_TEXT_END_ADDR 224
93 #define PT_DATA_ADDR 228
94 /* These are still undefined in 3.10 kernels. */
95 #elif defined(__TMS320C6X__)
96 #define PT_TEXT_ADDR (0x10000*4)
97 #define PT_DATA_ADDR (0x10004*4)
98 #define PT_TEXT_END_ADDR (0x10008*4)
102 #ifdef HAVE_LINUX_BTRACE
103 # include "nat/linux-btrace.h"
104 # include "gdbsupport/btrace-common.h"
107 #ifndef HAVE_ELF32_AUXV_T
108 /* Copied from glibc's elf.h. */
111 uint32_t a_type
; /* Entry type */
114 uint32_t a_val
; /* Integer value */
115 /* We use to have pointer elements added here. We cannot do that,
116 though, since it does not work when using 32-bit definitions
117 on 64-bit platforms and vice versa. */
122 #ifndef HAVE_ELF64_AUXV_T
123 /* Copied from glibc's elf.h. */
126 uint64_t a_type
; /* Entry type */
129 uint64_t a_val
; /* Integer value */
130 /* We use to have pointer elements added here. We cannot do that,
131 though, since it does not work when using 32-bit definitions
132 on 64-bit platforms and vice versa. */
137 /* Does the current host support PTRACE_GETREGSET? */
138 int have_ptrace_getregset
= -1;
142 /* See nat/linux-nat.h. */
145 ptid_of_lwp (struct lwp_info
*lwp
)
147 return ptid_of (get_lwp_thread (lwp
));
150 /* See nat/linux-nat.h. */
153 lwp_set_arch_private_info (struct lwp_info
*lwp
,
154 struct arch_lwp_info
*info
)
156 lwp
->arch_private
= info
;
159 /* See nat/linux-nat.h. */
161 struct arch_lwp_info
*
162 lwp_arch_private_info (struct lwp_info
*lwp
)
164 return lwp
->arch_private
;
167 /* See nat/linux-nat.h. */
170 lwp_is_stopped (struct lwp_info
*lwp
)
175 /* See nat/linux-nat.h. */
177 enum target_stop_reason
178 lwp_stop_reason (struct lwp_info
*lwp
)
180 return lwp
->stop_reason
;
183 /* See nat/linux-nat.h. */
186 lwp_is_stepping (struct lwp_info
*lwp
)
188 return lwp
->stepping
;
191 /* A list of all unknown processes which receive stop signals. Some
192 other process will presumably claim each of these as forked
193 children momentarily. */
195 struct simple_pid_list
197 /* The process ID. */
200 /* The status as reported by waitpid. */
204 struct simple_pid_list
*next
;
206 struct simple_pid_list
*stopped_pids
;
208 /* Trivial list manipulation functions to keep track of a list of new
209 stopped processes. */
212 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
214 struct simple_pid_list
*new_pid
= XNEW (struct simple_pid_list
);
217 new_pid
->status
= status
;
218 new_pid
->next
= *listp
;
223 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
225 struct simple_pid_list
**p
;
227 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
228 if ((*p
)->pid
== pid
)
230 struct simple_pid_list
*next
= (*p
)->next
;
232 *statusp
= (*p
)->status
;
240 enum stopping_threads_kind
242 /* Not stopping threads presently. */
243 NOT_STOPPING_THREADS
,
245 /* Stopping threads. */
248 /* Stopping and suspending threads. */
249 STOPPING_AND_SUSPENDING_THREADS
252 /* This is set while stop_all_lwps is in effect. */
253 enum stopping_threads_kind stopping_threads
= NOT_STOPPING_THREADS
;
255 /* FIXME make into a target method? */
256 int using_threads
= 1;
258 /* True if we're presently stabilizing threads (moving them out of
260 static int stabilizing_threads
;
262 static void linux_resume_one_lwp (struct lwp_info
*lwp
,
263 int step
, int signal
, siginfo_t
*info
);
264 static void linux_resume (struct thread_resume
*resume_info
, size_t n
);
265 static void stop_all_lwps (int suspend
, struct lwp_info
*except
);
266 static void unstop_all_lwps (int unsuspend
, struct lwp_info
*except
);
267 static void unsuspend_all_lwps (struct lwp_info
*except
);
268 static int linux_wait_for_event_filtered (ptid_t wait_ptid
, ptid_t filter_ptid
,
269 int *wstat
, int options
);
270 static int linux_wait_for_event (ptid_t ptid
, int *wstat
, int options
);
271 static struct lwp_info
*add_lwp (ptid_t ptid
);
272 static void linux_mourn (struct process_info
*process
);
273 static int linux_stopped_by_watchpoint (void);
274 static void mark_lwp_dead (struct lwp_info
*lwp
, int wstat
);
275 static int lwp_is_marked_dead (struct lwp_info
*lwp
);
276 static void proceed_all_lwps (void);
277 static int finish_step_over (struct lwp_info
*lwp
);
278 static int kill_lwp (unsigned long lwpid
, int signo
);
279 static void enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
);
280 static void complete_ongoing_step_over (void);
281 static int linux_low_ptrace_options (int attached
);
282 static int check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
);
283 static void proceed_one_lwp (thread_info
*thread
, lwp_info
*except
);
285 /* When the event-loop is doing a step-over, this points at the thread
287 ptid_t step_over_bkpt
;
289 /* True if the low target can hardware single-step. */
292 can_hardware_single_step (void)
294 if (the_low_target
.supports_hardware_single_step
!= NULL
)
295 return the_low_target
.supports_hardware_single_step ();
300 /* True if the low target can software single-step. Such targets
301 implement the GET_NEXT_PCS callback. */
304 can_software_single_step (void)
306 return (the_low_target
.get_next_pcs
!= NULL
);
309 /* True if the low target supports memory breakpoints. If so, we'll
310 have a GET_PC implementation. */
313 supports_breakpoints (void)
315 return (the_low_target
.get_pc
!= NULL
);
318 /* Returns true if this target can support fast tracepoints. This
319 does not mean that the in-process agent has been loaded in the
323 supports_fast_tracepoints (void)
325 return the_low_target
.install_fast_tracepoint_jump_pad
!= NULL
;
328 /* True if LWP is stopped in its stepping range. */
331 lwp_in_step_range (struct lwp_info
*lwp
)
333 CORE_ADDR pc
= lwp
->stop_pc
;
335 return (pc
>= lwp
->step_range_start
&& pc
< lwp
->step_range_end
);
338 struct pending_signals
342 struct pending_signals
*prev
;
345 /* The read/write ends of the pipe registered as waitable file in the
347 static int linux_event_pipe
[2] = { -1, -1 };
349 /* True if we're currently in async mode. */
350 #define target_is_async_p() (linux_event_pipe[0] != -1)
352 static void send_sigstop (struct lwp_info
*lwp
);
353 static void wait_for_sigstop (void);
355 /* Return non-zero if HEADER is a 64-bit ELF file. */
358 elf_64_header_p (const Elf64_Ehdr
*header
, unsigned int *machine
)
360 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
361 && header
->e_ident
[EI_MAG1
] == ELFMAG1
362 && header
->e_ident
[EI_MAG2
] == ELFMAG2
363 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
365 *machine
= header
->e_machine
;
366 return header
->e_ident
[EI_CLASS
] == ELFCLASS64
;
373 /* Return non-zero if FILE is a 64-bit ELF file,
374 zero if the file is not a 64-bit ELF file,
375 and -1 if the file is not accessible or doesn't exist. */
378 elf_64_file_p (const char *file
, unsigned int *machine
)
383 fd
= open (file
, O_RDONLY
);
387 if (read (fd
, &header
, sizeof (header
)) != sizeof (header
))
394 return elf_64_header_p (&header
, machine
);
397 /* Accepts an integer PID; Returns true if the executable PID is
398 running is a 64-bit ELF file.. */
401 linux_pid_exe_is_elf_64_file (int pid
, unsigned int *machine
)
405 sprintf (file
, "/proc/%d/exe", pid
);
406 return elf_64_file_p (file
, machine
);
410 delete_lwp (struct lwp_info
*lwp
)
412 struct thread_info
*thr
= get_lwp_thread (lwp
);
415 debug_printf ("deleting %ld\n", lwpid_of (thr
));
419 if (the_low_target
.delete_thread
!= NULL
)
420 the_low_target
.delete_thread (lwp
->arch_private
);
422 gdb_assert (lwp
->arch_private
== NULL
);
427 /* Add a process to the common process list, and set its private
430 static struct process_info
*
431 linux_add_process (int pid
, int attached
)
433 struct process_info
*proc
;
435 proc
= add_process (pid
, attached
);
436 proc
->priv
= XCNEW (struct process_info_private
);
438 if (the_low_target
.new_process
!= NULL
)
439 proc
->priv
->arch_private
= the_low_target
.new_process ();
444 static CORE_ADDR
get_pc (struct lwp_info
*lwp
);
446 /* Call the target arch_setup function on the current thread. */
449 linux_arch_setup (void)
451 the_low_target
.arch_setup ();
454 /* Call the target arch_setup function on THREAD. */
457 linux_arch_setup_thread (struct thread_info
*thread
)
459 struct thread_info
*saved_thread
;
461 saved_thread
= current_thread
;
462 current_thread
= thread
;
466 current_thread
= saved_thread
;
469 /* Handle a GNU/Linux extended wait response. If we see a clone,
470 fork, or vfork event, we need to add the new LWP to our list
471 (and return 0 so as not to report the trap to higher layers).
472 If we see an exec event, we will modify ORIG_EVENT_LWP to point
473 to a new LWP representing the new program. */
476 handle_extended_wait (struct lwp_info
**orig_event_lwp
, int wstat
)
478 client_state
&cs
= get_client_state ();
479 struct lwp_info
*event_lwp
= *orig_event_lwp
;
480 int event
= linux_ptrace_get_extended_event (wstat
);
481 struct thread_info
*event_thr
= get_lwp_thread (event_lwp
);
482 struct lwp_info
*new_lwp
;
484 gdb_assert (event_lwp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
);
486 /* All extended events we currently use are mid-syscall. Only
487 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
488 you have to be using PTRACE_SEIZE to get that. */
489 event_lwp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
491 if ((event
== PTRACE_EVENT_FORK
) || (event
== PTRACE_EVENT_VFORK
)
492 || (event
== PTRACE_EVENT_CLONE
))
495 unsigned long new_pid
;
498 /* Get the pid of the new lwp. */
499 ptrace (PTRACE_GETEVENTMSG
, lwpid_of (event_thr
), (PTRACE_TYPE_ARG3
) 0,
502 /* If we haven't already seen the new PID stop, wait for it now. */
503 if (!pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
505 /* The new child has a pending SIGSTOP. We can't affect it until it
506 hits the SIGSTOP, but we're already attached. */
508 ret
= my_waitpid (new_pid
, &status
, __WALL
);
511 perror_with_name ("waiting for new child");
512 else if (ret
!= new_pid
)
513 warning ("wait returned unexpected PID %d", ret
);
514 else if (!WIFSTOPPED (status
))
515 warning ("wait returned unexpected status 0x%x", status
);
518 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
)
520 struct process_info
*parent_proc
;
521 struct process_info
*child_proc
;
522 struct lwp_info
*child_lwp
;
523 struct thread_info
*child_thr
;
524 struct target_desc
*tdesc
;
526 ptid
= ptid_t (new_pid
, new_pid
, 0);
530 debug_printf ("HEW: Got fork event from LWP %ld, "
532 ptid_of (event_thr
).lwp (),
536 /* Add the new process to the tables and clone the breakpoint
537 lists of the parent. We need to do this even if the new process
538 will be detached, since we will need the process object and the
539 breakpoints to remove any breakpoints from memory when we
540 detach, and the client side will access registers. */
541 child_proc
= linux_add_process (new_pid
, 0);
542 gdb_assert (child_proc
!= NULL
);
543 child_lwp
= add_lwp (ptid
);
544 gdb_assert (child_lwp
!= NULL
);
545 child_lwp
->stopped
= 1;
546 child_lwp
->must_set_ptrace_flags
= 1;
547 child_lwp
->status_pending_p
= 0;
548 child_thr
= get_lwp_thread (child_lwp
);
549 child_thr
->last_resume_kind
= resume_stop
;
550 child_thr
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
552 /* If we're suspending all threads, leave this one suspended
553 too. If the fork/clone parent is stepping over a breakpoint,
554 all other threads have been suspended already. Leave the
555 child suspended too. */
556 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
557 || event_lwp
->bp_reinsert
!= 0)
560 debug_printf ("HEW: leaving child suspended\n");
561 child_lwp
->suspended
= 1;
564 parent_proc
= get_thread_process (event_thr
);
565 child_proc
->attached
= parent_proc
->attached
;
567 if (event_lwp
->bp_reinsert
!= 0
568 && can_software_single_step ()
569 && event
== PTRACE_EVENT_VFORK
)
571 /* If we leave single-step breakpoints there, child will
572 hit it, so uninsert single-step breakpoints from parent
573 (and child). Once vfork child is done, reinsert
574 them back to parent. */
575 uninsert_single_step_breakpoints (event_thr
);
578 clone_all_breakpoints (child_thr
, event_thr
);
580 tdesc
= allocate_target_description ();
581 copy_target_description (tdesc
, parent_proc
->tdesc
);
582 child_proc
->tdesc
= tdesc
;
584 /* Clone arch-specific process data. */
585 if (the_low_target
.new_fork
!= NULL
)
586 the_low_target
.new_fork (parent_proc
, child_proc
);
588 /* Save fork info in the parent thread. */
589 if (event
== PTRACE_EVENT_FORK
)
590 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_FORKED
;
591 else if (event
== PTRACE_EVENT_VFORK
)
592 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_VFORKED
;
594 event_lwp
->waitstatus
.value
.related_pid
= ptid
;
596 /* The status_pending field contains bits denoting the
597 extended event, so when the pending event is handled,
598 the handler will look at lwp->waitstatus. */
599 event_lwp
->status_pending_p
= 1;
600 event_lwp
->status_pending
= wstat
;
602 /* Link the threads until the parent event is passed on to
604 event_lwp
->fork_relative
= child_lwp
;
605 child_lwp
->fork_relative
= event_lwp
;
607 /* If the parent thread is doing step-over with single-step
608 breakpoints, the list of single-step breakpoints are cloned
609 from the parent's. Remove them from the child process.
610 In case of vfork, we'll reinsert them back once vforked
612 if (event_lwp
->bp_reinsert
!= 0
613 && can_software_single_step ())
615 /* The child process is forked and stopped, so it is safe
616 to access its memory without stopping all other threads
617 from other processes. */
618 delete_single_step_breakpoints (child_thr
);
620 gdb_assert (has_single_step_breakpoints (event_thr
));
621 gdb_assert (!has_single_step_breakpoints (child_thr
));
624 /* Report the event. */
629 debug_printf ("HEW: Got clone event "
630 "from LWP %ld, new child is LWP %ld\n",
631 lwpid_of (event_thr
), new_pid
);
633 ptid
= ptid_t (pid_of (event_thr
), new_pid
, 0);
634 new_lwp
= add_lwp (ptid
);
636 /* Either we're going to immediately resume the new thread
637 or leave it stopped. linux_resume_one_lwp is a nop if it
638 thinks the thread is currently running, so set this first
639 before calling linux_resume_one_lwp. */
640 new_lwp
->stopped
= 1;
642 /* If we're suspending all threads, leave this one suspended
643 too. If the fork/clone parent is stepping over a breakpoint,
644 all other threads have been suspended already. Leave the
645 child suspended too. */
646 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
647 || event_lwp
->bp_reinsert
!= 0)
648 new_lwp
->suspended
= 1;
650 /* Normally we will get the pending SIGSTOP. But in some cases
651 we might get another signal delivered to the group first.
652 If we do get another signal, be sure not to lose it. */
653 if (WSTOPSIG (status
) != SIGSTOP
)
655 new_lwp
->stop_expected
= 1;
656 new_lwp
->status_pending_p
= 1;
657 new_lwp
->status_pending
= status
;
659 else if (cs
.report_thread_events
)
661 new_lwp
->waitstatus
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
662 new_lwp
->status_pending_p
= 1;
663 new_lwp
->status_pending
= status
;
667 thread_db_notice_clone (event_thr
, ptid
);
670 /* Don't report the event. */
673 else if (event
== PTRACE_EVENT_VFORK_DONE
)
675 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_VFORK_DONE
;
677 if (event_lwp
->bp_reinsert
!= 0 && can_software_single_step ())
679 reinsert_single_step_breakpoints (event_thr
);
681 gdb_assert (has_single_step_breakpoints (event_thr
));
684 /* Report the event. */
687 else if (event
== PTRACE_EVENT_EXEC
&& cs
.report_exec_events
)
689 struct process_info
*proc
;
690 std::vector
<int> syscalls_to_catch
;
696 debug_printf ("HEW: Got exec event from LWP %ld\n",
697 lwpid_of (event_thr
));
700 /* Get the event ptid. */
701 event_ptid
= ptid_of (event_thr
);
702 event_pid
= event_ptid
.pid ();
704 /* Save the syscall list from the execing process. */
705 proc
= get_thread_process (event_thr
);
706 syscalls_to_catch
= std::move (proc
->syscalls_to_catch
);
708 /* Delete the execing process and all its threads. */
710 current_thread
= NULL
;
712 /* Create a new process/lwp/thread. */
713 proc
= linux_add_process (event_pid
, 0);
714 event_lwp
= add_lwp (event_ptid
);
715 event_thr
= get_lwp_thread (event_lwp
);
716 gdb_assert (current_thread
== event_thr
);
717 linux_arch_setup_thread (event_thr
);
719 /* Set the event status. */
720 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_EXECD
;
721 event_lwp
->waitstatus
.value
.execd_pathname
722 = xstrdup (linux_proc_pid_to_exec_file (lwpid_of (event_thr
)));
724 /* Mark the exec status as pending. */
725 event_lwp
->stopped
= 1;
726 event_lwp
->status_pending_p
= 1;
727 event_lwp
->status_pending
= wstat
;
728 event_thr
->last_resume_kind
= resume_continue
;
729 event_thr
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
731 /* Update syscall state in the new lwp, effectively mid-syscall too. */
732 event_lwp
->syscall_state
= TARGET_WAITKIND_SYSCALL_ENTRY
;
734 /* Restore the list to catch. Don't rely on the client, which is free
735 to avoid sending a new list when the architecture doesn't change.
736 Also, for ANY_SYSCALL, the architecture doesn't really matter. */
737 proc
->syscalls_to_catch
= std::move (syscalls_to_catch
);
739 /* Report the event. */
740 *orig_event_lwp
= event_lwp
;
744 internal_error (__FILE__
, __LINE__
, _("unknown ptrace event %d"), event
);
747 /* Return the PC as read from the regcache of LWP, without any
751 get_pc (struct lwp_info
*lwp
)
753 struct thread_info
*saved_thread
;
754 struct regcache
*regcache
;
757 if (the_low_target
.get_pc
== NULL
)
760 saved_thread
= current_thread
;
761 current_thread
= get_lwp_thread (lwp
);
763 regcache
= get_thread_regcache (current_thread
, 1);
764 pc
= (*the_low_target
.get_pc
) (regcache
);
767 debug_printf ("pc is 0x%lx\n", (long) pc
);
769 current_thread
= saved_thread
;
773 /* This function should only be called if LWP got a SYSCALL_SIGTRAP.
774 Fill *SYSNO with the syscall nr trapped. */
777 get_syscall_trapinfo (struct lwp_info
*lwp
, int *sysno
)
779 struct thread_info
*saved_thread
;
780 struct regcache
*regcache
;
782 if (the_low_target
.get_syscall_trapinfo
== NULL
)
784 /* If we cannot get the syscall trapinfo, report an unknown
785 system call number. */
786 *sysno
= UNKNOWN_SYSCALL
;
790 saved_thread
= current_thread
;
791 current_thread
= get_lwp_thread (lwp
);
793 regcache
= get_thread_regcache (current_thread
, 1);
794 (*the_low_target
.get_syscall_trapinfo
) (regcache
, sysno
);
797 debug_printf ("get_syscall_trapinfo sysno %d\n", *sysno
);
799 current_thread
= saved_thread
;
802 static int check_stopped_by_watchpoint (struct lwp_info
*child
);
804 /* Called when the LWP stopped for a signal/trap. If it stopped for a
805 trap check what caused it (breakpoint, watchpoint, trace, etc.),
806 and save the result in the LWP's stop_reason field. If it stopped
807 for a breakpoint, decrement the PC if necessary on the lwp's
808 architecture. Returns true if we now have the LWP's stop PC. */
811 save_stop_reason (struct lwp_info
*lwp
)
814 CORE_ADDR sw_breakpoint_pc
;
815 struct thread_info
*saved_thread
;
816 #if USE_SIGTRAP_SIGINFO
820 if (the_low_target
.get_pc
== NULL
)
824 sw_breakpoint_pc
= pc
- the_low_target
.decr_pc_after_break
;
826 /* breakpoint_at reads from the current thread. */
827 saved_thread
= current_thread
;
828 current_thread
= get_lwp_thread (lwp
);
830 #if USE_SIGTRAP_SIGINFO
831 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
832 (PTRACE_TYPE_ARG3
) 0, &siginfo
) == 0)
834 if (siginfo
.si_signo
== SIGTRAP
)
836 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
)
837 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
839 /* The si_code is ambiguous on this arch -- check debug
841 if (!check_stopped_by_watchpoint (lwp
))
842 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
844 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo
.si_code
))
846 /* If we determine the LWP stopped for a SW breakpoint,
847 trust it. Particularly don't check watchpoint
848 registers, because at least on s390, we'd find
849 stopped-by-watchpoint as long as there's a watchpoint
851 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
853 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo
.si_code
))
855 /* This can indicate either a hardware breakpoint or
856 hardware watchpoint. Check debug registers. */
857 if (!check_stopped_by_watchpoint (lwp
))
858 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
860 else if (siginfo
.si_code
== TRAP_TRACE
)
862 /* We may have single stepped an instruction that
863 triggered a watchpoint. In that case, on some
864 architectures (such as x86), instead of TRAP_HWBKPT,
865 si_code indicates TRAP_TRACE, and we need to check
866 the debug registers separately. */
867 if (!check_stopped_by_watchpoint (lwp
))
868 lwp
->stop_reason
= TARGET_STOPPED_BY_SINGLE_STEP
;
873 /* We may have just stepped a breakpoint instruction. E.g., in
874 non-stop mode, GDB first tells the thread A to step a range, and
875 then the user inserts a breakpoint inside the range. In that
876 case we need to report the breakpoint PC. */
877 if ((!lwp
->stepping
|| lwp
->stop_pc
== sw_breakpoint_pc
)
878 && (*the_low_target
.breakpoint_at
) (sw_breakpoint_pc
))
879 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
881 if (hardware_breakpoint_inserted_here (pc
))
882 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
884 if (lwp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
)
885 check_stopped_by_watchpoint (lwp
);
888 if (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
)
892 struct thread_info
*thr
= get_lwp_thread (lwp
);
894 debug_printf ("CSBB: %s stopped by software breakpoint\n",
895 target_pid_to_str (ptid_of (thr
)));
898 /* Back up the PC if necessary. */
899 if (pc
!= sw_breakpoint_pc
)
901 struct regcache
*regcache
902 = get_thread_regcache (current_thread
, 1);
903 (*the_low_target
.set_pc
) (regcache
, sw_breakpoint_pc
);
906 /* Update this so we record the correct stop PC below. */
907 pc
= sw_breakpoint_pc
;
909 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
913 struct thread_info
*thr
= get_lwp_thread (lwp
);
915 debug_printf ("CSBB: %s stopped by hardware breakpoint\n",
916 target_pid_to_str (ptid_of (thr
)));
919 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
923 struct thread_info
*thr
= get_lwp_thread (lwp
);
925 debug_printf ("CSBB: %s stopped by hardware watchpoint\n",
926 target_pid_to_str (ptid_of (thr
)));
929 else if (lwp
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
)
933 struct thread_info
*thr
= get_lwp_thread (lwp
);
935 debug_printf ("CSBB: %s stopped by trace\n",
936 target_pid_to_str (ptid_of (thr
)));
941 current_thread
= saved_thread
;
945 static struct lwp_info
*
946 add_lwp (ptid_t ptid
)
948 struct lwp_info
*lwp
;
950 lwp
= XCNEW (struct lwp_info
);
952 lwp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
954 lwp
->thread
= add_thread (ptid
, lwp
);
956 if (the_low_target
.new_thread
!= NULL
)
957 the_low_target
.new_thread (lwp
);
962 /* Callback to be used when calling fork_inferior, responsible for
963 actually initiating the tracing of the inferior. */
968 if (ptrace (PTRACE_TRACEME
, 0, (PTRACE_TYPE_ARG3
) 0,
969 (PTRACE_TYPE_ARG4
) 0) < 0)
970 trace_start_error_with_name ("ptrace");
972 if (setpgid (0, 0) < 0)
973 trace_start_error_with_name ("setpgid");
975 /* If GDBserver is connected to gdb via stdio, redirect the inferior's
976 stdout to stderr so that inferior i/o doesn't corrupt the connection.
977 Also, redirect stdin to /dev/null. */
978 if (remote_connection_is_stdio ())
981 trace_start_error_with_name ("close");
982 if (open ("/dev/null", O_RDONLY
) < 0)
983 trace_start_error_with_name ("open");
985 trace_start_error_with_name ("dup2");
986 if (write (2, "stdin/stdout redirected\n",
987 sizeof ("stdin/stdout redirected\n") - 1) < 0)
989 /* Errors ignored. */;
994 /* Start an inferior process and returns its pid.
995 PROGRAM is the name of the program to be started, and PROGRAM_ARGS
996 are its arguments. */
999 linux_create_inferior (const char *program
,
1000 const std::vector
<char *> &program_args
)
1002 client_state
&cs
= get_client_state ();
1003 struct lwp_info
*new_lwp
;
1008 maybe_disable_address_space_randomization restore_personality
1009 (cs
.disable_randomization
);
1010 std::string str_program_args
= stringify_argv (program_args
);
1012 pid
= fork_inferior (program
,
1013 str_program_args
.c_str (),
1014 get_environ ()->envp (), linux_ptrace_fun
,
1015 NULL
, NULL
, NULL
, NULL
);
1018 linux_add_process (pid
, 0);
1020 ptid
= ptid_t (pid
, pid
, 0);
1021 new_lwp
= add_lwp (ptid
);
1022 new_lwp
->must_set_ptrace_flags
= 1;
1024 post_fork_inferior (pid
, program
);
1029 /* Implement the post_create_inferior target_ops method. */
1032 linux_post_create_inferior (void)
1034 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
1036 linux_arch_setup ();
1038 if (lwp
->must_set_ptrace_flags
)
1040 struct process_info
*proc
= current_process ();
1041 int options
= linux_low_ptrace_options (proc
->attached
);
1043 linux_enable_event_reporting (lwpid_of (current_thread
), options
);
1044 lwp
->must_set_ptrace_flags
= 0;
1048 /* Attach to an inferior process. Returns 0 on success, ERRNO on
1052 linux_attach_lwp (ptid_t ptid
)
1054 struct lwp_info
*new_lwp
;
1055 int lwpid
= ptid
.lwp ();
1057 if (ptrace (PTRACE_ATTACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0)
1061 new_lwp
= add_lwp (ptid
);
1063 /* We need to wait for SIGSTOP before being able to make the next
1064 ptrace call on this LWP. */
1065 new_lwp
->must_set_ptrace_flags
= 1;
1067 if (linux_proc_pid_is_stopped (lwpid
))
1070 debug_printf ("Attached to a stopped process\n");
1072 /* The process is definitely stopped. It is in a job control
1073 stop, unless the kernel predates the TASK_STOPPED /
1074 TASK_TRACED distinction, in which case it might be in a
1075 ptrace stop. Make sure it is in a ptrace stop; from there we
1076 can kill it, signal it, et cetera.
1078 First make sure there is a pending SIGSTOP. Since we are
1079 already attached, the process can not transition from stopped
1080 to running without a PTRACE_CONT; so we know this signal will
1081 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1082 probably already in the queue (unless this kernel is old
1083 enough to use TASK_STOPPED for ptrace stops); but since
1084 SIGSTOP is not an RT signal, it can only be queued once. */
1085 kill_lwp (lwpid
, SIGSTOP
);
1087 /* Finally, resume the stopped process. This will deliver the
1088 SIGSTOP (or a higher priority signal, just like normal
1089 PTRACE_ATTACH), which we'll catch later on. */
1090 ptrace (PTRACE_CONT
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1093 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
1094 brings it to a halt.
1096 There are several cases to consider here:
1098 1) gdbserver has already attached to the process and is being notified
1099 of a new thread that is being created.
1100 In this case we should ignore that SIGSTOP and resume the
1101 process. This is handled below by setting stop_expected = 1,
1102 and the fact that add_thread sets last_resume_kind ==
1105 2) This is the first thread (the process thread), and we're attaching
1106 to it via attach_inferior.
1107 In this case we want the process thread to stop.
1108 This is handled by having linux_attach set last_resume_kind ==
1109 resume_stop after we return.
1111 If the pid we are attaching to is also the tgid, we attach to and
1112 stop all the existing threads. Otherwise, we attach to pid and
1113 ignore any other threads in the same group as this pid.
1115 3) GDB is connecting to gdbserver and is requesting an enumeration of all
1117 In this case we want the thread to stop.
1118 FIXME: This case is currently not properly handled.
1119 We should wait for the SIGSTOP but don't. Things work apparently
1120 because enough time passes between when we ptrace (ATTACH) and when
1121 gdb makes the next ptrace call on the thread.
1123 On the other hand, if we are currently trying to stop all threads, we
1124 should treat the new thread as if we had sent it a SIGSTOP. This works
1125 because we are guaranteed that the add_lwp call above added us to the
1126 end of the list, and so the new thread has not yet reached
1127 wait_for_sigstop (but will). */
1128 new_lwp
->stop_expected
= 1;
1133 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1134 already attached. Returns true if a new LWP is found, false
1138 attach_proc_task_lwp_callback (ptid_t ptid
)
1140 /* Is this a new thread? */
1141 if (find_thread_ptid (ptid
) == NULL
)
1143 int lwpid
= ptid
.lwp ();
1147 debug_printf ("Found new lwp %d\n", lwpid
);
1149 err
= linux_attach_lwp (ptid
);
1151 /* Be quiet if we simply raced with the thread exiting. EPERM
1152 is returned if the thread's task still exists, and is marked
1153 as exited or zombie, as well as other conditions, so in that
1154 case, confirm the status in /proc/PID/status. */
1156 || (err
== EPERM
&& linux_proc_pid_is_gone (lwpid
)))
1160 debug_printf ("Cannot attach to lwp %d: "
1161 "thread is gone (%d: %s)\n",
1162 lwpid
, err
, strerror (err
));
1168 = linux_ptrace_attach_fail_reason_string (ptid
, err
);
1170 warning (_("Cannot attach to lwp %d: %s"), lwpid
, reason
.c_str ());
1178 static void async_file_mark (void);
1180 /* Attach to PID. If PID is the tgid, attach to it and all
1184 linux_attach (unsigned long pid
)
1186 struct process_info
*proc
;
1187 struct thread_info
*initial_thread
;
1188 ptid_t ptid
= ptid_t (pid
, pid
, 0);
1191 proc
= linux_add_process (pid
, 1);
1193 /* Attach to PID. We will check for other threads
1195 err
= linux_attach_lwp (ptid
);
1198 remove_process (proc
);
1200 std::string reason
= linux_ptrace_attach_fail_reason_string (ptid
, err
);
1201 error ("Cannot attach to process %ld: %s", pid
, reason
.c_str ());
1204 /* Don't ignore the initial SIGSTOP if we just attached to this
1205 process. It will be collected by wait shortly. */
1206 initial_thread
= find_thread_ptid (ptid_t (pid
, pid
, 0));
1207 initial_thread
->last_resume_kind
= resume_stop
;
1209 /* We must attach to every LWP. If /proc is mounted, use that to
1210 find them now. On the one hand, the inferior may be using raw
1211 clone instead of using pthreads. On the other hand, even if it
1212 is using pthreads, GDB may not be connected yet (thread_db needs
1213 to do symbol lookups, through qSymbol). Also, thread_db walks
1214 structures in the inferior's address space to find the list of
1215 threads/LWPs, and those structures may well be corrupted. Note
1216 that once thread_db is loaded, we'll still use it to list threads
1217 and associate pthread info with each LWP. */
1218 linux_proc_attach_tgid_threads (pid
, attach_proc_task_lwp_callback
);
1220 /* GDB will shortly read the xml target description for this
1221 process, to figure out the process' architecture. But the target
1222 description is only filled in when the first process/thread in
1223 the thread group reports its initial PTRACE_ATTACH SIGSTOP. Do
1224 that now, otherwise, if GDB is fast enough, it could read the
1225 target description _before_ that initial stop. */
1228 struct lwp_info
*lwp
;
1230 ptid_t pid_ptid
= ptid_t (pid
);
1232 lwpid
= linux_wait_for_event_filtered (pid_ptid
, pid_ptid
,
1234 gdb_assert (lwpid
> 0);
1236 lwp
= find_lwp_pid (ptid_t (lwpid
));
1238 if (!WIFSTOPPED (wstat
) || WSTOPSIG (wstat
) != SIGSTOP
)
1240 lwp
->status_pending_p
= 1;
1241 lwp
->status_pending
= wstat
;
1244 initial_thread
->last_resume_kind
= resume_continue
;
1248 gdb_assert (proc
->tdesc
!= NULL
);
1255 last_thread_of_process_p (int pid
)
1257 bool seen_one
= false;
1259 thread_info
*thread
= find_thread (pid
, [&] (thread_info
*thr_arg
)
1263 /* This is the first thread of this process we see. */
1269 /* This is the second thread of this process we see. */
1274 return thread
== NULL
;
1280 linux_kill_one_lwp (struct lwp_info
*lwp
)
1282 struct thread_info
*thr
= get_lwp_thread (lwp
);
1283 int pid
= lwpid_of (thr
);
1285 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
1286 there is no signal context, and ptrace(PTRACE_KILL) (or
1287 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
1288 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
1289 alternative is to kill with SIGKILL. We only need one SIGKILL
1290 per process, not one for each thread. But since we still support
1291 support debugging programs using raw clone without CLONE_THREAD,
1292 we send one for each thread. For years, we used PTRACE_KILL
1293 only, so we're being a bit paranoid about some old kernels where
1294 PTRACE_KILL might work better (dubious if there are any such, but
1295 that's why it's paranoia), so we try SIGKILL first, PTRACE_KILL
1296 second, and so we're fine everywhere. */
1299 kill_lwp (pid
, SIGKILL
);
1302 int save_errno
= errno
;
1304 debug_printf ("LKL: kill_lwp (SIGKILL) %s, 0, 0 (%s)\n",
1305 target_pid_to_str (ptid_of (thr
)),
1306 save_errno
? strerror (save_errno
) : "OK");
1310 ptrace (PTRACE_KILL
, pid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1313 int save_errno
= errno
;
1315 debug_printf ("LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
1316 target_pid_to_str (ptid_of (thr
)),
1317 save_errno
? strerror (save_errno
) : "OK");
1321 /* Kill LWP and wait for it to die. */
1324 kill_wait_lwp (struct lwp_info
*lwp
)
1326 struct thread_info
*thr
= get_lwp_thread (lwp
);
1327 int pid
= ptid_of (thr
).pid ();
1328 int lwpid
= ptid_of (thr
).lwp ();
1333 debug_printf ("kwl: killing lwp %d, for pid: %d\n", lwpid
, pid
);
1337 linux_kill_one_lwp (lwp
);
1339 /* Make sure it died. Notes:
1341 - The loop is most likely unnecessary.
1343 - We don't use linux_wait_for_event as that could delete lwps
1344 while we're iterating over them. We're not interested in
1345 any pending status at this point, only in making sure all
1346 wait status on the kernel side are collected until the
1349 - We don't use __WALL here as the __WALL emulation relies on
1350 SIGCHLD, and killing a stopped process doesn't generate
1351 one, nor an exit status.
1353 res
= my_waitpid (lwpid
, &wstat
, 0);
1354 if (res
== -1 && errno
== ECHILD
)
1355 res
= my_waitpid (lwpid
, &wstat
, __WCLONE
);
1356 } while (res
> 0 && WIFSTOPPED (wstat
));
1358 /* Even if it was stopped, the child may have already disappeared.
1359 E.g., if it was killed by SIGKILL. */
1360 if (res
< 0 && errno
!= ECHILD
)
1361 perror_with_name ("kill_wait_lwp");
1364 /* Callback for `for_each_thread'. Kills an lwp of a given process,
1365 except the leader. */
1368 kill_one_lwp_callback (thread_info
*thread
, int pid
)
1370 struct lwp_info
*lwp
= get_thread_lwp (thread
);
1372 /* We avoid killing the first thread here, because of a Linux kernel (at
1373 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
1374 the children get a chance to be reaped, it will remain a zombie
1377 if (lwpid_of (thread
) == pid
)
1380 debug_printf ("lkop: is last of process %s\n",
1381 target_pid_to_str (thread
->id
));
1385 kill_wait_lwp (lwp
);
1389 linux_kill (process_info
*process
)
1391 int pid
= process
->pid
;
1393 /* If we're killing a running inferior, make sure it is stopped
1394 first, as PTRACE_KILL will not work otherwise. */
1395 stop_all_lwps (0, NULL
);
1397 for_each_thread (pid
, [&] (thread_info
*thread
)
1399 kill_one_lwp_callback (thread
, pid
);
1402 /* See the comment in linux_kill_one_lwp. We did not kill the first
1403 thread in the list, so do so now. */
1404 lwp_info
*lwp
= find_lwp_pid (ptid_t (pid
));
1409 debug_printf ("lk_1: cannot find lwp for pid: %d\n",
1413 kill_wait_lwp (lwp
);
1415 the_target
->mourn (process
);
1417 /* Since we presently can only stop all lwps of all processes, we
1418 need to unstop lwps of other processes. */
1419 unstop_all_lwps (0, NULL
);
1423 /* Get pending signal of THREAD, for detaching purposes. This is the
1424 signal the thread last stopped for, which we need to deliver to the
1425 thread when detaching, otherwise, it'd be suppressed/lost. */
1428 get_detach_signal (struct thread_info
*thread
)
1430 client_state
&cs
= get_client_state ();
1431 enum gdb_signal signo
= GDB_SIGNAL_0
;
1433 struct lwp_info
*lp
= get_thread_lwp (thread
);
1435 if (lp
->status_pending_p
)
1436 status
= lp
->status_pending
;
1439 /* If the thread had been suspended by gdbserver, and it stopped
1440 cleanly, then it'll have stopped with SIGSTOP. But we don't
1441 want to deliver that SIGSTOP. */
1442 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
1443 || thread
->last_status
.value
.sig
== GDB_SIGNAL_0
)
1446 /* Otherwise, we may need to deliver the signal we
1448 status
= lp
->last_status
;
1451 if (!WIFSTOPPED (status
))
1454 debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n",
1455 target_pid_to_str (ptid_of (thread
)));
1459 /* Extended wait statuses aren't real SIGTRAPs. */
1460 if (WSTOPSIG (status
) == SIGTRAP
&& linux_is_extended_waitstatus (status
))
1463 debug_printf ("GPS: lwp %s had stopped with extended "
1464 "status: no pending signal\n",
1465 target_pid_to_str (ptid_of (thread
)));
1469 signo
= gdb_signal_from_host (WSTOPSIG (status
));
1471 if (cs
.program_signals_p
&& !cs
.program_signals
[signo
])
1474 debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
1475 target_pid_to_str (ptid_of (thread
)),
1476 gdb_signal_to_string (signo
));
1479 else if (!cs
.program_signals_p
1480 /* If we have no way to know which signals GDB does not
1481 want to have passed to the program, assume
1482 SIGTRAP/SIGINT, which is GDB's default. */
1483 && (signo
== GDB_SIGNAL_TRAP
|| signo
== GDB_SIGNAL_INT
))
1486 debug_printf ("GPS: lwp %s had signal %s, "
1487 "but we don't know if we should pass it. "
1488 "Default to not.\n",
1489 target_pid_to_str (ptid_of (thread
)),
1490 gdb_signal_to_string (signo
));
1496 debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n",
1497 target_pid_to_str (ptid_of (thread
)),
1498 gdb_signal_to_string (signo
));
1500 return WSTOPSIG (status
);
1504 /* Detach from LWP. */
1507 linux_detach_one_lwp (struct lwp_info
*lwp
)
1509 struct thread_info
*thread
= get_lwp_thread (lwp
);
1513 /* If there is a pending SIGSTOP, get rid of it. */
1514 if (lwp
->stop_expected
)
1517 debug_printf ("Sending SIGCONT to %s\n",
1518 target_pid_to_str (ptid_of (thread
)));
1520 kill_lwp (lwpid_of (thread
), SIGCONT
);
1521 lwp
->stop_expected
= 0;
1524 /* Pass on any pending signal for this thread. */
1525 sig
= get_detach_signal (thread
);
1527 /* Preparing to resume may try to write registers, and fail if the
1528 lwp is zombie. If that happens, ignore the error. We'll handle
1529 it below, when detach fails with ESRCH. */
1532 /* Flush any pending changes to the process's registers. */
1533 regcache_invalidate_thread (thread
);
1535 /* Finally, let it resume. */
1536 if (the_low_target
.prepare_to_resume
!= NULL
)
1537 the_low_target
.prepare_to_resume (lwp
);
1539 catch (const gdb_exception_error
&ex
)
1541 if (!check_ptrace_stopped_lwp_gone (lwp
))
1545 lwpid
= lwpid_of (thread
);
1546 if (ptrace (PTRACE_DETACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0,
1547 (PTRACE_TYPE_ARG4
) (long) sig
) < 0)
1549 int save_errno
= errno
;
1551 /* We know the thread exists, so ESRCH must mean the lwp is
1552 zombie. This can happen if one of the already-detached
1553 threads exits the whole thread group. In that case we're
1554 still attached, and must reap the lwp. */
1555 if (save_errno
== ESRCH
)
1559 ret
= my_waitpid (lwpid
, &status
, __WALL
);
1562 warning (_("Couldn't reap LWP %d while detaching: %s"),
1563 lwpid
, strerror (errno
));
1565 else if (!WIFEXITED (status
) && !WIFSIGNALED (status
))
1567 warning (_("Reaping LWP %d while detaching "
1568 "returned unexpected status 0x%x"),
1574 error (_("Can't detach %s: %s"),
1575 target_pid_to_str (ptid_of (thread
)),
1576 strerror (save_errno
));
1579 else if (debug_threads
)
1581 debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)\n",
1582 target_pid_to_str (ptid_of (thread
)),
1589 /* Callback for for_each_thread. Detaches from non-leader threads of a
1593 linux_detach_lwp_callback (thread_info
*thread
)
1595 /* We don't actually detach from the thread group leader just yet.
1596 If the thread group exits, we must reap the zombie clone lwps
1597 before we're able to reap the leader. */
1598 if (thread
->id
.pid () == thread
->id
.lwp ())
1601 lwp_info
*lwp
= get_thread_lwp (thread
);
1602 linux_detach_one_lwp (lwp
);
1606 linux_detach (process_info
*process
)
1608 struct lwp_info
*main_lwp
;
1610 /* As there's a step over already in progress, let it finish first,
1611 otherwise nesting a stabilize_threads operation on top gets real
1613 complete_ongoing_step_over ();
1615 /* Stop all threads before detaching. First, ptrace requires that
1616 the thread is stopped to successfully detach. Second, thread_db
1617 may need to uninstall thread event breakpoints from memory, which
1618 only works with a stopped process anyway. */
1619 stop_all_lwps (0, NULL
);
1621 #ifdef USE_THREAD_DB
1622 thread_db_detach (process
);
1625 /* Stabilize threads (move out of jump pads). */
1626 stabilize_threads ();
1628 /* Detach from the clone lwps first. If the thread group exits just
1629 while we're detaching, we must reap the clone lwps before we're
1630 able to reap the leader. */
1631 for_each_thread (process
->pid
, linux_detach_lwp_callback
);
1633 main_lwp
= find_lwp_pid (ptid_t (process
->pid
));
1634 linux_detach_one_lwp (main_lwp
);
1636 the_target
->mourn (process
);
1638 /* Since we presently can only stop all lwps of all processes, we
1639 need to unstop lwps of other processes. */
1640 unstop_all_lwps (0, NULL
);
1644 /* Remove all LWPs that belong to process PROC from the lwp list. */
1647 linux_mourn (struct process_info
*process
)
1649 struct process_info_private
*priv
;
1651 #ifdef USE_THREAD_DB
1652 thread_db_mourn (process
);
1655 for_each_thread (process
->pid
, [] (thread_info
*thread
)
1657 delete_lwp (get_thread_lwp (thread
));
1660 /* Freeing all private data. */
1661 priv
= process
->priv
;
1662 if (the_low_target
.delete_process
!= NULL
)
1663 the_low_target
.delete_process (priv
->arch_private
);
1665 gdb_assert (priv
->arch_private
== NULL
);
1667 process
->priv
= NULL
;
1669 remove_process (process
);
1673 linux_join (int pid
)
1678 ret
= my_waitpid (pid
, &status
, 0);
1679 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1681 } while (ret
!= -1 || errno
!= ECHILD
);
1684 /* Return nonzero if the given thread is still alive. */
1686 linux_thread_alive (ptid_t ptid
)
1688 struct lwp_info
*lwp
= find_lwp_pid (ptid
);
1690 /* We assume we always know if a thread exits. If a whole process
1691 exited but we still haven't been able to report it to GDB, we'll
1692 hold on to the last lwp of the dead process. */
1694 return !lwp_is_marked_dead (lwp
);
1699 /* Return 1 if this lwp still has an interesting status pending. If
1700 not (e.g., it had stopped for a breakpoint that is gone), return
1704 thread_still_has_status_pending_p (struct thread_info
*thread
)
1706 struct lwp_info
*lp
= get_thread_lwp (thread
);
1708 if (!lp
->status_pending_p
)
1711 if (thread
->last_resume_kind
!= resume_stop
1712 && (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1713 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
1715 struct thread_info
*saved_thread
;
1719 gdb_assert (lp
->last_status
!= 0);
1723 saved_thread
= current_thread
;
1724 current_thread
= thread
;
1726 if (pc
!= lp
->stop_pc
)
1729 debug_printf ("PC of %ld changed\n",
1734 #if !USE_SIGTRAP_SIGINFO
1735 else if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1736 && !(*the_low_target
.breakpoint_at
) (pc
))
1739 debug_printf ("previous SW breakpoint of %ld gone\n",
1743 else if (lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
1744 && !hardware_breakpoint_inserted_here (pc
))
1747 debug_printf ("previous HW breakpoint of %ld gone\n",
1753 current_thread
= saved_thread
;
1758 debug_printf ("discarding pending breakpoint status\n");
1759 lp
->status_pending_p
= 0;
1767 /* Returns true if LWP is resumed from the client's perspective. */
1770 lwp_resumed (struct lwp_info
*lwp
)
1772 struct thread_info
*thread
= get_lwp_thread (lwp
);
1774 if (thread
->last_resume_kind
!= resume_stop
)
1777 /* Did gdb send us a `vCont;t', but we haven't reported the
1778 corresponding stop to gdb yet? If so, the thread is still
1779 resumed/running from gdb's perspective. */
1780 if (thread
->last_resume_kind
== resume_stop
1781 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
1787 /* Return true if this lwp has an interesting status pending. */
1789 status_pending_p_callback (thread_info
*thread
, ptid_t ptid
)
1791 struct lwp_info
*lp
= get_thread_lwp (thread
);
1793 /* Check if we're only interested in events from a specific process
1794 or a specific LWP. */
1795 if (!thread
->id
.matches (ptid
))
1798 if (!lwp_resumed (lp
))
1801 if (lp
->status_pending_p
1802 && !thread_still_has_status_pending_p (thread
))
1804 linux_resume_one_lwp (lp
, lp
->stepping
, GDB_SIGNAL_0
, NULL
);
1808 return lp
->status_pending_p
;
1812 find_lwp_pid (ptid_t ptid
)
1814 thread_info
*thread
= find_thread ([&] (thread_info
*thr_arg
)
1816 int lwp
= ptid
.lwp () != 0 ? ptid
.lwp () : ptid
.pid ();
1817 return thr_arg
->id
.lwp () == lwp
;
1823 return get_thread_lwp (thread
);
1826 /* Return the number of known LWPs in the tgid given by PID. */
1833 for_each_thread (pid
, [&] (thread_info
*thread
)
1841 /* See nat/linux-nat.h. */
1844 iterate_over_lwps (ptid_t filter
,
1845 gdb::function_view
<iterate_over_lwps_ftype
> callback
)
1847 thread_info
*thread
= find_thread (filter
, [&] (thread_info
*thr_arg
)
1849 lwp_info
*lwp
= get_thread_lwp (thr_arg
);
1851 return callback (lwp
);
1857 return get_thread_lwp (thread
);
1860 /* Detect zombie thread group leaders, and "exit" them. We can't reap
1861 their exits until all other threads in the group have exited. */
1864 check_zombie_leaders (void)
1866 for_each_process ([] (process_info
*proc
) {
1867 pid_t leader_pid
= pid_of (proc
);
1868 struct lwp_info
*leader_lp
;
1870 leader_lp
= find_lwp_pid (ptid_t (leader_pid
));
1873 debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
1874 "num_lwps=%d, zombie=%d\n",
1875 leader_pid
, leader_lp
!= NULL
, num_lwps (leader_pid
),
1876 linux_proc_pid_is_zombie (leader_pid
));
1878 if (leader_lp
!= NULL
&& !leader_lp
->stopped
1879 /* Check if there are other threads in the group, as we may
1880 have raced with the inferior simply exiting. */
1881 && !last_thread_of_process_p (leader_pid
)
1882 && linux_proc_pid_is_zombie (leader_pid
))
1884 /* A leader zombie can mean one of two things:
1886 - It exited, and there's an exit status pending
1887 available, or only the leader exited (not the whole
1888 program). In the latter case, we can't waitpid the
1889 leader's exit status until all other threads are gone.
1891 - There are 3 or more threads in the group, and a thread
1892 other than the leader exec'd. On an exec, the Linux
1893 kernel destroys all other threads (except the execing
1894 one) in the thread group, and resets the execing thread's
1895 tid to the tgid. No exit notification is sent for the
1896 execing thread -- from the ptracer's perspective, it
1897 appears as though the execing thread just vanishes.
1898 Until we reap all other threads except the leader and the
1899 execing thread, the leader will be zombie, and the
1900 execing thread will be in `D (disc sleep)'. As soon as
1901 all other threads are reaped, the execing thread changes
1902 it's tid to the tgid, and the previous (zombie) leader
1903 vanishes, giving place to the "new" leader. We could try
1904 distinguishing the exit and exec cases, by waiting once
1905 more, and seeing if something comes out, but it doesn't
1906 sound useful. The previous leader _does_ go away, and
1907 we'll re-add the new one once we see the exec event
1908 (which is just the same as what would happen if the
1909 previous leader did exit voluntarily before some other
1913 debug_printf ("CZL: Thread group leader %d zombie "
1914 "(it exited, or another thread execd).\n",
1917 delete_lwp (leader_lp
);
1922 /* Callback for `find_thread'. Returns the first LWP that is not
1926 not_stopped_callback (thread_info
*thread
, ptid_t filter
)
1928 if (!thread
->id
.matches (filter
))
1931 lwp_info
*lwp
= get_thread_lwp (thread
);
1933 return !lwp
->stopped
;
1936 /* Increment LWP's suspend count. */
1939 lwp_suspended_inc (struct lwp_info
*lwp
)
1943 if (debug_threads
&& lwp
->suspended
> 4)
1945 struct thread_info
*thread
= get_lwp_thread (lwp
);
1947 debug_printf ("LWP %ld has a suspiciously high suspend count,"
1948 " suspended=%d\n", lwpid_of (thread
), lwp
->suspended
);
1952 /* Decrement LWP's suspend count. */
1955 lwp_suspended_decr (struct lwp_info
*lwp
)
1959 if (lwp
->suspended
< 0)
1961 struct thread_info
*thread
= get_lwp_thread (lwp
);
1963 internal_error (__FILE__
, __LINE__
,
1964 "unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread
),
1969 /* This function should only be called if the LWP got a SIGTRAP.
1971 Handle any tracepoint steps or hits. Return true if a tracepoint
1972 event was handled, 0 otherwise. */
1975 handle_tracepoints (struct lwp_info
*lwp
)
1977 struct thread_info
*tinfo
= get_lwp_thread (lwp
);
1978 int tpoint_related_event
= 0;
1980 gdb_assert (lwp
->suspended
== 0);
1982 /* If this tracepoint hit causes a tracing stop, we'll immediately
1983 uninsert tracepoints. To do this, we temporarily pause all
1984 threads, unpatch away, and then unpause threads. We need to make
1985 sure the unpausing doesn't resume LWP too. */
1986 lwp_suspended_inc (lwp
);
1988 /* And we need to be sure that any all-threads-stopping doesn't try
1989 to move threads out of the jump pads, as it could deadlock the
1990 inferior (LWP could be in the jump pad, maybe even holding the
1993 /* Do any necessary step collect actions. */
1994 tpoint_related_event
|= tracepoint_finished_step (tinfo
, lwp
->stop_pc
);
1996 tpoint_related_event
|= handle_tracepoint_bkpts (tinfo
, lwp
->stop_pc
);
1998 /* See if we just hit a tracepoint and do its main collect
2000 tpoint_related_event
|= tracepoint_was_hit (tinfo
, lwp
->stop_pc
);
2002 lwp_suspended_decr (lwp
);
2004 gdb_assert (lwp
->suspended
== 0);
2005 gdb_assert (!stabilizing_threads
2006 || (lwp
->collecting_fast_tracepoint
2007 != fast_tpoint_collect_result::not_collecting
));
2009 if (tpoint_related_event
)
2012 debug_printf ("got a tracepoint event\n");
2019 /* Convenience wrapper. Returns information about LWP's fast tracepoint
2020 collection status. */
2022 static fast_tpoint_collect_result
2023 linux_fast_tracepoint_collecting (struct lwp_info
*lwp
,
2024 struct fast_tpoint_collect_status
*status
)
2026 CORE_ADDR thread_area
;
2027 struct thread_info
*thread
= get_lwp_thread (lwp
);
2029 if (the_low_target
.get_thread_area
== NULL
)
2030 return fast_tpoint_collect_result::not_collecting
;
2032 /* Get the thread area address. This is used to recognize which
2033 thread is which when tracing with the in-process agent library.
2034 We don't read anything from the address, and treat it as opaque;
2035 it's the address itself that we assume is unique per-thread. */
2036 if ((*the_low_target
.get_thread_area
) (lwpid_of (thread
), &thread_area
) == -1)
2037 return fast_tpoint_collect_result::not_collecting
;
2039 return fast_tracepoint_collecting (thread_area
, lwp
->stop_pc
, status
);
2042 /* The reason we resume in the caller, is because we want to be able
2043 to pass lwp->status_pending as WSTAT, and we need to clear
2044 status_pending_p before resuming, otherwise, linux_resume_one_lwp
2045 refuses to resume. */
2048 maybe_move_out_of_jump_pad (struct lwp_info
*lwp
, int *wstat
)
2050 struct thread_info
*saved_thread
;
2052 saved_thread
= current_thread
;
2053 current_thread
= get_lwp_thread (lwp
);
2056 || (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) != SIGTRAP
))
2057 && supports_fast_tracepoints ()
2058 && agent_loaded_p ())
2060 struct fast_tpoint_collect_status status
;
2063 debug_printf ("Checking whether LWP %ld needs to move out of the "
2065 lwpid_of (current_thread
));
2067 fast_tpoint_collect_result r
2068 = linux_fast_tracepoint_collecting (lwp
, &status
);
2071 || (WSTOPSIG (*wstat
) != SIGILL
2072 && WSTOPSIG (*wstat
) != SIGFPE
2073 && WSTOPSIG (*wstat
) != SIGSEGV
2074 && WSTOPSIG (*wstat
) != SIGBUS
))
2076 lwp
->collecting_fast_tracepoint
= r
;
2078 if (r
!= fast_tpoint_collect_result::not_collecting
)
2080 if (r
== fast_tpoint_collect_result::before_insn
2081 && lwp
->exit_jump_pad_bkpt
== NULL
)
2083 /* Haven't executed the original instruction yet.
2084 Set breakpoint there, and wait till it's hit,
2085 then single-step until exiting the jump pad. */
2086 lwp
->exit_jump_pad_bkpt
2087 = set_breakpoint_at (status
.adjusted_insn_addr
, NULL
);
2091 debug_printf ("Checking whether LWP %ld needs to move out of "
2092 "the jump pad...it does\n",
2093 lwpid_of (current_thread
));
2094 current_thread
= saved_thread
;
2101 /* If we get a synchronous signal while collecting, *and*
2102 while executing the (relocated) original instruction,
2103 reset the PC to point at the tpoint address, before
2104 reporting to GDB. Otherwise, it's an IPA lib bug: just
2105 report the signal to GDB, and pray for the best. */
2107 lwp
->collecting_fast_tracepoint
2108 = fast_tpoint_collect_result::not_collecting
;
2110 if (r
!= fast_tpoint_collect_result::not_collecting
2111 && (status
.adjusted_insn_addr
<= lwp
->stop_pc
2112 && lwp
->stop_pc
< status
.adjusted_insn_addr_end
))
2115 struct regcache
*regcache
;
2117 /* The si_addr on a few signals references the address
2118 of the faulting instruction. Adjust that as
2120 if ((WSTOPSIG (*wstat
) == SIGILL
2121 || WSTOPSIG (*wstat
) == SIGFPE
2122 || WSTOPSIG (*wstat
) == SIGBUS
2123 || WSTOPSIG (*wstat
) == SIGSEGV
)
2124 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
2125 (PTRACE_TYPE_ARG3
) 0, &info
) == 0
2126 /* Final check just to make sure we don't clobber
2127 the siginfo of non-kernel-sent signals. */
2128 && (uintptr_t) info
.si_addr
== lwp
->stop_pc
)
2130 info
.si_addr
= (void *) (uintptr_t) status
.tpoint_addr
;
2131 ptrace (PTRACE_SETSIGINFO
, lwpid_of (current_thread
),
2132 (PTRACE_TYPE_ARG3
) 0, &info
);
2135 regcache
= get_thread_regcache (current_thread
, 1);
2136 (*the_low_target
.set_pc
) (regcache
, status
.tpoint_addr
);
2137 lwp
->stop_pc
= status
.tpoint_addr
;
2139 /* Cancel any fast tracepoint lock this thread was
2141 force_unlock_trace_buffer ();
2144 if (lwp
->exit_jump_pad_bkpt
!= NULL
)
2147 debug_printf ("Cancelling fast exit-jump-pad: removing bkpt. "
2148 "stopping all threads momentarily.\n");
2150 stop_all_lwps (1, lwp
);
2152 delete_breakpoint (lwp
->exit_jump_pad_bkpt
);
2153 lwp
->exit_jump_pad_bkpt
= NULL
;
2155 unstop_all_lwps (1, lwp
);
2157 gdb_assert (lwp
->suspended
>= 0);
2163 debug_printf ("Checking whether LWP %ld needs to move out of the "
2165 lwpid_of (current_thread
));
2167 current_thread
= saved_thread
;
2171 /* Enqueue one signal in the "signals to report later when out of the
2175 enqueue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2177 struct pending_signals
*p_sig
;
2178 struct thread_info
*thread
= get_lwp_thread (lwp
);
2181 debug_printf ("Deferring signal %d for LWP %ld.\n",
2182 WSTOPSIG (*wstat
), lwpid_of (thread
));
2186 struct pending_signals
*sig
;
2188 for (sig
= lwp
->pending_signals_to_report
;
2191 debug_printf (" Already queued %d\n",
2194 debug_printf (" (no more currently queued signals)\n");
2197 /* Don't enqueue non-RT signals if they are already in the deferred
2198 queue. (SIGSTOP being the easiest signal to see ending up here
2200 if (WSTOPSIG (*wstat
) < __SIGRTMIN
)
2202 struct pending_signals
*sig
;
2204 for (sig
= lwp
->pending_signals_to_report
;
2208 if (sig
->signal
== WSTOPSIG (*wstat
))
2211 debug_printf ("Not requeuing already queued non-RT signal %d"
2220 p_sig
= XCNEW (struct pending_signals
);
2221 p_sig
->prev
= lwp
->pending_signals_to_report
;
2222 p_sig
->signal
= WSTOPSIG (*wstat
);
2224 ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2227 lwp
->pending_signals_to_report
= p_sig
;
2230 /* Dequeue one signal from the "signals to report later when out of
2231 the jump pad" list. */
2234 dequeue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2236 struct thread_info
*thread
= get_lwp_thread (lwp
);
2238 if (lwp
->pending_signals_to_report
!= NULL
)
2240 struct pending_signals
**p_sig
;
2242 p_sig
= &lwp
->pending_signals_to_report
;
2243 while ((*p_sig
)->prev
!= NULL
)
2244 p_sig
= &(*p_sig
)->prev
;
2246 *wstat
= W_STOPCODE ((*p_sig
)->signal
);
2247 if ((*p_sig
)->info
.si_signo
!= 0)
2248 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2254 debug_printf ("Reporting deferred signal %d for LWP %ld.\n",
2255 WSTOPSIG (*wstat
), lwpid_of (thread
));
2259 struct pending_signals
*sig
;
2261 for (sig
= lwp
->pending_signals_to_report
;
2264 debug_printf (" Still queued %d\n",
2267 debug_printf (" (no more queued signals)\n");
2276 /* Fetch the possibly triggered data watchpoint info and store it in
2279 On some archs, like x86, that use debug registers to set
2280 watchpoints, it's possible that the way to know which watched
2281 address trapped, is to check the register that is used to select
2282 which address to watch. Problem is, between setting the watchpoint
2283 and reading back which data address trapped, the user may change
2284 the set of watchpoints, and, as a consequence, GDB changes the
2285 debug registers in the inferior. To avoid reading back a stale
2286 stopped-data-address when that happens, we cache in LP the fact
2287 that a watchpoint trapped, and the corresponding data address, as
2288 soon as we see CHILD stop with a SIGTRAP. If GDB changes the debug
2289 registers meanwhile, we have the cached data we can rely on. */
2292 check_stopped_by_watchpoint (struct lwp_info
*child
)
2294 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
2296 struct thread_info
*saved_thread
;
2298 saved_thread
= current_thread
;
2299 current_thread
= get_lwp_thread (child
);
2301 if (the_low_target
.stopped_by_watchpoint ())
2303 child
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
2305 if (the_low_target
.stopped_data_address
!= NULL
)
2306 child
->stopped_data_address
2307 = the_low_target
.stopped_data_address ();
2309 child
->stopped_data_address
= 0;
2312 current_thread
= saved_thread
;
2315 return child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2318 /* Return the ptrace options that we want to try to enable. */
2321 linux_low_ptrace_options (int attached
)
2323 client_state
&cs
= get_client_state ();
2327 options
|= PTRACE_O_EXITKILL
;
2329 if (cs
.report_fork_events
)
2330 options
|= PTRACE_O_TRACEFORK
;
2332 if (cs
.report_vfork_events
)
2333 options
|= (PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEVFORKDONE
);
2335 if (cs
.report_exec_events
)
2336 options
|= PTRACE_O_TRACEEXEC
;
2338 options
|= PTRACE_O_TRACESYSGOOD
;
2343 /* Do low-level handling of the event, and check if we should go on
2344 and pass it to caller code. Return the affected lwp if we are, or
2347 static struct lwp_info
*
2348 linux_low_filter_event (int lwpid
, int wstat
)
2350 client_state
&cs
= get_client_state ();
2351 struct lwp_info
*child
;
2352 struct thread_info
*thread
;
2353 int have_stop_pc
= 0;
2355 child
= find_lwp_pid (ptid_t (lwpid
));
2357 /* Check for stop events reported by a process we didn't already
2358 know about - anything not already in our LWP list.
2360 If we're expecting to receive stopped processes after
2361 fork, vfork, and clone events, then we'll just add the
2362 new one to our list and go back to waiting for the event
2363 to be reported - the stopped process might be returned
2364 from waitpid before or after the event is.
2366 But note the case of a non-leader thread exec'ing after the
2367 leader having exited, and gone from our lists (because
2368 check_zombie_leaders deleted it). The non-leader thread
2369 changes its tid to the tgid. */
2371 if (WIFSTOPPED (wstat
) && child
== NULL
&& WSTOPSIG (wstat
) == SIGTRAP
2372 && linux_ptrace_get_extended_event (wstat
) == PTRACE_EVENT_EXEC
)
2376 /* A multi-thread exec after we had seen the leader exiting. */
2379 debug_printf ("LLW: Re-adding thread group leader LWP %d"
2380 "after exec.\n", lwpid
);
2383 child_ptid
= ptid_t (lwpid
, lwpid
, 0);
2384 child
= add_lwp (child_ptid
);
2386 current_thread
= child
->thread
;
2389 /* If we didn't find a process, one of two things presumably happened:
2390 - A process we started and then detached from has exited. Ignore it.
2391 - A process we are controlling has forked and the new child's stop
2392 was reported to us by the kernel. Save its PID. */
2393 if (child
== NULL
&& WIFSTOPPED (wstat
))
2395 add_to_pid_list (&stopped_pids
, lwpid
, wstat
);
2398 else if (child
== NULL
)
2401 thread
= get_lwp_thread (child
);
2405 child
->last_status
= wstat
;
2407 /* Check if the thread has exited. */
2408 if ((WIFEXITED (wstat
) || WIFSIGNALED (wstat
)))
2411 debug_printf ("LLFE: %d exited.\n", lwpid
);
2413 if (finish_step_over (child
))
2415 /* Unsuspend all other LWPs, and set them back running again. */
2416 unsuspend_all_lwps (child
);
2419 /* If there is at least one more LWP, then the exit signal was
2420 not the end of the debugged application and should be
2421 ignored, unless GDB wants to hear about thread exits. */
2422 if (cs
.report_thread_events
2423 || last_thread_of_process_p (pid_of (thread
)))
2425 /* Since events are serialized to GDB core, and we can't
2426 report this one right now. Leave the status pending for
2427 the next time we're able to report it. */
2428 mark_lwp_dead (child
, wstat
);
2438 gdb_assert (WIFSTOPPED (wstat
));
2440 if (WIFSTOPPED (wstat
))
2442 struct process_info
*proc
;
2444 /* Architecture-specific setup after inferior is running. */
2445 proc
= find_process_pid (pid_of (thread
));
2446 if (proc
->tdesc
== NULL
)
2450 /* This needs to happen after we have attached to the
2451 inferior and it is stopped for the first time, but
2452 before we access any inferior registers. */
2453 linux_arch_setup_thread (thread
);
2457 /* The process is started, but GDBserver will do
2458 architecture-specific setup after the program stops at
2459 the first instruction. */
2460 child
->status_pending_p
= 1;
2461 child
->status_pending
= wstat
;
2467 if (WIFSTOPPED (wstat
) && child
->must_set_ptrace_flags
)
2469 struct process_info
*proc
= find_process_pid (pid_of (thread
));
2470 int options
= linux_low_ptrace_options (proc
->attached
);
2472 linux_enable_event_reporting (lwpid
, options
);
2473 child
->must_set_ptrace_flags
= 0;
2476 /* Always update syscall_state, even if it will be filtered later. */
2477 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SYSCALL_SIGTRAP
)
2479 child
->syscall_state
2480 = (child
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
2481 ? TARGET_WAITKIND_SYSCALL_RETURN
2482 : TARGET_WAITKIND_SYSCALL_ENTRY
);
2486 /* Almost all other ptrace-stops are known to be outside of system
2487 calls, with further exceptions in handle_extended_wait. */
2488 child
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2491 /* Be careful to not overwrite stop_pc until save_stop_reason is
2493 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGTRAP
2494 && linux_is_extended_waitstatus (wstat
))
2496 child
->stop_pc
= get_pc (child
);
2497 if (handle_extended_wait (&child
, wstat
))
2499 /* The event has been handled, so just return without
2505 if (linux_wstatus_maybe_breakpoint (wstat
))
2507 if (save_stop_reason (child
))
2512 child
->stop_pc
= get_pc (child
);
2514 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGSTOP
2515 && child
->stop_expected
)
2518 debug_printf ("Expected stop.\n");
2519 child
->stop_expected
= 0;
2521 if (thread
->last_resume_kind
== resume_stop
)
2523 /* We want to report the stop to the core. Treat the
2524 SIGSTOP as a normal event. */
2526 debug_printf ("LLW: resume_stop SIGSTOP caught for %s.\n",
2527 target_pid_to_str (ptid_of (thread
)));
2529 else if (stopping_threads
!= NOT_STOPPING_THREADS
)
2531 /* Stopping threads. We don't want this SIGSTOP to end up
2534 debug_printf ("LLW: SIGSTOP caught for %s "
2535 "while stopping threads.\n",
2536 target_pid_to_str (ptid_of (thread
)));
2541 /* This is a delayed SIGSTOP. Filter out the event. */
2543 debug_printf ("LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
2544 child
->stepping
? "step" : "continue",
2545 target_pid_to_str (ptid_of (thread
)));
2547 linux_resume_one_lwp (child
, child
->stepping
, 0, NULL
);
2552 child
->status_pending_p
= 1;
2553 child
->status_pending
= wstat
;
2557 /* Return true if THREAD is doing hardware single step. */
2560 maybe_hw_step (struct thread_info
*thread
)
2562 if (can_hardware_single_step ())
2566 /* GDBserver must insert single-step breakpoint for software
2568 gdb_assert (has_single_step_breakpoints (thread
));
2573 /* Resume LWPs that are currently stopped without any pending status
2574 to report, but are resumed from the core's perspective. */
2577 resume_stopped_resumed_lwps (thread_info
*thread
)
2579 struct lwp_info
*lp
= get_thread_lwp (thread
);
2583 && !lp
->status_pending_p
2584 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2588 if (thread
->last_resume_kind
== resume_step
)
2589 step
= maybe_hw_step (thread
);
2592 debug_printf ("RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
2593 target_pid_to_str (ptid_of (thread
)),
2594 paddress (lp
->stop_pc
),
2597 linux_resume_one_lwp (lp
, step
, GDB_SIGNAL_0
, NULL
);
2601 /* Wait for an event from child(ren) WAIT_PTID, and return any that
2602 match FILTER_PTID (leaving others pending). The PTIDs can be:
2603 minus_one_ptid, to specify any child; a pid PTID, specifying all
2604 lwps of a thread group; or a PTID representing a single lwp. Store
2605 the stop status through the status pointer WSTAT. OPTIONS is
2606 passed to the waitpid call. Return 0 if no event was found and
2607 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
2608 was found. Return the PID of the stopped child otherwise. */
2611 linux_wait_for_event_filtered (ptid_t wait_ptid
, ptid_t filter_ptid
,
2612 int *wstatp
, int options
)
2614 struct thread_info
*event_thread
;
2615 struct lwp_info
*event_child
, *requested_child
;
2616 sigset_t block_mask
, prev_mask
;
2619 /* N.B. event_thread points to the thread_info struct that contains
2620 event_child. Keep them in sync. */
2621 event_thread
= NULL
;
2623 requested_child
= NULL
;
2625 /* Check for a lwp with a pending status. */
2627 if (filter_ptid
== minus_one_ptid
|| filter_ptid
.is_pid ())
2629 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2631 return status_pending_p_callback (thread
, filter_ptid
);
2634 if (event_thread
!= NULL
)
2635 event_child
= get_thread_lwp (event_thread
);
2636 if (debug_threads
&& event_thread
)
2637 debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread
));
2639 else if (filter_ptid
!= null_ptid
)
2641 requested_child
= find_lwp_pid (filter_ptid
);
2643 if (stopping_threads
== NOT_STOPPING_THREADS
2644 && requested_child
->status_pending_p
2645 && (requested_child
->collecting_fast_tracepoint
2646 != fast_tpoint_collect_result::not_collecting
))
2648 enqueue_one_deferred_signal (requested_child
,
2649 &requested_child
->status_pending
);
2650 requested_child
->status_pending_p
= 0;
2651 requested_child
->status_pending
= 0;
2652 linux_resume_one_lwp (requested_child
, 0, 0, NULL
);
2655 if (requested_child
->suspended
2656 && requested_child
->status_pending_p
)
2658 internal_error (__FILE__
, __LINE__
,
2659 "requesting an event out of a"
2660 " suspended child?");
2663 if (requested_child
->status_pending_p
)
2665 event_child
= requested_child
;
2666 event_thread
= get_lwp_thread (event_child
);
2670 if (event_child
!= NULL
)
2673 debug_printf ("Got an event from pending child %ld (%04x)\n",
2674 lwpid_of (event_thread
), event_child
->status_pending
);
2675 *wstatp
= event_child
->status_pending
;
2676 event_child
->status_pending_p
= 0;
2677 event_child
->status_pending
= 0;
2678 current_thread
= event_thread
;
2679 return lwpid_of (event_thread
);
2682 /* But if we don't find a pending event, we'll have to wait.
2684 We only enter this loop if no process has a pending wait status.
2685 Thus any action taken in response to a wait status inside this
2686 loop is responding as soon as we detect the status, not after any
2689 /* Make sure SIGCHLD is blocked until the sigsuspend below. Block
2690 all signals while here. */
2691 sigfillset (&block_mask
);
2692 sigprocmask (SIG_BLOCK
, &block_mask
, &prev_mask
);
2694 /* Always pull all events out of the kernel. We'll randomly select
2695 an event LWP out of all that have events, to prevent
2697 while (event_child
== NULL
)
2701 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
2704 - If the thread group leader exits while other threads in the
2705 thread group still exist, waitpid(TGID, ...) hangs. That
2706 waitpid won't return an exit status until the other threads
2707 in the group are reaped.
2709 - When a non-leader thread execs, that thread just vanishes
2710 without reporting an exit (so we'd hang if we waited for it
2711 explicitly in that case). The exec event is reported to
2714 ret
= my_waitpid (-1, wstatp
, options
| WNOHANG
);
2717 debug_printf ("LWFE: waitpid(-1, ...) returned %d, %s\n",
2718 ret
, errno
? strerror (errno
) : "ERRNO-OK");
2724 debug_printf ("LLW: waitpid %ld received %s\n",
2725 (long) ret
, status_to_str (*wstatp
));
2728 /* Filter all events. IOW, leave all events pending. We'll
2729 randomly select an event LWP out of all that have events
2731 linux_low_filter_event (ret
, *wstatp
);
2732 /* Retry until nothing comes out of waitpid. A single
2733 SIGCHLD can indicate more than one child stopped. */
2737 /* Now that we've pulled all events out of the kernel, resume
2738 LWPs that don't have an interesting event to report. */
2739 if (stopping_threads
== NOT_STOPPING_THREADS
)
2740 for_each_thread (resume_stopped_resumed_lwps
);
2742 /* ... and find an LWP with a status to report to the core, if
2744 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2746 return status_pending_p_callback (thread
, filter_ptid
);
2749 if (event_thread
!= NULL
)
2751 event_child
= get_thread_lwp (event_thread
);
2752 *wstatp
= event_child
->status_pending
;
2753 event_child
->status_pending_p
= 0;
2754 event_child
->status_pending
= 0;
2758 /* Check for zombie thread group leaders. Those can't be reaped
2759 until all other threads in the thread group are. */
2760 check_zombie_leaders ();
2762 auto not_stopped
= [&] (thread_info
*thread
)
2764 return not_stopped_callback (thread
, wait_ptid
);
2767 /* If there are no resumed children left in the set of LWPs we
2768 want to wait for, bail. We can't just block in
2769 waitpid/sigsuspend, because lwps might have been left stopped
2770 in trace-stop state, and we'd be stuck forever waiting for
2771 their status to change (which would only happen if we resumed
2772 them). Even if WNOHANG is set, this return code is preferred
2773 over 0 (below), as it is more detailed. */
2774 if (find_thread (not_stopped
) == NULL
)
2777 debug_printf ("LLW: exit (no unwaited-for LWP)\n");
2778 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
2782 /* No interesting event to report to the caller. */
2783 if ((options
& WNOHANG
))
2786 debug_printf ("WNOHANG set, no event found\n");
2788 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
2792 /* Block until we get an event reported with SIGCHLD. */
2794 debug_printf ("sigsuspend'ing\n");
2796 sigsuspend (&prev_mask
);
2797 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
2801 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
2803 current_thread
= event_thread
;
2805 return lwpid_of (event_thread
);
2808 /* Wait for an event from child(ren) PTID. PTIDs can be:
2809 minus_one_ptid, to specify any child; a pid PTID, specifying all
2810 lwps of a thread group; or a PTID representing a single lwp. Store
2811 the stop status through the status pointer WSTAT. OPTIONS is
2812 passed to the waitpid call. Return 0 if no event was found and
2813 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
2814 was found. Return the PID of the stopped child otherwise. */
2817 linux_wait_for_event (ptid_t ptid
, int *wstatp
, int options
)
2819 return linux_wait_for_event_filtered (ptid
, ptid
, wstatp
, options
);
2822 /* Select one LWP out of those that have events pending. */
2825 select_event_lwp (struct lwp_info
**orig_lp
)
2827 struct thread_info
*event_thread
= NULL
;
2829 /* In all-stop, give preference to the LWP that is being
2830 single-stepped. There will be at most one, and it's the LWP that
2831 the core is most interested in. If we didn't do this, then we'd
2832 have to handle pending step SIGTRAPs somehow in case the core
2833 later continues the previously-stepped thread, otherwise we'd
2834 report the pending SIGTRAP, and the core, not having stepped the
2835 thread, wouldn't understand what the trap was for, and therefore
2836 would report it to the user as a random signal. */
2839 event_thread
= find_thread ([] (thread_info
*thread
)
2841 lwp_info
*lp
= get_thread_lwp (thread
);
2843 return (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2844 && thread
->last_resume_kind
== resume_step
2845 && lp
->status_pending_p
);
2848 if (event_thread
!= NULL
)
2851 debug_printf ("SEL: Select single-step %s\n",
2852 target_pid_to_str (ptid_of (event_thread
)));
2855 if (event_thread
== NULL
)
2857 /* No single-stepping LWP. Select one at random, out of those
2858 which have had events. */
2860 event_thread
= find_thread_in_random ([&] (thread_info
*thread
)
2862 lwp_info
*lp
= get_thread_lwp (thread
);
2864 /* Only resumed LWPs that have an event pending. */
2865 return (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2866 && lp
->status_pending_p
);
2870 if (event_thread
!= NULL
)
2872 struct lwp_info
*event_lp
= get_thread_lwp (event_thread
);
2874 /* Switch the event LWP. */
2875 *orig_lp
= event_lp
;
2879 /* Decrement the suspend count of all LWPs, except EXCEPT, if non
2883 unsuspend_all_lwps (struct lwp_info
*except
)
2885 for_each_thread ([&] (thread_info
*thread
)
2887 lwp_info
*lwp
= get_thread_lwp (thread
);
2890 lwp_suspended_decr (lwp
);
2894 static void move_out_of_jump_pad_callback (thread_info
*thread
);
2895 static bool stuck_in_jump_pad_callback (thread_info
*thread
);
2896 static bool lwp_running (thread_info
*thread
);
2897 static ptid_t
linux_wait_1 (ptid_t ptid
,
2898 struct target_waitstatus
*ourstatus
,
2899 int target_options
);
2901 /* Stabilize threads (move out of jump pads).
2903 If a thread is midway collecting a fast tracepoint, we need to
2904 finish the collection and move it out of the jump pad before
2905 reporting the signal.
2907 This avoids recursion while collecting (when a signal arrives
2908 midway, and the signal handler itself collects), which would trash
2909 the trace buffer. In case the user set a breakpoint in a signal
2910 handler, this avoids the backtrace showing the jump pad, etc..
2911 Most importantly, there are certain things we can't do safely if
2912 threads are stopped in a jump pad (or in its callee's). For
2915 - starting a new trace run. A thread still collecting the
2916 previous run, could trash the trace buffer when resumed. The trace
2917 buffer control structures would have been reset but the thread had
2918 no way to tell. The thread could even midway memcpy'ing to the
2919 buffer, which would mean that when resumed, it would clobber the
2920 trace buffer that had been set for a new run.
2922 - we can't rewrite/reuse the jump pads for new tracepoints
2923 safely. Say you do tstart while a thread is stopped midway while
2924 collecting. When the thread is later resumed, it finishes the
2925 collection, and returns to the jump pad, to execute the original
2926 instruction that was under the tracepoint jump at the time the
2927 older run had been started. If the jump pad had been rewritten
2928 since for something else in the new run, the thread would now
2929 execute the wrong / random instructions. */
2932 linux_stabilize_threads (void)
2934 thread_info
*thread_stuck
= find_thread (stuck_in_jump_pad_callback
);
2936 if (thread_stuck
!= NULL
)
2939 debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n",
2940 lwpid_of (thread_stuck
));
2944 thread_info
*saved_thread
= current_thread
;
2946 stabilizing_threads
= 1;
2949 for_each_thread (move_out_of_jump_pad_callback
);
2951 /* Loop until all are stopped out of the jump pads. */
2952 while (find_thread (lwp_running
) != NULL
)
2954 struct target_waitstatus ourstatus
;
2955 struct lwp_info
*lwp
;
2958 /* Note that we go through the full wait even loop. While
2959 moving threads out of jump pad, we need to be able to step
2960 over internal breakpoints and such. */
2961 linux_wait_1 (minus_one_ptid
, &ourstatus
, 0);
2963 if (ourstatus
.kind
== TARGET_WAITKIND_STOPPED
)
2965 lwp
= get_thread_lwp (current_thread
);
2968 lwp_suspended_inc (lwp
);
2970 if (ourstatus
.value
.sig
!= GDB_SIGNAL_0
2971 || current_thread
->last_resume_kind
== resume_stop
)
2973 wstat
= W_STOPCODE (gdb_signal_to_host (ourstatus
.value
.sig
));
2974 enqueue_one_deferred_signal (lwp
, &wstat
);
2979 unsuspend_all_lwps (NULL
);
2981 stabilizing_threads
= 0;
2983 current_thread
= saved_thread
;
2987 thread_stuck
= find_thread (stuck_in_jump_pad_callback
);
2989 if (thread_stuck
!= NULL
)
2990 debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
2991 lwpid_of (thread_stuck
));
2995 /* Convenience function that is called when the kernel reports an
2996 event that is not passed out to GDB. */
2999 ignore_event (struct target_waitstatus
*ourstatus
)
3001 /* If we got an event, there may still be others, as a single
3002 SIGCHLD can indicate more than one child stopped. This forces
3003 another target_wait call. */
3006 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3010 /* Convenience function that is called when the kernel reports an exit
3011 event. This decides whether to report the event to GDB as a
3012 process exit event, a thread exit event, or to suppress the
3016 filter_exit_event (struct lwp_info
*event_child
,
3017 struct target_waitstatus
*ourstatus
)
3019 client_state
&cs
= get_client_state ();
3020 struct thread_info
*thread
= get_lwp_thread (event_child
);
3021 ptid_t ptid
= ptid_of (thread
);
3023 if (!last_thread_of_process_p (pid_of (thread
)))
3025 if (cs
.report_thread_events
)
3026 ourstatus
->kind
= TARGET_WAITKIND_THREAD_EXITED
;
3028 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3030 delete_lwp (event_child
);
3035 /* Returns 1 if GDB is interested in any event_child syscalls. */
3038 gdb_catching_syscalls_p (struct lwp_info
*event_child
)
3040 struct thread_info
*thread
= get_lwp_thread (event_child
);
3041 struct process_info
*proc
= get_thread_process (thread
);
3043 return !proc
->syscalls_to_catch
.empty ();
3046 /* Returns 1 if GDB is interested in the event_child syscall.
3047 Only to be called when stopped reason is SYSCALL_SIGTRAP. */
3050 gdb_catch_this_syscall_p (struct lwp_info
*event_child
)
3053 struct thread_info
*thread
= get_lwp_thread (event_child
);
3054 struct process_info
*proc
= get_thread_process (thread
);
3056 if (proc
->syscalls_to_catch
.empty ())
3059 if (proc
->syscalls_to_catch
[0] == ANY_SYSCALL
)
3062 get_syscall_trapinfo (event_child
, &sysno
);
3064 for (int iter
: proc
->syscalls_to_catch
)
3071 /* Wait for process, returns status. */
3074 linux_wait_1 (ptid_t ptid
,
3075 struct target_waitstatus
*ourstatus
, int target_options
)
3077 client_state
&cs
= get_client_state ();
3079 struct lwp_info
*event_child
;
3082 int step_over_finished
;
3083 int bp_explains_trap
;
3084 int maybe_internal_trap
;
3093 debug_printf ("linux_wait_1: [%s]\n", target_pid_to_str (ptid
));
3096 /* Translate generic target options into linux options. */
3098 if (target_options
& TARGET_WNOHANG
)
3101 bp_explains_trap
= 0;
3104 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3106 auto status_pending_p_any
= [&] (thread_info
*thread
)
3108 return status_pending_p_callback (thread
, minus_one_ptid
);
3111 auto not_stopped
= [&] (thread_info
*thread
)
3113 return not_stopped_callback (thread
, minus_one_ptid
);
3116 /* Find a resumed LWP, if any. */
3117 if (find_thread (status_pending_p_any
) != NULL
)
3119 else if (find_thread (not_stopped
) != NULL
)
3124 if (step_over_bkpt
== null_ptid
)
3125 pid
= linux_wait_for_event (ptid
, &w
, options
);
3129 debug_printf ("step_over_bkpt set [%s], doing a blocking wait\n",
3130 target_pid_to_str (step_over_bkpt
));
3131 pid
= linux_wait_for_event (step_over_bkpt
, &w
, options
& ~WNOHANG
);
3134 if (pid
== 0 || (pid
== -1 && !any_resumed
))
3136 gdb_assert (target_options
& TARGET_WNOHANG
);
3140 debug_printf ("linux_wait_1 ret = null_ptid, "
3141 "TARGET_WAITKIND_IGNORE\n");
3145 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3152 debug_printf ("linux_wait_1 ret = null_ptid, "
3153 "TARGET_WAITKIND_NO_RESUMED\n");
3157 ourstatus
->kind
= TARGET_WAITKIND_NO_RESUMED
;
3161 event_child
= get_thread_lwp (current_thread
);
3163 /* linux_wait_for_event only returns an exit status for the last
3164 child of a process. Report it. */
3165 if (WIFEXITED (w
) || WIFSIGNALED (w
))
3169 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
3170 ourstatus
->value
.integer
= WEXITSTATUS (w
);
3174 debug_printf ("linux_wait_1 ret = %s, exited with "
3176 target_pid_to_str (ptid_of (current_thread
)),
3183 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
3184 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (w
));
3188 debug_printf ("linux_wait_1 ret = %s, terminated with "
3190 target_pid_to_str (ptid_of (current_thread
)),
3196 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
3197 return filter_exit_event (event_child
, ourstatus
);
3199 return ptid_of (current_thread
);
3202 /* If step-over executes a breakpoint instruction, in the case of a
3203 hardware single step it means a gdb/gdbserver breakpoint had been
3204 planted on top of a permanent breakpoint, in the case of a software
3205 single step it may just mean that gdbserver hit the reinsert breakpoint.
3206 The PC has been adjusted by save_stop_reason to point at
3207 the breakpoint address.
3208 So in the case of the hardware single step advance the PC manually
3209 past the breakpoint and in the case of software single step advance only
3210 if it's not the single_step_breakpoint we are hitting.
3211 This avoids that a program would keep trapping a permanent breakpoint
3213 if (step_over_bkpt
!= null_ptid
3214 && event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3215 && (event_child
->stepping
3216 || !single_step_breakpoint_inserted_here (event_child
->stop_pc
)))
3218 int increment_pc
= 0;
3219 int breakpoint_kind
= 0;
3220 CORE_ADDR stop_pc
= event_child
->stop_pc
;
3223 the_target
->breakpoint_kind_from_current_state (&stop_pc
);
3224 the_target
->sw_breakpoint_from_kind (breakpoint_kind
, &increment_pc
);
3228 debug_printf ("step-over for %s executed software breakpoint\n",
3229 target_pid_to_str (ptid_of (current_thread
)));
3232 if (increment_pc
!= 0)
3234 struct regcache
*regcache
3235 = get_thread_regcache (current_thread
, 1);
3237 event_child
->stop_pc
+= increment_pc
;
3238 (*the_low_target
.set_pc
) (regcache
, event_child
->stop_pc
);
3240 if (!(*the_low_target
.breakpoint_at
) (event_child
->stop_pc
))
3241 event_child
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3245 /* If this event was not handled before, and is not a SIGTRAP, we
3246 report it. SIGILL and SIGSEGV are also treated as traps in case
3247 a breakpoint is inserted at the current PC. If this target does
3248 not support internal breakpoints at all, we also report the
3249 SIGTRAP without further processing; it's of no concern to us. */
3251 = (supports_breakpoints ()
3252 && (WSTOPSIG (w
) == SIGTRAP
3253 || ((WSTOPSIG (w
) == SIGILL
3254 || WSTOPSIG (w
) == SIGSEGV
)
3255 && (*the_low_target
.breakpoint_at
) (event_child
->stop_pc
))));
3257 if (maybe_internal_trap
)
3259 /* Handle anything that requires bookkeeping before deciding to
3260 report the event or continue waiting. */
3262 /* First check if we can explain the SIGTRAP with an internal
3263 breakpoint, or if we should possibly report the event to GDB.
3264 Do this before anything that may remove or insert a
3266 bp_explains_trap
= breakpoint_inserted_here (event_child
->stop_pc
);
3268 /* We have a SIGTRAP, possibly a step-over dance has just
3269 finished. If so, tweak the state machine accordingly,
3270 reinsert breakpoints and delete any single-step
3272 step_over_finished
= finish_step_over (event_child
);
3274 /* Now invoke the callbacks of any internal breakpoints there. */
3275 check_breakpoints (event_child
->stop_pc
);
3277 /* Handle tracepoint data collecting. This may overflow the
3278 trace buffer, and cause a tracing stop, removing
3280 trace_event
= handle_tracepoints (event_child
);
3282 if (bp_explains_trap
)
3285 debug_printf ("Hit a gdbserver breakpoint.\n");
3290 /* We have some other signal, possibly a step-over dance was in
3291 progress, and it should be cancelled too. */
3292 step_over_finished
= finish_step_over (event_child
);
3295 /* We have all the data we need. Either report the event to GDB, or
3296 resume threads and keep waiting for more. */
3298 /* If we're collecting a fast tracepoint, finish the collection and
3299 move out of the jump pad before delivering a signal. See
3300 linux_stabilize_threads. */
3303 && WSTOPSIG (w
) != SIGTRAP
3304 && supports_fast_tracepoints ()
3305 && agent_loaded_p ())
3308 debug_printf ("Got signal %d for LWP %ld. Check if we need "
3309 "to defer or adjust it.\n",
3310 WSTOPSIG (w
), lwpid_of (current_thread
));
3312 /* Allow debugging the jump pad itself. */
3313 if (current_thread
->last_resume_kind
!= resume_step
3314 && maybe_move_out_of_jump_pad (event_child
, &w
))
3316 enqueue_one_deferred_signal (event_child
, &w
);
3319 debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
3320 WSTOPSIG (w
), lwpid_of (current_thread
));
3322 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
3326 return ignore_event (ourstatus
);
3330 if (event_child
->collecting_fast_tracepoint
3331 != fast_tpoint_collect_result::not_collecting
)
3334 debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
3335 "Check if we're already there.\n",
3336 lwpid_of (current_thread
),
3337 (int) event_child
->collecting_fast_tracepoint
);
3341 event_child
->collecting_fast_tracepoint
3342 = linux_fast_tracepoint_collecting (event_child
, NULL
);
3344 if (event_child
->collecting_fast_tracepoint
3345 != fast_tpoint_collect_result::before_insn
)
3347 /* No longer need this breakpoint. */
3348 if (event_child
->exit_jump_pad_bkpt
!= NULL
)
3351 debug_printf ("No longer need exit-jump-pad bkpt; removing it."
3352 "stopping all threads momentarily.\n");
3354 /* Other running threads could hit this breakpoint.
3355 We don't handle moribund locations like GDB does,
3356 instead we always pause all threads when removing
3357 breakpoints, so that any step-over or
3358 decr_pc_after_break adjustment is always taken
3359 care of while the breakpoint is still
3361 stop_all_lwps (1, event_child
);
3363 delete_breakpoint (event_child
->exit_jump_pad_bkpt
);
3364 event_child
->exit_jump_pad_bkpt
= NULL
;
3366 unstop_all_lwps (1, event_child
);
3368 gdb_assert (event_child
->suspended
>= 0);
3372 if (event_child
->collecting_fast_tracepoint
3373 == fast_tpoint_collect_result::not_collecting
)
3376 debug_printf ("fast tracepoint finished "
3377 "collecting successfully.\n");
3379 /* We may have a deferred signal to report. */
3380 if (dequeue_one_deferred_signal (event_child
, &w
))
3383 debug_printf ("dequeued one signal.\n");
3388 debug_printf ("no deferred signals.\n");
3390 if (stabilizing_threads
)
3392 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3393 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3397 debug_printf ("linux_wait_1 ret = %s, stopped "
3398 "while stabilizing threads\n",
3399 target_pid_to_str (ptid_of (current_thread
)));
3403 return ptid_of (current_thread
);
3409 /* Check whether GDB would be interested in this event. */
3411 /* Check if GDB is interested in this syscall. */
3413 && WSTOPSIG (w
) == SYSCALL_SIGTRAP
3414 && !gdb_catch_this_syscall_p (event_child
))
3418 debug_printf ("Ignored syscall for LWP %ld.\n",
3419 lwpid_of (current_thread
));
3422 linux_resume_one_lwp (event_child
, event_child
->stepping
,
3427 return ignore_event (ourstatus
);
3430 /* If GDB is not interested in this signal, don't stop other
3431 threads, and don't report it to GDB. Just resume the inferior
3432 right away. We do this for threading-related signals as well as
3433 any that GDB specifically requested we ignore. But never ignore
3434 SIGSTOP if we sent it ourselves, and do not ignore signals when
3435 stepping - they may require special handling to skip the signal
3436 handler. Also never ignore signals that could be caused by a
3439 && current_thread
->last_resume_kind
!= resume_step
3441 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
3442 (current_process ()->priv
->thread_db
!= NULL
3443 && (WSTOPSIG (w
) == __SIGRTMIN
3444 || WSTOPSIG (w
) == __SIGRTMIN
+ 1))
3447 (cs
.pass_signals
[gdb_signal_from_host (WSTOPSIG (w
))]
3448 && !(WSTOPSIG (w
) == SIGSTOP
3449 && current_thread
->last_resume_kind
== resume_stop
)
3450 && !linux_wstatus_maybe_breakpoint (w
))))
3452 siginfo_t info
, *info_p
;
3455 debug_printf ("Ignored signal %d for LWP %ld.\n",
3456 WSTOPSIG (w
), lwpid_of (current_thread
));
3458 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
3459 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
3464 if (step_over_finished
)
3466 /* We cancelled this thread's step-over above. We still
3467 need to unsuspend all other LWPs, and set them back
3468 running again while the signal handler runs. */
3469 unsuspend_all_lwps (event_child
);
3471 /* Enqueue the pending signal info so that proceed_all_lwps
3473 enqueue_pending_signal (event_child
, WSTOPSIG (w
), info_p
);
3475 proceed_all_lwps ();
3479 linux_resume_one_lwp (event_child
, event_child
->stepping
,
3480 WSTOPSIG (w
), info_p
);
3486 return ignore_event (ourstatus
);
3489 /* Note that all addresses are always "out of the step range" when
3490 there's no range to begin with. */
3491 in_step_range
= lwp_in_step_range (event_child
);
3493 /* If GDB wanted this thread to single step, and the thread is out
3494 of the step range, we always want to report the SIGTRAP, and let
3495 GDB handle it. Watchpoints should always be reported. So should
3496 signals we can't explain. A SIGTRAP we can't explain could be a
3497 GDB breakpoint --- we may or not support Z0 breakpoints. If we
3498 do, we're be able to handle GDB breakpoints on top of internal
3499 breakpoints, by handling the internal breakpoint and still
3500 reporting the event to GDB. If we don't, we're out of luck, GDB
3501 won't see the breakpoint hit. If we see a single-step event but
3502 the thread should be continuing, don't pass the trap to gdb.
3503 That indicates that we had previously finished a single-step but
3504 left the single-step pending -- see
3505 complete_ongoing_step_over. */
3506 report_to_gdb
= (!maybe_internal_trap
3507 || (current_thread
->last_resume_kind
== resume_step
3509 || event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3511 && !bp_explains_trap
3513 && !step_over_finished
3514 && !(current_thread
->last_resume_kind
== resume_continue
3515 && event_child
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
))
3516 || (gdb_breakpoint_here (event_child
->stop_pc
)
3517 && gdb_condition_true_at_breakpoint (event_child
->stop_pc
)
3518 && gdb_no_commands_at_breakpoint (event_child
->stop_pc
))
3519 || event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
);
3521 run_breakpoint_commands (event_child
->stop_pc
);
3523 /* We found no reason GDB would want us to stop. We either hit one
3524 of our own breakpoints, or finished an internal step GDB
3525 shouldn't know about. */
3530 if (bp_explains_trap
)
3531 debug_printf ("Hit a gdbserver breakpoint.\n");
3532 if (step_over_finished
)
3533 debug_printf ("Step-over finished.\n");
3535 debug_printf ("Tracepoint event.\n");
3536 if (lwp_in_step_range (event_child
))
3537 debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).\n",
3538 paddress (event_child
->stop_pc
),
3539 paddress (event_child
->step_range_start
),
3540 paddress (event_child
->step_range_end
));
3543 /* We're not reporting this breakpoint to GDB, so apply the
3544 decr_pc_after_break adjustment to the inferior's regcache
3547 if (the_low_target
.set_pc
!= NULL
)
3549 struct regcache
*regcache
3550 = get_thread_regcache (current_thread
, 1);
3551 (*the_low_target
.set_pc
) (regcache
, event_child
->stop_pc
);
3554 if (step_over_finished
)
3556 /* If we have finished stepping over a breakpoint, we've
3557 stopped and suspended all LWPs momentarily except the
3558 stepping one. This is where we resume them all again.
3559 We're going to keep waiting, so use proceed, which
3560 handles stepping over the next breakpoint. */
3561 unsuspend_all_lwps (event_child
);
3565 /* Remove the single-step breakpoints if any. Note that
3566 there isn't single-step breakpoint if we finished stepping
3568 if (can_software_single_step ()
3569 && has_single_step_breakpoints (current_thread
))
3571 stop_all_lwps (0, event_child
);
3572 delete_single_step_breakpoints (current_thread
);
3573 unstop_all_lwps (0, event_child
);
3578 debug_printf ("proceeding all threads.\n");
3579 proceed_all_lwps ();
3584 return ignore_event (ourstatus
);
3589 if (event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3592 = target_waitstatus_to_string (&event_child
->waitstatus
);
3594 debug_printf ("LWP %ld: extended event with waitstatus %s\n",
3595 lwpid_of (get_lwp_thread (event_child
)), str
.c_str ());
3597 if (current_thread
->last_resume_kind
== resume_step
)
3599 if (event_child
->step_range_start
== event_child
->step_range_end
)
3600 debug_printf ("GDB wanted to single-step, reporting event.\n");
3601 else if (!lwp_in_step_range (event_child
))
3602 debug_printf ("Out of step range, reporting event.\n");
3604 if (event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
3605 debug_printf ("Stopped by watchpoint.\n");
3606 else if (gdb_breakpoint_here (event_child
->stop_pc
))
3607 debug_printf ("Stopped by GDB breakpoint.\n");
3609 debug_printf ("Hit a non-gdbserver trap event.\n");
3612 /* Alright, we're going to report a stop. */
3614 /* Remove single-step breakpoints. */
3615 if (can_software_single_step ())
3617 /* Remove single-step breakpoints or not. It it is true, stop all
3618 lwps, so that other threads won't hit the breakpoint in the
3620 int remove_single_step_breakpoints_p
= 0;
3624 remove_single_step_breakpoints_p
3625 = has_single_step_breakpoints (current_thread
);
3629 /* In all-stop, a stop reply cancels all previous resume
3630 requests. Delete all single-step breakpoints. */
3632 find_thread ([&] (thread_info
*thread
) {
3633 if (has_single_step_breakpoints (thread
))
3635 remove_single_step_breakpoints_p
= 1;
3643 if (remove_single_step_breakpoints_p
)
3645 /* If we remove single-step breakpoints from memory, stop all lwps,
3646 so that other threads won't hit the breakpoint in the staled
3648 stop_all_lwps (0, event_child
);
3652 gdb_assert (has_single_step_breakpoints (current_thread
));
3653 delete_single_step_breakpoints (current_thread
);
3657 for_each_thread ([] (thread_info
*thread
){
3658 if (has_single_step_breakpoints (thread
))
3659 delete_single_step_breakpoints (thread
);
3663 unstop_all_lwps (0, event_child
);
3667 if (!stabilizing_threads
)
3669 /* In all-stop, stop all threads. */
3671 stop_all_lwps (0, NULL
);
3673 if (step_over_finished
)
3677 /* If we were doing a step-over, all other threads but
3678 the stepping one had been paused in start_step_over,
3679 with their suspend counts incremented. We don't want
3680 to do a full unstop/unpause, because we're in
3681 all-stop mode (so we want threads stopped), but we
3682 still need to unsuspend the other threads, to
3683 decrement their `suspended' count back. */
3684 unsuspend_all_lwps (event_child
);
3688 /* If we just finished a step-over, then all threads had
3689 been momentarily paused. In all-stop, that's fine,
3690 we want threads stopped by now anyway. In non-stop,
3691 we need to re-resume threads that GDB wanted to be
3693 unstop_all_lwps (1, event_child
);
3697 /* If we're not waiting for a specific LWP, choose an event LWP
3698 from among those that have had events. Giving equal priority
3699 to all LWPs that have had events helps prevent
3701 if (ptid
== minus_one_ptid
)
3703 event_child
->status_pending_p
= 1;
3704 event_child
->status_pending
= w
;
3706 select_event_lwp (&event_child
);
3708 /* current_thread and event_child must stay in sync. */
3709 current_thread
= get_lwp_thread (event_child
);
3711 event_child
->status_pending_p
= 0;
3712 w
= event_child
->status_pending
;
3716 /* Stabilize threads (move out of jump pads). */
3718 stabilize_threads ();
3722 /* If we just finished a step-over, then all threads had been
3723 momentarily paused. In all-stop, that's fine, we want
3724 threads stopped by now anyway. In non-stop, we need to
3725 re-resume threads that GDB wanted to be running. */
3726 if (step_over_finished
)
3727 unstop_all_lwps (1, event_child
);
3730 if (event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3732 /* If the reported event is an exit, fork, vfork or exec, let
3735 /* Break the unreported fork relationship chain. */
3736 if (event_child
->waitstatus
.kind
== TARGET_WAITKIND_FORKED
3737 || event_child
->waitstatus
.kind
== TARGET_WAITKIND_VFORKED
)
3739 event_child
->fork_relative
->fork_relative
= NULL
;
3740 event_child
->fork_relative
= NULL
;
3743 *ourstatus
= event_child
->waitstatus
;
3744 /* Clear the event lwp's waitstatus since we handled it already. */
3745 event_child
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
3748 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3750 /* Now that we've selected our final event LWP, un-adjust its PC if
3751 it was a software breakpoint, and the client doesn't know we can
3752 adjust the breakpoint ourselves. */
3753 if (event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3754 && !cs
.swbreak_feature
)
3756 int decr_pc
= the_low_target
.decr_pc_after_break
;
3760 struct regcache
*regcache
3761 = get_thread_regcache (current_thread
, 1);
3762 (*the_low_target
.set_pc
) (regcache
, event_child
->stop_pc
+ decr_pc
);
3766 if (WSTOPSIG (w
) == SYSCALL_SIGTRAP
)
3768 get_syscall_trapinfo (event_child
,
3769 &ourstatus
->value
.syscall_number
);
3770 ourstatus
->kind
= event_child
->syscall_state
;
3772 else if (current_thread
->last_resume_kind
== resume_stop
3773 && WSTOPSIG (w
) == SIGSTOP
)
3775 /* A thread that has been requested to stop by GDB with vCont;t,
3776 and it stopped cleanly, so report as SIG0. The use of
3777 SIGSTOP is an implementation detail. */
3778 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3780 else if (current_thread
->last_resume_kind
== resume_stop
3781 && WSTOPSIG (w
) != SIGSTOP
)
3783 /* A thread that has been requested to stop by GDB with vCont;t,
3784 but, it stopped for other reasons. */
3785 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
3787 else if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
3789 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
3792 gdb_assert (step_over_bkpt
== null_ptid
);
3796 debug_printf ("linux_wait_1 ret = %s, %d, %d\n",
3797 target_pid_to_str (ptid_of (current_thread
)),
3798 ourstatus
->kind
, ourstatus
->value
.sig
);
3802 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
3803 return filter_exit_event (event_child
, ourstatus
);
3805 return ptid_of (current_thread
);
3808 /* Get rid of any pending event in the pipe. */
3810 async_file_flush (void)
3816 ret
= read (linux_event_pipe
[0], &buf
, 1);
3817 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
3820 /* Put something in the pipe, so the event loop wakes up. */
3822 async_file_mark (void)
3826 async_file_flush ();
3829 ret
= write (linux_event_pipe
[1], "+", 1);
3830 while (ret
== 0 || (ret
== -1 && errno
== EINTR
));
3832 /* Ignore EAGAIN. If the pipe is full, the event loop will already
3833 be awakened anyway. */
3837 linux_wait (ptid_t ptid
,
3838 struct target_waitstatus
*ourstatus
, int target_options
)
3842 /* Flush the async file first. */
3843 if (target_is_async_p ())
3844 async_file_flush ();
3848 event_ptid
= linux_wait_1 (ptid
, ourstatus
, target_options
);
3850 while ((target_options
& TARGET_WNOHANG
) == 0
3851 && event_ptid
== null_ptid
3852 && ourstatus
->kind
== TARGET_WAITKIND_IGNORE
);
3854 /* If at least one stop was reported, there may be more. A single
3855 SIGCHLD can signal more than one child stop. */
3856 if (target_is_async_p ()
3857 && (target_options
& TARGET_WNOHANG
) != 0
3858 && event_ptid
!= null_ptid
)
3864 /* Send a signal to an LWP. */
3867 kill_lwp (unsigned long lwpid
, int signo
)
3872 ret
= syscall (__NR_tkill
, lwpid
, signo
);
3873 if (errno
== ENOSYS
)
3875 /* If tkill fails, then we are not using nptl threads, a
3876 configuration we no longer support. */
3877 perror_with_name (("tkill"));
3883 linux_stop_lwp (struct lwp_info
*lwp
)
3889 send_sigstop (struct lwp_info
*lwp
)
3893 pid
= lwpid_of (get_lwp_thread (lwp
));
3895 /* If we already have a pending stop signal for this process, don't
3897 if (lwp
->stop_expected
)
3900 debug_printf ("Have pending sigstop for lwp %d\n", pid
);
3906 debug_printf ("Sending sigstop to lwp %d\n", pid
);
3908 lwp
->stop_expected
= 1;
3909 kill_lwp (pid
, SIGSTOP
);
3913 send_sigstop (thread_info
*thread
, lwp_info
*except
)
3915 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3917 /* Ignore EXCEPT. */
3927 /* Increment the suspend count of an LWP, and stop it, if not stopped
3930 suspend_and_send_sigstop (thread_info
*thread
, lwp_info
*except
)
3932 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3934 /* Ignore EXCEPT. */
3938 lwp_suspended_inc (lwp
);
3940 send_sigstop (thread
, except
);
3944 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
3946 /* Store the exit status for later. */
3947 lwp
->status_pending_p
= 1;
3948 lwp
->status_pending
= wstat
;
3950 /* Store in waitstatus as well, as there's nothing else to process
3952 if (WIFEXITED (wstat
))
3954 lwp
->waitstatus
.kind
= TARGET_WAITKIND_EXITED
;
3955 lwp
->waitstatus
.value
.integer
= WEXITSTATUS (wstat
);
3957 else if (WIFSIGNALED (wstat
))
3959 lwp
->waitstatus
.kind
= TARGET_WAITKIND_SIGNALLED
;
3960 lwp
->waitstatus
.value
.sig
= gdb_signal_from_host (WTERMSIG (wstat
));
3963 /* Prevent trying to stop it. */
3966 /* No further stops are expected from a dead lwp. */
3967 lwp
->stop_expected
= 0;
3970 /* Return true if LWP has exited already, and has a pending exit event
3971 to report to GDB. */
3974 lwp_is_marked_dead (struct lwp_info
*lwp
)
3976 return (lwp
->status_pending_p
3977 && (WIFEXITED (lwp
->status_pending
)
3978 || WIFSIGNALED (lwp
->status_pending
)));
3981 /* Wait for all children to stop for the SIGSTOPs we just queued. */
3984 wait_for_sigstop (void)
3986 struct thread_info
*saved_thread
;
3991 saved_thread
= current_thread
;
3992 if (saved_thread
!= NULL
)
3993 saved_tid
= saved_thread
->id
;
3995 saved_tid
= null_ptid
; /* avoid bogus unused warning */
3998 debug_printf ("wait_for_sigstop: pulling events\n");
4000 /* Passing NULL_PTID as filter indicates we want all events to be
4001 left pending. Eventually this returns when there are no
4002 unwaited-for children left. */
4003 ret
= linux_wait_for_event_filtered (minus_one_ptid
, null_ptid
,
4005 gdb_assert (ret
== -1);
4007 if (saved_thread
== NULL
|| linux_thread_alive (saved_tid
))
4008 current_thread
= saved_thread
;
4012 debug_printf ("Previously current thread died.\n");
4014 /* We can't change the current inferior behind GDB's back,
4015 otherwise, a subsequent command may apply to the wrong
4017 current_thread
= NULL
;
4021 /* Returns true if THREAD is stopped in a jump pad, and we can't
4022 move it out, because we need to report the stop event to GDB. For
4023 example, if the user puts a breakpoint in the jump pad, it's
4024 because she wants to debug it. */
4027 stuck_in_jump_pad_callback (thread_info
*thread
)
4029 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4031 if (lwp
->suspended
!= 0)
4033 internal_error (__FILE__
, __LINE__
,
4034 "LWP %ld is suspended, suspended=%d\n",
4035 lwpid_of (thread
), lwp
->suspended
);
4037 gdb_assert (lwp
->stopped
);
4039 /* Allow debugging the jump pad, gdb_collect, etc.. */
4040 return (supports_fast_tracepoints ()
4041 && agent_loaded_p ()
4042 && (gdb_breakpoint_here (lwp
->stop_pc
)
4043 || lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
4044 || thread
->last_resume_kind
== resume_step
)
4045 && (linux_fast_tracepoint_collecting (lwp
, NULL
)
4046 != fast_tpoint_collect_result::not_collecting
));
4050 move_out_of_jump_pad_callback (thread_info
*thread
)
4052 struct thread_info
*saved_thread
;
4053 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4056 if (lwp
->suspended
!= 0)
4058 internal_error (__FILE__
, __LINE__
,
4059 "LWP %ld is suspended, suspended=%d\n",
4060 lwpid_of (thread
), lwp
->suspended
);
4062 gdb_assert (lwp
->stopped
);
4064 /* For gdb_breakpoint_here. */
4065 saved_thread
= current_thread
;
4066 current_thread
= thread
;
4068 wstat
= lwp
->status_pending_p
? &lwp
->status_pending
: NULL
;
4070 /* Allow debugging the jump pad, gdb_collect, etc. */
4071 if (!gdb_breakpoint_here (lwp
->stop_pc
)
4072 && lwp
->stop_reason
!= TARGET_STOPPED_BY_WATCHPOINT
4073 && thread
->last_resume_kind
!= resume_step
4074 && maybe_move_out_of_jump_pad (lwp
, wstat
))
4077 debug_printf ("LWP %ld needs stabilizing (in jump pad)\n",
4082 lwp
->status_pending_p
= 0;
4083 enqueue_one_deferred_signal (lwp
, wstat
);
4086 debug_printf ("Signal %d for LWP %ld deferred "
4088 WSTOPSIG (*wstat
), lwpid_of (thread
));
4091 linux_resume_one_lwp (lwp
, 0, 0, NULL
);
4094 lwp_suspended_inc (lwp
);
4096 current_thread
= saved_thread
;
4100 lwp_running (thread_info
*thread
)
4102 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4104 if (lwp_is_marked_dead (lwp
))
4107 return !lwp
->stopped
;
4110 /* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
4111 If SUSPEND, then also increase the suspend count of every LWP,
4115 stop_all_lwps (int suspend
, struct lwp_info
*except
)
4117 /* Should not be called recursively. */
4118 gdb_assert (stopping_threads
== NOT_STOPPING_THREADS
);
4123 debug_printf ("stop_all_lwps (%s, except=%s)\n",
4124 suspend
? "stop-and-suspend" : "stop",
4126 ? target_pid_to_str (ptid_of (get_lwp_thread (except
)))
4130 stopping_threads
= (suspend
4131 ? STOPPING_AND_SUSPENDING_THREADS
4132 : STOPPING_THREADS
);
4135 for_each_thread ([&] (thread_info
*thread
)
4137 suspend_and_send_sigstop (thread
, except
);
4140 for_each_thread ([&] (thread_info
*thread
)
4142 send_sigstop (thread
, except
);
4145 wait_for_sigstop ();
4146 stopping_threads
= NOT_STOPPING_THREADS
;
4150 debug_printf ("stop_all_lwps done, setting stopping_threads "
4151 "back to !stopping\n");
4156 /* Enqueue one signal in the chain of signals which need to be
4157 delivered to this process on next resume. */
4160 enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
)
4162 struct pending_signals
*p_sig
= XNEW (struct pending_signals
);
4164 p_sig
->prev
= lwp
->pending_signals
;
4165 p_sig
->signal
= signal
;
4167 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
4169 memcpy (&p_sig
->info
, info
, sizeof (siginfo_t
));
4170 lwp
->pending_signals
= p_sig
;
4173 /* Install breakpoints for software single stepping. */
4176 install_software_single_step_breakpoints (struct lwp_info
*lwp
)
4178 struct thread_info
*thread
= get_lwp_thread (lwp
);
4179 struct regcache
*regcache
= get_thread_regcache (thread
, 1);
4181 scoped_restore save_current_thread
= make_scoped_restore (¤t_thread
);
4183 current_thread
= thread
;
4184 std::vector
<CORE_ADDR
> next_pcs
= the_low_target
.get_next_pcs (regcache
);
4186 for (CORE_ADDR pc
: next_pcs
)
4187 set_single_step_breakpoint (pc
, current_ptid
);
4190 /* Single step via hardware or software single step.
4191 Return 1 if hardware single stepping, 0 if software single stepping
4192 or can't single step. */
4195 single_step (struct lwp_info
* lwp
)
4199 if (can_hardware_single_step ())
4203 else if (can_software_single_step ())
4205 install_software_single_step_breakpoints (lwp
);
4211 debug_printf ("stepping is not implemented on this target");
4217 /* The signal can be delivered to the inferior if we are not trying to
4218 finish a fast tracepoint collect. Since signal can be delivered in
4219 the step-over, the program may go to signal handler and trap again
4220 after return from the signal handler. We can live with the spurious
4224 lwp_signal_can_be_delivered (struct lwp_info
*lwp
)
4226 return (lwp
->collecting_fast_tracepoint
4227 == fast_tpoint_collect_result::not_collecting
);
4230 /* Resume execution of LWP. If STEP is nonzero, single-step it. If
4231 SIGNAL is nonzero, give it that signal. */
4234 linux_resume_one_lwp_throw (struct lwp_info
*lwp
,
4235 int step
, int signal
, siginfo_t
*info
)
4237 struct thread_info
*thread
= get_lwp_thread (lwp
);
4238 struct thread_info
*saved_thread
;
4240 struct process_info
*proc
= get_thread_process (thread
);
4242 /* Note that target description may not be initialised
4243 (proc->tdesc == NULL) at this point because the program hasn't
4244 stopped at the first instruction yet. It means GDBserver skips
4245 the extra traps from the wrapper program (see option --wrapper).
4246 Code in this function that requires register access should be
4247 guarded by proc->tdesc == NULL or something else. */
4249 if (lwp
->stopped
== 0)
4252 gdb_assert (lwp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
);
4254 fast_tpoint_collect_result fast_tp_collecting
4255 = lwp
->collecting_fast_tracepoint
;
4257 gdb_assert (!stabilizing_threads
4258 || (fast_tp_collecting
4259 != fast_tpoint_collect_result::not_collecting
));
4261 /* Cancel actions that rely on GDB not changing the PC (e.g., the
4262 user used the "jump" command, or "set $pc = foo"). */
4263 if (thread
->while_stepping
!= NULL
&& lwp
->stop_pc
!= get_pc (lwp
))
4265 /* Collecting 'while-stepping' actions doesn't make sense
4267 release_while_stepping_state_list (thread
);
4270 /* If we have pending signals or status, and a new signal, enqueue the
4271 signal. Also enqueue the signal if it can't be delivered to the
4272 inferior right now. */
4274 && (lwp
->status_pending_p
4275 || lwp
->pending_signals
!= NULL
4276 || !lwp_signal_can_be_delivered (lwp
)))
4278 enqueue_pending_signal (lwp
, signal
, info
);
4280 /* Postpone any pending signal. It was enqueued above. */
4284 if (lwp
->status_pending_p
)
4287 debug_printf ("Not resuming lwp %ld (%s, stop %s);"
4288 " has pending status\n",
4289 lwpid_of (thread
), step
? "step" : "continue",
4290 lwp
->stop_expected
? "expected" : "not expected");
4294 saved_thread
= current_thread
;
4295 current_thread
= thread
;
4297 /* This bit needs some thinking about. If we get a signal that
4298 we must report while a single-step reinsert is still pending,
4299 we often end up resuming the thread. It might be better to
4300 (ew) allow a stack of pending events; then we could be sure that
4301 the reinsert happened right away and not lose any signals.
4303 Making this stack would also shrink the window in which breakpoints are
4304 uninserted (see comment in linux_wait_for_lwp) but not enough for
4305 complete correctness, so it won't solve that problem. It may be
4306 worthwhile just to solve this one, however. */
4307 if (lwp
->bp_reinsert
!= 0)
4310 debug_printf (" pending reinsert at 0x%s\n",
4311 paddress (lwp
->bp_reinsert
));
4313 if (can_hardware_single_step ())
4315 if (fast_tp_collecting
== fast_tpoint_collect_result::not_collecting
)
4318 warning ("BAD - reinserting but not stepping.");
4320 warning ("BAD - reinserting and suspended(%d).",
4325 step
= maybe_hw_step (thread
);
4328 if (fast_tp_collecting
== fast_tpoint_collect_result::before_insn
)
4331 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
4332 " (exit-jump-pad-bkpt)\n",
4335 else if (fast_tp_collecting
== fast_tpoint_collect_result::at_insn
)
4338 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
4339 " single-stepping\n",
4342 if (can_hardware_single_step ())
4346 internal_error (__FILE__
, __LINE__
,
4347 "moving out of jump pad single-stepping"
4348 " not implemented on this target");
4352 /* If we have while-stepping actions in this thread set it stepping.
4353 If we have a signal to deliver, it may or may not be set to
4354 SIG_IGN, we don't know. Assume so, and allow collecting
4355 while-stepping into a signal handler. A possible smart thing to
4356 do would be to set an internal breakpoint at the signal return
4357 address, continue, and carry on catching this while-stepping
4358 action only when that breakpoint is hit. A future
4360 if (thread
->while_stepping
!= NULL
)
4363 debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n",
4366 step
= single_step (lwp
);
4369 if (proc
->tdesc
!= NULL
&& the_low_target
.get_pc
!= NULL
)
4371 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
4373 lwp
->stop_pc
= (*the_low_target
.get_pc
) (regcache
);
4377 debug_printf (" %s from pc 0x%lx\n", step
? "step" : "continue",
4378 (long) lwp
->stop_pc
);
4382 /* If we have pending signals, consume one if it can be delivered to
4384 if (lwp
->pending_signals
!= NULL
&& lwp_signal_can_be_delivered (lwp
))
4386 struct pending_signals
**p_sig
;
4388 p_sig
= &lwp
->pending_signals
;
4389 while ((*p_sig
)->prev
!= NULL
)
4390 p_sig
= &(*p_sig
)->prev
;
4392 signal
= (*p_sig
)->signal
;
4393 if ((*p_sig
)->info
.si_signo
!= 0)
4394 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
4402 debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
4403 lwpid_of (thread
), step
? "step" : "continue", signal
,
4404 lwp
->stop_expected
? "expected" : "not expected");
4406 if (the_low_target
.prepare_to_resume
!= NULL
)
4407 the_low_target
.prepare_to_resume (lwp
);
4409 regcache_invalidate_thread (thread
);
4411 lwp
->stepping
= step
;
4413 ptrace_request
= PTRACE_SINGLESTEP
;
4414 else if (gdb_catching_syscalls_p (lwp
))
4415 ptrace_request
= PTRACE_SYSCALL
;
4417 ptrace_request
= PTRACE_CONT
;
4418 ptrace (ptrace_request
,
4420 (PTRACE_TYPE_ARG3
) 0,
4421 /* Coerce to a uintptr_t first to avoid potential gcc warning
4422 of coercing an 8 byte integer to a 4 byte pointer. */
4423 (PTRACE_TYPE_ARG4
) (uintptr_t) signal
);
4425 current_thread
= saved_thread
;
4427 perror_with_name ("resuming thread");
4429 /* Successfully resumed. Clear state that no longer makes sense,
4430 and mark the LWP as running. Must not do this before resuming
4431 otherwise if that fails other code will be confused. E.g., we'd
4432 later try to stop the LWP and hang forever waiting for a stop
4433 status. Note that we must not throw after this is cleared,
4434 otherwise handle_zombie_lwp_error would get confused. */
4436 lwp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4439 /* Called when we try to resume a stopped LWP and that errors out. If
4440 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
4441 or about to become), discard the error, clear any pending status
4442 the LWP may have, and return true (we'll collect the exit status
4443 soon enough). Otherwise, return false. */
4446 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
4448 struct thread_info
*thread
= get_lwp_thread (lp
);
4450 /* If we get an error after resuming the LWP successfully, we'd
4451 confuse !T state for the LWP being gone. */
4452 gdb_assert (lp
->stopped
);
4454 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
4455 because even if ptrace failed with ESRCH, the tracee may be "not
4456 yet fully dead", but already refusing ptrace requests. In that
4457 case the tracee has 'R (Running)' state for a little bit
4458 (observed in Linux 3.18). See also the note on ESRCH in the
4459 ptrace(2) man page. Instead, check whether the LWP has any state
4460 other than ptrace-stopped. */
4462 /* Don't assume anything if /proc/PID/status can't be read. */
4463 if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread
)) == 0)
4465 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4466 lp
->status_pending_p
= 0;
4472 /* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
4473 disappears while we try to resume it. */
4476 linux_resume_one_lwp (struct lwp_info
*lwp
,
4477 int step
, int signal
, siginfo_t
*info
)
4481 linux_resume_one_lwp_throw (lwp
, step
, signal
, info
);
4483 catch (const gdb_exception_error
&ex
)
4485 if (!check_ptrace_stopped_lwp_gone (lwp
))
4490 /* This function is called once per thread via for_each_thread.
4491 We look up which resume request applies to THREAD and mark it with a
4492 pointer to the appropriate resume request.
4494 This algorithm is O(threads * resume elements), but resume elements
4495 is small (and will remain small at least until GDB supports thread
4499 linux_set_resume_request (thread_info
*thread
, thread_resume
*resume
, size_t n
)
4501 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4503 for (int ndx
= 0; ndx
< n
; ndx
++)
4505 ptid_t ptid
= resume
[ndx
].thread
;
4506 if (ptid
== minus_one_ptid
4507 || ptid
== thread
->id
4508 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
4510 || (ptid
.pid () == pid_of (thread
)
4512 || ptid
.lwp () == -1)))
4514 if (resume
[ndx
].kind
== resume_stop
4515 && thread
->last_resume_kind
== resume_stop
)
4518 debug_printf ("already %s LWP %ld at GDB's request\n",
4519 (thread
->last_status
.kind
4520 == TARGET_WAITKIND_STOPPED
)
4528 /* Ignore (wildcard) resume requests for already-resumed
4530 if (resume
[ndx
].kind
!= resume_stop
4531 && thread
->last_resume_kind
!= resume_stop
)
4534 debug_printf ("already %s LWP %ld at GDB's request\n",
4535 (thread
->last_resume_kind
4543 /* Don't let wildcard resumes resume fork children that GDB
4544 does not yet know are new fork children. */
4545 if (lwp
->fork_relative
!= NULL
)
4547 struct lwp_info
*rel
= lwp
->fork_relative
;
4549 if (rel
->status_pending_p
4550 && (rel
->waitstatus
.kind
== TARGET_WAITKIND_FORKED
4551 || rel
->waitstatus
.kind
== TARGET_WAITKIND_VFORKED
))
4554 debug_printf ("not resuming LWP %ld: has queued stop reply\n",
4560 /* If the thread has a pending event that has already been
4561 reported to GDBserver core, but GDB has not pulled the
4562 event out of the vStopped queue yet, likewise, ignore the
4563 (wildcard) resume request. */
4564 if (in_queued_stop_replies (thread
->id
))
4567 debug_printf ("not resuming LWP %ld: has queued stop reply\n",
4572 lwp
->resume
= &resume
[ndx
];
4573 thread
->last_resume_kind
= lwp
->resume
->kind
;
4575 lwp
->step_range_start
= lwp
->resume
->step_range_start
;
4576 lwp
->step_range_end
= lwp
->resume
->step_range_end
;
4578 /* If we had a deferred signal to report, dequeue one now.
4579 This can happen if LWP gets more than one signal while
4580 trying to get out of a jump pad. */
4582 && !lwp
->status_pending_p
4583 && dequeue_one_deferred_signal (lwp
, &lwp
->status_pending
))
4585 lwp
->status_pending_p
= 1;
4588 debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
4589 "leaving status pending.\n",
4590 WSTOPSIG (lwp
->status_pending
),
4598 /* No resume action for this thread. */
4602 /* find_thread callback for linux_resume. Return true if this lwp has an
4603 interesting status pending. */
4606 resume_status_pending_p (thread_info
*thread
)
4608 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4610 /* LWPs which will not be resumed are not interesting, because
4611 we might not wait for them next time through linux_wait. */
4612 if (lwp
->resume
== NULL
)
4615 return thread_still_has_status_pending_p (thread
);
4618 /* Return 1 if this lwp that GDB wants running is stopped at an
4619 internal breakpoint that we need to step over. It assumes that any
4620 required STOP_PC adjustment has already been propagated to the
4621 inferior's regcache. */
4624 need_step_over_p (thread_info
*thread
)
4626 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4627 struct thread_info
*saved_thread
;
4629 struct process_info
*proc
= get_thread_process (thread
);
4631 /* GDBserver is skipping the extra traps from the wrapper program,
4632 don't have to do step over. */
4633 if (proc
->tdesc
== NULL
)
4636 /* LWPs which will not be resumed are not interesting, because we
4637 might not wait for them next time through linux_wait. */
4642 debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n",
4647 if (thread
->last_resume_kind
== resume_stop
)
4650 debug_printf ("Need step over [LWP %ld]? Ignoring, should remain"
4656 gdb_assert (lwp
->suspended
>= 0);
4661 debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n",
4666 if (lwp
->status_pending_p
)
4669 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4675 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
4679 /* If the PC has changed since we stopped, then don't do anything,
4680 and let the breakpoint/tracepoint be hit. This happens if, for
4681 instance, GDB handled the decr_pc_after_break subtraction itself,
4682 GDB is OOL stepping this thread, or the user has issued a "jump"
4683 command, or poked thread's registers herself. */
4684 if (pc
!= lwp
->stop_pc
)
4687 debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. "
4688 "Old stop_pc was 0x%s, PC is now 0x%s\n",
4690 paddress (lwp
->stop_pc
), paddress (pc
));
4694 /* On software single step target, resume the inferior with signal
4695 rather than stepping over. */
4696 if (can_software_single_step ()
4697 && lwp
->pending_signals
!= NULL
4698 && lwp_signal_can_be_delivered (lwp
))
4701 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4708 saved_thread
= current_thread
;
4709 current_thread
= thread
;
4711 /* We can only step over breakpoints we know about. */
4712 if (breakpoint_here (pc
) || fast_tracepoint_jump_here (pc
))
4714 /* Don't step over a breakpoint that GDB expects to hit
4715 though. If the condition is being evaluated on the target's side
4716 and it evaluate to false, step over this breakpoint as well. */
4717 if (gdb_breakpoint_here (pc
)
4718 && gdb_condition_true_at_breakpoint (pc
)
4719 && gdb_no_commands_at_breakpoint (pc
))
4722 debug_printf ("Need step over [LWP %ld]? yes, but found"
4723 " GDB breakpoint at 0x%s; skipping step over\n",
4724 lwpid_of (thread
), paddress (pc
));
4726 current_thread
= saved_thread
;
4732 debug_printf ("Need step over [LWP %ld]? yes, "
4733 "found breakpoint at 0x%s\n",
4734 lwpid_of (thread
), paddress (pc
));
4736 /* We've found an lwp that needs stepping over --- return 1 so
4737 that find_thread stops looking. */
4738 current_thread
= saved_thread
;
4744 current_thread
= saved_thread
;
4747 debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
4749 lwpid_of (thread
), paddress (pc
));
4754 /* Start a step-over operation on LWP. When LWP stopped at a
4755 breakpoint, to make progress, we need to remove the breakpoint out
4756 of the way. If we let other threads run while we do that, they may
4757 pass by the breakpoint location and miss hitting it. To avoid
4758 that, a step-over momentarily stops all threads while LWP is
4759 single-stepped by either hardware or software while the breakpoint
4760 is temporarily uninserted from the inferior. When the single-step
4761 finishes, we reinsert the breakpoint, and let all threads that are
4762 supposed to be running, run again. */
4765 start_step_over (struct lwp_info
*lwp
)
4767 struct thread_info
*thread
= get_lwp_thread (lwp
);
4768 struct thread_info
*saved_thread
;
4773 debug_printf ("Starting step-over on LWP %ld. Stopping all threads\n",
4776 stop_all_lwps (1, lwp
);
4778 if (lwp
->suspended
!= 0)
4780 internal_error (__FILE__
, __LINE__
,
4781 "LWP %ld suspended=%d\n", lwpid_of (thread
),
4786 debug_printf ("Done stopping all threads for step-over.\n");
4788 /* Note, we should always reach here with an already adjusted PC,
4789 either by GDB (if we're resuming due to GDB's request), or by our
4790 caller, if we just finished handling an internal breakpoint GDB
4791 shouldn't care about. */
4794 saved_thread
= current_thread
;
4795 current_thread
= thread
;
4797 lwp
->bp_reinsert
= pc
;
4798 uninsert_breakpoints_at (pc
);
4799 uninsert_fast_tracepoint_jumps_at (pc
);
4801 step
= single_step (lwp
);
4803 current_thread
= saved_thread
;
4805 linux_resume_one_lwp (lwp
, step
, 0, NULL
);
4807 /* Require next event from this LWP. */
4808 step_over_bkpt
= thread
->id
;
4812 /* Finish a step-over. Reinsert the breakpoint we had uninserted in
4813 start_step_over, if still there, and delete any single-step
4814 breakpoints we've set, on non hardware single-step targets. */
4817 finish_step_over (struct lwp_info
*lwp
)
4819 if (lwp
->bp_reinsert
!= 0)
4821 struct thread_info
*saved_thread
= current_thread
;
4824 debug_printf ("Finished step over.\n");
4826 current_thread
= get_lwp_thread (lwp
);
4828 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
4829 may be no breakpoint to reinsert there by now. */
4830 reinsert_breakpoints_at (lwp
->bp_reinsert
);
4831 reinsert_fast_tracepoint_jumps_at (lwp
->bp_reinsert
);
4833 lwp
->bp_reinsert
= 0;
4835 /* Delete any single-step breakpoints. No longer needed. We
4836 don't have to worry about other threads hitting this trap,
4837 and later not being able to explain it, because we were
4838 stepping over a breakpoint, and we hold all threads but
4839 LWP stopped while doing that. */
4840 if (!can_hardware_single_step ())
4842 gdb_assert (has_single_step_breakpoints (current_thread
));
4843 delete_single_step_breakpoints (current_thread
);
4846 step_over_bkpt
= null_ptid
;
4847 current_thread
= saved_thread
;
4854 /* If there's a step over in progress, wait until all threads stop
4855 (that is, until the stepping thread finishes its step), and
4856 unsuspend all lwps. The stepping thread ends with its status
4857 pending, which is processed later when we get back to processing
4861 complete_ongoing_step_over (void)
4863 if (step_over_bkpt
!= null_ptid
)
4865 struct lwp_info
*lwp
;
4870 debug_printf ("detach: step over in progress, finish it first\n");
4872 /* Passing NULL_PTID as filter indicates we want all events to
4873 be left pending. Eventually this returns when there are no
4874 unwaited-for children left. */
4875 ret
= linux_wait_for_event_filtered (minus_one_ptid
, null_ptid
,
4877 gdb_assert (ret
== -1);
4879 lwp
= find_lwp_pid (step_over_bkpt
);
4881 finish_step_over (lwp
);
4882 step_over_bkpt
= null_ptid
;
4883 unsuspend_all_lwps (lwp
);
4887 /* This function is called once per thread. We check the thread's resume
4888 request, which will tell us whether to resume, step, or leave the thread
4889 stopped; and what signal, if any, it should be sent.
4891 For threads which we aren't explicitly told otherwise, we preserve
4892 the stepping flag; this is used for stepping over gdbserver-placed
4895 If pending_flags was set in any thread, we queue any needed
4896 signals, since we won't actually resume. We already have a pending
4897 event to report, so we don't need to preserve any step requests;
4898 they should be re-issued if necessary. */
4901 linux_resume_one_thread (thread_info
*thread
, bool leave_all_stopped
)
4903 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4906 if (lwp
->resume
== NULL
)
4909 if (lwp
->resume
->kind
== resume_stop
)
4912 debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread
));
4917 debug_printf ("stopping LWP %ld\n", lwpid_of (thread
));
4919 /* Stop the thread, and wait for the event asynchronously,
4920 through the event loop. */
4926 debug_printf ("already stopped LWP %ld\n",
4929 /* The LWP may have been stopped in an internal event that
4930 was not meant to be notified back to GDB (e.g., gdbserver
4931 breakpoint), so we should be reporting a stop event in
4934 /* If the thread already has a pending SIGSTOP, this is a
4935 no-op. Otherwise, something later will presumably resume
4936 the thread and this will cause it to cancel any pending
4937 operation, due to last_resume_kind == resume_stop. If
4938 the thread already has a pending status to report, we
4939 will still report it the next time we wait - see
4940 status_pending_p_callback. */
4942 /* If we already have a pending signal to report, then
4943 there's no need to queue a SIGSTOP, as this means we're
4944 midway through moving the LWP out of the jumppad, and we
4945 will report the pending signal as soon as that is
4947 if (lwp
->pending_signals_to_report
== NULL
)
4951 /* For stop requests, we're done. */
4953 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
4957 /* If this thread which is about to be resumed has a pending status,
4958 then don't resume it - we can just report the pending status.
4959 Likewise if it is suspended, because e.g., another thread is
4960 stepping past a breakpoint. Make sure to queue any signals that
4961 would otherwise be sent. In all-stop mode, we do this decision
4962 based on if *any* thread has a pending status. If there's a
4963 thread that needs the step-over-breakpoint dance, then don't
4964 resume any other thread but that particular one. */
4965 leave_pending
= (lwp
->suspended
4966 || lwp
->status_pending_p
4967 || leave_all_stopped
);
4969 /* If we have a new signal, enqueue the signal. */
4970 if (lwp
->resume
->sig
!= 0)
4972 siginfo_t info
, *info_p
;
4974 /* If this is the same signal we were previously stopped by,
4975 make sure to queue its siginfo. */
4976 if (WIFSTOPPED (lwp
->last_status
)
4977 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
4978 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
),
4979 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
4984 enqueue_pending_signal (lwp
, lwp
->resume
->sig
, info_p
);
4990 debug_printf ("resuming LWP %ld\n", lwpid_of (thread
));
4992 proceed_one_lwp (thread
, NULL
);
4997 debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread
));
5000 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
5005 linux_resume (struct thread_resume
*resume_info
, size_t n
)
5007 struct thread_info
*need_step_over
= NULL
;
5012 debug_printf ("linux_resume:\n");
5015 for_each_thread ([&] (thread_info
*thread
)
5017 linux_set_resume_request (thread
, resume_info
, n
);
5020 /* If there is a thread which would otherwise be resumed, which has
5021 a pending status, then don't resume any threads - we can just
5022 report the pending status. Make sure to queue any signals that
5023 would otherwise be sent. In non-stop mode, we'll apply this
5024 logic to each thread individually. We consume all pending events
5025 before considering to start a step-over (in all-stop). */
5026 bool any_pending
= false;
5028 any_pending
= find_thread (resume_status_pending_p
) != NULL
;
5030 /* If there is a thread which would otherwise be resumed, which is
5031 stopped at a breakpoint that needs stepping over, then don't
5032 resume any threads - have it step over the breakpoint with all
5033 other threads stopped, then resume all threads again. Make sure
5034 to queue any signals that would otherwise be delivered or
5036 if (!any_pending
&& supports_breakpoints ())
5037 need_step_over
= find_thread (need_step_over_p
);
5039 bool leave_all_stopped
= (need_step_over
!= NULL
|| any_pending
);
5043 if (need_step_over
!= NULL
)
5044 debug_printf ("Not resuming all, need step over\n");
5045 else if (any_pending
)
5046 debug_printf ("Not resuming, all-stop and found "
5047 "an LWP with pending status\n");
5049 debug_printf ("Resuming, no pending status or step over needed\n");
5052 /* Even if we're leaving threads stopped, queue all signals we'd
5053 otherwise deliver. */
5054 for_each_thread ([&] (thread_info
*thread
)
5056 linux_resume_one_thread (thread
, leave_all_stopped
);
5060 start_step_over (get_thread_lwp (need_step_over
));
5064 debug_printf ("linux_resume done\n");
5068 /* We may have events that were pending that can/should be sent to
5069 the client now. Trigger a linux_wait call. */
5070 if (target_is_async_p ())
5074 /* This function is called once per thread. We check the thread's
5075 last resume request, which will tell us whether to resume, step, or
5076 leave the thread stopped. Any signal the client requested to be
5077 delivered has already been enqueued at this point.
5079 If any thread that GDB wants running is stopped at an internal
5080 breakpoint that needs stepping over, we start a step-over operation
5081 on that particular thread, and leave all others stopped. */
5084 proceed_one_lwp (thread_info
*thread
, lwp_info
*except
)
5086 struct lwp_info
*lwp
= get_thread_lwp (thread
);
5093 debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread
));
5098 debug_printf (" LWP %ld already running\n", lwpid_of (thread
));
5102 if (thread
->last_resume_kind
== resume_stop
5103 && thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
5106 debug_printf (" client wants LWP to remain %ld stopped\n",
5111 if (lwp
->status_pending_p
)
5114 debug_printf (" LWP %ld has pending status, leaving stopped\n",
5119 gdb_assert (lwp
->suspended
>= 0);
5124 debug_printf (" LWP %ld is suspended\n", lwpid_of (thread
));
5128 if (thread
->last_resume_kind
== resume_stop
5129 && lwp
->pending_signals_to_report
== NULL
5130 && (lwp
->collecting_fast_tracepoint
5131 == fast_tpoint_collect_result::not_collecting
))
5133 /* We haven't reported this LWP as stopped yet (otherwise, the
5134 last_status.kind check above would catch it, and we wouldn't
5135 reach here. This LWP may have been momentarily paused by a
5136 stop_all_lwps call while handling for example, another LWP's
5137 step-over. In that case, the pending expected SIGSTOP signal
5138 that was queued at vCont;t handling time will have already
5139 been consumed by wait_for_sigstop, and so we need to requeue
5140 another one here. Note that if the LWP already has a SIGSTOP
5141 pending, this is a no-op. */
5144 debug_printf ("Client wants LWP %ld to stop. "
5145 "Making sure it has a SIGSTOP pending\n",
5151 if (thread
->last_resume_kind
== resume_step
)
5154 debug_printf (" stepping LWP %ld, client wants it stepping\n",
5157 /* If resume_step is requested by GDB, install single-step
5158 breakpoints when the thread is about to be actually resumed if
5159 the single-step breakpoints weren't removed. */
5160 if (can_software_single_step ()
5161 && !has_single_step_breakpoints (thread
))
5162 install_software_single_step_breakpoints (lwp
);
5164 step
= maybe_hw_step (thread
);
5166 else if (lwp
->bp_reinsert
!= 0)
5169 debug_printf (" stepping LWP %ld, reinsert set\n",
5172 step
= maybe_hw_step (thread
);
5177 linux_resume_one_lwp (lwp
, step
, 0, NULL
);
5181 unsuspend_and_proceed_one_lwp (thread_info
*thread
, lwp_info
*except
)
5183 struct lwp_info
*lwp
= get_thread_lwp (thread
);
5188 lwp_suspended_decr (lwp
);
5190 proceed_one_lwp (thread
, except
);
5193 /* When we finish a step-over, set threads running again. If there's
5194 another thread that may need a step-over, now's the time to start
5195 it. Eventually, we'll move all threads past their breakpoints. */
5198 proceed_all_lwps (void)
5200 struct thread_info
*need_step_over
;
5202 /* If there is a thread which would otherwise be resumed, which is
5203 stopped at a breakpoint that needs stepping over, then don't
5204 resume any threads - have it step over the breakpoint with all
5205 other threads stopped, then resume all threads again. */
5207 if (supports_breakpoints ())
5209 need_step_over
= find_thread (need_step_over_p
);
5211 if (need_step_over
!= NULL
)
5214 debug_printf ("proceed_all_lwps: found "
5215 "thread %ld needing a step-over\n",
5216 lwpid_of (need_step_over
));
5218 start_step_over (get_thread_lwp (need_step_over
));
5224 debug_printf ("Proceeding, no step-over needed\n");
5226 for_each_thread ([] (thread_info
*thread
)
5228 proceed_one_lwp (thread
, NULL
);
5232 /* Stopped LWPs that the client wanted to be running, that don't have
5233 pending statuses, are set to run again, except for EXCEPT, if not
5234 NULL. This undoes a stop_all_lwps call. */
5237 unstop_all_lwps (int unsuspend
, struct lwp_info
*except
)
5243 debug_printf ("unstopping all lwps, except=(LWP %ld)\n",
5244 lwpid_of (get_lwp_thread (except
)));
5246 debug_printf ("unstopping all lwps\n");
5250 for_each_thread ([&] (thread_info
*thread
)
5252 unsuspend_and_proceed_one_lwp (thread
, except
);
5255 for_each_thread ([&] (thread_info
*thread
)
5257 proceed_one_lwp (thread
, except
);
5262 debug_printf ("unstop_all_lwps done\n");
5268 #ifdef HAVE_LINUX_REGSETS
5270 #define use_linux_regsets 1
5272 /* Returns true if REGSET has been disabled. */
5275 regset_disabled (struct regsets_info
*info
, struct regset_info
*regset
)
5277 return (info
->disabled_regsets
!= NULL
5278 && info
->disabled_regsets
[regset
- info
->regsets
]);
5281 /* Disable REGSET. */
5284 disable_regset (struct regsets_info
*info
, struct regset_info
*regset
)
5288 dr_offset
= regset
- info
->regsets
;
5289 if (info
->disabled_regsets
== NULL
)
5290 info
->disabled_regsets
= (char *) xcalloc (1, info
->num_regsets
);
5291 info
->disabled_regsets
[dr_offset
] = 1;
5295 regsets_fetch_inferior_registers (struct regsets_info
*regsets_info
,
5296 struct regcache
*regcache
)
5298 struct regset_info
*regset
;
5299 int saw_general_regs
= 0;
5303 pid
= lwpid_of (current_thread
);
5304 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
5309 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
))
5312 buf
= xmalloc (regset
->size
);
5314 nt_type
= regset
->nt_type
;
5318 iov
.iov_len
= regset
->size
;
5319 data
= (void *) &iov
;
5325 res
= ptrace (regset
->get_request
, pid
,
5326 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5328 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
5333 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5335 /* If we get EIO on a regset, or an EINVAL and the regset is
5336 optional, do not try it again for this process mode. */
5337 disable_regset (regsets_info
, regset
);
5339 else if (errno
== ENODATA
)
5341 /* ENODATA may be returned if the regset is currently
5342 not "active". This can happen in normal operation,
5343 so suppress the warning in this case. */
5345 else if (errno
== ESRCH
)
5347 /* At this point, ESRCH should mean the process is
5348 already gone, in which case we simply ignore attempts
5349 to read its registers. */
5354 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
5361 if (regset
->type
== GENERAL_REGS
)
5362 saw_general_regs
= 1;
5363 regset
->store_function (regcache
, buf
);
5367 if (saw_general_regs
)
5374 regsets_store_inferior_registers (struct regsets_info
*regsets_info
,
5375 struct regcache
*regcache
)
5377 struct regset_info
*regset
;
5378 int saw_general_regs
= 0;
5382 pid
= lwpid_of (current_thread
);
5383 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
5388 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
)
5389 || regset
->fill_function
== NULL
)
5392 buf
= xmalloc (regset
->size
);
5394 /* First fill the buffer with the current register set contents,
5395 in case there are any items in the kernel's regset that are
5396 not in gdbserver's regcache. */
5398 nt_type
= regset
->nt_type
;
5402 iov
.iov_len
= regset
->size
;
5403 data
= (void *) &iov
;
5409 res
= ptrace (regset
->get_request
, pid
,
5410 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5412 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
5417 /* Then overlay our cached registers on that. */
5418 regset
->fill_function (regcache
, buf
);
5420 /* Only now do we write the register set. */
5422 res
= ptrace (regset
->set_request
, pid
,
5423 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
5425 res
= ptrace (regset
->set_request
, pid
, data
, nt_type
);
5432 || (errno
== EINVAL
&& regset
->type
== OPTIONAL_REGS
))
5434 /* If we get EIO on a regset, or an EINVAL and the regset is
5435 optional, do not try it again for this process mode. */
5436 disable_regset (regsets_info
, regset
);
5438 else if (errno
== ESRCH
)
5440 /* At this point, ESRCH should mean the process is
5441 already gone, in which case we simply ignore attempts
5442 to change its registers. See also the related
5443 comment in linux_resume_one_lwp. */
5449 perror ("Warning: ptrace(regsets_store_inferior_registers)");
5452 else if (regset
->type
== GENERAL_REGS
)
5453 saw_general_regs
= 1;
5456 if (saw_general_regs
)
5462 #else /* !HAVE_LINUX_REGSETS */
5464 #define use_linux_regsets 0
5465 #define regsets_fetch_inferior_registers(regsets_info, regcache) 1
5466 #define regsets_store_inferior_registers(regsets_info, regcache) 1
5470 /* Return 1 if register REGNO is supported by one of the regset ptrace
5471 calls or 0 if it has to be transferred individually. */
5474 linux_register_in_regsets (const struct regs_info
*regs_info
, int regno
)
5476 unsigned char mask
= 1 << (regno
% 8);
5477 size_t index
= regno
/ 8;
5479 return (use_linux_regsets
5480 && (regs_info
->regset_bitmap
== NULL
5481 || (regs_info
->regset_bitmap
[index
] & mask
) != 0));
5484 #ifdef HAVE_LINUX_USRREGS
5487 register_addr (const struct usrregs_info
*usrregs
, int regnum
)
5491 if (regnum
< 0 || regnum
>= usrregs
->num_regs
)
5492 error ("Invalid register number %d.", regnum
);
5494 addr
= usrregs
->regmap
[regnum
];
5499 /* Fetch one register. */
5501 fetch_register (const struct usrregs_info
*usrregs
,
5502 struct regcache
*regcache
, int regno
)
5509 if (regno
>= usrregs
->num_regs
)
5511 if ((*the_low_target
.cannot_fetch_register
) (regno
))
5514 regaddr
= register_addr (usrregs
, regno
);
5518 size
= ((register_size (regcache
->tdesc
, regno
)
5519 + sizeof (PTRACE_XFER_TYPE
) - 1)
5520 & -sizeof (PTRACE_XFER_TYPE
));
5521 buf
= (char *) alloca (size
);
5523 pid
= lwpid_of (current_thread
);
5524 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5527 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
5528 ptrace (PTRACE_PEEKUSER
, pid
,
5529 /* Coerce to a uintptr_t first to avoid potential gcc warning
5530 of coercing an 8 byte integer to a 4 byte pointer. */
5531 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
, (PTRACE_TYPE_ARG4
) 0);
5532 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5535 /* Mark register REGNO unavailable. */
5536 supply_register (regcache
, regno
, NULL
);
5541 if (the_low_target
.supply_ptrace_register
)
5542 the_low_target
.supply_ptrace_register (regcache
, regno
, buf
);
5544 supply_register (regcache
, regno
, buf
);
5547 /* Store one register. */
5549 store_register (const struct usrregs_info
*usrregs
,
5550 struct regcache
*regcache
, int regno
)
5557 if (regno
>= usrregs
->num_regs
)
5559 if ((*the_low_target
.cannot_store_register
) (regno
))
5562 regaddr
= register_addr (usrregs
, regno
);
5566 size
= ((register_size (regcache
->tdesc
, regno
)
5567 + sizeof (PTRACE_XFER_TYPE
) - 1)
5568 & -sizeof (PTRACE_XFER_TYPE
));
5569 buf
= (char *) alloca (size
);
5570 memset (buf
, 0, size
);
5572 if (the_low_target
.collect_ptrace_register
)
5573 the_low_target
.collect_ptrace_register (regcache
, regno
, buf
);
5575 collect_register (regcache
, regno
, buf
);
5577 pid
= lwpid_of (current_thread
);
5578 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5581 ptrace (PTRACE_POKEUSER
, pid
,
5582 /* Coerce to a uintptr_t first to avoid potential gcc warning
5583 about coercing an 8 byte integer to a 4 byte pointer. */
5584 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
,
5585 (PTRACE_TYPE_ARG4
) *(PTRACE_XFER_TYPE
*) (buf
+ i
));
5588 /* At this point, ESRCH should mean the process is
5589 already gone, in which case we simply ignore attempts
5590 to change its registers. See also the related
5591 comment in linux_resume_one_lwp. */
5595 if ((*the_low_target
.cannot_store_register
) (regno
) == 0)
5596 error ("writing register %d: %s", regno
, strerror (errno
));
5598 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5602 /* Fetch all registers, or just one, from the child process.
5603 If REGNO is -1, do this for all registers, skipping any that are
5604 assumed to have been retrieved by regsets_fetch_inferior_registers,
5605 unless ALL is non-zero.
5606 Otherwise, REGNO specifies which register (so we can save time). */
5608 usr_fetch_inferior_registers (const struct regs_info
*regs_info
,
5609 struct regcache
*regcache
, int regno
, int all
)
5611 struct usrregs_info
*usr
= regs_info
->usrregs
;
5615 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5616 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5617 fetch_register (usr
, regcache
, regno
);
5620 fetch_register (usr
, regcache
, regno
);
5623 /* Store our register values back into the inferior.
5624 If REGNO is -1, do this for all registers, skipping any that are
5625 assumed to have been saved by regsets_store_inferior_registers,
5626 unless ALL is non-zero.
5627 Otherwise, REGNO specifies which register (so we can save time). */
5629 usr_store_inferior_registers (const struct regs_info
*regs_info
,
5630 struct regcache
*regcache
, int regno
, int all
)
5632 struct usrregs_info
*usr
= regs_info
->usrregs
;
5636 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5637 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5638 store_register (usr
, regcache
, regno
);
5641 store_register (usr
, regcache
, regno
);
5644 #else /* !HAVE_LINUX_USRREGS */
5646 #define usr_fetch_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
5647 #define usr_store_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
5653 linux_fetch_registers (struct regcache
*regcache
, int regno
)
5657 const struct regs_info
*regs_info
= (*the_low_target
.regs_info
) ();
5661 if (the_low_target
.fetch_register
!= NULL
5662 && regs_info
->usrregs
!= NULL
)
5663 for (regno
= 0; regno
< regs_info
->usrregs
->num_regs
; regno
++)
5664 (*the_low_target
.fetch_register
) (regcache
, regno
);
5666 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
, regcache
);
5667 if (regs_info
->usrregs
!= NULL
)
5668 usr_fetch_inferior_registers (regs_info
, regcache
, -1, all
);
5672 if (the_low_target
.fetch_register
!= NULL
5673 && (*the_low_target
.fetch_register
) (regcache
, regno
))
5676 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5678 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
,
5680 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5681 usr_fetch_inferior_registers (regs_info
, regcache
, regno
, 1);
5686 linux_store_registers (struct regcache
*regcache
, int regno
)
5690 const struct regs_info
*regs_info
= (*the_low_target
.regs_info
) ();
5694 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5696 if (regs_info
->usrregs
!= NULL
)
5697 usr_store_inferior_registers (regs_info
, regcache
, regno
, all
);
5701 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5703 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5705 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5706 usr_store_inferior_registers (regs_info
, regcache
, regno
, 1);
5711 /* Copy LEN bytes from inferior's memory starting at MEMADDR
5712 to debugger memory starting at MYADDR. */
5715 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
5717 int pid
= lwpid_of (current_thread
);
5718 PTRACE_XFER_TYPE
*buffer
;
5726 /* Try using /proc. Don't bother for one word. */
5727 if (len
>= 3 * sizeof (long))
5731 /* We could keep this file open and cache it - possibly one per
5732 thread. That requires some juggling, but is even faster. */
5733 sprintf (filename
, "/proc/%d/mem", pid
);
5734 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
5738 /* If pread64 is available, use it. It's faster if the kernel
5739 supports it (only one syscall), and it's 64-bit safe even on
5740 32-bit platforms (for instance, SPARC debugging a SPARC64
5743 bytes
= pread64 (fd
, myaddr
, len
, memaddr
);
5746 if (lseek (fd
, memaddr
, SEEK_SET
) != -1)
5747 bytes
= read (fd
, myaddr
, len
);
5754 /* Some data was read, we'll try to get the rest with ptrace. */
5764 /* Round starting address down to longword boundary. */
5765 addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
5766 /* Round ending address up; get number of longwords that makes. */
5767 count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
5768 / sizeof (PTRACE_XFER_TYPE
));
5769 /* Allocate buffer of that many longwords. */
5770 buffer
= XALLOCAVEC (PTRACE_XFER_TYPE
, count
);
5772 /* Read all the longwords */
5774 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
5776 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5777 about coercing an 8 byte integer to a 4 byte pointer. */
5778 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, pid
,
5779 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5780 (PTRACE_TYPE_ARG4
) 0);
5786 /* Copy appropriate bytes out of the buffer. */
5789 i
*= sizeof (PTRACE_XFER_TYPE
);
5790 i
-= memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1);
5792 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
5799 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
5800 memory at MEMADDR. On failure (cannot write to the inferior)
5801 returns the value of errno. Always succeeds if LEN is zero. */
5804 linux_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
5807 /* Round starting address down to longword boundary. */
5808 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
5809 /* Round ending address up; get number of longwords that makes. */
5811 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
5812 / sizeof (PTRACE_XFER_TYPE
);
5814 /* Allocate buffer of that many longwords. */
5815 PTRACE_XFER_TYPE
*buffer
= XALLOCAVEC (PTRACE_XFER_TYPE
, count
);
5817 int pid
= lwpid_of (current_thread
);
5821 /* Zero length write always succeeds. */
5827 /* Dump up to four bytes. */
5828 char str
[4 * 2 + 1];
5830 int dump
= len
< 4 ? len
: 4;
5832 for (i
= 0; i
< dump
; i
++)
5834 sprintf (p
, "%02x", myaddr
[i
]);
5839 debug_printf ("Writing %s to 0x%08lx in process %d\n",
5840 str
, (long) memaddr
, pid
);
5843 /* Fill start and end extra bytes of buffer with existing memory data. */
5846 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5847 about coercing an 8 byte integer to a 4 byte pointer. */
5848 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, pid
,
5849 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5850 (PTRACE_TYPE_ARG4
) 0);
5858 = ptrace (PTRACE_PEEKTEXT
, pid
,
5859 /* Coerce to a uintptr_t first to avoid potential gcc warning
5860 about coercing an 8 byte integer to a 4 byte pointer. */
5861 (PTRACE_TYPE_ARG3
) (uintptr_t) (addr
+ (count
- 1)
5862 * sizeof (PTRACE_XFER_TYPE
)),
5863 (PTRACE_TYPE_ARG4
) 0);
5868 /* Copy data to be written over corresponding part of buffer. */
5870 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
5873 /* Write the entire buffer. */
5875 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
5878 ptrace (PTRACE_POKETEXT
, pid
,
5879 /* Coerce to a uintptr_t first to avoid potential gcc warning
5880 about coercing an 8 byte integer to a 4 byte pointer. */
5881 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5882 (PTRACE_TYPE_ARG4
) buffer
[i
]);
5891 linux_look_up_symbols (void)
5893 #ifdef USE_THREAD_DB
5894 struct process_info
*proc
= current_process ();
5896 if (proc
->priv
->thread_db
!= NULL
)
5904 linux_request_interrupt (void)
5906 /* Send a SIGINT to the process group. This acts just like the user
5907 typed a ^C on the controlling terminal. */
5908 kill (-signal_pid
, SIGINT
);
5911 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
5912 to debugger memory starting at MYADDR. */
5915 linux_read_auxv (CORE_ADDR offset
, unsigned char *myaddr
, unsigned int len
)
5917 char filename
[PATH_MAX
];
5919 int pid
= lwpid_of (current_thread
);
5921 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
5923 fd
= open (filename
, O_RDONLY
);
5927 if (offset
!= (CORE_ADDR
) 0
5928 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5931 n
= read (fd
, myaddr
, len
);
5938 /* These breakpoint and watchpoint related wrapper functions simply
5939 pass on the function call if the target has registered a
5940 corresponding function. */
5943 linux_supports_z_point_type (char z_type
)
5945 return (the_low_target
.supports_z_point_type
!= NULL
5946 && the_low_target
.supports_z_point_type (z_type
));
5950 linux_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5951 int size
, struct raw_breakpoint
*bp
)
5953 if (type
== raw_bkpt_type_sw
)
5954 return insert_memory_breakpoint (bp
);
5955 else if (the_low_target
.insert_point
!= NULL
)
5956 return the_low_target
.insert_point (type
, addr
, size
, bp
);
5958 /* Unsupported (see target.h). */
5963 linux_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5964 int size
, struct raw_breakpoint
*bp
)
5966 if (type
== raw_bkpt_type_sw
)
5967 return remove_memory_breakpoint (bp
);
5968 else if (the_low_target
.remove_point
!= NULL
)
5969 return the_low_target
.remove_point (type
, addr
, size
, bp
);
5971 /* Unsupported (see target.h). */
5975 /* Implement the to_stopped_by_sw_breakpoint target_ops
5979 linux_stopped_by_sw_breakpoint (void)
5981 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5983 return (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
5986 /* Implement the to_supports_stopped_by_sw_breakpoint target_ops
5990 linux_supports_stopped_by_sw_breakpoint (void)
5992 return USE_SIGTRAP_SIGINFO
;
5995 /* Implement the to_stopped_by_hw_breakpoint target_ops
5999 linux_stopped_by_hw_breakpoint (void)
6001 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
6003 return (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
6006 /* Implement the to_supports_stopped_by_hw_breakpoint target_ops
6010 linux_supports_stopped_by_hw_breakpoint (void)
6012 return USE_SIGTRAP_SIGINFO
;
6015 /* Implement the supports_hardware_single_step target_ops method. */
6018 linux_supports_hardware_single_step (void)
6020 return can_hardware_single_step ();
6024 linux_supports_software_single_step (void)
6026 return can_software_single_step ();
6030 linux_stopped_by_watchpoint (void)
6032 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
6034 return lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
6038 linux_stopped_data_address (void)
6040 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
6042 return lwp
->stopped_data_address
;
6045 #if defined(__UCLIBC__) && defined(HAS_NOMMU) \
6046 && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
6047 && defined(PT_TEXT_END_ADDR)
6049 /* This is only used for targets that define PT_TEXT_ADDR,
6050 PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
6051 the target has different ways of acquiring this information, like
6054 /* Under uClinux, programs are loaded at non-zero offsets, which we need
6055 to tell gdb about. */
6058 linux_read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
6060 unsigned long text
, text_end
, data
;
6061 int pid
= lwpid_of (current_thread
);
6065 text
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_ADDR
,
6066 (PTRACE_TYPE_ARG4
) 0);
6067 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_END_ADDR
,
6068 (PTRACE_TYPE_ARG4
) 0);
6069 data
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_DATA_ADDR
,
6070 (PTRACE_TYPE_ARG4
) 0);
6074 /* Both text and data offsets produced at compile-time (and so
6075 used by gdb) are relative to the beginning of the program,
6076 with the data segment immediately following the text segment.
6077 However, the actual runtime layout in memory may put the data
6078 somewhere else, so when we send gdb a data base-address, we
6079 use the real data base address and subtract the compile-time
6080 data base-address from it (which is just the length of the
6081 text segment). BSS immediately follows data in both
6084 *data_p
= data
- (text_end
- text
);
6093 linux_qxfer_osdata (const char *annex
,
6094 unsigned char *readbuf
, unsigned const char *writebuf
,
6095 CORE_ADDR offset
, int len
)
6097 return linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
6100 /* Convert a native/host siginfo object, into/from the siginfo in the
6101 layout of the inferiors' architecture. */
6104 siginfo_fixup (siginfo_t
*siginfo
, gdb_byte
*inf_siginfo
, int direction
)
6108 if (the_low_target
.siginfo_fixup
!= NULL
)
6109 done
= the_low_target
.siginfo_fixup (siginfo
, inf_siginfo
, direction
);
6111 /* If there was no callback, or the callback didn't do anything,
6112 then just do a straight memcpy. */
6116 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
6118 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
6123 linux_xfer_siginfo (const char *annex
, unsigned char *readbuf
,
6124 unsigned const char *writebuf
, CORE_ADDR offset
, int len
)
6128 gdb_byte inf_siginfo
[sizeof (siginfo_t
)];
6130 if (current_thread
== NULL
)
6133 pid
= lwpid_of (current_thread
);
6136 debug_printf ("%s siginfo for lwp %d.\n",
6137 readbuf
!= NULL
? "Reading" : "Writing",
6140 if (offset
>= sizeof (siginfo
))
6143 if (ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
6146 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
6147 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
6148 inferior with a 64-bit GDBSERVER should look the same as debugging it
6149 with a 32-bit GDBSERVER, we need to convert it. */
6150 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
6152 if (offset
+ len
> sizeof (siginfo
))
6153 len
= sizeof (siginfo
) - offset
;
6155 if (readbuf
!= NULL
)
6156 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
6159 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
6161 /* Convert back to ptrace layout before flushing it out. */
6162 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
6164 if (ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
6171 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
6172 so we notice when children change state; as the handler for the
6173 sigsuspend in my_waitpid. */
6176 sigchld_handler (int signo
)
6178 int old_errno
= errno
;
6184 /* Use the async signal safe debug function. */
6185 if (debug_write ("sigchld_handler\n",
6186 sizeof ("sigchld_handler\n") - 1) < 0)
6187 break; /* just ignore */
6191 if (target_is_async_p ())
6192 async_file_mark (); /* trigger a linux_wait */
6198 linux_supports_non_stop (void)
6204 linux_async (int enable
)
6206 int previous
= target_is_async_p ();
6209 debug_printf ("linux_async (%d), previous=%d\n",
6212 if (previous
!= enable
)
6215 sigemptyset (&mask
);
6216 sigaddset (&mask
, SIGCHLD
);
6218 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
6222 if (pipe (linux_event_pipe
) == -1)
6224 linux_event_pipe
[0] = -1;
6225 linux_event_pipe
[1] = -1;
6226 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
6228 warning ("creating event pipe failed.");
6232 fcntl (linux_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
6233 fcntl (linux_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
6235 /* Register the event loop handler. */
6236 add_file_handler (linux_event_pipe
[0],
6237 handle_target_event
, NULL
);
6239 /* Always trigger a linux_wait. */
6244 delete_file_handler (linux_event_pipe
[0]);
6246 close (linux_event_pipe
[0]);
6247 close (linux_event_pipe
[1]);
6248 linux_event_pipe
[0] = -1;
6249 linux_event_pipe
[1] = -1;
6252 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
6259 linux_start_non_stop (int nonstop
)
6261 /* Register or unregister from event-loop accordingly. */
6262 linux_async (nonstop
);
6264 if (target_is_async_p () != (nonstop
!= 0))
6271 linux_supports_multi_process (void)
6276 /* Check if fork events are supported. */
6279 linux_supports_fork_events (void)
6281 return linux_supports_tracefork ();
6284 /* Check if vfork events are supported. */
6287 linux_supports_vfork_events (void)
6289 return linux_supports_tracefork ();
6292 /* Check if exec events are supported. */
6295 linux_supports_exec_events (void)
6297 return linux_supports_traceexec ();
6300 /* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
6301 ptrace flags for all inferiors. This is in case the new GDB connection
6302 doesn't support the same set of events that the previous one did. */
6305 linux_handle_new_gdb_connection (void)
6307 /* Request that all the lwps reset their ptrace options. */
6308 for_each_thread ([] (thread_info
*thread
)
6310 struct lwp_info
*lwp
= get_thread_lwp (thread
);
6314 /* Stop the lwp so we can modify its ptrace options. */
6315 lwp
->must_set_ptrace_flags
= 1;
6316 linux_stop_lwp (lwp
);
6320 /* Already stopped; go ahead and set the ptrace options. */
6321 struct process_info
*proc
= find_process_pid (pid_of (thread
));
6322 int options
= linux_low_ptrace_options (proc
->attached
);
6324 linux_enable_event_reporting (lwpid_of (thread
), options
);
6325 lwp
->must_set_ptrace_flags
= 0;
6331 linux_supports_disable_randomization (void)
6333 #ifdef HAVE_PERSONALITY
6341 linux_supports_agent (void)
6347 linux_supports_range_stepping (void)
6349 if (can_software_single_step ())
6351 if (*the_low_target
.supports_range_stepping
== NULL
)
6354 return (*the_low_target
.supports_range_stepping
) ();
6357 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
6358 struct target_loadseg
6360 /* Core address to which the segment is mapped. */
6362 /* VMA recorded in the program header. */
6364 /* Size of this segment in memory. */
6368 # if defined PT_GETDSBT
6369 struct target_loadmap
6371 /* Protocol version number, must be zero. */
6373 /* Pointer to the DSBT table, its size, and the DSBT index. */
6374 unsigned *dsbt_table
;
6375 unsigned dsbt_size
, dsbt_index
;
6376 /* Number of segments in this map. */
6378 /* The actual memory map. */
6379 struct target_loadseg segs
[/*nsegs*/];
6381 # define LINUX_LOADMAP PT_GETDSBT
6382 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
6383 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
6385 struct target_loadmap
6387 /* Protocol version number, must be zero. */
6389 /* Number of segments in this map. */
6391 /* The actual memory map. */
6392 struct target_loadseg segs
[/*nsegs*/];
6394 # define LINUX_LOADMAP PTRACE_GETFDPIC
6395 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
6396 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
6400 linux_read_loadmap (const char *annex
, CORE_ADDR offset
,
6401 unsigned char *myaddr
, unsigned int len
)
6403 int pid
= lwpid_of (current_thread
);
6405 struct target_loadmap
*data
= NULL
;
6406 unsigned int actual_length
, copy_length
;
6408 if (strcmp (annex
, "exec") == 0)
6409 addr
= (int) LINUX_LOADMAP_EXEC
;
6410 else if (strcmp (annex
, "interp") == 0)
6411 addr
= (int) LINUX_LOADMAP_INTERP
;
6415 if (ptrace (LINUX_LOADMAP
, pid
, addr
, &data
) != 0)
6421 actual_length
= sizeof (struct target_loadmap
)
6422 + sizeof (struct target_loadseg
) * data
->nsegs
;
6424 if (offset
< 0 || offset
> actual_length
)
6427 copy_length
= actual_length
- offset
< len
? actual_length
- offset
: len
;
6428 memcpy (myaddr
, (char *) data
+ offset
, copy_length
);
6432 # define linux_read_loadmap NULL
6433 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
6436 linux_process_qsupported (char **features
, int count
)
6438 if (the_low_target
.process_qsupported
!= NULL
)
6439 the_low_target
.process_qsupported (features
, count
);
6443 linux_supports_catch_syscall (void)
6445 return (the_low_target
.get_syscall_trapinfo
!= NULL
6446 && linux_supports_tracesysgood ());
6450 linux_get_ipa_tdesc_idx (void)
6452 if (the_low_target
.get_ipa_tdesc_idx
== NULL
)
6455 return (*the_low_target
.get_ipa_tdesc_idx
) ();
6459 linux_supports_tracepoints (void)
6461 if (*the_low_target
.supports_tracepoints
== NULL
)
6464 return (*the_low_target
.supports_tracepoints
) ();
6468 linux_read_pc (struct regcache
*regcache
)
6470 if (the_low_target
.get_pc
== NULL
)
6473 return (*the_low_target
.get_pc
) (regcache
);
6477 linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
6479 gdb_assert (the_low_target
.set_pc
!= NULL
);
6481 (*the_low_target
.set_pc
) (regcache
, pc
);
6485 linux_thread_stopped (struct thread_info
*thread
)
6487 return get_thread_lwp (thread
)->stopped
;
6490 /* This exposes stop-all-threads functionality to other modules. */
6493 linux_pause_all (int freeze
)
6495 stop_all_lwps (freeze
, NULL
);
6498 /* This exposes unstop-all-threads functionality to other gdbserver
6502 linux_unpause_all (int unfreeze
)
6504 unstop_all_lwps (unfreeze
, NULL
);
6508 linux_prepare_to_access_memory (void)
6510 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6513 linux_pause_all (1);
6518 linux_done_accessing_memory (void)
6520 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6523 linux_unpause_all (1);
6527 linux_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint
, CORE_ADDR tpaddr
,
6528 CORE_ADDR collector
,
6531 CORE_ADDR
*jump_entry
,
6532 CORE_ADDR
*trampoline
,
6533 ULONGEST
*trampoline_size
,
6534 unsigned char *jjump_pad_insn
,
6535 ULONGEST
*jjump_pad_insn_size
,
6536 CORE_ADDR
*adjusted_insn_addr
,
6537 CORE_ADDR
*adjusted_insn_addr_end
,
6540 return (*the_low_target
.install_fast_tracepoint_jump_pad
)
6541 (tpoint
, tpaddr
, collector
, lockaddr
, orig_size
,
6542 jump_entry
, trampoline
, trampoline_size
,
6543 jjump_pad_insn
, jjump_pad_insn_size
,
6544 adjusted_insn_addr
, adjusted_insn_addr_end
,
6548 static struct emit_ops
*
6549 linux_emit_ops (void)
6551 if (the_low_target
.emit_ops
!= NULL
)
6552 return (*the_low_target
.emit_ops
) ();
6558 linux_get_min_fast_tracepoint_insn_len (void)
6560 return (*the_low_target
.get_min_fast_tracepoint_insn_len
) ();
6563 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
6566 get_phdr_phnum_from_proc_auxv (const int pid
, const int is_elf64
,
6567 CORE_ADDR
*phdr_memaddr
, int *num_phdr
)
6569 char filename
[PATH_MAX
];
6571 const int auxv_size
= is_elf64
6572 ? sizeof (Elf64_auxv_t
) : sizeof (Elf32_auxv_t
);
6573 char buf
[sizeof (Elf64_auxv_t
)]; /* The larger of the two. */
6575 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
6577 fd
= open (filename
, O_RDONLY
);
6583 while (read (fd
, buf
, auxv_size
) == auxv_size
6584 && (*phdr_memaddr
== 0 || *num_phdr
== 0))
6588 Elf64_auxv_t
*const aux
= (Elf64_auxv_t
*) buf
;
6590 switch (aux
->a_type
)
6593 *phdr_memaddr
= aux
->a_un
.a_val
;
6596 *num_phdr
= aux
->a_un
.a_val
;
6602 Elf32_auxv_t
*const aux
= (Elf32_auxv_t
*) buf
;
6604 switch (aux
->a_type
)
6607 *phdr_memaddr
= aux
->a_un
.a_val
;
6610 *num_phdr
= aux
->a_un
.a_val
;
6618 if (*phdr_memaddr
== 0 || *num_phdr
== 0)
6620 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
6621 "phdr_memaddr = %ld, phdr_num = %d",
6622 (long) *phdr_memaddr
, *num_phdr
);
6629 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
6632 get_dynamic (const int pid
, const int is_elf64
)
6634 CORE_ADDR phdr_memaddr
, relocation
;
6636 unsigned char *phdr_buf
;
6637 const int phdr_size
= is_elf64
? sizeof (Elf64_Phdr
) : sizeof (Elf32_Phdr
);
6639 if (get_phdr_phnum_from_proc_auxv (pid
, is_elf64
, &phdr_memaddr
, &num_phdr
))
6642 gdb_assert (num_phdr
< 100); /* Basic sanity check. */
6643 phdr_buf
= (unsigned char *) alloca (num_phdr
* phdr_size
);
6645 if (linux_read_memory (phdr_memaddr
, phdr_buf
, num_phdr
* phdr_size
))
6648 /* Compute relocation: it is expected to be 0 for "regular" executables,
6649 non-zero for PIE ones. */
6651 for (i
= 0; relocation
== -1 && i
< num_phdr
; i
++)
6654 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6656 if (p
->p_type
== PT_PHDR
)
6657 relocation
= phdr_memaddr
- p
->p_vaddr
;
6661 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6663 if (p
->p_type
== PT_PHDR
)
6664 relocation
= phdr_memaddr
- p
->p_vaddr
;
6667 if (relocation
== -1)
6669 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
6670 any real world executables, including PIE executables, have always
6671 PT_PHDR present. PT_PHDR is not present in some shared libraries or
6672 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
6673 or present DT_DEBUG anyway (fpc binaries are statically linked).
6675 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
6677 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
6682 for (i
= 0; i
< num_phdr
; i
++)
6686 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6688 if (p
->p_type
== PT_DYNAMIC
)
6689 return p
->p_vaddr
+ relocation
;
6693 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6695 if (p
->p_type
== PT_DYNAMIC
)
6696 return p
->p_vaddr
+ relocation
;
6703 /* Return &_r_debug in the inferior, or -1 if not present. Return value
6704 can be 0 if the inferior does not yet have the library list initialized.
6705 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
6706 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
6709 get_r_debug (const int pid
, const int is_elf64
)
6711 CORE_ADDR dynamic_memaddr
;
6712 const int dyn_size
= is_elf64
? sizeof (Elf64_Dyn
) : sizeof (Elf32_Dyn
);
6713 unsigned char buf
[sizeof (Elf64_Dyn
)]; /* The larger of the two. */
6716 dynamic_memaddr
= get_dynamic (pid
, is_elf64
);
6717 if (dynamic_memaddr
== 0)
6720 while (linux_read_memory (dynamic_memaddr
, buf
, dyn_size
) == 0)
6724 Elf64_Dyn
*const dyn
= (Elf64_Dyn
*) buf
;
6725 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6729 unsigned char buf
[sizeof (Elf64_Xword
)];
6733 #ifdef DT_MIPS_RLD_MAP
6734 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6736 if (linux_read_memory (dyn
->d_un
.d_val
,
6737 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6742 #endif /* DT_MIPS_RLD_MAP */
6743 #ifdef DT_MIPS_RLD_MAP_REL
6744 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6746 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6747 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6752 #endif /* DT_MIPS_RLD_MAP_REL */
6754 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6755 map
= dyn
->d_un
.d_val
;
6757 if (dyn
->d_tag
== DT_NULL
)
6762 Elf32_Dyn
*const dyn
= (Elf32_Dyn
*) buf
;
6763 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6767 unsigned char buf
[sizeof (Elf32_Word
)];
6771 #ifdef DT_MIPS_RLD_MAP
6772 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6774 if (linux_read_memory (dyn
->d_un
.d_val
,
6775 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6780 #endif /* DT_MIPS_RLD_MAP */
6781 #ifdef DT_MIPS_RLD_MAP_REL
6782 if (dyn
->d_tag
== DT_MIPS_RLD_MAP_REL
)
6784 if (linux_read_memory (dyn
->d_un
.d_val
+ dynamic_memaddr
,
6785 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6790 #endif /* DT_MIPS_RLD_MAP_REL */
6792 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6793 map
= dyn
->d_un
.d_val
;
6795 if (dyn
->d_tag
== DT_NULL
)
6799 dynamic_memaddr
+= dyn_size
;
6805 /* Read one pointer from MEMADDR in the inferior. */
6808 read_one_ptr (CORE_ADDR memaddr
, CORE_ADDR
*ptr
, int ptr_size
)
6812 /* Go through a union so this works on either big or little endian
6813 hosts, when the inferior's pointer size is smaller than the size
6814 of CORE_ADDR. It is assumed the inferior's endianness is the
6815 same of the superior's. */
6818 CORE_ADDR core_addr
;
6823 ret
= linux_read_memory (memaddr
, &addr
.uc
, ptr_size
);
6826 if (ptr_size
== sizeof (CORE_ADDR
))
6827 *ptr
= addr
.core_addr
;
6828 else if (ptr_size
== sizeof (unsigned int))
6831 gdb_assert_not_reached ("unhandled pointer size");
6836 struct link_map_offsets
6838 /* Offset and size of r_debug.r_version. */
6839 int r_version_offset
;
6841 /* Offset and size of r_debug.r_map. */
6844 /* Offset to l_addr field in struct link_map. */
6847 /* Offset to l_name field in struct link_map. */
6850 /* Offset to l_ld field in struct link_map. */
6853 /* Offset to l_next field in struct link_map. */
6856 /* Offset to l_prev field in struct link_map. */
6860 /* Construct qXfer:libraries-svr4:read reply. */
6863 linux_qxfer_libraries_svr4 (const char *annex
, unsigned char *readbuf
,
6864 unsigned const char *writebuf
,
6865 CORE_ADDR offset
, int len
)
6867 struct process_info_private
*const priv
= current_process ()->priv
;
6868 char filename
[PATH_MAX
];
6871 static const struct link_map_offsets lmo_32bit_offsets
=
6873 0, /* r_version offset. */
6874 4, /* r_debug.r_map offset. */
6875 0, /* l_addr offset in link_map. */
6876 4, /* l_name offset in link_map. */
6877 8, /* l_ld offset in link_map. */
6878 12, /* l_next offset in link_map. */
6879 16 /* l_prev offset in link_map. */
6882 static const struct link_map_offsets lmo_64bit_offsets
=
6884 0, /* r_version offset. */
6885 8, /* r_debug.r_map offset. */
6886 0, /* l_addr offset in link_map. */
6887 8, /* l_name offset in link_map. */
6888 16, /* l_ld offset in link_map. */
6889 24, /* l_next offset in link_map. */
6890 32 /* l_prev offset in link_map. */
6892 const struct link_map_offsets
*lmo
;
6893 unsigned int machine
;
6895 CORE_ADDR lm_addr
= 0, lm_prev
= 0;
6896 CORE_ADDR l_name
, l_addr
, l_ld
, l_next
, l_prev
;
6897 int header_done
= 0;
6899 if (writebuf
!= NULL
)
6901 if (readbuf
== NULL
)
6904 pid
= lwpid_of (current_thread
);
6905 xsnprintf (filename
, sizeof filename
, "/proc/%d/exe", pid
);
6906 is_elf64
= elf_64_file_p (filename
, &machine
);
6907 lmo
= is_elf64
? &lmo_64bit_offsets
: &lmo_32bit_offsets
;
6908 ptr_size
= is_elf64
? 8 : 4;
6910 while (annex
[0] != '\0')
6916 sep
= strchr (annex
, '=');
6920 name_len
= sep
- annex
;
6921 if (name_len
== 5 && startswith (annex
, "start"))
6923 else if (name_len
== 4 && startswith (annex
, "prev"))
6927 annex
= strchr (sep
, ';');
6934 annex
= decode_address_to_semicolon (addrp
, sep
+ 1);
6941 if (priv
->r_debug
== 0)
6942 priv
->r_debug
= get_r_debug (pid
, is_elf64
);
6944 /* We failed to find DT_DEBUG. Such situation will not change
6945 for this inferior - do not retry it. Report it to GDB as
6946 E01, see for the reasons at the GDB solib-svr4.c side. */
6947 if (priv
->r_debug
== (CORE_ADDR
) -1)
6950 if (priv
->r_debug
!= 0)
6952 if (linux_read_memory (priv
->r_debug
+ lmo
->r_version_offset
,
6953 (unsigned char *) &r_version
,
6954 sizeof (r_version
)) != 0
6957 warning ("unexpected r_debug version %d", r_version
);
6959 else if (read_one_ptr (priv
->r_debug
+ lmo
->r_map_offset
,
6960 &lm_addr
, ptr_size
) != 0)
6962 warning ("unable to read r_map from 0x%lx",
6963 (long) priv
->r_debug
+ lmo
->r_map_offset
);
6968 std::string document
= "<library-list-svr4 version=\"1.0\"";
6971 && read_one_ptr (lm_addr
+ lmo
->l_name_offset
,
6972 &l_name
, ptr_size
) == 0
6973 && read_one_ptr (lm_addr
+ lmo
->l_addr_offset
,
6974 &l_addr
, ptr_size
) == 0
6975 && read_one_ptr (lm_addr
+ lmo
->l_ld_offset
,
6976 &l_ld
, ptr_size
) == 0
6977 && read_one_ptr (lm_addr
+ lmo
->l_prev_offset
,
6978 &l_prev
, ptr_size
) == 0
6979 && read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
6980 &l_next
, ptr_size
) == 0)
6982 unsigned char libname
[PATH_MAX
];
6984 if (lm_prev
!= l_prev
)
6986 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
6987 (long) lm_prev
, (long) l_prev
);
6991 /* Ignore the first entry even if it has valid name as the first entry
6992 corresponds to the main executable. The first entry should not be
6993 skipped if the dynamic loader was loaded late by a static executable
6994 (see solib-svr4.c parameter ignore_first). But in such case the main
6995 executable does not have PT_DYNAMIC present and this function already
6996 exited above due to failed get_r_debug. */
6998 string_appendf (document
, " main-lm=\"0x%lx\"", (unsigned long) lm_addr
);
7001 /* Not checking for error because reading may stop before
7002 we've got PATH_MAX worth of characters. */
7004 linux_read_memory (l_name
, libname
, sizeof (libname
) - 1);
7005 libname
[sizeof (libname
) - 1] = '\0';
7006 if (libname
[0] != '\0')
7010 /* Terminate `<library-list-svr4'. */
7015 string_appendf (document
, "<library name=\"");
7016 xml_escape_text_append (&document
, (char *) libname
);
7017 string_appendf (document
, "\" lm=\"0x%lx\" "
7018 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
7019 (unsigned long) lm_addr
, (unsigned long) l_addr
,
7020 (unsigned long) l_ld
);
7030 /* Empty list; terminate `<library-list-svr4'. */
7034 document
+= "</library-list-svr4>";
7036 int document_len
= document
.length ();
7037 if (offset
< document_len
)
7038 document_len
-= offset
;
7041 if (len
> document_len
)
7044 memcpy (readbuf
, document
.data () + offset
, len
);
7049 #ifdef HAVE_LINUX_BTRACE
7051 /* See to_disable_btrace target method. */
7054 linux_low_disable_btrace (struct btrace_target_info
*tinfo
)
7056 enum btrace_error err
;
7058 err
= linux_disable_btrace (tinfo
);
7059 return (err
== BTRACE_ERR_NONE
? 0 : -1);
7062 /* Encode an Intel Processor Trace configuration. */
7065 linux_low_encode_pt_config (struct buffer
*buffer
,
7066 const struct btrace_data_pt_config
*config
)
7068 buffer_grow_str (buffer
, "<pt-config>\n");
7070 switch (config
->cpu
.vendor
)
7073 buffer_xml_printf (buffer
, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
7074 "model=\"%u\" stepping=\"%u\"/>\n",
7075 config
->cpu
.family
, config
->cpu
.model
,
7076 config
->cpu
.stepping
);
7083 buffer_grow_str (buffer
, "</pt-config>\n");
7086 /* Encode a raw buffer. */
7089 linux_low_encode_raw (struct buffer
*buffer
, const gdb_byte
*data
,
7095 /* We use hex encoding - see gdbsupport/rsp-low.h. */
7096 buffer_grow_str (buffer
, "<raw>\n");
7102 elem
[0] = tohex ((*data
>> 4) & 0xf);
7103 elem
[1] = tohex (*data
++ & 0xf);
7105 buffer_grow (buffer
, elem
, 2);
7108 buffer_grow_str (buffer
, "</raw>\n");
7111 /* See to_read_btrace target method. */
7114 linux_low_read_btrace (struct btrace_target_info
*tinfo
, struct buffer
*buffer
,
7115 enum btrace_read_type type
)
7117 struct btrace_data btrace
;
7118 enum btrace_error err
;
7120 err
= linux_read_btrace (&btrace
, tinfo
, type
);
7121 if (err
!= BTRACE_ERR_NONE
)
7123 if (err
== BTRACE_ERR_OVERFLOW
)
7124 buffer_grow_str0 (buffer
, "E.Overflow.");
7126 buffer_grow_str0 (buffer
, "E.Generic Error.");
7131 switch (btrace
.format
)
7133 case BTRACE_FORMAT_NONE
:
7134 buffer_grow_str0 (buffer
, "E.No Trace.");
7137 case BTRACE_FORMAT_BTS
:
7138 buffer_grow_str (buffer
, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
7139 buffer_grow_str (buffer
, "<btrace version=\"1.0\">\n");
7141 for (const btrace_block
&block
: *btrace
.variant
.bts
.blocks
)
7142 buffer_xml_printf (buffer
, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
7143 paddress (block
.begin
), paddress (block
.end
));
7145 buffer_grow_str0 (buffer
, "</btrace>\n");
7148 case BTRACE_FORMAT_PT
:
7149 buffer_grow_str (buffer
, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
7150 buffer_grow_str (buffer
, "<btrace version=\"1.0\">\n");
7151 buffer_grow_str (buffer
, "<pt>\n");
7153 linux_low_encode_pt_config (buffer
, &btrace
.variant
.pt
.config
);
7155 linux_low_encode_raw (buffer
, btrace
.variant
.pt
.data
,
7156 btrace
.variant
.pt
.size
);
7158 buffer_grow_str (buffer
, "</pt>\n");
7159 buffer_grow_str0 (buffer
, "</btrace>\n");
7163 buffer_grow_str0 (buffer
, "E.Unsupported Trace Format.");
7170 /* See to_btrace_conf target method. */
7173 linux_low_btrace_conf (const struct btrace_target_info
*tinfo
,
7174 struct buffer
*buffer
)
7176 const struct btrace_config
*conf
;
7178 buffer_grow_str (buffer
, "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n");
7179 buffer_grow_str (buffer
, "<btrace-conf version=\"1.0\">\n");
7181 conf
= linux_btrace_conf (tinfo
);
7184 switch (conf
->format
)
7186 case BTRACE_FORMAT_NONE
:
7189 case BTRACE_FORMAT_BTS
:
7190 buffer_xml_printf (buffer
, "<bts");
7191 buffer_xml_printf (buffer
, " size=\"0x%x\"", conf
->bts
.size
);
7192 buffer_xml_printf (buffer
, " />\n");
7195 case BTRACE_FORMAT_PT
:
7196 buffer_xml_printf (buffer
, "<pt");
7197 buffer_xml_printf (buffer
, " size=\"0x%x\"", conf
->pt
.size
);
7198 buffer_xml_printf (buffer
, "/>\n");
7203 buffer_grow_str0 (buffer
, "</btrace-conf>\n");
7206 #endif /* HAVE_LINUX_BTRACE */
7208 /* See nat/linux-nat.h. */
7211 current_lwp_ptid (void)
7213 return ptid_of (current_thread
);
7216 /* Implementation of the target_ops method "breakpoint_kind_from_pc". */
7219 linux_breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
7221 if (the_low_target
.breakpoint_kind_from_pc
!= NULL
)
7222 return (*the_low_target
.breakpoint_kind_from_pc
) (pcptr
);
7224 return default_breakpoint_kind_from_pc (pcptr
);
7227 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
7229 static const gdb_byte
*
7230 linux_sw_breakpoint_from_kind (int kind
, int *size
)
7232 gdb_assert (the_low_target
.sw_breakpoint_from_kind
!= NULL
);
7234 return (*the_low_target
.sw_breakpoint_from_kind
) (kind
, size
);
7237 /* Implementation of the target_ops method
7238 "breakpoint_kind_from_current_state". */
7241 linux_breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
7243 if (the_low_target
.breakpoint_kind_from_current_state
!= NULL
)
7244 return (*the_low_target
.breakpoint_kind_from_current_state
) (pcptr
);
7246 return linux_breakpoint_kind_from_pc (pcptr
);
7249 /* Default implementation of linux_target_ops method "set_pc" for
7250 32-bit pc register which is literally named "pc". */
7253 linux_set_pc_32bit (struct regcache
*regcache
, CORE_ADDR pc
)
7255 uint32_t newpc
= pc
;
7257 supply_register_by_name (regcache
, "pc", &newpc
);
7260 /* Default implementation of linux_target_ops method "get_pc" for
7261 32-bit pc register which is literally named "pc". */
7264 linux_get_pc_32bit (struct regcache
*regcache
)
7268 collect_register_by_name (regcache
, "pc", &pc
);
7270 debug_printf ("stop pc is 0x%" PRIx32
"\n", pc
);
7274 /* Default implementation of linux_target_ops method "set_pc" for
7275 64-bit pc register which is literally named "pc". */
7278 linux_set_pc_64bit (struct regcache
*regcache
, CORE_ADDR pc
)
7280 uint64_t newpc
= pc
;
7282 supply_register_by_name (regcache
, "pc", &newpc
);
7285 /* Default implementation of linux_target_ops method "get_pc" for
7286 64-bit pc register which is literally named "pc". */
7289 linux_get_pc_64bit (struct regcache
*regcache
)
7293 collect_register_by_name (regcache
, "pc", &pc
);
7295 debug_printf ("stop pc is 0x%" PRIx64
"\n", pc
);
7299 /* See linux-low.h. */
7302 linux_get_auxv (int wordsize
, CORE_ADDR match
, CORE_ADDR
*valp
)
7304 gdb_byte
*data
= (gdb_byte
*) alloca (2 * wordsize
);
7307 gdb_assert (wordsize
== 4 || wordsize
== 8);
7309 while ((*the_target
->read_auxv
) (offset
, data
, 2 * wordsize
) == 2 * wordsize
)
7313 uint32_t *data_p
= (uint32_t *) data
;
7314 if (data_p
[0] == match
)
7322 uint64_t *data_p
= (uint64_t *) data
;
7323 if (data_p
[0] == match
)
7330 offset
+= 2 * wordsize
;
7336 /* See linux-low.h. */
7339 linux_get_hwcap (int wordsize
)
7341 CORE_ADDR hwcap
= 0;
7342 linux_get_auxv (wordsize
, AT_HWCAP
, &hwcap
);
7346 /* See linux-low.h. */
7349 linux_get_hwcap2 (int wordsize
)
7351 CORE_ADDR hwcap2
= 0;
7352 linux_get_auxv (wordsize
, AT_HWCAP2
, &hwcap2
);
7356 static struct target_ops linux_target_ops
= {
7357 linux_create_inferior
,
7358 linux_post_create_inferior
,
7367 linux_fetch_registers
,
7368 linux_store_registers
,
7369 linux_prepare_to_access_memory
,
7370 linux_done_accessing_memory
,
7373 linux_look_up_symbols
,
7374 linux_request_interrupt
,
7376 linux_supports_z_point_type
,
7379 linux_stopped_by_sw_breakpoint
,
7380 linux_supports_stopped_by_sw_breakpoint
,
7381 linux_stopped_by_hw_breakpoint
,
7382 linux_supports_stopped_by_hw_breakpoint
,
7383 linux_supports_hardware_single_step
,
7384 linux_stopped_by_watchpoint
,
7385 linux_stopped_data_address
,
7386 #if defined(__UCLIBC__) && defined(HAS_NOMMU) \
7387 && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
7388 && defined(PT_TEXT_END_ADDR)
7393 #ifdef USE_THREAD_DB
7394 thread_db_get_tls_address
,
7398 hostio_last_error_from_errno
,
7401 linux_supports_non_stop
,
7403 linux_start_non_stop
,
7404 linux_supports_multi_process
,
7405 linux_supports_fork_events
,
7406 linux_supports_vfork_events
,
7407 linux_supports_exec_events
,
7408 linux_handle_new_gdb_connection
,
7409 #ifdef USE_THREAD_DB
7410 thread_db_handle_monitor_command
,
7414 linux_common_core_of_thread
,
7416 linux_process_qsupported
,
7417 linux_supports_tracepoints
,
7420 linux_thread_stopped
,
7424 linux_stabilize_threads
,
7425 linux_install_fast_tracepoint_jump_pad
,
7427 linux_supports_disable_randomization
,
7428 linux_get_min_fast_tracepoint_insn_len
,
7429 linux_qxfer_libraries_svr4
,
7430 linux_supports_agent
,
7431 #ifdef HAVE_LINUX_BTRACE
7432 linux_enable_btrace
,
7433 linux_low_disable_btrace
,
7434 linux_low_read_btrace
,
7435 linux_low_btrace_conf
,
7442 linux_supports_range_stepping
,
7443 linux_proc_pid_to_exec_file
,
7444 linux_mntns_open_cloexec
,
7446 linux_mntns_readlink
,
7447 linux_breakpoint_kind_from_pc
,
7448 linux_sw_breakpoint_from_kind
,
7449 linux_proc_tid_get_name
,
7450 linux_breakpoint_kind_from_current_state
,
7451 linux_supports_software_single_step
,
7452 linux_supports_catch_syscall
,
7453 linux_get_ipa_tdesc_idx
,
7455 thread_db_thread_handle
,
7461 #ifdef HAVE_LINUX_REGSETS
7463 initialize_regsets_info (struct regsets_info
*info
)
7465 for (info
->num_regsets
= 0;
7466 info
->regsets
[info
->num_regsets
].size
>= 0;
7467 info
->num_regsets
++)
7473 initialize_low (void)
7475 struct sigaction sigchld_action
;
7477 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
7478 set_target_ops (&linux_target_ops
);
7480 linux_ptrace_init_warnings ();
7481 linux_proc_init_warnings ();
7483 sigchld_action
.sa_handler
= sigchld_handler
;
7484 sigemptyset (&sigchld_action
.sa_mask
);
7485 sigchld_action
.sa_flags
= SA_RESTART
;
7486 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
7488 initialize_low_arch ();
7490 linux_check_ptrace_features ();