1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995-2015 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"
26 #include "nat/linux-nat.h"
27 #include "nat/linux-waitpid.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 "filestuff.h"
47 #include "tracepoint.h"
50 /* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
51 then ELFMAG0 will have been defined. If it didn't get included by
52 gdb_proc_service.h then including it will likely introduce a duplicate
53 definition of elf_fpregset_t. */
56 #include "nat/linux-namespaces.h"
59 #define SPUFS_MAGIC 0x23c9b64e
62 #ifdef HAVE_PERSONALITY
63 # include <sys/personality.h>
64 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
65 # define ADDR_NO_RANDOMIZE 0x0040000
74 #define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
77 /* This is the kernel's hard limit. Not to be confused with
83 /* Some targets did not define these ptrace constants from the start,
84 so gdbserver defines them locally here. In the future, these may
85 be removed after they are added to asm/ptrace.h. */
86 #if !(defined(PT_TEXT_ADDR) \
87 || defined(PT_DATA_ADDR) \
88 || defined(PT_TEXT_END_ADDR))
89 #if defined(__mcoldfire__)
90 /* These are still undefined in 3.10 kernels. */
91 #define PT_TEXT_ADDR 49*4
92 #define PT_DATA_ADDR 50*4
93 #define PT_TEXT_END_ADDR 51*4
94 /* BFIN already defines these since at least 2.6.32 kernels. */
96 #define PT_TEXT_ADDR 220
97 #define PT_TEXT_END_ADDR 224
98 #define PT_DATA_ADDR 228
99 /* These are still undefined in 3.10 kernels. */
100 #elif defined(__TMS320C6X__)
101 #define PT_TEXT_ADDR (0x10000*4)
102 #define PT_DATA_ADDR (0x10004*4)
103 #define PT_TEXT_END_ADDR (0x10008*4)
107 #ifdef HAVE_LINUX_BTRACE
108 # include "nat/linux-btrace.h"
109 # include "btrace-common.h"
112 #ifndef HAVE_ELF32_AUXV_T
113 /* Copied from glibc's elf.h. */
116 uint32_t a_type
; /* Entry type */
119 uint32_t a_val
; /* Integer value */
120 /* We use to have pointer elements added here. We cannot do that,
121 though, since it does not work when using 32-bit definitions
122 on 64-bit platforms and vice versa. */
127 #ifndef HAVE_ELF64_AUXV_T
128 /* Copied from glibc's elf.h. */
131 uint64_t a_type
; /* Entry type */
134 uint64_t a_val
; /* Integer value */
135 /* We use to have pointer elements added here. We cannot do that,
136 though, since it does not work when using 32-bit definitions
137 on 64-bit platforms and vice versa. */
142 /* Does the current host support PTRACE_GETREGSET? */
143 int have_ptrace_getregset
= -1;
147 /* See nat/linux-nat.h. */
150 ptid_of_lwp (struct lwp_info
*lwp
)
152 return ptid_of (get_lwp_thread (lwp
));
155 /* See nat/linux-nat.h. */
158 lwp_set_arch_private_info (struct lwp_info
*lwp
,
159 struct arch_lwp_info
*info
)
161 lwp
->arch_private
= info
;
164 /* See nat/linux-nat.h. */
166 struct arch_lwp_info
*
167 lwp_arch_private_info (struct lwp_info
*lwp
)
169 return lwp
->arch_private
;
172 /* See nat/linux-nat.h. */
175 lwp_is_stopped (struct lwp_info
*lwp
)
180 /* See nat/linux-nat.h. */
182 enum target_stop_reason
183 lwp_stop_reason (struct lwp_info
*lwp
)
185 return lwp
->stop_reason
;
188 /* A list of all unknown processes which receive stop signals. Some
189 other process will presumably claim each of these as forked
190 children momentarily. */
192 struct simple_pid_list
194 /* The process ID. */
197 /* The status as reported by waitpid. */
201 struct simple_pid_list
*next
;
203 struct simple_pid_list
*stopped_pids
;
205 /* Trivial list manipulation functions to keep track of a list of new
206 stopped processes. */
209 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
211 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
214 new_pid
->status
= status
;
215 new_pid
->next
= *listp
;
220 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
222 struct simple_pid_list
**p
;
224 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
225 if ((*p
)->pid
== pid
)
227 struct simple_pid_list
*next
= (*p
)->next
;
229 *statusp
= (*p
)->status
;
237 enum stopping_threads_kind
239 /* Not stopping threads presently. */
240 NOT_STOPPING_THREADS
,
242 /* Stopping threads. */
245 /* Stopping and suspending threads. */
246 STOPPING_AND_SUSPENDING_THREADS
249 /* This is set while stop_all_lwps is in effect. */
250 enum stopping_threads_kind stopping_threads
= NOT_STOPPING_THREADS
;
252 /* FIXME make into a target method? */
253 int using_threads
= 1;
255 /* True if we're presently stabilizing threads (moving them out of
257 static int stabilizing_threads
;
259 static void linux_resume_one_lwp (struct lwp_info
*lwp
,
260 int step
, int signal
, siginfo_t
*info
);
261 static void linux_resume (struct thread_resume
*resume_info
, size_t n
);
262 static void stop_all_lwps (int suspend
, struct lwp_info
*except
);
263 static void unstop_all_lwps (int unsuspend
, struct lwp_info
*except
);
264 static int linux_wait_for_event_filtered (ptid_t wait_ptid
, ptid_t filter_ptid
,
265 int *wstat
, int options
);
266 static int linux_wait_for_event (ptid_t ptid
, int *wstat
, int options
);
267 static struct lwp_info
*add_lwp (ptid_t ptid
);
268 static int linux_stopped_by_watchpoint (void);
269 static void mark_lwp_dead (struct lwp_info
*lwp
, int wstat
);
270 static int lwp_is_marked_dead (struct lwp_info
*lwp
);
271 static void proceed_all_lwps (void);
272 static int finish_step_over (struct lwp_info
*lwp
);
273 static int kill_lwp (unsigned long lwpid
, int signo
);
274 static void enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
);
275 static void complete_ongoing_step_over (void);
277 /* When the event-loop is doing a step-over, this points at the thread
279 ptid_t step_over_bkpt
;
281 /* True if the low target can hardware single-step. Such targets
282 don't need a BREAKPOINT_REINSERT_ADDR callback. */
285 can_hardware_single_step (void)
287 return (the_low_target
.breakpoint_reinsert_addr
== NULL
);
290 /* True if the low target supports memory breakpoints. If so, we'll
291 have a GET_PC implementation. */
294 supports_breakpoints (void)
296 return (the_low_target
.get_pc
!= NULL
);
299 /* Returns true if this target can support fast tracepoints. This
300 does not mean that the in-process agent has been loaded in the
304 supports_fast_tracepoints (void)
306 return the_low_target
.install_fast_tracepoint_jump_pad
!= NULL
;
309 /* True if LWP is stopped in its stepping range. */
312 lwp_in_step_range (struct lwp_info
*lwp
)
314 CORE_ADDR pc
= lwp
->stop_pc
;
316 return (pc
>= lwp
->step_range_start
&& pc
< lwp
->step_range_end
);
319 struct pending_signals
323 struct pending_signals
*prev
;
326 /* The read/write ends of the pipe registered as waitable file in the
328 static int linux_event_pipe
[2] = { -1, -1 };
330 /* True if we're currently in async mode. */
331 #define target_is_async_p() (linux_event_pipe[0] != -1)
333 static void send_sigstop (struct lwp_info
*lwp
);
334 static void wait_for_sigstop (void);
336 /* Return non-zero if HEADER is a 64-bit ELF file. */
339 elf_64_header_p (const Elf64_Ehdr
*header
, unsigned int *machine
)
341 if (header
->e_ident
[EI_MAG0
] == ELFMAG0
342 && header
->e_ident
[EI_MAG1
] == ELFMAG1
343 && header
->e_ident
[EI_MAG2
] == ELFMAG2
344 && header
->e_ident
[EI_MAG3
] == ELFMAG3
)
346 *machine
= header
->e_machine
;
347 return header
->e_ident
[EI_CLASS
] == ELFCLASS64
;
354 /* Return non-zero if FILE is a 64-bit ELF file,
355 zero if the file is not a 64-bit ELF file,
356 and -1 if the file is not accessible or doesn't exist. */
359 elf_64_file_p (const char *file
, unsigned int *machine
)
364 fd
= open (file
, O_RDONLY
);
368 if (read (fd
, &header
, sizeof (header
)) != sizeof (header
))
375 return elf_64_header_p (&header
, machine
);
378 /* Accepts an integer PID; Returns true if the executable PID is
379 running is a 64-bit ELF file.. */
382 linux_pid_exe_is_elf_64_file (int pid
, unsigned int *machine
)
386 sprintf (file
, "/proc/%d/exe", pid
);
387 return elf_64_file_p (file
, machine
);
391 delete_lwp (struct lwp_info
*lwp
)
393 struct thread_info
*thr
= get_lwp_thread (lwp
);
396 debug_printf ("deleting %ld\n", lwpid_of (thr
));
399 free (lwp
->arch_private
);
403 /* Add a process to the common process list, and set its private
406 static struct process_info
*
407 linux_add_process (int pid
, int attached
)
409 struct process_info
*proc
;
411 proc
= add_process (pid
, attached
);
412 proc
->priv
= xcalloc (1, sizeof (*proc
->priv
));
414 if (the_low_target
.new_process
!= NULL
)
415 proc
->priv
->arch_private
= the_low_target
.new_process ();
420 static CORE_ADDR
get_pc (struct lwp_info
*lwp
);
422 /* Handle a GNU/Linux extended wait response. If we see a clone
423 event, we need to add the new LWP to our list (and return 0 so as
424 not to report the trap to higher layers). */
427 handle_extended_wait (struct lwp_info
*event_lwp
, int wstat
)
429 int event
= linux_ptrace_get_extended_event (wstat
);
430 struct thread_info
*event_thr
= get_lwp_thread (event_lwp
);
431 struct lwp_info
*new_lwp
;
433 if ((event
== PTRACE_EVENT_FORK
) || (event
== PTRACE_EVENT_VFORK
)
434 || (event
== PTRACE_EVENT_CLONE
))
437 unsigned long new_pid
;
440 /* Get the pid of the new lwp. */
441 ptrace (PTRACE_GETEVENTMSG
, lwpid_of (event_thr
), (PTRACE_TYPE_ARG3
) 0,
444 /* If we haven't already seen the new PID stop, wait for it now. */
445 if (!pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
447 /* The new child has a pending SIGSTOP. We can't affect it until it
448 hits the SIGSTOP, but we're already attached. */
450 ret
= my_waitpid (new_pid
, &status
, __WALL
);
453 perror_with_name ("waiting for new child");
454 else if (ret
!= new_pid
)
455 warning ("wait returned unexpected PID %d", ret
);
456 else if (!WIFSTOPPED (status
))
457 warning ("wait returned unexpected status 0x%x", status
);
460 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
)
462 struct process_info
*parent_proc
;
463 struct process_info
*child_proc
;
464 struct lwp_info
*child_lwp
;
465 struct thread_info
*child_thr
;
466 struct target_desc
*tdesc
;
468 ptid
= ptid_build (new_pid
, new_pid
, 0);
472 debug_printf ("HEW: Got fork event from LWP %ld, "
474 ptid_get_lwp (ptid_of (event_thr
)),
475 ptid_get_pid (ptid
));
478 /* Add the new process to the tables and clone the breakpoint
479 lists of the parent. We need to do this even if the new process
480 will be detached, since we will need the process object and the
481 breakpoints to remove any breakpoints from memory when we
482 detach, and the client side will access registers. */
483 child_proc
= linux_add_process (new_pid
, 0);
484 gdb_assert (child_proc
!= NULL
);
485 child_lwp
= add_lwp (ptid
);
486 gdb_assert (child_lwp
!= NULL
);
487 child_lwp
->stopped
= 1;
488 child_lwp
->must_set_ptrace_flags
= 1;
489 child_lwp
->status_pending_p
= 0;
490 child_thr
= get_lwp_thread (child_lwp
);
491 child_thr
->last_resume_kind
= resume_stop
;
492 child_thr
->last_status
.kind
= TARGET_WAITKIND_STOPPED
;
494 /* If we're suspending all threads, leave this one suspended
496 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
)
499 debug_printf ("HEW: leaving child suspended\n");
500 child_lwp
->suspended
= 1;
503 parent_proc
= get_thread_process (event_thr
);
504 child_proc
->attached
= parent_proc
->attached
;
505 clone_all_breakpoints (&child_proc
->breakpoints
,
506 &child_proc
->raw_breakpoints
,
507 parent_proc
->breakpoints
);
509 tdesc
= xmalloc (sizeof (struct target_desc
));
510 copy_target_description (tdesc
, parent_proc
->tdesc
);
511 child_proc
->tdesc
= tdesc
;
513 /* Clone arch-specific process data. */
514 if (the_low_target
.new_fork
!= NULL
)
515 the_low_target
.new_fork (parent_proc
, child_proc
);
517 /* Save fork info in the parent thread. */
518 if (event
== PTRACE_EVENT_FORK
)
519 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_FORKED
;
520 else if (event
== PTRACE_EVENT_VFORK
)
521 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_VFORKED
;
523 event_lwp
->waitstatus
.value
.related_pid
= ptid
;
525 /* The status_pending field contains bits denoting the
526 extended event, so when the pending event is handled,
527 the handler will look at lwp->waitstatus. */
528 event_lwp
->status_pending_p
= 1;
529 event_lwp
->status_pending
= wstat
;
531 /* Report the event. */
536 debug_printf ("HEW: Got clone event "
537 "from LWP %ld, new child is LWP %ld\n",
538 lwpid_of (event_thr
), new_pid
);
540 ptid
= ptid_build (pid_of (event_thr
), new_pid
, 0);
541 new_lwp
= add_lwp (ptid
);
543 /* Either we're going to immediately resume the new thread
544 or leave it stopped. linux_resume_one_lwp is a nop if it
545 thinks the thread is currently running, so set this first
546 before calling linux_resume_one_lwp. */
547 new_lwp
->stopped
= 1;
549 /* If we're suspending all threads, leave this one suspended
551 if (stopping_threads
== STOPPING_AND_SUSPENDING_THREADS
)
552 new_lwp
->suspended
= 1;
554 /* Normally we will get the pending SIGSTOP. But in some cases
555 we might get another signal delivered to the group first.
556 If we do get another signal, be sure not to lose it. */
557 if (WSTOPSIG (status
) != SIGSTOP
)
559 new_lwp
->stop_expected
= 1;
560 new_lwp
->status_pending_p
= 1;
561 new_lwp
->status_pending
= status
;
564 /* Don't report the event. */
567 else if (event
== PTRACE_EVENT_VFORK_DONE
)
569 event_lwp
->waitstatus
.kind
= TARGET_WAITKIND_VFORK_DONE
;
571 /* Report the event. */
575 internal_error (__FILE__
, __LINE__
, _("unknown ptrace event %d"), event
);
578 /* Return the PC as read from the regcache of LWP, without any
582 get_pc (struct lwp_info
*lwp
)
584 struct thread_info
*saved_thread
;
585 struct regcache
*regcache
;
588 if (the_low_target
.get_pc
== NULL
)
591 saved_thread
= current_thread
;
592 current_thread
= get_lwp_thread (lwp
);
594 regcache
= get_thread_regcache (current_thread
, 1);
595 pc
= (*the_low_target
.get_pc
) (regcache
);
598 debug_printf ("pc is 0x%lx\n", (long) pc
);
600 current_thread
= saved_thread
;
604 /* This function should only be called if LWP got a SIGTRAP.
605 The SIGTRAP could mean several things.
607 On i386, where decr_pc_after_break is non-zero:
609 If we were single-stepping this process using PTRACE_SINGLESTEP, we
610 will get only the one SIGTRAP. The value of $eip will be the next
611 instruction. If the instruction we stepped over was a breakpoint,
612 we need to decrement the PC.
614 If we continue the process using PTRACE_CONT, we will get a
615 SIGTRAP when we hit a breakpoint. The value of $eip will be
616 the instruction after the breakpoint (i.e. needs to be
617 decremented). If we report the SIGTRAP to GDB, we must also
618 report the undecremented PC. If the breakpoint is removed, we
619 must resume at the decremented PC.
621 On a non-decr_pc_after_break machine with hardware or kernel
624 If we either single-step a breakpoint instruction, or continue and
625 hit a breakpoint instruction, our PC will point at the breakpoint
629 check_stopped_by_breakpoint (struct lwp_info
*lwp
)
632 CORE_ADDR sw_breakpoint_pc
;
633 struct thread_info
*saved_thread
;
634 #if USE_SIGTRAP_SIGINFO
638 if (the_low_target
.get_pc
== NULL
)
642 sw_breakpoint_pc
= pc
- the_low_target
.decr_pc_after_break
;
644 /* breakpoint_at reads from the current thread. */
645 saved_thread
= current_thread
;
646 current_thread
= get_lwp_thread (lwp
);
648 #if USE_SIGTRAP_SIGINFO
649 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
650 (PTRACE_TYPE_ARG3
) 0, &siginfo
) == 0)
652 if (siginfo
.si_signo
== SIGTRAP
)
654 if (siginfo
.si_code
== GDB_ARCH_TRAP_BRKPT
)
658 struct thread_info
*thr
= get_lwp_thread (lwp
);
660 debug_printf ("CSBB: %s stopped by software breakpoint\n",
661 target_pid_to_str (ptid_of (thr
)));
664 /* Back up the PC if necessary. */
665 if (pc
!= sw_breakpoint_pc
)
667 struct regcache
*regcache
668 = get_thread_regcache (current_thread
, 1);
669 (*the_low_target
.set_pc
) (regcache
, sw_breakpoint_pc
);
672 lwp
->stop_pc
= sw_breakpoint_pc
;
673 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
674 current_thread
= saved_thread
;
677 else if (siginfo
.si_code
== TRAP_HWBKPT
)
681 struct thread_info
*thr
= get_lwp_thread (lwp
);
683 debug_printf ("CSBB: %s stopped by hardware "
684 "breakpoint/watchpoint\n",
685 target_pid_to_str (ptid_of (thr
)));
689 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
690 current_thread
= saved_thread
;
693 else if (siginfo
.si_code
== TRAP_TRACE
)
697 struct thread_info
*thr
= get_lwp_thread (lwp
);
699 debug_printf ("CSBB: %s stopped by trace\n",
700 target_pid_to_str (ptid_of (thr
)));
703 lwp
->stop_reason
= TARGET_STOPPED_BY_SINGLE_STEP
;
708 /* We may have just stepped a breakpoint instruction. E.g., in
709 non-stop mode, GDB first tells the thread A to step a range, and
710 then the user inserts a breakpoint inside the range. In that
711 case we need to report the breakpoint PC. */
712 if ((!lwp
->stepping
|| lwp
->stop_pc
== sw_breakpoint_pc
)
713 && (*the_low_target
.breakpoint_at
) (sw_breakpoint_pc
))
717 struct thread_info
*thr
= get_lwp_thread (lwp
);
719 debug_printf ("CSBB: %s stopped by software breakpoint\n",
720 target_pid_to_str (ptid_of (thr
)));
723 /* Back up the PC if necessary. */
724 if (pc
!= sw_breakpoint_pc
)
726 struct regcache
*regcache
727 = get_thread_regcache (current_thread
, 1);
728 (*the_low_target
.set_pc
) (regcache
, sw_breakpoint_pc
);
731 lwp
->stop_pc
= sw_breakpoint_pc
;
732 lwp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
733 current_thread
= saved_thread
;
737 if (hardware_breakpoint_inserted_here (pc
))
741 struct thread_info
*thr
= get_lwp_thread (lwp
);
743 debug_printf ("CSBB: %s stopped by hardware breakpoint\n",
744 target_pid_to_str (ptid_of (thr
)));
748 lwp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
749 current_thread
= saved_thread
;
754 current_thread
= saved_thread
;
758 static struct lwp_info
*
759 add_lwp (ptid_t ptid
)
761 struct lwp_info
*lwp
;
763 lwp
= (struct lwp_info
*) xcalloc (1, sizeof (*lwp
));
765 lwp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
767 if (the_low_target
.new_thread
!= NULL
)
768 the_low_target
.new_thread (lwp
);
770 lwp
->thread
= add_thread (ptid
, lwp
);
775 /* Start an inferior process and returns its pid.
776 ALLARGS is a vector of program-name and args. */
779 linux_create_inferior (char *program
, char **allargs
)
781 struct lwp_info
*new_lwp
;
784 struct cleanup
*restore_personality
785 = maybe_disable_address_space_randomization (disable_randomization
);
787 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
793 perror_with_name ("fork");
798 ptrace (PTRACE_TRACEME
, 0, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
800 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
801 signal (__SIGRTMIN
+ 1, SIG_DFL
);
806 /* If gdbserver is connected to gdb via stdio, redirect the inferior's
807 stdout to stderr so that inferior i/o doesn't corrupt the connection.
808 Also, redirect stdin to /dev/null. */
809 if (remote_connection_is_stdio ())
812 open ("/dev/null", O_RDONLY
);
814 if (write (2, "stdin/stdout redirected\n",
815 sizeof ("stdin/stdout redirected\n") - 1) < 0)
817 /* Errors ignored. */;
821 execv (program
, allargs
);
823 execvp (program
, allargs
);
825 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
831 do_cleanups (restore_personality
);
833 linux_add_process (pid
, 0);
835 ptid
= ptid_build (pid
, pid
, 0);
836 new_lwp
= add_lwp (ptid
);
837 new_lwp
->must_set_ptrace_flags
= 1;
842 /* Implement the arch_setup target_ops method. */
845 linux_arch_setup (void)
847 the_low_target
.arch_setup ();
850 /* Attach to an inferior process. Returns 0 on success, ERRNO on
854 linux_attach_lwp (ptid_t ptid
)
856 struct lwp_info
*new_lwp
;
857 int lwpid
= ptid_get_lwp (ptid
);
859 if (ptrace (PTRACE_ATTACH
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0)
863 new_lwp
= add_lwp (ptid
);
865 /* We need to wait for SIGSTOP before being able to make the next
866 ptrace call on this LWP. */
867 new_lwp
->must_set_ptrace_flags
= 1;
869 if (linux_proc_pid_is_stopped (lwpid
))
872 debug_printf ("Attached to a stopped process\n");
874 /* The process is definitely stopped. It is in a job control
875 stop, unless the kernel predates the TASK_STOPPED /
876 TASK_TRACED distinction, in which case it might be in a
877 ptrace stop. Make sure it is in a ptrace stop; from there we
878 can kill it, signal it, et cetera.
880 First make sure there is a pending SIGSTOP. Since we are
881 already attached, the process can not transition from stopped
882 to running without a PTRACE_CONT; so we know this signal will
883 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
884 probably already in the queue (unless this kernel is old
885 enough to use TASK_STOPPED for ptrace stops); but since
886 SIGSTOP is not an RT signal, it can only be queued once. */
887 kill_lwp (lwpid
, SIGSTOP
);
889 /* Finally, resume the stopped process. This will deliver the
890 SIGSTOP (or a higher priority signal, just like normal
891 PTRACE_ATTACH), which we'll catch later on. */
892 ptrace (PTRACE_CONT
, lwpid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
895 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
898 There are several cases to consider here:
900 1) gdbserver has already attached to the process and is being notified
901 of a new thread that is being created.
902 In this case we should ignore that SIGSTOP and resume the
903 process. This is handled below by setting stop_expected = 1,
904 and the fact that add_thread sets last_resume_kind ==
907 2) This is the first thread (the process thread), and we're attaching
908 to it via attach_inferior.
909 In this case we want the process thread to stop.
910 This is handled by having linux_attach set last_resume_kind ==
911 resume_stop after we return.
913 If the pid we are attaching to is also the tgid, we attach to and
914 stop all the existing threads. Otherwise, we attach to pid and
915 ignore any other threads in the same group as this pid.
917 3) GDB is connecting to gdbserver and is requesting an enumeration of all
919 In this case we want the thread to stop.
920 FIXME: This case is currently not properly handled.
921 We should wait for the SIGSTOP but don't. Things work apparently
922 because enough time passes between when we ptrace (ATTACH) and when
923 gdb makes the next ptrace call on the thread.
925 On the other hand, if we are currently trying to stop all threads, we
926 should treat the new thread as if we had sent it a SIGSTOP. This works
927 because we are guaranteed that the add_lwp call above added us to the
928 end of the list, and so the new thread has not yet reached
929 wait_for_sigstop (but will). */
930 new_lwp
->stop_expected
= 1;
935 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
936 already attached. Returns true if a new LWP is found, false
940 attach_proc_task_lwp_callback (ptid_t ptid
)
942 /* Is this a new thread? */
943 if (find_thread_ptid (ptid
) == NULL
)
945 int lwpid
= ptid_get_lwp (ptid
);
949 debug_printf ("Found new lwp %d\n", lwpid
);
951 err
= linux_attach_lwp (ptid
);
953 /* Be quiet if we simply raced with the thread exiting. EPERM
954 is returned if the thread's task still exists, and is marked
955 as exited or zombie, as well as other conditions, so in that
956 case, confirm the status in /proc/PID/status. */
958 || (err
== EPERM
&& linux_proc_pid_is_gone (lwpid
)))
962 debug_printf ("Cannot attach to lwp %d: "
963 "thread is gone (%d: %s)\n",
964 lwpid
, err
, strerror (err
));
969 warning (_("Cannot attach to lwp %d: %s"),
971 linux_ptrace_attach_fail_reason_string (ptid
, err
));
979 /* Attach to PID. If PID is the tgid, attach to it and all
983 linux_attach (unsigned long pid
)
985 ptid_t ptid
= ptid_build (pid
, pid
, 0);
988 /* Attach to PID. We will check for other threads
990 err
= linux_attach_lwp (ptid
);
992 error ("Cannot attach to process %ld: %s",
993 pid
, linux_ptrace_attach_fail_reason_string (ptid
, err
));
995 linux_add_process (pid
, 1);
999 struct thread_info
*thread
;
1001 /* Don't ignore the initial SIGSTOP if we just attached to this
1002 process. It will be collected by wait shortly. */
1003 thread
= find_thread_ptid (ptid_build (pid
, pid
, 0));
1004 thread
->last_resume_kind
= resume_stop
;
1007 /* We must attach to every LWP. If /proc is mounted, use that to
1008 find them now. On the one hand, the inferior may be using raw
1009 clone instead of using pthreads. On the other hand, even if it
1010 is using pthreads, GDB may not be connected yet (thread_db needs
1011 to do symbol lookups, through qSymbol). Also, thread_db walks
1012 structures in the inferior's address space to find the list of
1013 threads/LWPs, and those structures may well be corrupted. Note
1014 that once thread_db is loaded, we'll still use it to list threads
1015 and associate pthread info with each LWP. */
1016 linux_proc_attach_tgid_threads (pid
, attach_proc_task_lwp_callback
);
1027 second_thread_of_pid_p (struct inferior_list_entry
*entry
, void *args
)
1029 struct counter
*counter
= args
;
1031 if (ptid_get_pid (entry
->id
) == counter
->pid
)
1033 if (++counter
->count
> 1)
1041 last_thread_of_process_p (int pid
)
1043 struct counter counter
= { pid
, 0 };
1045 return (find_inferior (&all_threads
,
1046 second_thread_of_pid_p
, &counter
) == NULL
);
1052 linux_kill_one_lwp (struct lwp_info
*lwp
)
1054 struct thread_info
*thr
= get_lwp_thread (lwp
);
1055 int pid
= lwpid_of (thr
);
1057 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
1058 there is no signal context, and ptrace(PTRACE_KILL) (or
1059 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
1060 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
1061 alternative is to kill with SIGKILL. We only need one SIGKILL
1062 per process, not one for each thread. But since we still support
1063 linuxthreads, and we also support debugging programs using raw
1064 clone without CLONE_THREAD, we send one for each thread. For
1065 years, we used PTRACE_KILL only, so we're being a bit paranoid
1066 about some old kernels where PTRACE_KILL might work better
1067 (dubious if there are any such, but that's why it's paranoia), so
1068 we try SIGKILL first, PTRACE_KILL second, and so we're fine
1072 kill_lwp (pid
, SIGKILL
);
1075 int save_errno
= errno
;
1077 debug_printf ("LKL: kill_lwp (SIGKILL) %s, 0, 0 (%s)\n",
1078 target_pid_to_str (ptid_of (thr
)),
1079 save_errno
? strerror (save_errno
) : "OK");
1083 ptrace (PTRACE_KILL
, pid
, (PTRACE_TYPE_ARG3
) 0, (PTRACE_TYPE_ARG4
) 0);
1086 int save_errno
= errno
;
1088 debug_printf ("LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
1089 target_pid_to_str (ptid_of (thr
)),
1090 save_errno
? strerror (save_errno
) : "OK");
1094 /* Kill LWP and wait for it to die. */
1097 kill_wait_lwp (struct lwp_info
*lwp
)
1099 struct thread_info
*thr
= get_lwp_thread (lwp
);
1100 int pid
= ptid_get_pid (ptid_of (thr
));
1101 int lwpid
= ptid_get_lwp (ptid_of (thr
));
1106 debug_printf ("kwl: killing lwp %d, for pid: %d\n", lwpid
, pid
);
1110 linux_kill_one_lwp (lwp
);
1112 /* Make sure it died. Notes:
1114 - The loop is most likely unnecessary.
1116 - We don't use linux_wait_for_event as that could delete lwps
1117 while we're iterating over them. We're not interested in
1118 any pending status at this point, only in making sure all
1119 wait status on the kernel side are collected until the
1122 - We don't use __WALL here as the __WALL emulation relies on
1123 SIGCHLD, and killing a stopped process doesn't generate
1124 one, nor an exit status.
1126 res
= my_waitpid (lwpid
, &wstat
, 0);
1127 if (res
== -1 && errno
== ECHILD
)
1128 res
= my_waitpid (lwpid
, &wstat
, __WCLONE
);
1129 } while (res
> 0 && WIFSTOPPED (wstat
));
1131 /* Even if it was stopped, the child may have already disappeared.
1132 E.g., if it was killed by SIGKILL. */
1133 if (res
< 0 && errno
!= ECHILD
)
1134 perror_with_name ("kill_wait_lwp");
1137 /* Callback for `find_inferior'. Kills an lwp of a given process,
1138 except the leader. */
1141 kill_one_lwp_callback (struct inferior_list_entry
*entry
, void *args
)
1143 struct thread_info
*thread
= (struct thread_info
*) entry
;
1144 struct lwp_info
*lwp
= get_thread_lwp (thread
);
1145 int pid
= * (int *) args
;
1147 if (ptid_get_pid (entry
->id
) != pid
)
1150 /* We avoid killing the first thread here, because of a Linux kernel (at
1151 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
1152 the children get a chance to be reaped, it will remain a zombie
1155 if (lwpid_of (thread
) == pid
)
1158 debug_printf ("lkop: is last of process %s\n",
1159 target_pid_to_str (entry
->id
));
1163 kill_wait_lwp (lwp
);
1168 linux_kill (int pid
)
1170 struct process_info
*process
;
1171 struct lwp_info
*lwp
;
1173 process
= find_process_pid (pid
);
1174 if (process
== NULL
)
1177 /* If we're killing a running inferior, make sure it is stopped
1178 first, as PTRACE_KILL will not work otherwise. */
1179 stop_all_lwps (0, NULL
);
1181 find_inferior (&all_threads
, kill_one_lwp_callback
, &pid
);
1183 /* See the comment in linux_kill_one_lwp. We did not kill the first
1184 thread in the list, so do so now. */
1185 lwp
= find_lwp_pid (pid_to_ptid (pid
));
1190 debug_printf ("lk_1: cannot find lwp for pid: %d\n",
1194 kill_wait_lwp (lwp
);
1196 the_target
->mourn (process
);
1198 /* Since we presently can only stop all lwps of all processes, we
1199 need to unstop lwps of other processes. */
1200 unstop_all_lwps (0, NULL
);
1204 /* Get pending signal of THREAD, for detaching purposes. This is the
1205 signal the thread last stopped for, which we need to deliver to the
1206 thread when detaching, otherwise, it'd be suppressed/lost. */
1209 get_detach_signal (struct thread_info
*thread
)
1211 enum gdb_signal signo
= GDB_SIGNAL_0
;
1213 struct lwp_info
*lp
= get_thread_lwp (thread
);
1215 if (lp
->status_pending_p
)
1216 status
= lp
->status_pending
;
1219 /* If the thread had been suspended by gdbserver, and it stopped
1220 cleanly, then it'll have stopped with SIGSTOP. But we don't
1221 want to deliver that SIGSTOP. */
1222 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
1223 || thread
->last_status
.value
.sig
== GDB_SIGNAL_0
)
1226 /* Otherwise, we may need to deliver the signal we
1228 status
= lp
->last_status
;
1231 if (!WIFSTOPPED (status
))
1234 debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n",
1235 target_pid_to_str (ptid_of (thread
)));
1239 /* Extended wait statuses aren't real SIGTRAPs. */
1240 if (WSTOPSIG (status
) == SIGTRAP
&& linux_is_extended_waitstatus (status
))
1243 debug_printf ("GPS: lwp %s had stopped with extended "
1244 "status: no pending signal\n",
1245 target_pid_to_str (ptid_of (thread
)));
1249 signo
= gdb_signal_from_host (WSTOPSIG (status
));
1251 if (program_signals_p
&& !program_signals
[signo
])
1254 debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
1255 target_pid_to_str (ptid_of (thread
)),
1256 gdb_signal_to_string (signo
));
1259 else if (!program_signals_p
1260 /* If we have no way to know which signals GDB does not
1261 want to have passed to the program, assume
1262 SIGTRAP/SIGINT, which is GDB's default. */
1263 && (signo
== GDB_SIGNAL_TRAP
|| signo
== GDB_SIGNAL_INT
))
1266 debug_printf ("GPS: lwp %s had signal %s, "
1267 "but we don't know if we should pass it. "
1268 "Default to not.\n",
1269 target_pid_to_str (ptid_of (thread
)),
1270 gdb_signal_to_string (signo
));
1276 debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n",
1277 target_pid_to_str (ptid_of (thread
)),
1278 gdb_signal_to_string (signo
));
1280 return WSTOPSIG (status
);
1285 linux_detach_one_lwp (struct inferior_list_entry
*entry
, void *args
)
1287 struct thread_info
*thread
= (struct thread_info
*) entry
;
1288 struct lwp_info
*lwp
= get_thread_lwp (thread
);
1289 int pid
= * (int *) args
;
1292 if (ptid_get_pid (entry
->id
) != pid
)
1295 /* If there is a pending SIGSTOP, get rid of it. */
1296 if (lwp
->stop_expected
)
1299 debug_printf ("Sending SIGCONT to %s\n",
1300 target_pid_to_str (ptid_of (thread
)));
1302 kill_lwp (lwpid_of (thread
), SIGCONT
);
1303 lwp
->stop_expected
= 0;
1306 /* Flush any pending changes to the process's registers. */
1307 regcache_invalidate_thread (thread
);
1309 /* Pass on any pending signal for this thread. */
1310 sig
= get_detach_signal (thread
);
1312 /* Finally, let it resume. */
1313 if (the_low_target
.prepare_to_resume
!= NULL
)
1314 the_low_target
.prepare_to_resume (lwp
);
1315 if (ptrace (PTRACE_DETACH
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
1316 (PTRACE_TYPE_ARG4
) (long) sig
) < 0)
1317 error (_("Can't detach %s: %s"),
1318 target_pid_to_str (ptid_of (thread
)),
1326 linux_detach (int pid
)
1328 struct process_info
*process
;
1330 process
= find_process_pid (pid
);
1331 if (process
== NULL
)
1334 /* As there's a step over already in progress, let it finish first,
1335 otherwise nesting a stabilize_threads operation on top gets real
1337 complete_ongoing_step_over ();
1339 /* Stop all threads before detaching. First, ptrace requires that
1340 the thread is stopped to sucessfully detach. Second, thread_db
1341 may need to uninstall thread event breakpoints from memory, which
1342 only works with a stopped process anyway. */
1343 stop_all_lwps (0, NULL
);
1345 #ifdef USE_THREAD_DB
1346 thread_db_detach (process
);
1349 /* Stabilize threads (move out of jump pads). */
1350 stabilize_threads ();
1352 find_inferior (&all_threads
, linux_detach_one_lwp
, &pid
);
1354 the_target
->mourn (process
);
1356 /* Since we presently can only stop all lwps of all processes, we
1357 need to unstop lwps of other processes. */
1358 unstop_all_lwps (0, NULL
);
1362 /* Remove all LWPs that belong to process PROC from the lwp list. */
1365 delete_lwp_callback (struct inferior_list_entry
*entry
, void *proc
)
1367 struct thread_info
*thread
= (struct thread_info
*) entry
;
1368 struct lwp_info
*lwp
= get_thread_lwp (thread
);
1369 struct process_info
*process
= proc
;
1371 if (pid_of (thread
) == pid_of (process
))
1378 linux_mourn (struct process_info
*process
)
1380 struct process_info_private
*priv
;
1382 #ifdef USE_THREAD_DB
1383 thread_db_mourn (process
);
1386 find_inferior (&all_threads
, delete_lwp_callback
, process
);
1388 /* Freeing all private data. */
1389 priv
= process
->priv
;
1390 free (priv
->arch_private
);
1392 process
->priv
= NULL
;
1394 remove_process (process
);
1398 linux_join (int pid
)
1403 ret
= my_waitpid (pid
, &status
, 0);
1404 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1406 } while (ret
!= -1 || errno
!= ECHILD
);
1409 /* Return nonzero if the given thread is still alive. */
1411 linux_thread_alive (ptid_t ptid
)
1413 struct lwp_info
*lwp
= find_lwp_pid (ptid
);
1415 /* We assume we always know if a thread exits. If a whole process
1416 exited but we still haven't been able to report it to GDB, we'll
1417 hold on to the last lwp of the dead process. */
1419 return !lwp_is_marked_dead (lwp
);
1424 /* Return 1 if this lwp still has an interesting status pending. If
1425 not (e.g., it had stopped for a breakpoint that is gone), return
1429 thread_still_has_status_pending_p (struct thread_info
*thread
)
1431 struct lwp_info
*lp
= get_thread_lwp (thread
);
1433 if (!lp
->status_pending_p
)
1436 /* If we got a `vCont;t', but we haven't reported a stop yet, do
1437 report any status pending the LWP may have. */
1438 if (thread
->last_resume_kind
== resume_stop
1439 && thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1442 if (thread
->last_resume_kind
!= resume_stop
1443 && (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1444 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
))
1446 struct thread_info
*saved_thread
;
1450 gdb_assert (lp
->last_status
!= 0);
1454 saved_thread
= current_thread
;
1455 current_thread
= thread
;
1457 if (pc
!= lp
->stop_pc
)
1460 debug_printf ("PC of %ld changed\n",
1465 #if !USE_SIGTRAP_SIGINFO
1466 else if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
1467 && !(*the_low_target
.breakpoint_at
) (pc
))
1470 debug_printf ("previous SW breakpoint of %ld gone\n",
1474 else if (lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
1475 && !hardware_breakpoint_inserted_here (pc
))
1478 debug_printf ("previous HW breakpoint of %ld gone\n",
1484 current_thread
= saved_thread
;
1489 debug_printf ("discarding pending breakpoint status\n");
1490 lp
->status_pending_p
= 0;
1498 /* Return 1 if this lwp has an interesting status pending. */
1500 status_pending_p_callback (struct inferior_list_entry
*entry
, void *arg
)
1502 struct thread_info
*thread
= (struct thread_info
*) entry
;
1503 struct lwp_info
*lp
= get_thread_lwp (thread
);
1504 ptid_t ptid
= * (ptid_t
*) arg
;
1506 /* Check if we're only interested in events from a specific process
1507 or a specific LWP. */
1508 if (!ptid_match (ptid_of (thread
), ptid
))
1511 if (lp
->status_pending_p
1512 && !thread_still_has_status_pending_p (thread
))
1514 linux_resume_one_lwp (lp
, lp
->stepping
, GDB_SIGNAL_0
, NULL
);
1518 return lp
->status_pending_p
;
1522 same_lwp (struct inferior_list_entry
*entry
, void *data
)
1524 ptid_t ptid
= *(ptid_t
*) data
;
1527 if (ptid_get_lwp (ptid
) != 0)
1528 lwp
= ptid_get_lwp (ptid
);
1530 lwp
= ptid_get_pid (ptid
);
1532 if (ptid_get_lwp (entry
->id
) == lwp
)
1539 find_lwp_pid (ptid_t ptid
)
1541 struct inferior_list_entry
*thread
1542 = find_inferior (&all_threads
, same_lwp
, &ptid
);
1547 return get_thread_lwp ((struct thread_info
*) thread
);
1550 /* Return the number of known LWPs in the tgid given by PID. */
1555 struct inferior_list_entry
*inf
, *tmp
;
1558 ALL_INFERIORS (&all_threads
, inf
, tmp
)
1560 if (ptid_get_pid (inf
->id
) == pid
)
1567 /* The arguments passed to iterate_over_lwps. */
1569 struct iterate_over_lwps_args
1571 /* The FILTER argument passed to iterate_over_lwps. */
1574 /* The CALLBACK argument passed to iterate_over_lwps. */
1575 iterate_over_lwps_ftype
*callback
;
1577 /* The DATA argument passed to iterate_over_lwps. */
1581 /* Callback for find_inferior used by iterate_over_lwps to filter
1582 calls to the callback supplied to that function. Returning a
1583 nonzero value causes find_inferiors to stop iterating and return
1584 the current inferior_list_entry. Returning zero indicates that
1585 find_inferiors should continue iterating. */
1588 iterate_over_lwps_filter (struct inferior_list_entry
*entry
, void *args_p
)
1590 struct iterate_over_lwps_args
*args
1591 = (struct iterate_over_lwps_args
*) args_p
;
1593 if (ptid_match (entry
->id
, args
->filter
))
1595 struct thread_info
*thr
= (struct thread_info
*) entry
;
1596 struct lwp_info
*lwp
= get_thread_lwp (thr
);
1598 return (*args
->callback
) (lwp
, args
->data
);
1604 /* See nat/linux-nat.h. */
1607 iterate_over_lwps (ptid_t filter
,
1608 iterate_over_lwps_ftype callback
,
1611 struct iterate_over_lwps_args args
= {filter
, callback
, data
};
1612 struct inferior_list_entry
*entry
;
1614 entry
= find_inferior (&all_threads
, iterate_over_lwps_filter
, &args
);
1618 return get_thread_lwp ((struct thread_info
*) entry
);
1621 /* Detect zombie thread group leaders, and "exit" them. We can't reap
1622 their exits until all other threads in the group have exited. */
1625 check_zombie_leaders (void)
1627 struct process_info
*proc
, *tmp
;
1629 ALL_PROCESSES (proc
, tmp
)
1631 pid_t leader_pid
= pid_of (proc
);
1632 struct lwp_info
*leader_lp
;
1634 leader_lp
= find_lwp_pid (pid_to_ptid (leader_pid
));
1637 debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
1638 "num_lwps=%d, zombie=%d\n",
1639 leader_pid
, leader_lp
!= NULL
, num_lwps (leader_pid
),
1640 linux_proc_pid_is_zombie (leader_pid
));
1642 if (leader_lp
!= NULL
1643 /* Check if there are other threads in the group, as we may
1644 have raced with the inferior simply exiting. */
1645 && !last_thread_of_process_p (leader_pid
)
1646 && linux_proc_pid_is_zombie (leader_pid
))
1648 /* A leader zombie can mean one of two things:
1650 - It exited, and there's an exit status pending
1651 available, or only the leader exited (not the whole
1652 program). In the latter case, we can't waitpid the
1653 leader's exit status until all other threads are gone.
1655 - There are 3 or more threads in the group, and a thread
1656 other than the leader exec'd. On an exec, the Linux
1657 kernel destroys all other threads (except the execing
1658 one) in the thread group, and resets the execing thread's
1659 tid to the tgid. No exit notification is sent for the
1660 execing thread -- from the ptracer's perspective, it
1661 appears as though the execing thread just vanishes.
1662 Until we reap all other threads except the leader and the
1663 execing thread, the leader will be zombie, and the
1664 execing thread will be in `D (disc sleep)'. As soon as
1665 all other threads are reaped, the execing thread changes
1666 it's tid to the tgid, and the previous (zombie) leader
1667 vanishes, giving place to the "new" leader. We could try
1668 distinguishing the exit and exec cases, by waiting once
1669 more, and seeing if something comes out, but it doesn't
1670 sound useful. The previous leader _does_ go away, and
1671 we'll re-add the new one once we see the exec event
1672 (which is just the same as what would happen if the
1673 previous leader did exit voluntarily before some other
1678 "CZL: Thread group leader %d zombie "
1679 "(it exited, or another thread execd).\n",
1682 delete_lwp (leader_lp
);
1687 /* Callback for `find_inferior'. Returns the first LWP that is not
1688 stopped. ARG is a PTID filter. */
1691 not_stopped_callback (struct inferior_list_entry
*entry
, void *arg
)
1693 struct thread_info
*thr
= (struct thread_info
*) entry
;
1694 struct lwp_info
*lwp
;
1695 ptid_t filter
= *(ptid_t
*) arg
;
1697 if (!ptid_match (ptid_of (thr
), filter
))
1700 lwp
= get_thread_lwp (thr
);
1707 /* Increment LWP's suspend count. */
1710 lwp_suspended_inc (struct lwp_info
*lwp
)
1714 if (debug_threads
&& lwp
->suspended
> 4)
1716 struct thread_info
*thread
= get_lwp_thread (lwp
);
1718 debug_printf ("LWP %ld has a suspiciously high suspend count,"
1719 " suspended=%d\n", lwpid_of (thread
), lwp
->suspended
);
1723 /* Decrement LWP's suspend count. */
1726 lwp_suspended_decr (struct lwp_info
*lwp
)
1730 if (lwp
->suspended
< 0)
1732 struct thread_info
*thread
= get_lwp_thread (lwp
);
1734 internal_error (__FILE__
, __LINE__
,
1735 "unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread
),
1740 /* This function should only be called if the LWP got a SIGTRAP.
1742 Handle any tracepoint steps or hits. Return true if a tracepoint
1743 event was handled, 0 otherwise. */
1746 handle_tracepoints (struct lwp_info
*lwp
)
1748 struct thread_info
*tinfo
= get_lwp_thread (lwp
);
1749 int tpoint_related_event
= 0;
1751 gdb_assert (lwp
->suspended
== 0);
1753 /* If this tracepoint hit causes a tracing stop, we'll immediately
1754 uninsert tracepoints. To do this, we temporarily pause all
1755 threads, unpatch away, and then unpause threads. We need to make
1756 sure the unpausing doesn't resume LWP too. */
1757 lwp_suspended_inc (lwp
);
1759 /* And we need to be sure that any all-threads-stopping doesn't try
1760 to move threads out of the jump pads, as it could deadlock the
1761 inferior (LWP could be in the jump pad, maybe even holding the
1764 /* Do any necessary step collect actions. */
1765 tpoint_related_event
|= tracepoint_finished_step (tinfo
, lwp
->stop_pc
);
1767 tpoint_related_event
|= handle_tracepoint_bkpts (tinfo
, lwp
->stop_pc
);
1769 /* See if we just hit a tracepoint and do its main collect
1771 tpoint_related_event
|= tracepoint_was_hit (tinfo
, lwp
->stop_pc
);
1773 lwp_suspended_decr (lwp
);
1775 gdb_assert (lwp
->suspended
== 0);
1776 gdb_assert (!stabilizing_threads
|| lwp
->collecting_fast_tracepoint
);
1778 if (tpoint_related_event
)
1781 debug_printf ("got a tracepoint event\n");
1788 /* Convenience wrapper. Returns true if LWP is presently collecting a
1792 linux_fast_tracepoint_collecting (struct lwp_info
*lwp
,
1793 struct fast_tpoint_collect_status
*status
)
1795 CORE_ADDR thread_area
;
1796 struct thread_info
*thread
= get_lwp_thread (lwp
);
1798 if (the_low_target
.get_thread_area
== NULL
)
1801 /* Get the thread area address. This is used to recognize which
1802 thread is which when tracing with the in-process agent library.
1803 We don't read anything from the address, and treat it as opaque;
1804 it's the address itself that we assume is unique per-thread. */
1805 if ((*the_low_target
.get_thread_area
) (lwpid_of (thread
), &thread_area
) == -1)
1808 return fast_tracepoint_collecting (thread_area
, lwp
->stop_pc
, status
);
1811 /* The reason we resume in the caller, is because we want to be able
1812 to pass lwp->status_pending as WSTAT, and we need to clear
1813 status_pending_p before resuming, otherwise, linux_resume_one_lwp
1814 refuses to resume. */
1817 maybe_move_out_of_jump_pad (struct lwp_info
*lwp
, int *wstat
)
1819 struct thread_info
*saved_thread
;
1821 saved_thread
= current_thread
;
1822 current_thread
= get_lwp_thread (lwp
);
1825 || (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) != SIGTRAP
))
1826 && supports_fast_tracepoints ()
1827 && agent_loaded_p ())
1829 struct fast_tpoint_collect_status status
;
1833 debug_printf ("Checking whether LWP %ld needs to move out of the "
1835 lwpid_of (current_thread
));
1837 r
= linux_fast_tracepoint_collecting (lwp
, &status
);
1840 || (WSTOPSIG (*wstat
) != SIGILL
1841 && WSTOPSIG (*wstat
) != SIGFPE
1842 && WSTOPSIG (*wstat
) != SIGSEGV
1843 && WSTOPSIG (*wstat
) != SIGBUS
))
1845 lwp
->collecting_fast_tracepoint
= r
;
1849 if (r
== 1 && lwp
->exit_jump_pad_bkpt
== NULL
)
1851 /* Haven't executed the original instruction yet.
1852 Set breakpoint there, and wait till it's hit,
1853 then single-step until exiting the jump pad. */
1854 lwp
->exit_jump_pad_bkpt
1855 = set_breakpoint_at (status
.adjusted_insn_addr
, NULL
);
1859 debug_printf ("Checking whether LWP %ld needs to move out of "
1860 "the jump pad...it does\n",
1861 lwpid_of (current_thread
));
1862 current_thread
= saved_thread
;
1869 /* If we get a synchronous signal while collecting, *and*
1870 while executing the (relocated) original instruction,
1871 reset the PC to point at the tpoint address, before
1872 reporting to GDB. Otherwise, it's an IPA lib bug: just
1873 report the signal to GDB, and pray for the best. */
1875 lwp
->collecting_fast_tracepoint
= 0;
1878 && (status
.adjusted_insn_addr
<= lwp
->stop_pc
1879 && lwp
->stop_pc
< status
.adjusted_insn_addr_end
))
1882 struct regcache
*regcache
;
1884 /* The si_addr on a few signals references the address
1885 of the faulting instruction. Adjust that as
1887 if ((WSTOPSIG (*wstat
) == SIGILL
1888 || WSTOPSIG (*wstat
) == SIGFPE
1889 || WSTOPSIG (*wstat
) == SIGBUS
1890 || WSTOPSIG (*wstat
) == SIGSEGV
)
1891 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
1892 (PTRACE_TYPE_ARG3
) 0, &info
) == 0
1893 /* Final check just to make sure we don't clobber
1894 the siginfo of non-kernel-sent signals. */
1895 && (uintptr_t) info
.si_addr
== lwp
->stop_pc
)
1897 info
.si_addr
= (void *) (uintptr_t) status
.tpoint_addr
;
1898 ptrace (PTRACE_SETSIGINFO
, lwpid_of (current_thread
),
1899 (PTRACE_TYPE_ARG3
) 0, &info
);
1902 regcache
= get_thread_regcache (current_thread
, 1);
1903 (*the_low_target
.set_pc
) (regcache
, status
.tpoint_addr
);
1904 lwp
->stop_pc
= status
.tpoint_addr
;
1906 /* Cancel any fast tracepoint lock this thread was
1908 force_unlock_trace_buffer ();
1911 if (lwp
->exit_jump_pad_bkpt
!= NULL
)
1914 debug_printf ("Cancelling fast exit-jump-pad: removing bkpt. "
1915 "stopping all threads momentarily.\n");
1917 stop_all_lwps (1, lwp
);
1919 delete_breakpoint (lwp
->exit_jump_pad_bkpt
);
1920 lwp
->exit_jump_pad_bkpt
= NULL
;
1922 unstop_all_lwps (1, lwp
);
1924 gdb_assert (lwp
->suspended
>= 0);
1930 debug_printf ("Checking whether LWP %ld needs to move out of the "
1932 lwpid_of (current_thread
));
1934 current_thread
= saved_thread
;
1938 /* Enqueue one signal in the "signals to report later when out of the
1942 enqueue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
1944 struct pending_signals
*p_sig
;
1945 struct thread_info
*thread
= get_lwp_thread (lwp
);
1948 debug_printf ("Deferring signal %d for LWP %ld.\n",
1949 WSTOPSIG (*wstat
), lwpid_of (thread
));
1953 struct pending_signals
*sig
;
1955 for (sig
= lwp
->pending_signals_to_report
;
1958 debug_printf (" Already queued %d\n",
1961 debug_printf (" (no more currently queued signals)\n");
1964 /* Don't enqueue non-RT signals if they are already in the deferred
1965 queue. (SIGSTOP being the easiest signal to see ending up here
1967 if (WSTOPSIG (*wstat
) < __SIGRTMIN
)
1969 struct pending_signals
*sig
;
1971 for (sig
= lwp
->pending_signals_to_report
;
1975 if (sig
->signal
== WSTOPSIG (*wstat
))
1978 debug_printf ("Not requeuing already queued non-RT signal %d"
1987 p_sig
= xmalloc (sizeof (*p_sig
));
1988 p_sig
->prev
= lwp
->pending_signals_to_report
;
1989 p_sig
->signal
= WSTOPSIG (*wstat
);
1990 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
1991 ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
1994 lwp
->pending_signals_to_report
= p_sig
;
1997 /* Dequeue one signal from the "signals to report later when out of
1998 the jump pad" list. */
2001 dequeue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
2003 struct thread_info
*thread
= get_lwp_thread (lwp
);
2005 if (lwp
->pending_signals_to_report
!= NULL
)
2007 struct pending_signals
**p_sig
;
2009 p_sig
= &lwp
->pending_signals_to_report
;
2010 while ((*p_sig
)->prev
!= NULL
)
2011 p_sig
= &(*p_sig
)->prev
;
2013 *wstat
= W_STOPCODE ((*p_sig
)->signal
);
2014 if ((*p_sig
)->info
.si_signo
!= 0)
2015 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
2021 debug_printf ("Reporting deferred signal %d for LWP %ld.\n",
2022 WSTOPSIG (*wstat
), lwpid_of (thread
));
2026 struct pending_signals
*sig
;
2028 for (sig
= lwp
->pending_signals_to_report
;
2031 debug_printf (" Still queued %d\n",
2034 debug_printf (" (no more queued signals)\n");
2043 /* Fetch the possibly triggered data watchpoint info and store it in
2046 On some archs, like x86, that use debug registers to set
2047 watchpoints, it's possible that the way to know which watched
2048 address trapped, is to check the register that is used to select
2049 which address to watch. Problem is, between setting the watchpoint
2050 and reading back which data address trapped, the user may change
2051 the set of watchpoints, and, as a consequence, GDB changes the
2052 debug registers in the inferior. To avoid reading back a stale
2053 stopped-data-address when that happens, we cache in LP the fact
2054 that a watchpoint trapped, and the corresponding data address, as
2055 soon as we see CHILD stop with a SIGTRAP. If GDB changes the debug
2056 registers meanwhile, we have the cached data we can rely on. */
2059 check_stopped_by_watchpoint (struct lwp_info
*child
)
2061 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
2063 struct thread_info
*saved_thread
;
2065 saved_thread
= current_thread
;
2066 current_thread
= get_lwp_thread (child
);
2068 if (the_low_target
.stopped_by_watchpoint ())
2070 child
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
2072 if (the_low_target
.stopped_data_address
!= NULL
)
2073 child
->stopped_data_address
2074 = the_low_target
.stopped_data_address ();
2076 child
->stopped_data_address
= 0;
2079 current_thread
= saved_thread
;
2082 return child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2085 /* Return the ptrace options that we want to try to enable. */
2088 linux_low_ptrace_options (int attached
)
2093 options
|= PTRACE_O_EXITKILL
;
2095 if (report_fork_events
)
2096 options
|= PTRACE_O_TRACEFORK
;
2098 if (report_vfork_events
)
2099 options
|= (PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEVFORKDONE
);
2104 /* Do low-level handling of the event, and check if we should go on
2105 and pass it to caller code. Return the affected lwp if we are, or
2108 static struct lwp_info
*
2109 linux_low_filter_event (int lwpid
, int wstat
)
2111 struct lwp_info
*child
;
2112 struct thread_info
*thread
;
2113 int have_stop_pc
= 0;
2115 child
= find_lwp_pid (pid_to_ptid (lwpid
));
2117 /* If we didn't find a process, one of two things presumably happened:
2118 - A process we started and then detached from has exited. Ignore it.
2119 - A process we are controlling has forked and the new child's stop
2120 was reported to us by the kernel. Save its PID. */
2121 if (child
== NULL
&& WIFSTOPPED (wstat
))
2123 add_to_pid_list (&stopped_pids
, lwpid
, wstat
);
2126 else if (child
== NULL
)
2129 thread
= get_lwp_thread (child
);
2133 child
->last_status
= wstat
;
2135 /* Check if the thread has exited. */
2136 if ((WIFEXITED (wstat
) || WIFSIGNALED (wstat
)))
2139 debug_printf ("LLFE: %d exited.\n", lwpid
);
2140 if (num_lwps (pid_of (thread
)) > 1)
2143 /* If there is at least one more LWP, then the exit signal was
2144 not the end of the debugged application and should be
2151 /* This was the last lwp in the process. Since events are
2152 serialized to GDB core, and we can't report this one
2153 right now, but GDB core and the other target layers will
2154 want to be notified about the exit code/signal, leave the
2155 status pending for the next time we're able to report
2157 mark_lwp_dead (child
, wstat
);
2162 gdb_assert (WIFSTOPPED (wstat
));
2164 if (WIFSTOPPED (wstat
))
2166 struct process_info
*proc
;
2168 /* Architecture-specific setup after inferior is running. */
2169 proc
= find_process_pid (pid_of (thread
));
2170 if (proc
->tdesc
== NULL
)
2174 struct thread_info
*saved_thread
;
2176 /* This needs to happen after we have attached to the
2177 inferior and it is stopped for the first time, but
2178 before we access any inferior registers. */
2179 saved_thread
= current_thread
;
2180 current_thread
= thread
;
2182 the_low_target
.arch_setup ();
2184 current_thread
= saved_thread
;
2188 /* The process is started, but GDBserver will do
2189 architecture-specific setup after the program stops at
2190 the first instruction. */
2191 child
->status_pending_p
= 1;
2192 child
->status_pending
= wstat
;
2198 if (WIFSTOPPED (wstat
) && child
->must_set_ptrace_flags
)
2200 struct process_info
*proc
= find_process_pid (pid_of (thread
));
2201 int options
= linux_low_ptrace_options (proc
->attached
);
2203 linux_enable_event_reporting (lwpid
, options
);
2204 child
->must_set_ptrace_flags
= 0;
2207 /* Be careful to not overwrite stop_pc until
2208 check_stopped_by_breakpoint is called. */
2209 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGTRAP
2210 && linux_is_extended_waitstatus (wstat
))
2212 child
->stop_pc
= get_pc (child
);
2213 if (handle_extended_wait (child
, wstat
))
2215 /* The event has been handled, so just return without
2221 /* Check first whether this was a SW/HW breakpoint before checking
2222 watchpoints, because at least s390 can't tell the data address of
2223 hardware watchpoint hits, and returns stopped-by-watchpoint as
2224 long as there's a watchpoint set. */
2225 if (WIFSTOPPED (wstat
) && linux_wstatus_maybe_breakpoint (wstat
))
2227 if (check_stopped_by_breakpoint (child
))
2231 /* Note that TRAP_HWBKPT can indicate either a hardware breakpoint
2232 or hardware watchpoint. Check which is which if we got
2233 TARGET_STOPPED_BY_HW_BREAKPOINT. Likewise, we may have single
2234 stepped an instruction that triggered a watchpoint. In that
2235 case, on some architectures (such as x86), instead of
2236 TRAP_HWBKPT, si_code indicates TRAP_TRACE, and we need to check
2237 the debug registers separately. */
2238 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGTRAP
2239 && child
->stop_reason
!= TARGET_STOPPED_BY_SW_BREAKPOINT
)
2240 check_stopped_by_watchpoint (child
);
2243 child
->stop_pc
= get_pc (child
);
2245 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGSTOP
2246 && child
->stop_expected
)
2249 debug_printf ("Expected stop.\n");
2250 child
->stop_expected
= 0;
2252 if (thread
->last_resume_kind
== resume_stop
)
2254 /* We want to report the stop to the core. Treat the
2255 SIGSTOP as a normal event. */
2257 debug_printf ("LLW: resume_stop SIGSTOP caught for %s.\n",
2258 target_pid_to_str (ptid_of (thread
)));
2260 else if (stopping_threads
!= NOT_STOPPING_THREADS
)
2262 /* Stopping threads. We don't want this SIGSTOP to end up
2265 debug_printf ("LLW: SIGSTOP caught for %s "
2266 "while stopping threads.\n",
2267 target_pid_to_str (ptid_of (thread
)));
2272 /* This is a delayed SIGSTOP. Filter out the event. */
2274 debug_printf ("LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
2275 child
->stepping
? "step" : "continue",
2276 target_pid_to_str (ptid_of (thread
)));
2278 linux_resume_one_lwp (child
, child
->stepping
, 0, NULL
);
2283 child
->status_pending_p
= 1;
2284 child
->status_pending
= wstat
;
2288 /* Resume LWPs that are currently stopped without any pending status
2289 to report, but are resumed from the core's perspective. */
2292 resume_stopped_resumed_lwps (struct inferior_list_entry
*entry
)
2294 struct thread_info
*thread
= (struct thread_info
*) entry
;
2295 struct lwp_info
*lp
= get_thread_lwp (thread
);
2299 && !lp
->status_pending_p
2300 && thread
->last_resume_kind
!= resume_stop
2301 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
)
2303 int step
= thread
->last_resume_kind
== resume_step
;
2306 debug_printf ("RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
2307 target_pid_to_str (ptid_of (thread
)),
2308 paddress (lp
->stop_pc
),
2311 linux_resume_one_lwp (lp
, step
, GDB_SIGNAL_0
, NULL
);
2315 /* Wait for an event from child(ren) WAIT_PTID, and return any that
2316 match FILTER_PTID (leaving others pending). The PTIDs can be:
2317 minus_one_ptid, to specify any child; a pid PTID, specifying all
2318 lwps of a thread group; or a PTID representing a single lwp. Store
2319 the stop status through the status pointer WSTAT. OPTIONS is
2320 passed to the waitpid call. Return 0 if no event was found and
2321 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
2322 was found. Return the PID of the stopped child otherwise. */
2325 linux_wait_for_event_filtered (ptid_t wait_ptid
, ptid_t filter_ptid
,
2326 int *wstatp
, int options
)
2328 struct thread_info
*event_thread
;
2329 struct lwp_info
*event_child
, *requested_child
;
2330 sigset_t block_mask
, prev_mask
;
2333 /* N.B. event_thread points to the thread_info struct that contains
2334 event_child. Keep them in sync. */
2335 event_thread
= NULL
;
2337 requested_child
= NULL
;
2339 /* Check for a lwp with a pending status. */
2341 if (ptid_equal (filter_ptid
, minus_one_ptid
) || ptid_is_pid (filter_ptid
))
2343 event_thread
= (struct thread_info
*)
2344 find_inferior (&all_threads
, status_pending_p_callback
, &filter_ptid
);
2345 if (event_thread
!= NULL
)
2346 event_child
= get_thread_lwp (event_thread
);
2347 if (debug_threads
&& event_thread
)
2348 debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread
));
2350 else if (!ptid_equal (filter_ptid
, null_ptid
))
2352 requested_child
= find_lwp_pid (filter_ptid
);
2354 if (stopping_threads
== NOT_STOPPING_THREADS
2355 && requested_child
->status_pending_p
2356 && requested_child
->collecting_fast_tracepoint
)
2358 enqueue_one_deferred_signal (requested_child
,
2359 &requested_child
->status_pending
);
2360 requested_child
->status_pending_p
= 0;
2361 requested_child
->status_pending
= 0;
2362 linux_resume_one_lwp (requested_child
, 0, 0, NULL
);
2365 if (requested_child
->suspended
2366 && requested_child
->status_pending_p
)
2368 internal_error (__FILE__
, __LINE__
,
2369 "requesting an event out of a"
2370 " suspended child?");
2373 if (requested_child
->status_pending_p
)
2375 event_child
= requested_child
;
2376 event_thread
= get_lwp_thread (event_child
);
2380 if (event_child
!= NULL
)
2383 debug_printf ("Got an event from pending child %ld (%04x)\n",
2384 lwpid_of (event_thread
), event_child
->status_pending
);
2385 *wstatp
= event_child
->status_pending
;
2386 event_child
->status_pending_p
= 0;
2387 event_child
->status_pending
= 0;
2388 current_thread
= event_thread
;
2389 return lwpid_of (event_thread
);
2392 /* But if we don't find a pending event, we'll have to wait.
2394 We only enter this loop if no process has a pending wait status.
2395 Thus any action taken in response to a wait status inside this
2396 loop is responding as soon as we detect the status, not after any
2399 /* Make sure SIGCHLD is blocked until the sigsuspend below. Block
2400 all signals while here. */
2401 sigfillset (&block_mask
);
2402 sigprocmask (SIG_BLOCK
, &block_mask
, &prev_mask
);
2404 /* Always pull all events out of the kernel. We'll randomly select
2405 an event LWP out of all that have events, to prevent
2407 while (event_child
== NULL
)
2411 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
2414 - If the thread group leader exits while other threads in the
2415 thread group still exist, waitpid(TGID, ...) hangs. That
2416 waitpid won't return an exit status until the other threads
2417 in the group are reaped.
2419 - When a non-leader thread execs, that thread just vanishes
2420 without reporting an exit (so we'd hang if we waited for it
2421 explicitly in that case). The exec event is reported to
2422 the TGID pid (although we don't currently enable exec
2425 ret
= my_waitpid (-1, wstatp
, options
| WNOHANG
);
2428 debug_printf ("LWFE: waitpid(-1, ...) returned %d, %s\n",
2429 ret
, errno
? strerror (errno
) : "ERRNO-OK");
2435 debug_printf ("LLW: waitpid %ld received %s\n",
2436 (long) ret
, status_to_str (*wstatp
));
2439 /* Filter all events. IOW, leave all events pending. We'll
2440 randomly select an event LWP out of all that have events
2442 linux_low_filter_event (ret
, *wstatp
);
2443 /* Retry until nothing comes out of waitpid. A single
2444 SIGCHLD can indicate more than one child stopped. */
2448 /* Now that we've pulled all events out of the kernel, resume
2449 LWPs that don't have an interesting event to report. */
2450 if (stopping_threads
== NOT_STOPPING_THREADS
)
2451 for_each_inferior (&all_threads
, resume_stopped_resumed_lwps
);
2453 /* ... and find an LWP with a status to report to the core, if
2455 event_thread
= (struct thread_info
*)
2456 find_inferior (&all_threads
, status_pending_p_callback
, &filter_ptid
);
2457 if (event_thread
!= NULL
)
2459 event_child
= get_thread_lwp (event_thread
);
2460 *wstatp
= event_child
->status_pending
;
2461 event_child
->status_pending_p
= 0;
2462 event_child
->status_pending
= 0;
2466 /* Check for zombie thread group leaders. Those can't be reaped
2467 until all other threads in the thread group are. */
2468 check_zombie_leaders ();
2470 /* If there are no resumed children left in the set of LWPs we
2471 want to wait for, bail. We can't just block in
2472 waitpid/sigsuspend, because lwps might have been left stopped
2473 in trace-stop state, and we'd be stuck forever waiting for
2474 their status to change (which would only happen if we resumed
2475 them). Even if WNOHANG is set, this return code is preferred
2476 over 0 (below), as it is more detailed. */
2477 if ((find_inferior (&all_threads
,
2478 not_stopped_callback
,
2479 &wait_ptid
) == NULL
))
2482 debug_printf ("LLW: exit (no unwaited-for LWP)\n");
2483 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
2487 /* No interesting event to report to the caller. */
2488 if ((options
& WNOHANG
))
2491 debug_printf ("WNOHANG set, no event found\n");
2493 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
2497 /* Block until we get an event reported with SIGCHLD. */
2499 debug_printf ("sigsuspend'ing\n");
2501 sigsuspend (&prev_mask
);
2502 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
2506 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
2508 current_thread
= event_thread
;
2510 /* Check for thread exit. */
2511 if (! WIFSTOPPED (*wstatp
))
2513 gdb_assert (last_thread_of_process_p (pid_of (event_thread
)));
2516 debug_printf ("LWP %d is the last lwp of process. "
2517 "Process %ld exiting.\n",
2518 pid_of (event_thread
), lwpid_of (event_thread
));
2519 return lwpid_of (event_thread
);
2522 return lwpid_of (event_thread
);
2525 /* Wait for an event from child(ren) PTID. PTIDs can be:
2526 minus_one_ptid, to specify any child; a pid PTID, specifying all
2527 lwps of a thread group; or a PTID representing a single lwp. Store
2528 the stop status through the status pointer WSTAT. OPTIONS is
2529 passed to the waitpid call. Return 0 if no event was found and
2530 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
2531 was found. Return the PID of the stopped child otherwise. */
2534 linux_wait_for_event (ptid_t ptid
, int *wstatp
, int options
)
2536 return linux_wait_for_event_filtered (ptid
, ptid
, wstatp
, options
);
2539 /* Count the LWP's that have had events. */
2542 count_events_callback (struct inferior_list_entry
*entry
, void *data
)
2544 struct thread_info
*thread
= (struct thread_info
*) entry
;
2545 struct lwp_info
*lp
= get_thread_lwp (thread
);
2548 gdb_assert (count
!= NULL
);
2550 /* Count only resumed LWPs that have an event pending. */
2551 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2552 && lp
->status_pending_p
)
2558 /* Select the LWP (if any) that is currently being single-stepped. */
2561 select_singlestep_lwp_callback (struct inferior_list_entry
*entry
, void *data
)
2563 struct thread_info
*thread
= (struct thread_info
*) entry
;
2564 struct lwp_info
*lp
= get_thread_lwp (thread
);
2566 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2567 && thread
->last_resume_kind
== resume_step
2568 && lp
->status_pending_p
)
2574 /* Select the Nth LWP that has had an event. */
2577 select_event_lwp_callback (struct inferior_list_entry
*entry
, void *data
)
2579 struct thread_info
*thread
= (struct thread_info
*) entry
;
2580 struct lwp_info
*lp
= get_thread_lwp (thread
);
2581 int *selector
= data
;
2583 gdb_assert (selector
!= NULL
);
2585 /* Select only resumed LWPs that have an event pending. */
2586 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2587 && lp
->status_pending_p
)
2588 if ((*selector
)-- == 0)
2594 /* Select one LWP out of those that have events pending. */
2597 select_event_lwp (struct lwp_info
**orig_lp
)
2600 int random_selector
;
2601 struct thread_info
*event_thread
= NULL
;
2603 /* In all-stop, give preference to the LWP that is being
2604 single-stepped. There will be at most one, and it's the LWP that
2605 the core is most interested in. If we didn't do this, then we'd
2606 have to handle pending step SIGTRAPs somehow in case the core
2607 later continues the previously-stepped thread, otherwise we'd
2608 report the pending SIGTRAP, and the core, not having stepped the
2609 thread, wouldn't understand what the trap was for, and therefore
2610 would report it to the user as a random signal. */
2614 = (struct thread_info
*) find_inferior (&all_threads
,
2615 select_singlestep_lwp_callback
,
2617 if (event_thread
!= NULL
)
2620 debug_printf ("SEL: Select single-step %s\n",
2621 target_pid_to_str (ptid_of (event_thread
)));
2624 if (event_thread
== NULL
)
2626 /* No single-stepping LWP. Select one at random, out of those
2627 which have had events. */
2629 /* First see how many events we have. */
2630 find_inferior (&all_threads
, count_events_callback
, &num_events
);
2631 gdb_assert (num_events
> 0);
2633 /* Now randomly pick a LWP out of those that have had
2635 random_selector
= (int)
2636 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2638 if (debug_threads
&& num_events
> 1)
2639 debug_printf ("SEL: Found %d SIGTRAP events, selecting #%d\n",
2640 num_events
, random_selector
);
2643 = (struct thread_info
*) find_inferior (&all_threads
,
2644 select_event_lwp_callback
,
2648 if (event_thread
!= NULL
)
2650 struct lwp_info
*event_lp
= get_thread_lwp (event_thread
);
2652 /* Switch the event LWP. */
2653 *orig_lp
= event_lp
;
2657 /* Decrement the suspend count of an LWP. */
2660 unsuspend_one_lwp (struct inferior_list_entry
*entry
, void *except
)
2662 struct thread_info
*thread
= (struct thread_info
*) entry
;
2663 struct lwp_info
*lwp
= get_thread_lwp (thread
);
2665 /* Ignore EXCEPT. */
2669 lwp_suspended_decr (lwp
);
2673 /* Decrement the suspend count of all LWPs, except EXCEPT, if non
2677 unsuspend_all_lwps (struct lwp_info
*except
)
2679 find_inferior (&all_threads
, unsuspend_one_lwp
, except
);
2682 static void move_out_of_jump_pad_callback (struct inferior_list_entry
*entry
);
2683 static int stuck_in_jump_pad_callback (struct inferior_list_entry
*entry
,
2685 static int lwp_running (struct inferior_list_entry
*entry
, void *data
);
2686 static ptid_t
linux_wait_1 (ptid_t ptid
,
2687 struct target_waitstatus
*ourstatus
,
2688 int target_options
);
2690 /* Stabilize threads (move out of jump pads).
2692 If a thread is midway collecting a fast tracepoint, we need to
2693 finish the collection and move it out of the jump pad before
2694 reporting the signal.
2696 This avoids recursion while collecting (when a signal arrives
2697 midway, and the signal handler itself collects), which would trash
2698 the trace buffer. In case the user set a breakpoint in a signal
2699 handler, this avoids the backtrace showing the jump pad, etc..
2700 Most importantly, there are certain things we can't do safely if
2701 threads are stopped in a jump pad (or in its callee's). For
2704 - starting a new trace run. A thread still collecting the
2705 previous run, could trash the trace buffer when resumed. The trace
2706 buffer control structures would have been reset but the thread had
2707 no way to tell. The thread could even midway memcpy'ing to the
2708 buffer, which would mean that when resumed, it would clobber the
2709 trace buffer that had been set for a new run.
2711 - we can't rewrite/reuse the jump pads for new tracepoints
2712 safely. Say you do tstart while a thread is stopped midway while
2713 collecting. When the thread is later resumed, it finishes the
2714 collection, and returns to the jump pad, to execute the original
2715 instruction that was under the tracepoint jump at the time the
2716 older run had been started. If the jump pad had been rewritten
2717 since for something else in the new run, the thread would now
2718 execute the wrong / random instructions. */
2721 linux_stabilize_threads (void)
2723 struct thread_info
*saved_thread
;
2724 struct thread_info
*thread_stuck
;
2727 = (struct thread_info
*) find_inferior (&all_threads
,
2728 stuck_in_jump_pad_callback
,
2730 if (thread_stuck
!= NULL
)
2733 debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n",
2734 lwpid_of (thread_stuck
));
2738 saved_thread
= current_thread
;
2740 stabilizing_threads
= 1;
2743 for_each_inferior (&all_threads
, move_out_of_jump_pad_callback
);
2745 /* Loop until all are stopped out of the jump pads. */
2746 while (find_inferior (&all_threads
, lwp_running
, NULL
) != NULL
)
2748 struct target_waitstatus ourstatus
;
2749 struct lwp_info
*lwp
;
2752 /* Note that we go through the full wait even loop. While
2753 moving threads out of jump pad, we need to be able to step
2754 over internal breakpoints and such. */
2755 linux_wait_1 (minus_one_ptid
, &ourstatus
, 0);
2757 if (ourstatus
.kind
== TARGET_WAITKIND_STOPPED
)
2759 lwp
= get_thread_lwp (current_thread
);
2762 lwp_suspended_inc (lwp
);
2764 if (ourstatus
.value
.sig
!= GDB_SIGNAL_0
2765 || current_thread
->last_resume_kind
== resume_stop
)
2767 wstat
= W_STOPCODE (gdb_signal_to_host (ourstatus
.value
.sig
));
2768 enqueue_one_deferred_signal (lwp
, &wstat
);
2773 find_inferior (&all_threads
, unsuspend_one_lwp
, NULL
);
2775 stabilizing_threads
= 0;
2777 current_thread
= saved_thread
;
2782 = (struct thread_info
*) find_inferior (&all_threads
,
2783 stuck_in_jump_pad_callback
,
2785 if (thread_stuck
!= NULL
)
2786 debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
2787 lwpid_of (thread_stuck
));
2791 static void async_file_mark (void);
2793 /* Convenience function that is called when the kernel reports an
2794 event that is not passed out to GDB. */
2797 ignore_event (struct target_waitstatus
*ourstatus
)
2799 /* If we got an event, there may still be others, as a single
2800 SIGCHLD can indicate more than one child stopped. This forces
2801 another target_wait call. */
2804 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2808 /* Wait for process, returns status. */
2811 linux_wait_1 (ptid_t ptid
,
2812 struct target_waitstatus
*ourstatus
, int target_options
)
2815 struct lwp_info
*event_child
;
2818 int step_over_finished
;
2819 int bp_explains_trap
;
2820 int maybe_internal_trap
;
2828 debug_printf ("linux_wait_1: [%s]\n", target_pid_to_str (ptid
));
2831 /* Translate generic target options into linux options. */
2833 if (target_options
& TARGET_WNOHANG
)
2836 bp_explains_trap
= 0;
2839 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2841 if (ptid_equal (step_over_bkpt
, null_ptid
))
2842 pid
= linux_wait_for_event (ptid
, &w
, options
);
2846 debug_printf ("step_over_bkpt set [%s], doing a blocking wait\n",
2847 target_pid_to_str (step_over_bkpt
));
2848 pid
= linux_wait_for_event (step_over_bkpt
, &w
, options
& ~WNOHANG
);
2853 gdb_assert (target_options
& TARGET_WNOHANG
);
2857 debug_printf ("linux_wait_1 ret = null_ptid, "
2858 "TARGET_WAITKIND_IGNORE\n");
2862 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2869 debug_printf ("linux_wait_1 ret = null_ptid, "
2870 "TARGET_WAITKIND_NO_RESUMED\n");
2874 ourstatus
->kind
= TARGET_WAITKIND_NO_RESUMED
;
2878 event_child
= get_thread_lwp (current_thread
);
2880 /* linux_wait_for_event only returns an exit status for the last
2881 child of a process. Report it. */
2882 if (WIFEXITED (w
) || WIFSIGNALED (w
))
2886 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2887 ourstatus
->value
.integer
= WEXITSTATUS (w
);
2891 debug_printf ("linux_wait_1 ret = %s, exited with "
2893 target_pid_to_str (ptid_of (current_thread
)),
2900 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2901 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (w
));
2905 debug_printf ("linux_wait_1 ret = %s, terminated with "
2907 target_pid_to_str (ptid_of (current_thread
)),
2913 return ptid_of (current_thread
);
2916 /* If step-over executes a breakpoint instruction, it means a
2917 gdb/gdbserver breakpoint had been planted on top of a permanent
2918 breakpoint. The PC has been adjusted by
2919 check_stopped_by_breakpoint to point at the breakpoint address.
2920 Advance the PC manually past the breakpoint, otherwise the
2921 program would keep trapping the permanent breakpoint forever. */
2922 if (!ptid_equal (step_over_bkpt
, null_ptid
)
2923 && event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
)
2925 unsigned int increment_pc
= the_low_target
.breakpoint_len
;
2929 debug_printf ("step-over for %s executed software breakpoint\n",
2930 target_pid_to_str (ptid_of (current_thread
)));
2933 if (increment_pc
!= 0)
2935 struct regcache
*regcache
2936 = get_thread_regcache (current_thread
, 1);
2938 event_child
->stop_pc
+= increment_pc
;
2939 (*the_low_target
.set_pc
) (regcache
, event_child
->stop_pc
);
2941 if (!(*the_low_target
.breakpoint_at
) (event_child
->stop_pc
))
2942 event_child
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
2946 /* If this event was not handled before, and is not a SIGTRAP, we
2947 report it. SIGILL and SIGSEGV are also treated as traps in case
2948 a breakpoint is inserted at the current PC. If this target does
2949 not support internal breakpoints at all, we also report the
2950 SIGTRAP without further processing; it's of no concern to us. */
2952 = (supports_breakpoints ()
2953 && (WSTOPSIG (w
) == SIGTRAP
2954 || ((WSTOPSIG (w
) == SIGILL
2955 || WSTOPSIG (w
) == SIGSEGV
)
2956 && (*the_low_target
.breakpoint_at
) (event_child
->stop_pc
))));
2958 if (maybe_internal_trap
)
2960 /* Handle anything that requires bookkeeping before deciding to
2961 report the event or continue waiting. */
2963 /* First check if we can explain the SIGTRAP with an internal
2964 breakpoint, or if we should possibly report the event to GDB.
2965 Do this before anything that may remove or insert a
2967 bp_explains_trap
= breakpoint_inserted_here (event_child
->stop_pc
);
2969 /* We have a SIGTRAP, possibly a step-over dance has just
2970 finished. If so, tweak the state machine accordingly,
2971 reinsert breakpoints and delete any reinsert (software
2972 single-step) breakpoints. */
2973 step_over_finished
= finish_step_over (event_child
);
2975 /* Now invoke the callbacks of any internal breakpoints there. */
2976 check_breakpoints (event_child
->stop_pc
);
2978 /* Handle tracepoint data collecting. This may overflow the
2979 trace buffer, and cause a tracing stop, removing
2981 trace_event
= handle_tracepoints (event_child
);
2983 if (bp_explains_trap
)
2985 /* If we stepped or ran into an internal breakpoint, we've
2986 already handled it. So next time we resume (from this
2987 PC), we should step over it. */
2989 debug_printf ("Hit a gdbserver breakpoint.\n");
2991 if (breakpoint_here (event_child
->stop_pc
))
2992 event_child
->need_step_over
= 1;
2997 /* We have some other signal, possibly a step-over dance was in
2998 progress, and it should be cancelled too. */
2999 step_over_finished
= finish_step_over (event_child
);
3002 /* We have all the data we need. Either report the event to GDB, or
3003 resume threads and keep waiting for more. */
3005 /* If we're collecting a fast tracepoint, finish the collection and
3006 move out of the jump pad before delivering a signal. See
3007 linux_stabilize_threads. */
3010 && WSTOPSIG (w
) != SIGTRAP
3011 && supports_fast_tracepoints ()
3012 && agent_loaded_p ())
3015 debug_printf ("Got signal %d for LWP %ld. Check if we need "
3016 "to defer or adjust it.\n",
3017 WSTOPSIG (w
), lwpid_of (current_thread
));
3019 /* Allow debugging the jump pad itself. */
3020 if (current_thread
->last_resume_kind
!= resume_step
3021 && maybe_move_out_of_jump_pad (event_child
, &w
))
3023 enqueue_one_deferred_signal (event_child
, &w
);
3026 debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
3027 WSTOPSIG (w
), lwpid_of (current_thread
));
3029 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
3031 return ignore_event (ourstatus
);
3035 if (event_child
->collecting_fast_tracepoint
)
3038 debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
3039 "Check if we're already there.\n",
3040 lwpid_of (current_thread
),
3041 event_child
->collecting_fast_tracepoint
);
3045 event_child
->collecting_fast_tracepoint
3046 = linux_fast_tracepoint_collecting (event_child
, NULL
);
3048 if (event_child
->collecting_fast_tracepoint
!= 1)
3050 /* No longer need this breakpoint. */
3051 if (event_child
->exit_jump_pad_bkpt
!= NULL
)
3054 debug_printf ("No longer need exit-jump-pad bkpt; removing it."
3055 "stopping all threads momentarily.\n");
3057 /* Other running threads could hit this breakpoint.
3058 We don't handle moribund locations like GDB does,
3059 instead we always pause all threads when removing
3060 breakpoints, so that any step-over or
3061 decr_pc_after_break adjustment is always taken
3062 care of while the breakpoint is still
3064 stop_all_lwps (1, event_child
);
3066 delete_breakpoint (event_child
->exit_jump_pad_bkpt
);
3067 event_child
->exit_jump_pad_bkpt
= NULL
;
3069 unstop_all_lwps (1, event_child
);
3071 gdb_assert (event_child
->suspended
>= 0);
3075 if (event_child
->collecting_fast_tracepoint
== 0)
3078 debug_printf ("fast tracepoint finished "
3079 "collecting successfully.\n");
3081 /* We may have a deferred signal to report. */
3082 if (dequeue_one_deferred_signal (event_child
, &w
))
3085 debug_printf ("dequeued one signal.\n");
3090 debug_printf ("no deferred signals.\n");
3092 if (stabilizing_threads
)
3094 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3095 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3099 debug_printf ("linux_wait_1 ret = %s, stopped "
3100 "while stabilizing threads\n",
3101 target_pid_to_str (ptid_of (current_thread
)));
3105 return ptid_of (current_thread
);
3111 /* Check whether GDB would be interested in this event. */
3113 /* If GDB is not interested in this signal, don't stop other
3114 threads, and don't report it to GDB. Just resume the inferior
3115 right away. We do this for threading-related signals as well as
3116 any that GDB specifically requested we ignore. But never ignore
3117 SIGSTOP if we sent it ourselves, and do not ignore signals when
3118 stepping - they may require special handling to skip the signal
3119 handler. Also never ignore signals that could be caused by a
3121 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
3124 && current_thread
->last_resume_kind
!= resume_step
3126 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
3127 (current_process ()->priv
->thread_db
!= NULL
3128 && (WSTOPSIG (w
) == __SIGRTMIN
3129 || WSTOPSIG (w
) == __SIGRTMIN
+ 1))
3132 (pass_signals
[gdb_signal_from_host (WSTOPSIG (w
))]
3133 && !(WSTOPSIG (w
) == SIGSTOP
3134 && current_thread
->last_resume_kind
== resume_stop
)
3135 && !linux_wstatus_maybe_breakpoint (w
))))
3137 siginfo_t info
, *info_p
;
3140 debug_printf ("Ignored signal %d for LWP %ld.\n",
3141 WSTOPSIG (w
), lwpid_of (current_thread
));
3143 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
),
3144 (PTRACE_TYPE_ARG3
) 0, &info
) == 0)
3149 if (step_over_finished
)
3151 /* We cancelled this thread's step-over above. We still
3152 need to unsuspend all other LWPs, and set them back
3153 running again while the signal handler runs. */
3154 unsuspend_all_lwps (event_child
);
3156 /* Enqueue the pending signal info so that proceed_all_lwps
3158 enqueue_pending_signal (event_child
, WSTOPSIG (w
), info_p
);
3160 proceed_all_lwps ();
3164 linux_resume_one_lwp (event_child
, event_child
->stepping
,
3165 WSTOPSIG (w
), info_p
);
3167 return ignore_event (ourstatus
);
3170 /* Note that all addresses are always "out of the step range" when
3171 there's no range to begin with. */
3172 in_step_range
= lwp_in_step_range (event_child
);
3174 /* If GDB wanted this thread to single step, and the thread is out
3175 of the step range, we always want to report the SIGTRAP, and let
3176 GDB handle it. Watchpoints should always be reported. So should
3177 signals we can't explain. A SIGTRAP we can't explain could be a
3178 GDB breakpoint --- we may or not support Z0 breakpoints. If we
3179 do, we're be able to handle GDB breakpoints on top of internal
3180 breakpoints, by handling the internal breakpoint and still
3181 reporting the event to GDB. If we don't, we're out of luck, GDB
3182 won't see the breakpoint hit. If we see a single-step event but
3183 the thread should be continuing, don't pass the trap to gdb.
3184 That indicates that we had previously finished a single-step but
3185 left the single-step pending -- see
3186 complete_ongoing_step_over. */
3187 report_to_gdb
= (!maybe_internal_trap
3188 || (current_thread
->last_resume_kind
== resume_step
3190 || event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3192 && !bp_explains_trap
3194 && !step_over_finished
3195 && !(current_thread
->last_resume_kind
== resume_continue
3196 && event_child
->stop_reason
== TARGET_STOPPED_BY_SINGLE_STEP
))
3197 || (gdb_breakpoint_here (event_child
->stop_pc
)
3198 && gdb_condition_true_at_breakpoint (event_child
->stop_pc
)
3199 && gdb_no_commands_at_breakpoint (event_child
->stop_pc
))
3200 || event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
);
3202 run_breakpoint_commands (event_child
->stop_pc
);
3204 /* We found no reason GDB would want us to stop. We either hit one
3205 of our own breakpoints, or finished an internal step GDB
3206 shouldn't know about. */
3211 if (bp_explains_trap
)
3212 debug_printf ("Hit a gdbserver breakpoint.\n");
3213 if (step_over_finished
)
3214 debug_printf ("Step-over finished.\n");
3216 debug_printf ("Tracepoint event.\n");
3217 if (lwp_in_step_range (event_child
))
3218 debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).\n",
3219 paddress (event_child
->stop_pc
),
3220 paddress (event_child
->step_range_start
),
3221 paddress (event_child
->step_range_end
));
3224 /* We're not reporting this breakpoint to GDB, so apply the
3225 decr_pc_after_break adjustment to the inferior's regcache
3228 if (the_low_target
.set_pc
!= NULL
)
3230 struct regcache
*regcache
3231 = get_thread_regcache (current_thread
, 1);
3232 (*the_low_target
.set_pc
) (regcache
, event_child
->stop_pc
);
3235 /* We may have finished stepping over a breakpoint. If so,
3236 we've stopped and suspended all LWPs momentarily except the
3237 stepping one. This is where we resume them all again. We're
3238 going to keep waiting, so use proceed, which handles stepping
3239 over the next breakpoint. */
3241 debug_printf ("proceeding all threads.\n");
3243 if (step_over_finished
)
3244 unsuspend_all_lwps (event_child
);
3246 proceed_all_lwps ();
3247 return ignore_event (ourstatus
);
3252 if (event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3256 str
= target_waitstatus_to_string (&event_child
->waitstatus
);
3257 debug_printf ("LWP %ld: extended event with waitstatus %s\n",
3258 lwpid_of (get_lwp_thread (event_child
)), str
);
3261 if (current_thread
->last_resume_kind
== resume_step
)
3263 if (event_child
->step_range_start
== event_child
->step_range_end
)
3264 debug_printf ("GDB wanted to single-step, reporting event.\n");
3265 else if (!lwp_in_step_range (event_child
))
3266 debug_printf ("Out of step range, reporting event.\n");
3268 if (event_child
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
3269 debug_printf ("Stopped by watchpoint.\n");
3270 else if (gdb_breakpoint_here (event_child
->stop_pc
))
3271 debug_printf ("Stopped by GDB breakpoint.\n");
3273 debug_printf ("Hit a non-gdbserver trap event.\n");
3276 /* Alright, we're going to report a stop. */
3278 if (!stabilizing_threads
)
3280 /* In all-stop, stop all threads. */
3282 stop_all_lwps (0, NULL
);
3284 /* If we're not waiting for a specific LWP, choose an event LWP
3285 from among those that have had events. Giving equal priority
3286 to all LWPs that have had events helps prevent
3288 if (ptid_equal (ptid
, minus_one_ptid
))
3290 event_child
->status_pending_p
= 1;
3291 event_child
->status_pending
= w
;
3293 select_event_lwp (&event_child
);
3295 /* current_thread and event_child must stay in sync. */
3296 current_thread
= get_lwp_thread (event_child
);
3298 event_child
->status_pending_p
= 0;
3299 w
= event_child
->status_pending
;
3302 if (step_over_finished
)
3306 /* If we were doing a step-over, all other threads but
3307 the stepping one had been paused in start_step_over,
3308 with their suspend counts incremented. We don't want
3309 to do a full unstop/unpause, because we're in
3310 all-stop mode (so we want threads stopped), but we
3311 still need to unsuspend the other threads, to
3312 decrement their `suspended' count back. */
3313 unsuspend_all_lwps (event_child
);
3317 /* If we just finished a step-over, then all threads had
3318 been momentarily paused. In all-stop, that's fine,
3319 we want threads stopped by now anyway. In non-stop,
3320 we need to re-resume threads that GDB wanted to be
3322 unstop_all_lwps (1, event_child
);
3326 /* Stabilize threads (move out of jump pads). */
3328 stabilize_threads ();
3332 /* If we just finished a step-over, then all threads had been
3333 momentarily paused. In all-stop, that's fine, we want
3334 threads stopped by now anyway. In non-stop, we need to
3335 re-resume threads that GDB wanted to be running. */
3336 if (step_over_finished
)
3337 unstop_all_lwps (1, event_child
);
3340 if (event_child
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3342 /* If the reported event is an exit, fork, vfork or exec, let
3344 *ourstatus
= event_child
->waitstatus
;
3345 /* Clear the event lwp's waitstatus since we handled it already. */
3346 event_child
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
3349 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3351 /* Now that we've selected our final event LWP, un-adjust its PC if
3352 it was a software breakpoint, and the client doesn't know we can
3353 adjust the breakpoint ourselves. */
3354 if (event_child
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3355 && !swbreak_feature
)
3357 int decr_pc
= the_low_target
.decr_pc_after_break
;
3361 struct regcache
*regcache
3362 = get_thread_regcache (current_thread
, 1);
3363 (*the_low_target
.set_pc
) (regcache
, event_child
->stop_pc
+ decr_pc
);
3367 if (current_thread
->last_resume_kind
== resume_stop
3368 && WSTOPSIG (w
) == SIGSTOP
)
3370 /* A thread that has been requested to stop by GDB with vCont;t,
3371 and it stopped cleanly, so report as SIG0. The use of
3372 SIGSTOP is an implementation detail. */
3373 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3375 else if (current_thread
->last_resume_kind
== resume_stop
3376 && WSTOPSIG (w
) != SIGSTOP
)
3378 /* A thread that has been requested to stop by GDB with vCont;t,
3379 but, it stopped for other reasons. */
3380 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
3382 else if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
)
3384 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
3387 gdb_assert (ptid_equal (step_over_bkpt
, null_ptid
));
3391 debug_printf ("linux_wait_1 ret = %s, %d, %d\n",
3392 target_pid_to_str (ptid_of (current_thread
)),
3393 ourstatus
->kind
, ourstatus
->value
.sig
);
3397 return ptid_of (current_thread
);
3400 /* Get rid of any pending event in the pipe. */
3402 async_file_flush (void)
3408 ret
= read (linux_event_pipe
[0], &buf
, 1);
3409 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
3412 /* Put something in the pipe, so the event loop wakes up. */
3414 async_file_mark (void)
3418 async_file_flush ();
3421 ret
= write (linux_event_pipe
[1], "+", 1);
3422 while (ret
== 0 || (ret
== -1 && errno
== EINTR
));
3424 /* Ignore EAGAIN. If the pipe is full, the event loop will already
3425 be awakened anyway. */
3429 linux_wait (ptid_t ptid
,
3430 struct target_waitstatus
*ourstatus
, int target_options
)
3434 /* Flush the async file first. */
3435 if (target_is_async_p ())
3436 async_file_flush ();
3440 event_ptid
= linux_wait_1 (ptid
, ourstatus
, target_options
);
3442 while ((target_options
& TARGET_WNOHANG
) == 0
3443 && ptid_equal (event_ptid
, null_ptid
)
3444 && ourstatus
->kind
== TARGET_WAITKIND_IGNORE
);
3446 /* If at least one stop was reported, there may be more. A single
3447 SIGCHLD can signal more than one child stop. */
3448 if (target_is_async_p ()
3449 && (target_options
& TARGET_WNOHANG
) != 0
3450 && !ptid_equal (event_ptid
, null_ptid
))
3456 /* Send a signal to an LWP. */
3459 kill_lwp (unsigned long lwpid
, int signo
)
3461 /* Use tkill, if possible, in case we are using nptl threads. If tkill
3462 fails, then we are not using nptl threads and we should be using kill. */
3466 static int tkill_failed
;
3473 ret
= syscall (__NR_tkill
, lwpid
, signo
);
3474 if (errno
!= ENOSYS
)
3481 return kill (lwpid
, signo
);
3485 linux_stop_lwp (struct lwp_info
*lwp
)
3491 send_sigstop (struct lwp_info
*lwp
)
3495 pid
= lwpid_of (get_lwp_thread (lwp
));
3497 /* If we already have a pending stop signal for this process, don't
3499 if (lwp
->stop_expected
)
3502 debug_printf ("Have pending sigstop for lwp %d\n", pid
);
3508 debug_printf ("Sending sigstop to lwp %d\n", pid
);
3510 lwp
->stop_expected
= 1;
3511 kill_lwp (pid
, SIGSTOP
);
3515 send_sigstop_callback (struct inferior_list_entry
*entry
, void *except
)
3517 struct thread_info
*thread
= (struct thread_info
*) entry
;
3518 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3520 /* Ignore EXCEPT. */
3531 /* Increment the suspend count of an LWP, and stop it, if not stopped
3534 suspend_and_send_sigstop_callback (struct inferior_list_entry
*entry
,
3537 struct thread_info
*thread
= (struct thread_info
*) entry
;
3538 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3540 /* Ignore EXCEPT. */
3544 lwp_suspended_inc (lwp
);
3546 return send_sigstop_callback (entry
, except
);
3550 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
3552 /* Store the exit status for later. */
3553 lwp
->status_pending_p
= 1;
3554 lwp
->status_pending
= wstat
;
3556 /* Store in waitstatus as well, as there's nothing else to process
3558 if (WIFEXITED (wstat
))
3560 lwp
->waitstatus
.kind
= TARGET_WAITKIND_EXITED
;
3561 lwp
->waitstatus
.value
.integer
= WEXITSTATUS (wstat
);
3563 else if (WIFSIGNALED (wstat
))
3565 lwp
->waitstatus
.kind
= TARGET_WAITKIND_SIGNALLED
;
3566 lwp
->waitstatus
.value
.sig
= gdb_signal_from_host (WTERMSIG (wstat
));
3569 /* Prevent trying to stop it. */
3572 /* No further stops are expected from a dead lwp. */
3573 lwp
->stop_expected
= 0;
3576 /* Return true if LWP has exited already, and has a pending exit event
3577 to report to GDB. */
3580 lwp_is_marked_dead (struct lwp_info
*lwp
)
3582 return (lwp
->status_pending_p
3583 && (WIFEXITED (lwp
->status_pending
)
3584 || WIFSIGNALED (lwp
->status_pending
)));
3587 /* Wait for all children to stop for the SIGSTOPs we just queued. */
3590 wait_for_sigstop (void)
3592 struct thread_info
*saved_thread
;
3597 saved_thread
= current_thread
;
3598 if (saved_thread
!= NULL
)
3599 saved_tid
= saved_thread
->entry
.id
;
3601 saved_tid
= null_ptid
; /* avoid bogus unused warning */
3604 debug_printf ("wait_for_sigstop: pulling events\n");
3606 /* Passing NULL_PTID as filter indicates we want all events to be
3607 left pending. Eventually this returns when there are no
3608 unwaited-for children left. */
3609 ret
= linux_wait_for_event_filtered (minus_one_ptid
, null_ptid
,
3611 gdb_assert (ret
== -1);
3613 if (saved_thread
== NULL
|| linux_thread_alive (saved_tid
))
3614 current_thread
= saved_thread
;
3618 debug_printf ("Previously current thread died.\n");
3622 /* We can't change the current inferior behind GDB's back,
3623 otherwise, a subsequent command may apply to the wrong
3625 current_thread
= NULL
;
3629 /* Set a valid thread as current. */
3630 set_desired_thread (0);
3635 /* Returns true if LWP ENTRY is stopped in a jump pad, and we can't
3636 move it out, because we need to report the stop event to GDB. For
3637 example, if the user puts a breakpoint in the jump pad, it's
3638 because she wants to debug it. */
3641 stuck_in_jump_pad_callback (struct inferior_list_entry
*entry
, void *data
)
3643 struct thread_info
*thread
= (struct thread_info
*) entry
;
3644 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3646 if (lwp
->suspended
!= 0)
3648 internal_error (__FILE__
, __LINE__
,
3649 "LWP %ld is suspended, suspended=%d\n",
3650 lwpid_of (thread
), lwp
->suspended
);
3652 gdb_assert (lwp
->stopped
);
3654 /* Allow debugging the jump pad, gdb_collect, etc.. */
3655 return (supports_fast_tracepoints ()
3656 && agent_loaded_p ()
3657 && (gdb_breakpoint_here (lwp
->stop_pc
)
3658 || lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
3659 || thread
->last_resume_kind
== resume_step
)
3660 && linux_fast_tracepoint_collecting (lwp
, NULL
));
3664 move_out_of_jump_pad_callback (struct inferior_list_entry
*entry
)
3666 struct thread_info
*thread
= (struct thread_info
*) entry
;
3667 struct thread_info
*saved_thread
;
3668 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3671 if (lwp
->suspended
!= 0)
3673 internal_error (__FILE__
, __LINE__
,
3674 "LWP %ld is suspended, suspended=%d\n",
3675 lwpid_of (thread
), lwp
->suspended
);
3677 gdb_assert (lwp
->stopped
);
3679 /* For gdb_breakpoint_here. */
3680 saved_thread
= current_thread
;
3681 current_thread
= thread
;
3683 wstat
= lwp
->status_pending_p
? &lwp
->status_pending
: NULL
;
3685 /* Allow debugging the jump pad, gdb_collect, etc. */
3686 if (!gdb_breakpoint_here (lwp
->stop_pc
)
3687 && lwp
->stop_reason
!= TARGET_STOPPED_BY_WATCHPOINT
3688 && thread
->last_resume_kind
!= resume_step
3689 && maybe_move_out_of_jump_pad (lwp
, wstat
))
3692 debug_printf ("LWP %ld needs stabilizing (in jump pad)\n",
3697 lwp
->status_pending_p
= 0;
3698 enqueue_one_deferred_signal (lwp
, wstat
);
3701 debug_printf ("Signal %d for LWP %ld deferred "
3703 WSTOPSIG (*wstat
), lwpid_of (thread
));
3706 linux_resume_one_lwp (lwp
, 0, 0, NULL
);
3709 lwp_suspended_inc (lwp
);
3711 current_thread
= saved_thread
;
3715 lwp_running (struct inferior_list_entry
*entry
, void *data
)
3717 struct thread_info
*thread
= (struct thread_info
*) entry
;
3718 struct lwp_info
*lwp
= get_thread_lwp (thread
);
3720 if (lwp_is_marked_dead (lwp
))
3727 /* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
3728 If SUSPEND, then also increase the suspend count of every LWP,
3732 stop_all_lwps (int suspend
, struct lwp_info
*except
)
3734 /* Should not be called recursively. */
3735 gdb_assert (stopping_threads
== NOT_STOPPING_THREADS
);
3740 debug_printf ("stop_all_lwps (%s, except=%s)\n",
3741 suspend
? "stop-and-suspend" : "stop",
3743 ? target_pid_to_str (ptid_of (get_lwp_thread (except
)))
3747 stopping_threads
= (suspend
3748 ? STOPPING_AND_SUSPENDING_THREADS
3749 : STOPPING_THREADS
);
3752 find_inferior (&all_threads
, suspend_and_send_sigstop_callback
, except
);
3754 find_inferior (&all_threads
, send_sigstop_callback
, except
);
3755 wait_for_sigstop ();
3756 stopping_threads
= NOT_STOPPING_THREADS
;
3760 debug_printf ("stop_all_lwps done, setting stopping_threads "
3761 "back to !stopping\n");
3766 /* Enqueue one signal in the chain of signals which need to be
3767 delivered to this process on next resume. */
3770 enqueue_pending_signal (struct lwp_info
*lwp
, int signal
, siginfo_t
*info
)
3772 struct pending_signals
*p_sig
;
3774 p_sig
= xmalloc (sizeof (*p_sig
));
3775 p_sig
->prev
= lwp
->pending_signals
;
3776 p_sig
->signal
= signal
;
3778 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
3780 memcpy (&p_sig
->info
, info
, sizeof (siginfo_t
));
3781 lwp
->pending_signals
= p_sig
;
3784 /* Resume execution of LWP. If STEP is nonzero, single-step it. If
3785 SIGNAL is nonzero, give it that signal. */
3788 linux_resume_one_lwp_throw (struct lwp_info
*lwp
,
3789 int step
, int signal
, siginfo_t
*info
)
3791 struct thread_info
*thread
= get_lwp_thread (lwp
);
3792 struct thread_info
*saved_thread
;
3793 int fast_tp_collecting
;
3794 struct process_info
*proc
= get_thread_process (thread
);
3796 /* Note that target description may not be initialised
3797 (proc->tdesc == NULL) at this point because the program hasn't
3798 stopped at the first instruction yet. It means GDBserver skips
3799 the extra traps from the wrapper program (see option --wrapper).
3800 Code in this function that requires register access should be
3801 guarded by proc->tdesc == NULL or something else. */
3803 if (lwp
->stopped
== 0)
3806 fast_tp_collecting
= lwp
->collecting_fast_tracepoint
;
3808 gdb_assert (!stabilizing_threads
|| fast_tp_collecting
);
3810 /* Cancel actions that rely on GDB not changing the PC (e.g., the
3811 user used the "jump" command, or "set $pc = foo"). */
3812 if (thread
->while_stepping
!= NULL
&& lwp
->stop_pc
!= get_pc (lwp
))
3814 /* Collecting 'while-stepping' actions doesn't make sense
3816 release_while_stepping_state_list (thread
);
3819 /* If we have pending signals or status, and a new signal, enqueue the
3820 signal. Also enqueue the signal if we are waiting to reinsert a
3821 breakpoint; it will be picked up again below. */
3823 && (lwp
->status_pending_p
3824 || lwp
->pending_signals
!= NULL
3825 || lwp
->bp_reinsert
!= 0
3826 || fast_tp_collecting
))
3828 struct pending_signals
*p_sig
;
3829 p_sig
= xmalloc (sizeof (*p_sig
));
3830 p_sig
->prev
= lwp
->pending_signals
;
3831 p_sig
->signal
= signal
;
3833 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
3835 memcpy (&p_sig
->info
, info
, sizeof (siginfo_t
));
3836 lwp
->pending_signals
= p_sig
;
3839 if (lwp
->status_pending_p
)
3842 debug_printf ("Not resuming lwp %ld (%s, signal %d, stop %s);"
3843 " has pending status\n",
3844 lwpid_of (thread
), step
? "step" : "continue", signal
,
3845 lwp
->stop_expected
? "expected" : "not expected");
3849 saved_thread
= current_thread
;
3850 current_thread
= thread
;
3853 debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
3854 lwpid_of (thread
), step
? "step" : "continue", signal
,
3855 lwp
->stop_expected
? "expected" : "not expected");
3857 /* This bit needs some thinking about. If we get a signal that
3858 we must report while a single-step reinsert is still pending,
3859 we often end up resuming the thread. It might be better to
3860 (ew) allow a stack of pending events; then we could be sure that
3861 the reinsert happened right away and not lose any signals.
3863 Making this stack would also shrink the window in which breakpoints are
3864 uninserted (see comment in linux_wait_for_lwp) but not enough for
3865 complete correctness, so it won't solve that problem. It may be
3866 worthwhile just to solve this one, however. */
3867 if (lwp
->bp_reinsert
!= 0)
3870 debug_printf (" pending reinsert at 0x%s\n",
3871 paddress (lwp
->bp_reinsert
));
3873 if (can_hardware_single_step ())
3875 if (fast_tp_collecting
== 0)
3878 fprintf (stderr
, "BAD - reinserting but not stepping.\n");
3880 fprintf (stderr
, "BAD - reinserting and suspended(%d).\n",
3887 /* Postpone any pending signal. It was enqueued above. */
3891 if (fast_tp_collecting
== 1)
3894 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
3895 " (exit-jump-pad-bkpt)\n",
3898 /* Postpone any pending signal. It was enqueued above. */
3901 else if (fast_tp_collecting
== 2)
3904 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
3905 " single-stepping\n",
3908 if (can_hardware_single_step ())
3912 internal_error (__FILE__
, __LINE__
,
3913 "moving out of jump pad single-stepping"
3914 " not implemented on this target");
3917 /* Postpone any pending signal. It was enqueued above. */
3921 /* If we have while-stepping actions in this thread set it stepping.
3922 If we have a signal to deliver, it may or may not be set to
3923 SIG_IGN, we don't know. Assume so, and allow collecting
3924 while-stepping into a signal handler. A possible smart thing to
3925 do would be to set an internal breakpoint at the signal return
3926 address, continue, and carry on catching this while-stepping
3927 action only when that breakpoint is hit. A future
3929 if (thread
->while_stepping
!= NULL
3930 && can_hardware_single_step ())
3933 debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n",
3938 if (proc
->tdesc
!= NULL
&& the_low_target
.get_pc
!= NULL
)
3940 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
3942 lwp
->stop_pc
= (*the_low_target
.get_pc
) (regcache
);
3946 debug_printf (" %s from pc 0x%lx\n", step
? "step" : "continue",
3947 (long) lwp
->stop_pc
);
3951 /* If we have pending signals, consume one unless we are trying to
3952 reinsert a breakpoint or we're trying to finish a fast tracepoint
3954 if (lwp
->pending_signals
!= NULL
3955 && lwp
->bp_reinsert
== 0
3956 && fast_tp_collecting
== 0)
3958 struct pending_signals
**p_sig
;
3960 p_sig
= &lwp
->pending_signals
;
3961 while ((*p_sig
)->prev
!= NULL
)
3962 p_sig
= &(*p_sig
)->prev
;
3964 signal
= (*p_sig
)->signal
;
3965 if ((*p_sig
)->info
.si_signo
!= 0)
3966 ptrace (PTRACE_SETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
3973 if (the_low_target
.prepare_to_resume
!= NULL
)
3974 the_low_target
.prepare_to_resume (lwp
);
3976 regcache_invalidate_thread (thread
);
3978 lwp
->stepping
= step
;
3979 ptrace (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
, lwpid_of (thread
),
3980 (PTRACE_TYPE_ARG3
) 0,
3981 /* Coerce to a uintptr_t first to avoid potential gcc warning
3982 of coercing an 8 byte integer to a 4 byte pointer. */
3983 (PTRACE_TYPE_ARG4
) (uintptr_t) signal
);
3985 current_thread
= saved_thread
;
3987 perror_with_name ("resuming thread");
3989 /* Successfully resumed. Clear state that no longer makes sense,
3990 and mark the LWP as running. Must not do this before resuming
3991 otherwise if that fails other code will be confused. E.g., we'd
3992 later try to stop the LWP and hang forever waiting for a stop
3993 status. Note that we must not throw after this is cleared,
3994 otherwise handle_zombie_lwp_error would get confused. */
3996 lwp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
3999 /* Called when we try to resume a stopped LWP and that errors out. If
4000 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
4001 or about to become), discard the error, clear any pending status
4002 the LWP may have, and return true (we'll collect the exit status
4003 soon enough). Otherwise, return false. */
4006 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
4008 struct thread_info
*thread
= get_lwp_thread (lp
);
4010 /* If we get an error after resuming the LWP successfully, we'd
4011 confuse !T state for the LWP being gone. */
4012 gdb_assert (lp
->stopped
);
4014 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
4015 because even if ptrace failed with ESRCH, the tracee may be "not
4016 yet fully dead", but already refusing ptrace requests. In that
4017 case the tracee has 'R (Running)' state for a little bit
4018 (observed in Linux 3.18). See also the note on ESRCH in the
4019 ptrace(2) man page. Instead, check whether the LWP has any state
4020 other than ptrace-stopped. */
4022 /* Don't assume anything if /proc/PID/status can't be read. */
4023 if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread
)) == 0)
4025 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
4026 lp
->status_pending_p
= 0;
4032 /* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
4033 disappears while we try to resume it. */
4036 linux_resume_one_lwp (struct lwp_info
*lwp
,
4037 int step
, int signal
, siginfo_t
*info
)
4041 linux_resume_one_lwp_throw (lwp
, step
, signal
, info
);
4043 CATCH (ex
, RETURN_MASK_ERROR
)
4045 if (!check_ptrace_stopped_lwp_gone (lwp
))
4046 throw_exception (ex
);
4051 struct thread_resume_array
4053 struct thread_resume
*resume
;
4057 /* This function is called once per thread via find_inferior.
4058 ARG is a pointer to a thread_resume_array struct.
4059 We look up the thread specified by ENTRY in ARG, and mark the thread
4060 with a pointer to the appropriate resume request.
4062 This algorithm is O(threads * resume elements), but resume elements
4063 is small (and will remain small at least until GDB supports thread
4067 linux_set_resume_request (struct inferior_list_entry
*entry
, void *arg
)
4069 struct thread_info
*thread
= (struct thread_info
*) entry
;
4070 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4072 struct thread_resume_array
*r
;
4076 for (ndx
= 0; ndx
< r
->n
; ndx
++)
4078 ptid_t ptid
= r
->resume
[ndx
].thread
;
4079 if (ptid_equal (ptid
, minus_one_ptid
)
4080 || ptid_equal (ptid
, entry
->id
)
4081 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
4083 || (ptid_get_pid (ptid
) == pid_of (thread
)
4084 && (ptid_is_pid (ptid
)
4085 || ptid_get_lwp (ptid
) == -1)))
4087 if (r
->resume
[ndx
].kind
== resume_stop
4088 && thread
->last_resume_kind
== resume_stop
)
4091 debug_printf ("already %s LWP %ld at GDB's request\n",
4092 (thread
->last_status
.kind
4093 == TARGET_WAITKIND_STOPPED
)
4101 lwp
->resume
= &r
->resume
[ndx
];
4102 thread
->last_resume_kind
= lwp
->resume
->kind
;
4104 lwp
->step_range_start
= lwp
->resume
->step_range_start
;
4105 lwp
->step_range_end
= lwp
->resume
->step_range_end
;
4107 /* If we had a deferred signal to report, dequeue one now.
4108 This can happen if LWP gets more than one signal while
4109 trying to get out of a jump pad. */
4111 && !lwp
->status_pending_p
4112 && dequeue_one_deferred_signal (lwp
, &lwp
->status_pending
))
4114 lwp
->status_pending_p
= 1;
4117 debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
4118 "leaving status pending.\n",
4119 WSTOPSIG (lwp
->status_pending
),
4127 /* No resume action for this thread. */
4133 /* find_inferior callback for linux_resume.
4134 Set *FLAG_P if this lwp has an interesting status pending. */
4137 resume_status_pending_p (struct inferior_list_entry
*entry
, void *flag_p
)
4139 struct thread_info
*thread
= (struct thread_info
*) entry
;
4140 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4142 /* LWPs which will not be resumed are not interesting, because
4143 we might not wait for them next time through linux_wait. */
4144 if (lwp
->resume
== NULL
)
4147 if (thread_still_has_status_pending_p (thread
))
4148 * (int *) flag_p
= 1;
4153 /* Return 1 if this lwp that GDB wants running is stopped at an
4154 internal breakpoint that we need to step over. It assumes that any
4155 required STOP_PC adjustment has already been propagated to the
4156 inferior's regcache. */
4159 need_step_over_p (struct inferior_list_entry
*entry
, void *dummy
)
4161 struct thread_info
*thread
= (struct thread_info
*) entry
;
4162 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4163 struct thread_info
*saved_thread
;
4165 struct process_info
*proc
= get_thread_process (thread
);
4167 /* GDBserver is skipping the extra traps from the wrapper program,
4168 don't have to do step over. */
4169 if (proc
->tdesc
== NULL
)
4172 /* LWPs which will not be resumed are not interesting, because we
4173 might not wait for them next time through linux_wait. */
4178 debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n",
4183 if (thread
->last_resume_kind
== resume_stop
)
4186 debug_printf ("Need step over [LWP %ld]? Ignoring, should remain"
4192 gdb_assert (lwp
->suspended
>= 0);
4197 debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n",
4202 if (!lwp
->need_step_over
)
4205 debug_printf ("Need step over [LWP %ld]? No\n", lwpid_of (thread
));
4208 if (lwp
->status_pending_p
)
4211 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4217 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
4221 /* If the PC has changed since we stopped, then don't do anything,
4222 and let the breakpoint/tracepoint be hit. This happens if, for
4223 instance, GDB handled the decr_pc_after_break subtraction itself,
4224 GDB is OOL stepping this thread, or the user has issued a "jump"
4225 command, or poked thread's registers herself. */
4226 if (pc
!= lwp
->stop_pc
)
4229 debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. "
4230 "Old stop_pc was 0x%s, PC is now 0x%s\n",
4232 paddress (lwp
->stop_pc
), paddress (pc
));
4234 lwp
->need_step_over
= 0;
4238 saved_thread
= current_thread
;
4239 current_thread
= thread
;
4241 /* We can only step over breakpoints we know about. */
4242 if (breakpoint_here (pc
) || fast_tracepoint_jump_here (pc
))
4244 /* Don't step over a breakpoint that GDB expects to hit
4245 though. If the condition is being evaluated on the target's side
4246 and it evaluate to false, step over this breakpoint as well. */
4247 if (gdb_breakpoint_here (pc
)
4248 && gdb_condition_true_at_breakpoint (pc
)
4249 && gdb_no_commands_at_breakpoint (pc
))
4252 debug_printf ("Need step over [LWP %ld]? yes, but found"
4253 " GDB breakpoint at 0x%s; skipping step over\n",
4254 lwpid_of (thread
), paddress (pc
));
4256 current_thread
= saved_thread
;
4262 debug_printf ("Need step over [LWP %ld]? yes, "
4263 "found breakpoint at 0x%s\n",
4264 lwpid_of (thread
), paddress (pc
));
4266 /* We've found an lwp that needs stepping over --- return 1 so
4267 that find_inferior stops looking. */
4268 current_thread
= saved_thread
;
4270 /* If the step over is cancelled, this is set again. */
4271 lwp
->need_step_over
= 0;
4276 current_thread
= saved_thread
;
4279 debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
4281 lwpid_of (thread
), paddress (pc
));
4286 /* Start a step-over operation on LWP. When LWP stopped at a
4287 breakpoint, to make progress, we need to remove the breakpoint out
4288 of the way. If we let other threads run while we do that, they may
4289 pass by the breakpoint location and miss hitting it. To avoid
4290 that, a step-over momentarily stops all threads while LWP is
4291 single-stepped while the breakpoint is temporarily uninserted from
4292 the inferior. When the single-step finishes, we reinsert the
4293 breakpoint, and let all threads that are supposed to be running,
4296 On targets that don't support hardware single-step, we don't
4297 currently support full software single-stepping. Instead, we only
4298 support stepping over the thread event breakpoint, by asking the
4299 low target where to place a reinsert breakpoint. Since this
4300 routine assumes the breakpoint being stepped over is a thread event
4301 breakpoint, it usually assumes the return address of the current
4302 function is a good enough place to set the reinsert breakpoint. */
4305 start_step_over (struct lwp_info
*lwp
)
4307 struct thread_info
*thread
= get_lwp_thread (lwp
);
4308 struct thread_info
*saved_thread
;
4313 debug_printf ("Starting step-over on LWP %ld. Stopping all threads\n",
4316 stop_all_lwps (1, lwp
);
4318 if (lwp
->suspended
!= 0)
4320 internal_error (__FILE__
, __LINE__
,
4321 "LWP %ld suspended=%d\n", lwpid_of (thread
),
4326 debug_printf ("Done stopping all threads for step-over.\n");
4328 /* Note, we should always reach here with an already adjusted PC,
4329 either by GDB (if we're resuming due to GDB's request), or by our
4330 caller, if we just finished handling an internal breakpoint GDB
4331 shouldn't care about. */
4334 saved_thread
= current_thread
;
4335 current_thread
= thread
;
4337 lwp
->bp_reinsert
= pc
;
4338 uninsert_breakpoints_at (pc
);
4339 uninsert_fast_tracepoint_jumps_at (pc
);
4341 if (can_hardware_single_step ())
4347 CORE_ADDR raddr
= (*the_low_target
.breakpoint_reinsert_addr
) ();
4348 set_reinsert_breakpoint (raddr
);
4352 current_thread
= saved_thread
;
4354 linux_resume_one_lwp (lwp
, step
, 0, NULL
);
4356 /* Require next event from this LWP. */
4357 step_over_bkpt
= thread
->entry
.id
;
4361 /* Finish a step-over. Reinsert the breakpoint we had uninserted in
4362 start_step_over, if still there, and delete any reinsert
4363 breakpoints we've set, on non hardware single-step targets. */
4366 finish_step_over (struct lwp_info
*lwp
)
4368 if (lwp
->bp_reinsert
!= 0)
4371 debug_printf ("Finished step over.\n");
4373 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
4374 may be no breakpoint to reinsert there by now. */
4375 reinsert_breakpoints_at (lwp
->bp_reinsert
);
4376 reinsert_fast_tracepoint_jumps_at (lwp
->bp_reinsert
);
4378 lwp
->bp_reinsert
= 0;
4380 /* Delete any software-single-step reinsert breakpoints. No
4381 longer needed. We don't have to worry about other threads
4382 hitting this trap, and later not being able to explain it,
4383 because we were stepping over a breakpoint, and we hold all
4384 threads but LWP stopped while doing that. */
4385 if (!can_hardware_single_step ())
4386 delete_reinsert_breakpoints ();
4388 step_over_bkpt
= null_ptid
;
4395 /* If there's a step over in progress, wait until all threads stop
4396 (that is, until the stepping thread finishes its step), and
4397 unsuspend all lwps. The stepping thread ends with its status
4398 pending, which is processed later when we get back to processing
4402 complete_ongoing_step_over (void)
4404 if (!ptid_equal (step_over_bkpt
, null_ptid
))
4406 struct lwp_info
*lwp
;
4411 debug_printf ("detach: step over in progress, finish it first\n");
4413 /* Passing NULL_PTID as filter indicates we want all events to
4414 be left pending. Eventually this returns when there are no
4415 unwaited-for children left. */
4416 ret
= linux_wait_for_event_filtered (minus_one_ptid
, null_ptid
,
4418 gdb_assert (ret
== -1);
4420 lwp
= find_lwp_pid (step_over_bkpt
);
4422 finish_step_over (lwp
);
4423 step_over_bkpt
= null_ptid
;
4424 unsuspend_all_lwps (lwp
);
4428 /* This function is called once per thread. We check the thread's resume
4429 request, which will tell us whether to resume, step, or leave the thread
4430 stopped; and what signal, if any, it should be sent.
4432 For threads which we aren't explicitly told otherwise, we preserve
4433 the stepping flag; this is used for stepping over gdbserver-placed
4436 If pending_flags was set in any thread, we queue any needed
4437 signals, since we won't actually resume. We already have a pending
4438 event to report, so we don't need to preserve any step requests;
4439 they should be re-issued if necessary. */
4442 linux_resume_one_thread (struct inferior_list_entry
*entry
, void *arg
)
4444 struct thread_info
*thread
= (struct thread_info
*) entry
;
4445 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4447 int leave_all_stopped
= * (int *) arg
;
4450 if (lwp
->resume
== NULL
)
4453 if (lwp
->resume
->kind
== resume_stop
)
4456 debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread
));
4461 debug_printf ("stopping LWP %ld\n", lwpid_of (thread
));
4463 /* Stop the thread, and wait for the event asynchronously,
4464 through the event loop. */
4470 debug_printf ("already stopped LWP %ld\n",
4473 /* The LWP may have been stopped in an internal event that
4474 was not meant to be notified back to GDB (e.g., gdbserver
4475 breakpoint), so we should be reporting a stop event in
4478 /* If the thread already has a pending SIGSTOP, this is a
4479 no-op. Otherwise, something later will presumably resume
4480 the thread and this will cause it to cancel any pending
4481 operation, due to last_resume_kind == resume_stop. If
4482 the thread already has a pending status to report, we
4483 will still report it the next time we wait - see
4484 status_pending_p_callback. */
4486 /* If we already have a pending signal to report, then
4487 there's no need to queue a SIGSTOP, as this means we're
4488 midway through moving the LWP out of the jumppad, and we
4489 will report the pending signal as soon as that is
4491 if (lwp
->pending_signals_to_report
== NULL
)
4495 /* For stop requests, we're done. */
4497 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
4501 /* If this thread which is about to be resumed has a pending status,
4502 then don't resume it - we can just report the pending status.
4503 Likewise if it is suspended, because e.g., another thread is
4504 stepping past a breakpoint. Make sure to queue any signals that
4505 would otherwise be sent. In all-stop mode, we do this decision
4506 based on if *any* thread has a pending status. If there's a
4507 thread that needs the step-over-breakpoint dance, then don't
4508 resume any other thread but that particular one. */
4509 leave_pending
= (lwp
->suspended
4510 || lwp
->status_pending_p
4511 || leave_all_stopped
);
4516 debug_printf ("resuming LWP %ld\n", lwpid_of (thread
));
4518 step
= (lwp
->resume
->kind
== resume_step
);
4519 linux_resume_one_lwp (lwp
, step
, lwp
->resume
->sig
, NULL
);
4524 debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread
));
4526 /* If we have a new signal, enqueue the signal. */
4527 if (lwp
->resume
->sig
!= 0)
4529 struct pending_signals
*p_sig
;
4530 p_sig
= xmalloc (sizeof (*p_sig
));
4531 p_sig
->prev
= lwp
->pending_signals
;
4532 p_sig
->signal
= lwp
->resume
->sig
;
4533 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
4535 /* If this is the same signal we were previously stopped by,
4536 make sure to queue its siginfo. We can ignore the return
4537 value of ptrace; if it fails, we'll skip
4538 PTRACE_SETSIGINFO. */
4539 if (WIFSTOPPED (lwp
->last_status
)
4540 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
)
4541 ptrace (PTRACE_GETSIGINFO
, lwpid_of (thread
), (PTRACE_TYPE_ARG3
) 0,
4544 lwp
->pending_signals
= p_sig
;
4548 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
4554 linux_resume (struct thread_resume
*resume_info
, size_t n
)
4556 struct thread_resume_array array
= { resume_info
, n
};
4557 struct thread_info
*need_step_over
= NULL
;
4559 int leave_all_stopped
;
4564 debug_printf ("linux_resume:\n");
4567 find_inferior (&all_threads
, linux_set_resume_request
, &array
);
4569 /* If there is a thread which would otherwise be resumed, which has
4570 a pending status, then don't resume any threads - we can just
4571 report the pending status. Make sure to queue any signals that
4572 would otherwise be sent. In non-stop mode, we'll apply this
4573 logic to each thread individually. We consume all pending events
4574 before considering to start a step-over (in all-stop). */
4577 find_inferior (&all_threads
, resume_status_pending_p
, &any_pending
);
4579 /* If there is a thread which would otherwise be resumed, which is
4580 stopped at a breakpoint that needs stepping over, then don't
4581 resume any threads - have it step over the breakpoint with all
4582 other threads stopped, then resume all threads again. Make sure
4583 to queue any signals that would otherwise be delivered or
4585 if (!any_pending
&& supports_breakpoints ())
4587 = (struct thread_info
*) find_inferior (&all_threads
,
4588 need_step_over_p
, NULL
);
4590 leave_all_stopped
= (need_step_over
!= NULL
|| any_pending
);
4594 if (need_step_over
!= NULL
)
4595 debug_printf ("Not resuming all, need step over\n");
4596 else if (any_pending
)
4597 debug_printf ("Not resuming, all-stop and found "
4598 "an LWP with pending status\n");
4600 debug_printf ("Resuming, no pending status or step over needed\n");
4603 /* Even if we're leaving threads stopped, queue all signals we'd
4604 otherwise deliver. */
4605 find_inferior (&all_threads
, linux_resume_one_thread
, &leave_all_stopped
);
4608 start_step_over (get_thread_lwp (need_step_over
));
4612 debug_printf ("linux_resume done\n");
4617 /* This function is called once per thread. We check the thread's
4618 last resume request, which will tell us whether to resume, step, or
4619 leave the thread stopped. Any signal the client requested to be
4620 delivered has already been enqueued at this point.
4622 If any thread that GDB wants running is stopped at an internal
4623 breakpoint that needs stepping over, we start a step-over operation
4624 on that particular thread, and leave all others stopped. */
4627 proceed_one_lwp (struct inferior_list_entry
*entry
, void *except
)
4629 struct thread_info
*thread
= (struct thread_info
*) entry
;
4630 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4637 debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread
));
4642 debug_printf (" LWP %ld already running\n", lwpid_of (thread
));
4646 if (thread
->last_resume_kind
== resume_stop
4647 && thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
4650 debug_printf (" client wants LWP to remain %ld stopped\n",
4655 if (lwp
->status_pending_p
)
4658 debug_printf (" LWP %ld has pending status, leaving stopped\n",
4663 gdb_assert (lwp
->suspended
>= 0);
4668 debug_printf (" LWP %ld is suspended\n", lwpid_of (thread
));
4672 if (thread
->last_resume_kind
== resume_stop
4673 && lwp
->pending_signals_to_report
== NULL
4674 && lwp
->collecting_fast_tracepoint
== 0)
4676 /* We haven't reported this LWP as stopped yet (otherwise, the
4677 last_status.kind check above would catch it, and we wouldn't
4678 reach here. This LWP may have been momentarily paused by a
4679 stop_all_lwps call while handling for example, another LWP's
4680 step-over. In that case, the pending expected SIGSTOP signal
4681 that was queued at vCont;t handling time will have already
4682 been consumed by wait_for_sigstop, and so we need to requeue
4683 another one here. Note that if the LWP already has a SIGSTOP
4684 pending, this is a no-op. */
4687 debug_printf ("Client wants LWP %ld to stop. "
4688 "Making sure it has a SIGSTOP pending\n",
4694 if (thread
->last_resume_kind
== resume_step
)
4697 debug_printf (" stepping LWP %ld, client wants it stepping\n",
4701 else if (lwp
->bp_reinsert
!= 0)
4704 debug_printf (" stepping LWP %ld, reinsert set\n",
4711 linux_resume_one_lwp (lwp
, step
, 0, NULL
);
4716 unsuspend_and_proceed_one_lwp (struct inferior_list_entry
*entry
, void *except
)
4718 struct thread_info
*thread
= (struct thread_info
*) entry
;
4719 struct lwp_info
*lwp
= get_thread_lwp (thread
);
4724 lwp_suspended_decr (lwp
);
4726 return proceed_one_lwp (entry
, except
);
4729 /* When we finish a step-over, set threads running again. If there's
4730 another thread that may need a step-over, now's the time to start
4731 it. Eventually, we'll move all threads past their breakpoints. */
4734 proceed_all_lwps (void)
4736 struct thread_info
*need_step_over
;
4738 /* If there is a thread which would otherwise be resumed, which is
4739 stopped at a breakpoint that needs stepping over, then don't
4740 resume any threads - have it step over the breakpoint with all
4741 other threads stopped, then resume all threads again. */
4743 if (supports_breakpoints ())
4746 = (struct thread_info
*) find_inferior (&all_threads
,
4747 need_step_over_p
, NULL
);
4749 if (need_step_over
!= NULL
)
4752 debug_printf ("proceed_all_lwps: found "
4753 "thread %ld needing a step-over\n",
4754 lwpid_of (need_step_over
));
4756 start_step_over (get_thread_lwp (need_step_over
));
4762 debug_printf ("Proceeding, no step-over needed\n");
4764 find_inferior (&all_threads
, proceed_one_lwp
, NULL
);
4767 /* Stopped LWPs that the client wanted to be running, that don't have
4768 pending statuses, are set to run again, except for EXCEPT, if not
4769 NULL. This undoes a stop_all_lwps call. */
4772 unstop_all_lwps (int unsuspend
, struct lwp_info
*except
)
4778 debug_printf ("unstopping all lwps, except=(LWP %ld)\n",
4779 lwpid_of (get_lwp_thread (except
)));
4781 debug_printf ("unstopping all lwps\n");
4785 find_inferior (&all_threads
, unsuspend_and_proceed_one_lwp
, except
);
4787 find_inferior (&all_threads
, proceed_one_lwp
, except
);
4791 debug_printf ("unstop_all_lwps done\n");
4797 #ifdef HAVE_LINUX_REGSETS
4799 #define use_linux_regsets 1
4801 /* Returns true if REGSET has been disabled. */
4804 regset_disabled (struct regsets_info
*info
, struct regset_info
*regset
)
4806 return (info
->disabled_regsets
!= NULL
4807 && info
->disabled_regsets
[regset
- info
->regsets
]);
4810 /* Disable REGSET. */
4813 disable_regset (struct regsets_info
*info
, struct regset_info
*regset
)
4817 dr_offset
= regset
- info
->regsets
;
4818 if (info
->disabled_regsets
== NULL
)
4819 info
->disabled_regsets
= xcalloc (1, info
->num_regsets
);
4820 info
->disabled_regsets
[dr_offset
] = 1;
4824 regsets_fetch_inferior_registers (struct regsets_info
*regsets_info
,
4825 struct regcache
*regcache
)
4827 struct regset_info
*regset
;
4828 int saw_general_regs
= 0;
4832 pid
= lwpid_of (current_thread
);
4833 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
4838 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
))
4841 buf
= xmalloc (regset
->size
);
4843 nt_type
= regset
->nt_type
;
4847 iov
.iov_len
= regset
->size
;
4848 data
= (void *) &iov
;
4854 res
= ptrace (regset
->get_request
, pid
,
4855 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
4857 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
4863 /* If we get EIO on a regset, do not try it again for
4864 this process mode. */
4865 disable_regset (regsets_info
, regset
);
4867 else if (errno
== ENODATA
)
4869 /* ENODATA may be returned if the regset is currently
4870 not "active". This can happen in normal operation,
4871 so suppress the warning in this case. */
4876 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
4883 if (regset
->type
== GENERAL_REGS
)
4884 saw_general_regs
= 1;
4885 regset
->store_function (regcache
, buf
);
4889 if (saw_general_regs
)
4896 regsets_store_inferior_registers (struct regsets_info
*regsets_info
,
4897 struct regcache
*regcache
)
4899 struct regset_info
*regset
;
4900 int saw_general_regs
= 0;
4904 pid
= lwpid_of (current_thread
);
4905 for (regset
= regsets_info
->regsets
; regset
->size
>= 0; regset
++)
4910 if (regset
->size
== 0 || regset_disabled (regsets_info
, regset
)
4911 || regset
->fill_function
== NULL
)
4914 buf
= xmalloc (regset
->size
);
4916 /* First fill the buffer with the current register set contents,
4917 in case there are any items in the kernel's regset that are
4918 not in gdbserver's regcache. */
4920 nt_type
= regset
->nt_type
;
4924 iov
.iov_len
= regset
->size
;
4925 data
= (void *) &iov
;
4931 res
= ptrace (regset
->get_request
, pid
,
4932 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
4934 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
4939 /* Then overlay our cached registers on that. */
4940 regset
->fill_function (regcache
, buf
);
4942 /* Only now do we write the register set. */
4944 res
= ptrace (regset
->set_request
, pid
,
4945 (PTRACE_TYPE_ARG3
) (long) nt_type
, data
);
4947 res
= ptrace (regset
->set_request
, pid
, data
, nt_type
);
4955 /* If we get EIO on a regset, do not try it again for
4956 this process mode. */
4957 disable_regset (regsets_info
, regset
);
4959 else if (errno
== ESRCH
)
4961 /* At this point, ESRCH should mean the process is
4962 already gone, in which case we simply ignore attempts
4963 to change its registers. See also the related
4964 comment in linux_resume_one_lwp. */
4970 perror ("Warning: ptrace(regsets_store_inferior_registers)");
4973 else if (regset
->type
== GENERAL_REGS
)
4974 saw_general_regs
= 1;
4977 if (saw_general_regs
)
4983 #else /* !HAVE_LINUX_REGSETS */
4985 #define use_linux_regsets 0
4986 #define regsets_fetch_inferior_registers(regsets_info, regcache) 1
4987 #define regsets_store_inferior_registers(regsets_info, regcache) 1
4991 /* Return 1 if register REGNO is supported by one of the regset ptrace
4992 calls or 0 if it has to be transferred individually. */
4995 linux_register_in_regsets (const struct regs_info
*regs_info
, int regno
)
4997 unsigned char mask
= 1 << (regno
% 8);
4998 size_t index
= regno
/ 8;
5000 return (use_linux_regsets
5001 && (regs_info
->regset_bitmap
== NULL
5002 || (regs_info
->regset_bitmap
[index
] & mask
) != 0));
5005 #ifdef HAVE_LINUX_USRREGS
5008 register_addr (const struct usrregs_info
*usrregs
, int regnum
)
5012 if (regnum
< 0 || regnum
>= usrregs
->num_regs
)
5013 error ("Invalid register number %d.", regnum
);
5015 addr
= usrregs
->regmap
[regnum
];
5020 /* Fetch one register. */
5022 fetch_register (const struct usrregs_info
*usrregs
,
5023 struct regcache
*regcache
, int regno
)
5030 if (regno
>= usrregs
->num_regs
)
5032 if ((*the_low_target
.cannot_fetch_register
) (regno
))
5035 regaddr
= register_addr (usrregs
, regno
);
5039 size
= ((register_size (regcache
->tdesc
, regno
)
5040 + sizeof (PTRACE_XFER_TYPE
) - 1)
5041 & -sizeof (PTRACE_XFER_TYPE
));
5042 buf
= alloca (size
);
5044 pid
= lwpid_of (current_thread
);
5045 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5048 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
5049 ptrace (PTRACE_PEEKUSER
, pid
,
5050 /* Coerce to a uintptr_t first to avoid potential gcc warning
5051 of coercing an 8 byte integer to a 4 byte pointer. */
5052 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
, (PTRACE_TYPE_ARG4
) 0);
5053 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5055 error ("reading register %d: %s", regno
, strerror (errno
));
5058 if (the_low_target
.supply_ptrace_register
)
5059 the_low_target
.supply_ptrace_register (regcache
, regno
, buf
);
5061 supply_register (regcache
, regno
, buf
);
5064 /* Store one register. */
5066 store_register (const struct usrregs_info
*usrregs
,
5067 struct regcache
*regcache
, int regno
)
5074 if (regno
>= usrregs
->num_regs
)
5076 if ((*the_low_target
.cannot_store_register
) (regno
))
5079 regaddr
= register_addr (usrregs
, regno
);
5083 size
= ((register_size (regcache
->tdesc
, regno
)
5084 + sizeof (PTRACE_XFER_TYPE
) - 1)
5085 & -sizeof (PTRACE_XFER_TYPE
));
5086 buf
= alloca (size
);
5087 memset (buf
, 0, size
);
5089 if (the_low_target
.collect_ptrace_register
)
5090 the_low_target
.collect_ptrace_register (regcache
, regno
, buf
);
5092 collect_register (regcache
, regno
, buf
);
5094 pid
= lwpid_of (current_thread
);
5095 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
5098 ptrace (PTRACE_POKEUSER
, pid
,
5099 /* Coerce to a uintptr_t first to avoid potential gcc warning
5100 about coercing an 8 byte integer to a 4 byte pointer. */
5101 (PTRACE_TYPE_ARG3
) (uintptr_t) regaddr
,
5102 (PTRACE_TYPE_ARG4
) *(PTRACE_XFER_TYPE
*) (buf
+ i
));
5105 /* At this point, ESRCH should mean the process is
5106 already gone, in which case we simply ignore attempts
5107 to change its registers. See also the related
5108 comment in linux_resume_one_lwp. */
5112 if ((*the_low_target
.cannot_store_register
) (regno
) == 0)
5113 error ("writing register %d: %s", regno
, strerror (errno
));
5115 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
5119 /* Fetch all registers, or just one, from the child process.
5120 If REGNO is -1, do this for all registers, skipping any that are
5121 assumed to have been retrieved by regsets_fetch_inferior_registers,
5122 unless ALL is non-zero.
5123 Otherwise, REGNO specifies which register (so we can save time). */
5125 usr_fetch_inferior_registers (const struct regs_info
*regs_info
,
5126 struct regcache
*regcache
, int regno
, int all
)
5128 struct usrregs_info
*usr
= regs_info
->usrregs
;
5132 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5133 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5134 fetch_register (usr
, regcache
, regno
);
5137 fetch_register (usr
, regcache
, regno
);
5140 /* Store our register values back into the inferior.
5141 If REGNO is -1, do this for all registers, skipping any that are
5142 assumed to have been saved by regsets_store_inferior_registers,
5143 unless ALL is non-zero.
5144 Otherwise, REGNO specifies which register (so we can save time). */
5146 usr_store_inferior_registers (const struct regs_info
*regs_info
,
5147 struct regcache
*regcache
, int regno
, int all
)
5149 struct usrregs_info
*usr
= regs_info
->usrregs
;
5153 for (regno
= 0; regno
< usr
->num_regs
; regno
++)
5154 if (all
|| !linux_register_in_regsets (regs_info
, regno
))
5155 store_register (usr
, regcache
, regno
);
5158 store_register (usr
, regcache
, regno
);
5161 #else /* !HAVE_LINUX_USRREGS */
5163 #define usr_fetch_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
5164 #define usr_store_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
5170 linux_fetch_registers (struct regcache
*regcache
, int regno
)
5174 const struct regs_info
*regs_info
= (*the_low_target
.regs_info
) ();
5178 if (the_low_target
.fetch_register
!= NULL
5179 && regs_info
->usrregs
!= NULL
)
5180 for (regno
= 0; regno
< regs_info
->usrregs
->num_regs
; regno
++)
5181 (*the_low_target
.fetch_register
) (regcache
, regno
);
5183 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
, regcache
);
5184 if (regs_info
->usrregs
!= NULL
)
5185 usr_fetch_inferior_registers (regs_info
, regcache
, -1, all
);
5189 if (the_low_target
.fetch_register
!= NULL
5190 && (*the_low_target
.fetch_register
) (regcache
, regno
))
5193 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5195 all
= regsets_fetch_inferior_registers (regs_info
->regsets_info
,
5197 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5198 usr_fetch_inferior_registers (regs_info
, regcache
, regno
, 1);
5203 linux_store_registers (struct regcache
*regcache
, int regno
)
5207 const struct regs_info
*regs_info
= (*the_low_target
.regs_info
) ();
5211 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5213 if (regs_info
->usrregs
!= NULL
)
5214 usr_store_inferior_registers (regs_info
, regcache
, regno
, all
);
5218 use_regsets
= linux_register_in_regsets (regs_info
, regno
);
5220 all
= regsets_store_inferior_registers (regs_info
->regsets_info
,
5222 if ((!use_regsets
|| all
) && regs_info
->usrregs
!= NULL
)
5223 usr_store_inferior_registers (regs_info
, regcache
, regno
, 1);
5228 /* Copy LEN bytes from inferior's memory starting at MEMADDR
5229 to debugger memory starting at MYADDR. */
5232 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
5234 int pid
= lwpid_of (current_thread
);
5235 register PTRACE_XFER_TYPE
*buffer
;
5236 register CORE_ADDR addr
;
5243 /* Try using /proc. Don't bother for one word. */
5244 if (len
>= 3 * sizeof (long))
5248 /* We could keep this file open and cache it - possibly one per
5249 thread. That requires some juggling, but is even faster. */
5250 sprintf (filename
, "/proc/%d/mem", pid
);
5251 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
5255 /* If pread64 is available, use it. It's faster if the kernel
5256 supports it (only one syscall), and it's 64-bit safe even on
5257 32-bit platforms (for instance, SPARC debugging a SPARC64
5260 bytes
= pread64 (fd
, myaddr
, len
, memaddr
);
5263 if (lseek (fd
, memaddr
, SEEK_SET
) != -1)
5264 bytes
= read (fd
, myaddr
, len
);
5271 /* Some data was read, we'll try to get the rest with ptrace. */
5281 /* Round starting address down to longword boundary. */
5282 addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
5283 /* Round ending address up; get number of longwords that makes. */
5284 count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
5285 / sizeof (PTRACE_XFER_TYPE
));
5286 /* Allocate buffer of that many longwords. */
5287 buffer
= (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
5289 /* Read all the longwords */
5291 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
5293 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5294 about coercing an 8 byte integer to a 4 byte pointer. */
5295 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, pid
,
5296 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5297 (PTRACE_TYPE_ARG4
) 0);
5303 /* Copy appropriate bytes out of the buffer. */
5306 i
*= sizeof (PTRACE_XFER_TYPE
);
5307 i
-= memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1);
5309 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
5316 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
5317 memory at MEMADDR. On failure (cannot write to the inferior)
5318 returns the value of errno. Always succeeds if LEN is zero. */
5321 linux_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
5324 /* Round starting address down to longword boundary. */
5325 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
5326 /* Round ending address up; get number of longwords that makes. */
5328 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
5329 / sizeof (PTRACE_XFER_TYPE
);
5331 /* Allocate buffer of that many longwords. */
5332 register PTRACE_XFER_TYPE
*buffer
= (PTRACE_XFER_TYPE
*)
5333 alloca (count
* sizeof (PTRACE_XFER_TYPE
));
5335 int pid
= lwpid_of (current_thread
);
5339 /* Zero length write always succeeds. */
5345 /* Dump up to four bytes. */
5346 char str
[4 * 2 + 1];
5348 int dump
= len
< 4 ? len
: 4;
5350 for (i
= 0; i
< dump
; i
++)
5352 sprintf (p
, "%02x", myaddr
[i
]);
5357 debug_printf ("Writing %s to 0x%08lx in process %d\n",
5358 str
, (long) memaddr
, pid
);
5361 /* Fill start and end extra bytes of buffer with existing memory data. */
5364 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5365 about coercing an 8 byte integer to a 4 byte pointer. */
5366 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, pid
,
5367 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5368 (PTRACE_TYPE_ARG4
) 0);
5376 = ptrace (PTRACE_PEEKTEXT
, pid
,
5377 /* Coerce to a uintptr_t first to avoid potential gcc warning
5378 about coercing an 8 byte integer to a 4 byte pointer. */
5379 (PTRACE_TYPE_ARG3
) (uintptr_t) (addr
+ (count
- 1)
5380 * sizeof (PTRACE_XFER_TYPE
)),
5381 (PTRACE_TYPE_ARG4
) 0);
5386 /* Copy data to be written over corresponding part of buffer. */
5388 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
5391 /* Write the entire buffer. */
5393 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
5396 ptrace (PTRACE_POKETEXT
, pid
,
5397 /* Coerce to a uintptr_t first to avoid potential gcc warning
5398 about coercing an 8 byte integer to a 4 byte pointer. */
5399 (PTRACE_TYPE_ARG3
) (uintptr_t) addr
,
5400 (PTRACE_TYPE_ARG4
) buffer
[i
]);
5409 linux_look_up_symbols (void)
5411 #ifdef USE_THREAD_DB
5412 struct process_info
*proc
= current_process ();
5414 if (proc
->priv
->thread_db
!= NULL
)
5417 /* If the kernel supports tracing clones, then we don't need to
5418 use the magic thread event breakpoint to learn about
5420 thread_db_init (!linux_supports_traceclone ());
5425 linux_request_interrupt (void)
5427 extern unsigned long signal_pid
;
5429 /* Send a SIGINT to the process group. This acts just like the user
5430 typed a ^C on the controlling terminal. */
5431 kill (-signal_pid
, SIGINT
);
5434 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
5435 to debugger memory starting at MYADDR. */
5438 linux_read_auxv (CORE_ADDR offset
, unsigned char *myaddr
, unsigned int len
)
5440 char filename
[PATH_MAX
];
5442 int pid
= lwpid_of (current_thread
);
5444 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
5446 fd
= open (filename
, O_RDONLY
);
5450 if (offset
!= (CORE_ADDR
) 0
5451 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5454 n
= read (fd
, myaddr
, len
);
5461 /* These breakpoint and watchpoint related wrapper functions simply
5462 pass on the function call if the target has registered a
5463 corresponding function. */
5466 linux_supports_z_point_type (char z_type
)
5468 return (the_low_target
.supports_z_point_type
!= NULL
5469 && the_low_target
.supports_z_point_type (z_type
));
5473 linux_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5474 int size
, struct raw_breakpoint
*bp
)
5476 if (type
== raw_bkpt_type_sw
)
5477 return insert_memory_breakpoint (bp
);
5478 else if (the_low_target
.insert_point
!= NULL
)
5479 return the_low_target
.insert_point (type
, addr
, size
, bp
);
5481 /* Unsupported (see target.h). */
5486 linux_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
5487 int size
, struct raw_breakpoint
*bp
)
5489 if (type
== raw_bkpt_type_sw
)
5490 return remove_memory_breakpoint (bp
);
5491 else if (the_low_target
.remove_point
!= NULL
)
5492 return the_low_target
.remove_point (type
, addr
, size
, bp
);
5494 /* Unsupported (see target.h). */
5498 /* Implement the to_stopped_by_sw_breakpoint target_ops
5502 linux_stopped_by_sw_breakpoint (void)
5504 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5506 return (lwp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
5509 /* Implement the to_supports_stopped_by_sw_breakpoint target_ops
5513 linux_supports_stopped_by_sw_breakpoint (void)
5515 return USE_SIGTRAP_SIGINFO
;
5518 /* Implement the to_stopped_by_hw_breakpoint target_ops
5522 linux_stopped_by_hw_breakpoint (void)
5524 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5526 return (lwp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
5529 /* Implement the to_supports_stopped_by_hw_breakpoint target_ops
5533 linux_supports_stopped_by_hw_breakpoint (void)
5535 return USE_SIGTRAP_SIGINFO
;
5538 /* Implement the supports_conditional_breakpoints target_ops
5542 linux_supports_conditional_breakpoints (void)
5544 /* GDBserver needs to step over the breakpoint if the condition is
5545 false. GDBserver software single step is too simple, so disable
5546 conditional breakpoints if the target doesn't have hardware single
5548 return can_hardware_single_step ();
5552 linux_stopped_by_watchpoint (void)
5554 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5556 return lwp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
5560 linux_stopped_data_address (void)
5562 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
5564 return lwp
->stopped_data_address
;
5567 #if defined(__UCLIBC__) && defined(HAS_NOMMU) \
5568 && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
5569 && defined(PT_TEXT_END_ADDR)
5571 /* This is only used for targets that define PT_TEXT_ADDR,
5572 PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
5573 the target has different ways of acquiring this information, like
5576 /* Under uClinux, programs are loaded at non-zero offsets, which we need
5577 to tell gdb about. */
5580 linux_read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
5582 unsigned long text
, text_end
, data
;
5583 int pid
= lwpid_of (current_thread
);
5587 text
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_ADDR
,
5588 (PTRACE_TYPE_ARG4
) 0);
5589 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_TEXT_END_ADDR
,
5590 (PTRACE_TYPE_ARG4
) 0);
5591 data
= ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_TYPE_ARG3
) PT_DATA_ADDR
,
5592 (PTRACE_TYPE_ARG4
) 0);
5596 /* Both text and data offsets produced at compile-time (and so
5597 used by gdb) are relative to the beginning of the program,
5598 with the data segment immediately following the text segment.
5599 However, the actual runtime layout in memory may put the data
5600 somewhere else, so when we send gdb a data base-address, we
5601 use the real data base address and subtract the compile-time
5602 data base-address from it (which is just the length of the
5603 text segment). BSS immediately follows data in both
5606 *data_p
= data
- (text_end
- text
);
5615 linux_qxfer_osdata (const char *annex
,
5616 unsigned char *readbuf
, unsigned const char *writebuf
,
5617 CORE_ADDR offset
, int len
)
5619 return linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
5622 /* Convert a native/host siginfo object, into/from the siginfo in the
5623 layout of the inferiors' architecture. */
5626 siginfo_fixup (siginfo_t
*siginfo
, void *inf_siginfo
, int direction
)
5630 if (the_low_target
.siginfo_fixup
!= NULL
)
5631 done
= the_low_target
.siginfo_fixup (siginfo
, inf_siginfo
, direction
);
5633 /* If there was no callback, or the callback didn't do anything,
5634 then just do a straight memcpy. */
5638 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
5640 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
5645 linux_xfer_siginfo (const char *annex
, unsigned char *readbuf
,
5646 unsigned const char *writebuf
, CORE_ADDR offset
, int len
)
5650 char inf_siginfo
[sizeof (siginfo_t
)];
5652 if (current_thread
== NULL
)
5655 pid
= lwpid_of (current_thread
);
5658 debug_printf ("%s siginfo for lwp %d.\n",
5659 readbuf
!= NULL
? "Reading" : "Writing",
5662 if (offset
>= sizeof (siginfo
))
5665 if (ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
5668 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
5669 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
5670 inferior with a 64-bit GDBSERVER should look the same as debugging it
5671 with a 32-bit GDBSERVER, we need to convert it. */
5672 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
5674 if (offset
+ len
> sizeof (siginfo
))
5675 len
= sizeof (siginfo
) - offset
;
5677 if (readbuf
!= NULL
)
5678 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
5681 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
5683 /* Convert back to ptrace layout before flushing it out. */
5684 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
5686 if (ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
) != 0)
5693 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5694 so we notice when children change state; as the handler for the
5695 sigsuspend in my_waitpid. */
5698 sigchld_handler (int signo
)
5700 int old_errno
= errno
;
5706 /* fprintf is not async-signal-safe, so call write
5708 if (write (2, "sigchld_handler\n",
5709 sizeof ("sigchld_handler\n") - 1) < 0)
5710 break; /* just ignore */
5714 if (target_is_async_p ())
5715 async_file_mark (); /* trigger a linux_wait */
5721 linux_supports_non_stop (void)
5727 linux_async (int enable
)
5729 int previous
= target_is_async_p ();
5732 debug_printf ("linux_async (%d), previous=%d\n",
5735 if (previous
!= enable
)
5738 sigemptyset (&mask
);
5739 sigaddset (&mask
, SIGCHLD
);
5741 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
5745 if (pipe (linux_event_pipe
) == -1)
5747 linux_event_pipe
[0] = -1;
5748 linux_event_pipe
[1] = -1;
5749 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
5751 warning ("creating event pipe failed.");
5755 fcntl (linux_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
5756 fcntl (linux_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
5758 /* Register the event loop handler. */
5759 add_file_handler (linux_event_pipe
[0],
5760 handle_target_event
, NULL
);
5762 /* Always trigger a linux_wait. */
5767 delete_file_handler (linux_event_pipe
[0]);
5769 close (linux_event_pipe
[0]);
5770 close (linux_event_pipe
[1]);
5771 linux_event_pipe
[0] = -1;
5772 linux_event_pipe
[1] = -1;
5775 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
5782 linux_start_non_stop (int nonstop
)
5784 /* Register or unregister from event-loop accordingly. */
5785 linux_async (nonstop
);
5787 if (target_is_async_p () != (nonstop
!= 0))
5794 linux_supports_multi_process (void)
5799 /* Check if fork events are supported. */
5802 linux_supports_fork_events (void)
5804 return linux_supports_tracefork ();
5807 /* Check if vfork events are supported. */
5810 linux_supports_vfork_events (void)
5812 return linux_supports_tracefork ();
5815 /* Callback for 'find_inferior'. Set the (possibly changed) ptrace
5816 options for the specified lwp. */
5819 reset_lwp_ptrace_options_callback (struct inferior_list_entry
*entry
,
5822 struct thread_info
*thread
= (struct thread_info
*) entry
;
5823 struct lwp_info
*lwp
= get_thread_lwp (thread
);
5827 /* Stop the lwp so we can modify its ptrace options. */
5828 lwp
->must_set_ptrace_flags
= 1;
5829 linux_stop_lwp (lwp
);
5833 /* Already stopped; go ahead and set the ptrace options. */
5834 struct process_info
*proc
= find_process_pid (pid_of (thread
));
5835 int options
= linux_low_ptrace_options (proc
->attached
);
5837 linux_enable_event_reporting (lwpid_of (thread
), options
);
5838 lwp
->must_set_ptrace_flags
= 0;
5844 /* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
5845 ptrace flags for all inferiors. This is in case the new GDB connection
5846 doesn't support the same set of events that the previous one did. */
5849 linux_handle_new_gdb_connection (void)
5853 /* Request that all the lwps reset their ptrace options. */
5854 find_inferior (&all_threads
, reset_lwp_ptrace_options_callback
, &pid
);
5858 linux_supports_disable_randomization (void)
5860 #ifdef HAVE_PERSONALITY
5868 linux_supports_agent (void)
5874 linux_supports_range_stepping (void)
5876 if (*the_low_target
.supports_range_stepping
== NULL
)
5879 return (*the_low_target
.supports_range_stepping
) ();
5882 /* Enumerate spufs IDs for process PID. */
5884 spu_enumerate_spu_ids (long pid
, unsigned char *buf
, CORE_ADDR offset
, int len
)
5890 struct dirent
*entry
;
5892 sprintf (path
, "/proc/%ld/fd", pid
);
5893 dir
= opendir (path
);
5898 while ((entry
= readdir (dir
)) != NULL
)
5904 fd
= atoi (entry
->d_name
);
5908 sprintf (path
, "/proc/%ld/fd/%d", pid
, fd
);
5909 if (stat (path
, &st
) != 0)
5911 if (!S_ISDIR (st
.st_mode
))
5914 if (statfs (path
, &stfs
) != 0)
5916 if (stfs
.f_type
!= SPUFS_MAGIC
)
5919 if (pos
>= offset
&& pos
+ 4 <= offset
+ len
)
5921 *(unsigned int *)(buf
+ pos
- offset
) = fd
;
5931 /* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
5932 object type, using the /proc file system. */
5934 linux_qxfer_spu (const char *annex
, unsigned char *readbuf
,
5935 unsigned const char *writebuf
,
5936 CORE_ADDR offset
, int len
)
5938 long pid
= lwpid_of (current_thread
);
5943 if (!writebuf
&& !readbuf
)
5951 return spu_enumerate_spu_ids (pid
, readbuf
, offset
, len
);
5954 sprintf (buf
, "/proc/%ld/fd/%s", pid
, annex
);
5955 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
5960 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5967 ret
= write (fd
, writebuf
, (size_t) len
);
5969 ret
= read (fd
, readbuf
, (size_t) len
);
5975 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
5976 struct target_loadseg
5978 /* Core address to which the segment is mapped. */
5980 /* VMA recorded in the program header. */
5982 /* Size of this segment in memory. */
5986 # if defined PT_GETDSBT
5987 struct target_loadmap
5989 /* Protocol version number, must be zero. */
5991 /* Pointer to the DSBT table, its size, and the DSBT index. */
5992 unsigned *dsbt_table
;
5993 unsigned dsbt_size
, dsbt_index
;
5994 /* Number of segments in this map. */
5996 /* The actual memory map. */
5997 struct target_loadseg segs
[/*nsegs*/];
5999 # define LINUX_LOADMAP PT_GETDSBT
6000 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
6001 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
6003 struct target_loadmap
6005 /* Protocol version number, must be zero. */
6007 /* Number of segments in this map. */
6009 /* The actual memory map. */
6010 struct target_loadseg segs
[/*nsegs*/];
6012 # define LINUX_LOADMAP PTRACE_GETFDPIC
6013 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
6014 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
6018 linux_read_loadmap (const char *annex
, CORE_ADDR offset
,
6019 unsigned char *myaddr
, unsigned int len
)
6021 int pid
= lwpid_of (current_thread
);
6023 struct target_loadmap
*data
= NULL
;
6024 unsigned int actual_length
, copy_length
;
6026 if (strcmp (annex
, "exec") == 0)
6027 addr
= (int) LINUX_LOADMAP_EXEC
;
6028 else if (strcmp (annex
, "interp") == 0)
6029 addr
= (int) LINUX_LOADMAP_INTERP
;
6033 if (ptrace (LINUX_LOADMAP
, pid
, addr
, &data
) != 0)
6039 actual_length
= sizeof (struct target_loadmap
)
6040 + sizeof (struct target_loadseg
) * data
->nsegs
;
6042 if (offset
< 0 || offset
> actual_length
)
6045 copy_length
= actual_length
- offset
< len
? actual_length
- offset
: len
;
6046 memcpy (myaddr
, (char *) data
+ offset
, copy_length
);
6050 # define linux_read_loadmap NULL
6051 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
6054 linux_process_qsupported (const char *query
)
6056 if (the_low_target
.process_qsupported
!= NULL
)
6057 the_low_target
.process_qsupported (query
);
6061 linux_supports_tracepoints (void)
6063 if (*the_low_target
.supports_tracepoints
== NULL
)
6066 return (*the_low_target
.supports_tracepoints
) ();
6070 linux_read_pc (struct regcache
*regcache
)
6072 if (the_low_target
.get_pc
== NULL
)
6075 return (*the_low_target
.get_pc
) (regcache
);
6079 linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
6081 gdb_assert (the_low_target
.set_pc
!= NULL
);
6083 (*the_low_target
.set_pc
) (regcache
, pc
);
6087 linux_thread_stopped (struct thread_info
*thread
)
6089 return get_thread_lwp (thread
)->stopped
;
6092 /* This exposes stop-all-threads functionality to other modules. */
6095 linux_pause_all (int freeze
)
6097 stop_all_lwps (freeze
, NULL
);
6100 /* This exposes unstop-all-threads functionality to other gdbserver
6104 linux_unpause_all (int unfreeze
)
6106 unstop_all_lwps (unfreeze
, NULL
);
6110 linux_prepare_to_access_memory (void)
6112 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6115 linux_pause_all (1);
6120 linux_done_accessing_memory (void)
6122 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6125 linux_unpause_all (1);
6129 linux_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint
, CORE_ADDR tpaddr
,
6130 CORE_ADDR collector
,
6133 CORE_ADDR
*jump_entry
,
6134 CORE_ADDR
*trampoline
,
6135 ULONGEST
*trampoline_size
,
6136 unsigned char *jjump_pad_insn
,
6137 ULONGEST
*jjump_pad_insn_size
,
6138 CORE_ADDR
*adjusted_insn_addr
,
6139 CORE_ADDR
*adjusted_insn_addr_end
,
6142 return (*the_low_target
.install_fast_tracepoint_jump_pad
)
6143 (tpoint
, tpaddr
, collector
, lockaddr
, orig_size
,
6144 jump_entry
, trampoline
, trampoline_size
,
6145 jjump_pad_insn
, jjump_pad_insn_size
,
6146 adjusted_insn_addr
, adjusted_insn_addr_end
,
6150 static struct emit_ops
*
6151 linux_emit_ops (void)
6153 if (the_low_target
.emit_ops
!= NULL
)
6154 return (*the_low_target
.emit_ops
) ();
6160 linux_get_min_fast_tracepoint_insn_len (void)
6162 return (*the_low_target
.get_min_fast_tracepoint_insn_len
) ();
6165 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
6168 get_phdr_phnum_from_proc_auxv (const int pid
, const int is_elf64
,
6169 CORE_ADDR
*phdr_memaddr
, int *num_phdr
)
6171 char filename
[PATH_MAX
];
6173 const int auxv_size
= is_elf64
6174 ? sizeof (Elf64_auxv_t
) : sizeof (Elf32_auxv_t
);
6175 char buf
[sizeof (Elf64_auxv_t
)]; /* The larger of the two. */
6177 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
6179 fd
= open (filename
, O_RDONLY
);
6185 while (read (fd
, buf
, auxv_size
) == auxv_size
6186 && (*phdr_memaddr
== 0 || *num_phdr
== 0))
6190 Elf64_auxv_t
*const aux
= (Elf64_auxv_t
*) buf
;
6192 switch (aux
->a_type
)
6195 *phdr_memaddr
= aux
->a_un
.a_val
;
6198 *num_phdr
= aux
->a_un
.a_val
;
6204 Elf32_auxv_t
*const aux
= (Elf32_auxv_t
*) buf
;
6206 switch (aux
->a_type
)
6209 *phdr_memaddr
= aux
->a_un
.a_val
;
6212 *num_phdr
= aux
->a_un
.a_val
;
6220 if (*phdr_memaddr
== 0 || *num_phdr
== 0)
6222 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
6223 "phdr_memaddr = %ld, phdr_num = %d",
6224 (long) *phdr_memaddr
, *num_phdr
);
6231 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
6234 get_dynamic (const int pid
, const int is_elf64
)
6236 CORE_ADDR phdr_memaddr
, relocation
;
6238 unsigned char *phdr_buf
;
6239 const int phdr_size
= is_elf64
? sizeof (Elf64_Phdr
) : sizeof (Elf32_Phdr
);
6241 if (get_phdr_phnum_from_proc_auxv (pid
, is_elf64
, &phdr_memaddr
, &num_phdr
))
6244 gdb_assert (num_phdr
< 100); /* Basic sanity check. */
6245 phdr_buf
= alloca (num_phdr
* phdr_size
);
6247 if (linux_read_memory (phdr_memaddr
, phdr_buf
, num_phdr
* phdr_size
))
6250 /* Compute relocation: it is expected to be 0 for "regular" executables,
6251 non-zero for PIE ones. */
6253 for (i
= 0; relocation
== -1 && i
< num_phdr
; i
++)
6256 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6258 if (p
->p_type
== PT_PHDR
)
6259 relocation
= phdr_memaddr
- p
->p_vaddr
;
6263 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6265 if (p
->p_type
== PT_PHDR
)
6266 relocation
= phdr_memaddr
- p
->p_vaddr
;
6269 if (relocation
== -1)
6271 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
6272 any real world executables, including PIE executables, have always
6273 PT_PHDR present. PT_PHDR is not present in some shared libraries or
6274 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
6275 or present DT_DEBUG anyway (fpc binaries are statically linked).
6277 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
6279 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
6284 for (i
= 0; i
< num_phdr
; i
++)
6288 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6290 if (p
->p_type
== PT_DYNAMIC
)
6291 return p
->p_vaddr
+ relocation
;
6295 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
6297 if (p
->p_type
== PT_DYNAMIC
)
6298 return p
->p_vaddr
+ relocation
;
6305 /* Return &_r_debug in the inferior, or -1 if not present. Return value
6306 can be 0 if the inferior does not yet have the library list initialized.
6307 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
6308 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
6311 get_r_debug (const int pid
, const int is_elf64
)
6313 CORE_ADDR dynamic_memaddr
;
6314 const int dyn_size
= is_elf64
? sizeof (Elf64_Dyn
) : sizeof (Elf32_Dyn
);
6315 unsigned char buf
[sizeof (Elf64_Dyn
)]; /* The larger of the two. */
6318 dynamic_memaddr
= get_dynamic (pid
, is_elf64
);
6319 if (dynamic_memaddr
== 0)
6322 while (linux_read_memory (dynamic_memaddr
, buf
, dyn_size
) == 0)
6326 Elf64_Dyn
*const dyn
= (Elf64_Dyn
*) buf
;
6327 #ifdef DT_MIPS_RLD_MAP
6331 unsigned char buf
[sizeof (Elf64_Xword
)];
6335 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6337 if (linux_read_memory (dyn
->d_un
.d_val
,
6338 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6343 #endif /* DT_MIPS_RLD_MAP */
6345 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6346 map
= dyn
->d_un
.d_val
;
6348 if (dyn
->d_tag
== DT_NULL
)
6353 Elf32_Dyn
*const dyn
= (Elf32_Dyn
*) buf
;
6354 #ifdef DT_MIPS_RLD_MAP
6358 unsigned char buf
[sizeof (Elf32_Word
)];
6362 if (dyn
->d_tag
== DT_MIPS_RLD_MAP
)
6364 if (linux_read_memory (dyn
->d_un
.d_val
,
6365 rld_map
.buf
, sizeof (rld_map
.buf
)) == 0)
6370 #endif /* DT_MIPS_RLD_MAP */
6372 if (dyn
->d_tag
== DT_DEBUG
&& map
== -1)
6373 map
= dyn
->d_un
.d_val
;
6375 if (dyn
->d_tag
== DT_NULL
)
6379 dynamic_memaddr
+= dyn_size
;
6385 /* Read one pointer from MEMADDR in the inferior. */
6388 read_one_ptr (CORE_ADDR memaddr
, CORE_ADDR
*ptr
, int ptr_size
)
6392 /* Go through a union so this works on either big or little endian
6393 hosts, when the inferior's pointer size is smaller than the size
6394 of CORE_ADDR. It is assumed the inferior's endianness is the
6395 same of the superior's. */
6398 CORE_ADDR core_addr
;
6403 ret
= linux_read_memory (memaddr
, &addr
.uc
, ptr_size
);
6406 if (ptr_size
== sizeof (CORE_ADDR
))
6407 *ptr
= addr
.core_addr
;
6408 else if (ptr_size
== sizeof (unsigned int))
6411 gdb_assert_not_reached ("unhandled pointer size");
6416 struct link_map_offsets
6418 /* Offset and size of r_debug.r_version. */
6419 int r_version_offset
;
6421 /* Offset and size of r_debug.r_map. */
6424 /* Offset to l_addr field in struct link_map. */
6427 /* Offset to l_name field in struct link_map. */
6430 /* Offset to l_ld field in struct link_map. */
6433 /* Offset to l_next field in struct link_map. */
6436 /* Offset to l_prev field in struct link_map. */
6440 /* Construct qXfer:libraries-svr4:read reply. */
6443 linux_qxfer_libraries_svr4 (const char *annex
, unsigned char *readbuf
,
6444 unsigned const char *writebuf
,
6445 CORE_ADDR offset
, int len
)
6448 unsigned document_len
;
6449 struct process_info_private
*const priv
= current_process ()->priv
;
6450 char filename
[PATH_MAX
];
6453 static const struct link_map_offsets lmo_32bit_offsets
=
6455 0, /* r_version offset. */
6456 4, /* r_debug.r_map offset. */
6457 0, /* l_addr offset in link_map. */
6458 4, /* l_name offset in link_map. */
6459 8, /* l_ld offset in link_map. */
6460 12, /* l_next offset in link_map. */
6461 16 /* l_prev offset in link_map. */
6464 static const struct link_map_offsets lmo_64bit_offsets
=
6466 0, /* r_version offset. */
6467 8, /* r_debug.r_map offset. */
6468 0, /* l_addr offset in link_map. */
6469 8, /* l_name offset in link_map. */
6470 16, /* l_ld offset in link_map. */
6471 24, /* l_next offset in link_map. */
6472 32 /* l_prev offset in link_map. */
6474 const struct link_map_offsets
*lmo
;
6475 unsigned int machine
;
6477 CORE_ADDR lm_addr
= 0, lm_prev
= 0;
6478 int allocated
= 1024;
6480 CORE_ADDR l_name
, l_addr
, l_ld
, l_next
, l_prev
;
6481 int header_done
= 0;
6483 if (writebuf
!= NULL
)
6485 if (readbuf
== NULL
)
6488 pid
= lwpid_of (current_thread
);
6489 xsnprintf (filename
, sizeof filename
, "/proc/%d/exe", pid
);
6490 is_elf64
= elf_64_file_p (filename
, &machine
);
6491 lmo
= is_elf64
? &lmo_64bit_offsets
: &lmo_32bit_offsets
;
6492 ptr_size
= is_elf64
? 8 : 4;
6494 while (annex
[0] != '\0')
6500 sep
= strchr (annex
, '=');
6505 if (len
== 5 && startswith (annex
, "start"))
6507 else if (len
== 4 && startswith (annex
, "prev"))
6511 annex
= strchr (sep
, ';');
6518 annex
= decode_address_to_semicolon (addrp
, sep
+ 1);
6525 if (priv
->r_debug
== 0)
6526 priv
->r_debug
= get_r_debug (pid
, is_elf64
);
6528 /* We failed to find DT_DEBUG. Such situation will not change
6529 for this inferior - do not retry it. Report it to GDB as
6530 E01, see for the reasons at the GDB solib-svr4.c side. */
6531 if (priv
->r_debug
== (CORE_ADDR
) -1)
6534 if (priv
->r_debug
!= 0)
6536 if (linux_read_memory (priv
->r_debug
+ lmo
->r_version_offset
,
6537 (unsigned char *) &r_version
,
6538 sizeof (r_version
)) != 0
6541 warning ("unexpected r_debug version %d", r_version
);
6543 else if (read_one_ptr (priv
->r_debug
+ lmo
->r_map_offset
,
6544 &lm_addr
, ptr_size
) != 0)
6546 warning ("unable to read r_map from 0x%lx",
6547 (long) priv
->r_debug
+ lmo
->r_map_offset
);
6552 document
= xmalloc (allocated
);
6553 strcpy (document
, "<library-list-svr4 version=\"1.0\"");
6554 p
= document
+ strlen (document
);
6557 && read_one_ptr (lm_addr
+ lmo
->l_name_offset
,
6558 &l_name
, ptr_size
) == 0
6559 && read_one_ptr (lm_addr
+ lmo
->l_addr_offset
,
6560 &l_addr
, ptr_size
) == 0
6561 && read_one_ptr (lm_addr
+ lmo
->l_ld_offset
,
6562 &l_ld
, ptr_size
) == 0
6563 && read_one_ptr (lm_addr
+ lmo
->l_prev_offset
,
6564 &l_prev
, ptr_size
) == 0
6565 && read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
6566 &l_next
, ptr_size
) == 0)
6568 unsigned char libname
[PATH_MAX
];
6570 if (lm_prev
!= l_prev
)
6572 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
6573 (long) lm_prev
, (long) l_prev
);
6577 /* Ignore the first entry even if it has valid name as the first entry
6578 corresponds to the main executable. The first entry should not be
6579 skipped if the dynamic loader was loaded late by a static executable
6580 (see solib-svr4.c parameter ignore_first). But in such case the main
6581 executable does not have PT_DYNAMIC present and this function already
6582 exited above due to failed get_r_debug. */
6585 sprintf (p
, " main-lm=\"0x%lx\"", (unsigned long) lm_addr
);
6590 /* Not checking for error because reading may stop before
6591 we've got PATH_MAX worth of characters. */
6593 linux_read_memory (l_name
, libname
, sizeof (libname
) - 1);
6594 libname
[sizeof (libname
) - 1] = '\0';
6595 if (libname
[0] != '\0')
6597 /* 6x the size for xml_escape_text below. */
6598 size_t len
= 6 * strlen ((char *) libname
);
6603 /* Terminate `<library-list-svr4'. */
6608 while (allocated
< p
- document
+ len
+ 200)
6610 /* Expand to guarantee sufficient storage. */
6611 uintptr_t document_len
= p
- document
;
6613 document
= xrealloc (document
, 2 * allocated
);
6615 p
= document
+ document_len
;
6618 name
= xml_escape_text ((char *) libname
);
6619 p
+= sprintf (p
, "<library name=\"%s\" lm=\"0x%lx\" "
6620 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
6621 name
, (unsigned long) lm_addr
,
6622 (unsigned long) l_addr
, (unsigned long) l_ld
);
6633 /* Empty list; terminate `<library-list-svr4'. */
6637 strcpy (p
, "</library-list-svr4>");
6639 document_len
= strlen (document
);
6640 if (offset
< document_len
)
6641 document_len
-= offset
;
6644 if (len
> document_len
)
6647 memcpy (readbuf
, document
+ offset
, len
);
6653 #ifdef HAVE_LINUX_BTRACE
6655 /* See to_enable_btrace target method. */
6657 static struct btrace_target_info
*
6658 linux_low_enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
6660 struct btrace_target_info
*tinfo
;
6662 tinfo
= linux_enable_btrace (ptid
, conf
);
6664 if (tinfo
!= NULL
&& tinfo
->ptr_bits
== 0)
6666 struct thread_info
*thread
= find_thread_ptid (ptid
);
6667 struct regcache
*regcache
= get_thread_regcache (thread
, 0);
6669 tinfo
->ptr_bits
= register_size (regcache
->tdesc
, 0) * 8;
6675 /* See to_disable_btrace target method. */
6678 linux_low_disable_btrace (struct btrace_target_info
*tinfo
)
6680 enum btrace_error err
;
6682 err
= linux_disable_btrace (tinfo
);
6683 return (err
== BTRACE_ERR_NONE
? 0 : -1);
6686 /* Encode an Intel(R) Processor Trace configuration. */
6689 linux_low_encode_pt_config (struct buffer
*buffer
,
6690 const struct btrace_data_pt_config
*config
)
6692 buffer_grow_str (buffer
, "<pt-config>\n");
6694 switch (config
->cpu
.vendor
)
6697 buffer_xml_printf (buffer
, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
6698 "model=\"%u\" stepping=\"%u\"/>\n",
6699 config
->cpu
.family
, config
->cpu
.model
,
6700 config
->cpu
.stepping
);
6707 buffer_grow_str (buffer
, "</pt-config>\n");
6710 /* Encode a raw buffer. */
6713 linux_low_encode_raw (struct buffer
*buffer
, const gdb_byte
*data
,
6719 /* We use hex encoding - see common/rsp-low.h. */
6720 buffer_grow_str (buffer
, "<raw>\n");
6726 elem
[0] = tohex ((*data
>> 4) & 0xf);
6727 elem
[1] = tohex (*data
++ & 0xf);
6729 buffer_grow (buffer
, elem
, 2);
6732 buffer_grow_str (buffer
, "</raw>\n");
6735 /* See to_read_btrace target method. */
6738 linux_low_read_btrace (struct btrace_target_info
*tinfo
, struct buffer
*buffer
,
6741 struct btrace_data btrace
;
6742 struct btrace_block
*block
;
6743 enum btrace_error err
;
6746 btrace_data_init (&btrace
);
6748 err
= linux_read_btrace (&btrace
, tinfo
, type
);
6749 if (err
!= BTRACE_ERR_NONE
)
6751 if (err
== BTRACE_ERR_OVERFLOW
)
6752 buffer_grow_str0 (buffer
, "E.Overflow.");
6754 buffer_grow_str0 (buffer
, "E.Generic Error.");
6759 switch (btrace
.format
)
6761 case BTRACE_FORMAT_NONE
:
6762 buffer_grow_str0 (buffer
, "E.No Trace.");
6765 case BTRACE_FORMAT_BTS
:
6766 buffer_grow_str (buffer
, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
6767 buffer_grow_str (buffer
, "<btrace version=\"1.0\">\n");
6770 VEC_iterate (btrace_block_s
, btrace
.variant
.bts
.blocks
, i
, block
);
6772 buffer_xml_printf (buffer
, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
6773 paddress (block
->begin
), paddress (block
->end
));
6775 buffer_grow_str0 (buffer
, "</btrace>\n");
6778 case BTRACE_FORMAT_PT
:
6779 buffer_grow_str (buffer
, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
6780 buffer_grow_str (buffer
, "<btrace version=\"1.0\">\n");
6781 buffer_grow_str (buffer
, "<pt>\n");
6783 linux_low_encode_pt_config (buffer
, &btrace
.variant
.pt
.config
);
6785 linux_low_encode_raw (buffer
, btrace
.variant
.pt
.data
,
6786 btrace
.variant
.pt
.size
);
6788 buffer_grow_str (buffer
, "</pt>\n");
6789 buffer_grow_str0 (buffer
, "</btrace>\n");
6793 buffer_grow_str0 (buffer
, "E.Unsupported Trace Format.");
6797 btrace_data_fini (&btrace
);
6801 btrace_data_fini (&btrace
);
6805 /* See to_btrace_conf target method. */
6808 linux_low_btrace_conf (const struct btrace_target_info
*tinfo
,
6809 struct buffer
*buffer
)
6811 const struct btrace_config
*conf
;
6813 buffer_grow_str (buffer
, "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n");
6814 buffer_grow_str (buffer
, "<btrace-conf version=\"1.0\">\n");
6816 conf
= linux_btrace_conf (tinfo
);
6819 switch (conf
->format
)
6821 case BTRACE_FORMAT_NONE
:
6824 case BTRACE_FORMAT_BTS
:
6825 buffer_xml_printf (buffer
, "<bts");
6826 buffer_xml_printf (buffer
, " size=\"0x%x\"", conf
->bts
.size
);
6827 buffer_xml_printf (buffer
, " />\n");
6830 case BTRACE_FORMAT_PT
:
6831 buffer_xml_printf (buffer
, "<pt");
6832 buffer_xml_printf (buffer
, " size=\"0x%x\"", conf
->pt
.size
);
6833 buffer_xml_printf (buffer
, "/>\n");
6838 buffer_grow_str0 (buffer
, "</btrace-conf>\n");
6841 #endif /* HAVE_LINUX_BTRACE */
6843 /* See nat/linux-nat.h. */
6846 current_lwp_ptid (void)
6848 return ptid_of (current_thread
);
6851 static struct target_ops linux_target_ops
= {
6852 linux_create_inferior
,
6862 linux_fetch_registers
,
6863 linux_store_registers
,
6864 linux_prepare_to_access_memory
,
6865 linux_done_accessing_memory
,
6868 linux_look_up_symbols
,
6869 linux_request_interrupt
,
6871 linux_supports_z_point_type
,
6874 linux_stopped_by_sw_breakpoint
,
6875 linux_supports_stopped_by_sw_breakpoint
,
6876 linux_stopped_by_hw_breakpoint
,
6877 linux_supports_stopped_by_hw_breakpoint
,
6878 linux_supports_conditional_breakpoints
,
6879 linux_stopped_by_watchpoint
,
6880 linux_stopped_data_address
,
6881 #if defined(__UCLIBC__) && defined(HAS_NOMMU) \
6882 && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
6883 && defined(PT_TEXT_END_ADDR)
6888 #ifdef USE_THREAD_DB
6889 thread_db_get_tls_address
,
6894 hostio_last_error_from_errno
,
6897 linux_supports_non_stop
,
6899 linux_start_non_stop
,
6900 linux_supports_multi_process
,
6901 linux_supports_fork_events
,
6902 linux_supports_vfork_events
,
6903 linux_handle_new_gdb_connection
,
6904 #ifdef USE_THREAD_DB
6905 thread_db_handle_monitor_command
,
6909 linux_common_core_of_thread
,
6911 linux_process_qsupported
,
6912 linux_supports_tracepoints
,
6915 linux_thread_stopped
,
6919 linux_stabilize_threads
,
6920 linux_install_fast_tracepoint_jump_pad
,
6922 linux_supports_disable_randomization
,
6923 linux_get_min_fast_tracepoint_insn_len
,
6924 linux_qxfer_libraries_svr4
,
6925 linux_supports_agent
,
6926 #ifdef HAVE_LINUX_BTRACE
6927 linux_supports_btrace
,
6928 linux_low_enable_btrace
,
6929 linux_low_disable_btrace
,
6930 linux_low_read_btrace
,
6931 linux_low_btrace_conf
,
6939 linux_supports_range_stepping
,
6940 linux_proc_pid_to_exec_file
,
6941 linux_mntns_open_cloexec
,
6943 linux_mntns_readlink
,
6947 linux_init_signals ()
6949 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
6950 to find what the cancel signal actually is. */
6951 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
6952 signal (__SIGRTMIN
+1, SIG_IGN
);
6956 #ifdef HAVE_LINUX_REGSETS
6958 initialize_regsets_info (struct regsets_info
*info
)
6960 for (info
->num_regsets
= 0;
6961 info
->regsets
[info
->num_regsets
].size
>= 0;
6962 info
->num_regsets
++)
6968 initialize_low (void)
6970 struct sigaction sigchld_action
;
6971 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
6972 set_target_ops (&linux_target_ops
);
6973 set_breakpoint_data (the_low_target
.breakpoint
,
6974 the_low_target
.breakpoint_len
);
6975 linux_init_signals ();
6976 linux_ptrace_init_warnings ();
6978 sigchld_action
.sa_handler
= sigchld_handler
;
6979 sigemptyset (&sigchld_action
.sa_mask
);
6980 sigchld_action
.sa_flags
= SA_RESTART
;
6981 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
6983 initialize_low_arch ();
6985 linux_check_ptrace_features ();