1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "nat/linux-nat.h"
25 #include "nat/linux-waitpid.h"
27 #ifdef HAVE_TKILL_SYSCALL
29 #include <sys/syscall.h>
31 #include <sys/ptrace.h>
32 #include "linux-nat.h"
33 #include "nat/linux-ptrace.h"
34 #include "nat/linux-procfs.h"
35 #include "nat/linux-personality.h"
36 #include "linux-fork.h"
37 #include "gdbthread.h"
41 #include "inf-child.h"
42 #include "inf-ptrace.h"
44 #include <sys/procfs.h> /* for elf_gregset etc. */
45 #include "elf-bfd.h" /* for elfcore_write_* */
46 #include "gregset.h" /* for gregset */
47 #include "gdbcore.h" /* for get_exec_file */
48 #include <ctype.h> /* for isdigit */
49 #include <sys/stat.h> /* for struct stat */
50 #include <fcntl.h> /* for O_RDONLY */
52 #include "event-loop.h"
53 #include "event-top.h"
55 #include <sys/types.h>
57 #include "xml-support.h"
60 #include "nat/linux-osdata.h"
61 #include "linux-tdep.h"
64 #include "tracepoint.h"
66 #include "target-descriptions.h"
67 #include "filestuff.h"
71 #define SPUFS_MAGIC 0x23c9b64e
74 /* This comment documents high-level logic of this file.
76 Waiting for events in sync mode
77 ===============================
79 When waiting for an event in a specific thread, we just use waitpid, passing
80 the specific pid, and not passing WNOHANG.
82 When waiting for an event in all threads, waitpid is not quite good. Prior to
83 version 2.4, Linux can either wait for event in main thread, or in secondary
84 threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
85 miss an event. The solution is to use non-blocking waitpid, together with
86 sigsuspend. First, we use non-blocking waitpid to get an event in the main
87 process, if any. Second, we use non-blocking waitpid with the __WCLONED
88 flag to check for events in cloned processes. If nothing is found, we use
89 sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
90 happened to a child process -- and SIGCHLD will be delivered both for events
91 in main debugged process and in cloned processes. As soon as we know there's
92 an event, we get back to calling nonblocking waitpid with and without
95 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
96 so that we don't miss a signal. If SIGCHLD arrives in between, when it's
97 blocked, the signal becomes pending and sigsuspend immediately
98 notices it and returns.
100 Waiting for events in async mode
101 ================================
103 In async mode, GDB should always be ready to handle both user input
104 and target events, so neither blocking waitpid nor sigsuspend are
105 viable options. Instead, we should asynchronously notify the GDB main
106 event loop whenever there's an unprocessed event from the target. We
107 detect asynchronous target events by handling SIGCHLD signals. To
108 notify the event loop about target events, the self-pipe trick is used
109 --- a pipe is registered as waitable event source in the event loop,
110 the event loop select/poll's on the read end of this pipe (as well on
111 other event sources, e.g., stdin), and the SIGCHLD handler writes a
112 byte to this pipe. This is more portable than relying on
113 pselect/ppoll, since on kernels that lack those syscalls, libc
114 emulates them with select/poll+sigprocmask, and that is racy
115 (a.k.a. plain broken).
117 Obviously, if we fail to notify the event loop if there's a target
118 event, it's bad. OTOH, if we notify the event loop when there's no
119 event from the target, linux_nat_wait will detect that there's no real
120 event to report, and return event of type TARGET_WAITKIND_IGNORE.
121 This is mostly harmless, but it will waste time and is better avoided.
123 The main design point is that every time GDB is outside linux-nat.c,
124 we have a SIGCHLD handler installed that is called when something
125 happens to the target and notifies the GDB event loop. Whenever GDB
126 core decides to handle the event, and calls into linux-nat.c, we
127 process things as in sync mode, except that the we never block in
130 While processing an event, we may end up momentarily blocked in
131 waitpid calls. Those waitpid calls, while blocking, are guarantied to
132 return quickly. E.g., in all-stop mode, before reporting to the core
133 that an LWP hit a breakpoint, all LWPs are stopped by sending them
134 SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
135 Note that this is different from blocking indefinitely waiting for the
136 next event --- here, we're already handling an event.
141 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
142 signal is not entirely significant; we just need for a signal to be delivered,
143 so that we can intercept it. SIGSTOP's advantage is that it can not be
144 blocked. A disadvantage is that it is not a real-time signal, so it can only
145 be queued once; we do not keep track of other sources of SIGSTOP.
147 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
148 use them, because they have special behavior when the signal is generated -
149 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
150 kills the entire thread group.
152 A delivered SIGSTOP would stop the entire thread group, not just the thread we
153 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
154 cancel it (by PTRACE_CONT without passing SIGSTOP).
156 We could use a real-time signal instead. This would solve those problems; we
157 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
158 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
159 generates it, and there are races with trying to find a signal that is not
163 #define O_LARGEFILE 0
166 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
167 the use of the multi-threaded target. */
168 static struct target_ops
*linux_ops
;
169 static struct target_ops linux_ops_saved
;
171 /* The method to call, if any, when a new thread is attached. */
172 static void (*linux_nat_new_thread
) (struct lwp_info
*);
174 /* The method to call, if any, when a new fork is attached. */
175 static linux_nat_new_fork_ftype
*linux_nat_new_fork
;
177 /* The method to call, if any, when a process is no longer
179 static linux_nat_forget_process_ftype
*linux_nat_forget_process_hook
;
181 /* Hook to call prior to resuming a thread. */
182 static void (*linux_nat_prepare_to_resume
) (struct lwp_info
*);
184 /* The method to call, if any, when the siginfo object needs to be
185 converted between the layout returned by ptrace, and the layout in
186 the architecture of the inferior. */
187 static int (*linux_nat_siginfo_fixup
) (siginfo_t
*,
191 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
192 Called by our to_xfer_partial. */
193 static target_xfer_partial_ftype
*super_xfer_partial
;
195 /* The saved to_close method, inherited from inf-ptrace.c.
196 Called by our to_close. */
197 static void (*super_close
) (struct target_ops
*);
199 static unsigned int debug_linux_nat
;
201 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
202 struct cmd_list_element
*c
, const char *value
)
204 fprintf_filtered (file
, _("Debugging of GNU/Linux lwp module is %s.\n"),
208 struct simple_pid_list
212 struct simple_pid_list
*next
;
214 struct simple_pid_list
*stopped_pids
;
216 /* Async mode support. */
218 /* The read/write ends of the pipe registered as waitable file in the
220 static int linux_nat_event_pipe
[2] = { -1, -1 };
222 /* True if we're currently in async mode. */
223 #define linux_is_async_p() (linux_nat_event_pipe[0] != -1)
225 /* Flush the event pipe. */
228 async_file_flush (void)
235 ret
= read (linux_nat_event_pipe
[0], &buf
, 1);
237 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
240 /* Put something (anything, doesn't matter what, or how much) in event
241 pipe, so that the select/poll in the event-loop realizes we have
242 something to process. */
245 async_file_mark (void)
249 /* It doesn't really matter what the pipe contains, as long we end
250 up with something in it. Might as well flush the previous
256 ret
= write (linux_nat_event_pipe
[1], "+", 1);
258 while (ret
== -1 && errno
== EINTR
);
260 /* Ignore EAGAIN. If the pipe is full, the event loop will already
261 be awakened anyway. */
264 static int kill_lwp (int lwpid
, int signo
);
266 static int stop_callback (struct lwp_info
*lp
, void *data
);
267 static int resume_stopped_resumed_lwps (struct lwp_info
*lp
, void *data
);
269 static void block_child_signals (sigset_t
*prev_mask
);
270 static void restore_child_signals_mask (sigset_t
*prev_mask
);
273 static struct lwp_info
*add_lwp (ptid_t ptid
);
274 static void purge_lwp_list (int pid
);
275 static void delete_lwp (ptid_t ptid
);
276 static struct lwp_info
*find_lwp_pid (ptid_t ptid
);
278 static int lwp_status_pending_p (struct lwp_info
*lp
);
280 static int check_stopped_by_breakpoint (struct lwp_info
*lp
);
281 static int sigtrap_is_event (int status
);
282 static int (*linux_nat_status_is_event
) (int status
) = sigtrap_is_event
;
287 /* See nat/linux-nat.h. */
290 ptid_of_lwp (struct lwp_info
*lwp
)
295 /* See nat/linux-nat.h. */
298 lwp_is_stopped (struct lwp_info
*lwp
)
303 /* See nat/linux-nat.h. */
305 enum target_stop_reason
306 lwp_stop_reason (struct lwp_info
*lwp
)
308 return lwp
->stop_reason
;
312 /* Trivial list manipulation functions to keep track of a list of
313 new stopped processes. */
315 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
317 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
320 new_pid
->status
= status
;
321 new_pid
->next
= *listp
;
326 in_pid_list_p (struct simple_pid_list
*list
, int pid
)
328 struct simple_pid_list
*p
;
330 for (p
= list
; p
!= NULL
; p
= p
->next
)
337 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
339 struct simple_pid_list
**p
;
341 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
342 if ((*p
)->pid
== pid
)
344 struct simple_pid_list
*next
= (*p
)->next
;
346 *statusp
= (*p
)->status
;
354 /* Initialize ptrace warnings and check for supported ptrace
357 ATTACHED should be nonzero iff we attached to the inferior. */
360 linux_init_ptrace (pid_t pid
, int attached
)
362 linux_enable_event_reporting (pid
, attached
);
363 linux_ptrace_init_warnings ();
367 linux_child_post_attach (struct target_ops
*self
, int pid
)
369 linux_init_ptrace (pid
, 1);
373 linux_child_post_startup_inferior (struct target_ops
*self
, ptid_t ptid
)
375 linux_init_ptrace (ptid_get_pid (ptid
), 0);
378 /* Return the number of known LWPs in the tgid given by PID. */
386 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
387 if (ptid_get_pid (lp
->ptid
) == pid
)
393 /* Call delete_lwp with prototype compatible for make_cleanup. */
396 delete_lwp_cleanup (void *lp_voidp
)
398 struct lwp_info
*lp
= lp_voidp
;
400 delete_lwp (lp
->ptid
);
403 /* Target hook for follow_fork. On entry inferior_ptid must be the
404 ptid of the followed inferior. At return, inferior_ptid will be
408 linux_child_follow_fork (struct target_ops
*ops
, int follow_child
,
413 struct lwp_info
*child_lp
= NULL
;
414 int status
= W_STOPCODE (0);
415 struct cleanup
*old_chain
;
417 ptid_t parent_ptid
, child_ptid
;
418 int parent_pid
, child_pid
;
420 has_vforked
= (inferior_thread ()->pending_follow
.kind
421 == TARGET_WAITKIND_VFORKED
);
422 parent_ptid
= inferior_ptid
;
423 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
424 parent_pid
= ptid_get_lwp (parent_ptid
);
425 child_pid
= ptid_get_lwp (child_ptid
);
427 /* We're already attached to the parent, by default. */
428 old_chain
= save_inferior_ptid ();
429 inferior_ptid
= child_ptid
;
430 child_lp
= add_lwp (inferior_ptid
);
431 child_lp
->stopped
= 1;
432 child_lp
->last_resume_kind
= resume_stop
;
434 /* Detach new forked process? */
437 make_cleanup (delete_lwp_cleanup
, child_lp
);
439 if (linux_nat_prepare_to_resume
!= NULL
)
440 linux_nat_prepare_to_resume (child_lp
);
442 /* When debugging an inferior in an architecture that supports
443 hardware single stepping on a kernel without commit
444 6580807da14c423f0d0a708108e6df6ebc8bc83d, the vfork child
445 process starts with the TIF_SINGLESTEP/X86_EFLAGS_TF bits
446 set if the parent process had them set.
447 To work around this, single step the child process
448 once before detaching to clear the flags. */
450 if (!gdbarch_software_single_step_p (target_thread_architecture
453 linux_disable_event_reporting (child_pid
);
454 if (ptrace (PTRACE_SINGLESTEP
, child_pid
, 0, 0) < 0)
455 perror_with_name (_("Couldn't do single step"));
456 if (my_waitpid (child_pid
, &status
, 0) < 0)
457 perror_with_name (_("Couldn't wait vfork process"));
460 if (WIFSTOPPED (status
))
464 signo
= WSTOPSIG (status
);
466 && !signal_pass_state (gdb_signal_from_host (signo
)))
468 ptrace (PTRACE_DETACH
, child_pid
, 0, signo
);
471 /* Resets value of inferior_ptid to parent ptid. */
472 do_cleanups (old_chain
);
476 /* Let the thread_db layer learn about this new process. */
477 check_for_thread_db ();
480 do_cleanups (old_chain
);
484 struct lwp_info
*parent_lp
;
486 parent_lp
= find_lwp_pid (parent_ptid
);
487 gdb_assert (linux_supports_tracefork () >= 0);
489 if (linux_supports_tracevforkdone ())
492 fprintf_unfiltered (gdb_stdlog
,
493 "LCFF: waiting for VFORK_DONE on %d\n",
495 parent_lp
->stopped
= 1;
497 /* We'll handle the VFORK_DONE event like any other
498 event, in target_wait. */
502 /* We can't insert breakpoints until the child has
503 finished with the shared memory region. We need to
504 wait until that happens. Ideal would be to just
506 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
507 - waitpid (parent_pid, &status, __WALL);
508 However, most architectures can't handle a syscall
509 being traced on the way out if it wasn't traced on
512 We might also think to loop, continuing the child
513 until it exits or gets a SIGTRAP. One problem is
514 that the child might call ptrace with PTRACE_TRACEME.
516 There's no simple and reliable way to figure out when
517 the vforked child will be done with its copy of the
518 shared memory. We could step it out of the syscall,
519 two instructions, let it go, and then single-step the
520 parent once. When we have hardware single-step, this
521 would work; with software single-step it could still
522 be made to work but we'd have to be able to insert
523 single-step breakpoints in the child, and we'd have
524 to insert -just- the single-step breakpoint in the
525 parent. Very awkward.
527 In the end, the best we can do is to make sure it
528 runs for a little while. Hopefully it will be out of
529 range of any breakpoints we reinsert. Usually this
530 is only the single-step breakpoint at vfork's return
534 fprintf_unfiltered (gdb_stdlog
,
535 "LCFF: no VFORK_DONE "
536 "support, sleeping a bit\n");
540 /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
541 and leave it pending. The next linux_nat_resume call
542 will notice a pending event, and bypasses actually
543 resuming the inferior. */
544 parent_lp
->status
= 0;
545 parent_lp
->waitstatus
.kind
= TARGET_WAITKIND_VFORK_DONE
;
546 parent_lp
->stopped
= 1;
548 /* If we're in async mode, need to tell the event loop
549 there's something here to process. */
550 if (target_is_async_p ())
557 struct lwp_info
*child_lp
;
559 child_lp
= add_lwp (inferior_ptid
);
560 child_lp
->stopped
= 1;
561 child_lp
->last_resume_kind
= resume_stop
;
563 /* Let the thread_db layer learn about this new process. */
564 check_for_thread_db ();
572 linux_child_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
574 return !linux_supports_tracefork ();
578 linux_child_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
584 linux_child_insert_vfork_catchpoint (struct target_ops
*self
, int pid
)
586 return !linux_supports_tracefork ();
590 linux_child_remove_vfork_catchpoint (struct target_ops
*self
, int pid
)
596 linux_child_insert_exec_catchpoint (struct target_ops
*self
, int pid
)
598 return !linux_supports_tracefork ();
602 linux_child_remove_exec_catchpoint (struct target_ops
*self
, int pid
)
608 linux_child_set_syscall_catchpoint (struct target_ops
*self
,
609 int pid
, int needed
, int any_count
,
610 int table_size
, int *table
)
612 if (!linux_supports_tracesysgood ())
615 /* On GNU/Linux, we ignore the arguments. It means that we only
616 enable the syscall catchpoints, but do not disable them.
618 Also, we do not use the `table' information because we do not
619 filter system calls here. We let GDB do the logic for us. */
623 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
624 are processes sharing the same VM space. A multi-threaded process
625 is basically a group of such processes. However, such a grouping
626 is almost entirely a user-space issue; the kernel doesn't enforce
627 such a grouping at all (this might change in the future). In
628 general, we'll rely on the threads library (i.e. the GNU/Linux
629 Threads library) to provide such a grouping.
631 It is perfectly well possible to write a multi-threaded application
632 without the assistance of a threads library, by using the clone
633 system call directly. This module should be able to give some
634 rudimentary support for debugging such applications if developers
635 specify the CLONE_PTRACE flag in the clone system call, and are
636 using the Linux kernel 2.4 or above.
638 Note that there are some peculiarities in GNU/Linux that affect
641 - In general one should specify the __WCLONE flag to waitpid in
642 order to make it report events for any of the cloned processes
643 (and leave it out for the initial process). However, if a cloned
644 process has exited the exit status is only reported if the
645 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
646 we cannot use it since GDB must work on older systems too.
648 - When a traced, cloned process exits and is waited for by the
649 debugger, the kernel reassigns it to the original parent and
650 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
651 library doesn't notice this, which leads to the "zombie problem":
652 When debugged a multi-threaded process that spawns a lot of
653 threads will run out of processes, even if the threads exit,
654 because the "zombies" stay around. */
656 /* List of known LWPs. */
657 struct lwp_info
*lwp_list
;
660 /* Original signal mask. */
661 static sigset_t normal_mask
;
663 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
664 _initialize_linux_nat. */
665 static sigset_t suspend_mask
;
667 /* Signals to block to make that sigsuspend work. */
668 static sigset_t blocked_mask
;
670 /* SIGCHLD action. */
671 struct sigaction sigchld_action
;
673 /* Block child signals (SIGCHLD and linux threads signals), and store
674 the previous mask in PREV_MASK. */
677 block_child_signals (sigset_t
*prev_mask
)
679 /* Make sure SIGCHLD is blocked. */
680 if (!sigismember (&blocked_mask
, SIGCHLD
))
681 sigaddset (&blocked_mask
, SIGCHLD
);
683 sigprocmask (SIG_BLOCK
, &blocked_mask
, prev_mask
);
686 /* Restore child signals mask, previously returned by
687 block_child_signals. */
690 restore_child_signals_mask (sigset_t
*prev_mask
)
692 sigprocmask (SIG_SETMASK
, prev_mask
, NULL
);
695 /* Mask of signals to pass directly to the inferior. */
696 static sigset_t pass_mask
;
698 /* Update signals to pass to the inferior. */
700 linux_nat_pass_signals (struct target_ops
*self
,
701 int numsigs
, unsigned char *pass_signals
)
705 sigemptyset (&pass_mask
);
707 for (signo
= 1; signo
< NSIG
; signo
++)
709 int target_signo
= gdb_signal_from_host (signo
);
710 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
711 sigaddset (&pass_mask
, signo
);
717 /* Prototypes for local functions. */
718 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
719 static int linux_thread_alive (ptid_t ptid
);
720 static char *linux_child_pid_to_exec_file (struct target_ops
*self
, int pid
);
721 static int resume_stopped_resumed_lwps (struct lwp_info
*lp
, void *data
);
725 /* Destroy and free LP. */
728 lwp_free (struct lwp_info
*lp
)
730 xfree (lp
->arch_private
);
734 /* Remove all LWPs belong to PID from the lwp list. */
737 purge_lwp_list (int pid
)
739 struct lwp_info
*lp
, *lpprev
, *lpnext
;
743 for (lp
= lwp_list
; lp
; lp
= lpnext
)
747 if (ptid_get_pid (lp
->ptid
) == pid
)
752 lpprev
->next
= lp
->next
;
761 /* Add the LWP specified by PTID to the list. PTID is the first LWP
762 in the process. Return a pointer to the structure describing the
765 This differs from add_lwp in that we don't let the arch specific
766 bits know about this new thread. Current clients of this callback
767 take the opportunity to install watchpoints in the new thread, and
768 we shouldn't do that for the first thread. If we're spawning a
769 child ("run"), the thread executes the shell wrapper first, and we
770 shouldn't touch it until it execs the program we want to debug.
771 For "attach", it'd be okay to call the callback, but it's not
772 necessary, because watchpoints can't yet have been inserted into
775 static struct lwp_info
*
776 add_initial_lwp (ptid_t ptid
)
780 gdb_assert (ptid_lwp_p (ptid
));
782 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
784 memset (lp
, 0, sizeof (struct lwp_info
));
786 lp
->last_resume_kind
= resume_continue
;
787 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
798 /* Add the LWP specified by PID to the list. Return a pointer to the
799 structure describing the new LWP. The LWP should already be
802 static struct lwp_info
*
803 add_lwp (ptid_t ptid
)
807 lp
= add_initial_lwp (ptid
);
809 /* Let the arch specific bits know about this new thread. Current
810 clients of this callback take the opportunity to install
811 watchpoints in the new thread. We don't do this for the first
812 thread though. See add_initial_lwp. */
813 if (linux_nat_new_thread
!= NULL
)
814 linux_nat_new_thread (lp
);
819 /* Remove the LWP specified by PID from the list. */
822 delete_lwp (ptid_t ptid
)
824 struct lwp_info
*lp
, *lpprev
;
828 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
829 if (ptid_equal (lp
->ptid
, ptid
))
836 lpprev
->next
= lp
->next
;
843 /* Return a pointer to the structure describing the LWP corresponding
844 to PID. If no corresponding LWP could be found, return NULL. */
846 static struct lwp_info
*
847 find_lwp_pid (ptid_t ptid
)
852 if (ptid_lwp_p (ptid
))
853 lwp
= ptid_get_lwp (ptid
);
855 lwp
= ptid_get_pid (ptid
);
857 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
858 if (lwp
== ptid_get_lwp (lp
->ptid
))
864 /* See nat/linux-nat.h. */
867 iterate_over_lwps (ptid_t filter
,
868 iterate_over_lwps_ftype callback
,
871 struct lwp_info
*lp
, *lpnext
;
873 for (lp
= lwp_list
; lp
; lp
= lpnext
)
877 if (ptid_match (lp
->ptid
, filter
))
879 if ((*callback
) (lp
, data
) != 0)
887 /* Update our internal state when changing from one checkpoint to
888 another indicated by NEW_PTID. We can only switch single-threaded
889 applications, so we only create one new LWP, and the previous list
893 linux_nat_switch_fork (ptid_t new_ptid
)
897 purge_lwp_list (ptid_get_pid (inferior_ptid
));
899 lp
= add_lwp (new_ptid
);
902 /* This changes the thread's ptid while preserving the gdb thread
903 num. Also changes the inferior pid, while preserving the
905 thread_change_ptid (inferior_ptid
, new_ptid
);
907 /* We've just told GDB core that the thread changed target id, but,
908 in fact, it really is a different thread, with different register
910 registers_changed ();
913 /* Handle the exit of a single thread LP. */
916 exit_lwp (struct lwp_info
*lp
)
918 struct thread_info
*th
= find_thread_ptid (lp
->ptid
);
922 if (print_thread_events
)
923 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp
->ptid
));
925 delete_thread (lp
->ptid
);
928 delete_lwp (lp
->ptid
);
931 /* Wait for the LWP specified by LP, which we have just attached to.
932 Returns a wait status for that LWP, to cache. */
935 linux_nat_post_attach_wait (ptid_t ptid
, int first
, int *cloned
,
938 pid_t new_pid
, pid
= ptid_get_lwp (ptid
);
941 if (linux_proc_pid_is_stopped (pid
))
944 fprintf_unfiltered (gdb_stdlog
,
945 "LNPAW: Attaching to a stopped process\n");
947 /* The process is definitely stopped. It is in a job control
948 stop, unless the kernel predates the TASK_STOPPED /
949 TASK_TRACED distinction, in which case it might be in a
950 ptrace stop. Make sure it is in a ptrace stop; from there we
951 can kill it, signal it, et cetera.
953 First make sure there is a pending SIGSTOP. Since we are
954 already attached, the process can not transition from stopped
955 to running without a PTRACE_CONT; so we know this signal will
956 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
957 probably already in the queue (unless this kernel is old
958 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
959 is not an RT signal, it can only be queued once. */
960 kill_lwp (pid
, SIGSTOP
);
962 /* Finally, resume the stopped process. This will deliver the SIGSTOP
963 (or a higher priority signal, just like normal PTRACE_ATTACH). */
964 ptrace (PTRACE_CONT
, pid
, 0, 0);
967 /* Make sure the initial process is stopped. The user-level threads
968 layer might want to poke around in the inferior, and that won't
969 work if things haven't stabilized yet. */
970 new_pid
= my_waitpid (pid
, &status
, 0);
971 if (new_pid
== -1 && errno
== ECHILD
)
974 warning (_("%s is a cloned process"), target_pid_to_str (ptid
));
976 /* Try again with __WCLONE to check cloned processes. */
977 new_pid
= my_waitpid (pid
, &status
, __WCLONE
);
981 gdb_assert (pid
== new_pid
);
983 if (!WIFSTOPPED (status
))
985 /* The pid we tried to attach has apparently just exited. */
987 fprintf_unfiltered (gdb_stdlog
, "LNPAW: Failed to stop %d: %s",
988 pid
, status_to_str (status
));
992 if (WSTOPSIG (status
) != SIGSTOP
)
996 fprintf_unfiltered (gdb_stdlog
,
997 "LNPAW: Received %s after attaching\n",
998 status_to_str (status
));
1004 /* Attach to the LWP specified by PID. Return 0 if successful, -1 if
1005 the new LWP could not be attached, or 1 if we're already auto
1006 attached to this thread, but haven't processed the
1007 PTRACE_EVENT_CLONE event of its parent thread, so we just ignore
1008 its existance, without considering it an error. */
1011 lin_lwp_attach_lwp (ptid_t ptid
)
1013 struct lwp_info
*lp
;
1016 gdb_assert (ptid_lwp_p (ptid
));
1018 lp
= find_lwp_pid (ptid
);
1019 lwpid
= ptid_get_lwp (ptid
);
1021 /* We assume that we're already attached to any LWP that is already
1022 in our list of LWPs. If we're not seeing exit events from threads
1023 and we've had PID wraparound since we last tried to stop all threads,
1024 this assumption might be wrong; fortunately, this is very unlikely
1028 int status
, cloned
= 0, signalled
= 0;
1030 if (ptrace (PTRACE_ATTACH
, lwpid
, 0, 0) < 0)
1032 if (linux_supports_tracefork ())
1034 /* If we haven't stopped all threads when we get here,
1035 we may have seen a thread listed in thread_db's list,
1036 but not processed the PTRACE_EVENT_CLONE yet. If
1037 that's the case, ignore this new thread, and let
1038 normal event handling discover it later. */
1039 if (in_pid_list_p (stopped_pids
, lwpid
))
1041 /* We've already seen this thread stop, but we
1042 haven't seen the PTRACE_EVENT_CLONE extended
1044 if (debug_linux_nat
)
1045 fprintf_unfiltered (gdb_stdlog
,
1046 "LLAL: attach failed, but already seen "
1047 "this thread %s stop\n",
1048 target_pid_to_str (ptid
));
1056 if (debug_linux_nat
)
1057 fprintf_unfiltered (gdb_stdlog
,
1058 "LLAL: attach failed, and haven't seen "
1059 "this thread %s stop yet\n",
1060 target_pid_to_str (ptid
));
1062 /* We may or may not be attached to the LWP already.
1063 Try waitpid on it. If that errors, we're not
1064 attached to the LWP yet. Otherwise, we're
1065 already attached. */
1066 gdb_assert (lwpid
> 0);
1067 new_pid
= my_waitpid (lwpid
, &status
, WNOHANG
);
1068 if (new_pid
== -1 && errno
== ECHILD
)
1069 new_pid
= my_waitpid (lwpid
, &status
, __WCLONE
| WNOHANG
);
1074 /* The child hasn't stopped for its initial
1075 SIGSTOP stop yet. */
1076 if (debug_linux_nat
)
1077 fprintf_unfiltered (gdb_stdlog
,
1078 "LLAL: child hasn't "
1081 else if (WIFSTOPPED (status
))
1083 if (debug_linux_nat
)
1084 fprintf_unfiltered (gdb_stdlog
,
1085 "LLAL: adding to stopped_pids\n");
1086 add_to_pid_list (&stopped_pids
, lwpid
, status
);
1093 /* If we fail to attach to the thread, issue a warning,
1094 but continue. One way this can happen is if thread
1095 creation is interrupted; as of Linux kernel 2.6.19, a
1096 bug may place threads in the thread list and then fail
1098 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
1099 safe_strerror (errno
));
1103 if (debug_linux_nat
)
1104 fprintf_unfiltered (gdb_stdlog
,
1105 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1106 target_pid_to_str (ptid
));
1108 status
= linux_nat_post_attach_wait (ptid
, 0, &cloned
, &signalled
);
1109 if (!WIFSTOPPED (status
))
1112 lp
= add_lwp (ptid
);
1114 lp
->last_resume_kind
= resume_stop
;
1115 lp
->cloned
= cloned
;
1116 lp
->signalled
= signalled
;
1117 if (WSTOPSIG (status
) != SIGSTOP
)
1120 lp
->status
= status
;
1123 target_post_attach (ptid_get_lwp (lp
->ptid
));
1125 if (debug_linux_nat
)
1127 fprintf_unfiltered (gdb_stdlog
,
1128 "LLAL: waitpid %s received %s\n",
1129 target_pid_to_str (ptid
),
1130 status_to_str (status
));
1138 linux_nat_create_inferior (struct target_ops
*ops
,
1139 char *exec_file
, char *allargs
, char **env
,
1142 struct cleanup
*restore_personality
1143 = maybe_disable_address_space_randomization (disable_randomization
);
1145 /* The fork_child mechanism is synchronous and calls target_wait, so
1146 we have to mask the async mode. */
1148 /* Make sure we report all signals during startup. */
1149 linux_nat_pass_signals (ops
, 0, NULL
);
1151 linux_ops
->to_create_inferior (ops
, exec_file
, allargs
, env
, from_tty
);
1153 do_cleanups (restore_personality
);
1156 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1157 already attached. Returns true if a new LWP is found, false
1161 attach_proc_task_lwp_callback (ptid_t ptid
)
1163 struct lwp_info
*lp
;
1165 /* Ignore LWPs we're already attached to. */
1166 lp
= find_lwp_pid (ptid
);
1169 int lwpid
= ptid_get_lwp (ptid
);
1171 if (ptrace (PTRACE_ATTACH
, lwpid
, 0, 0) < 0)
1175 /* Be quiet if we simply raced with the thread exiting.
1176 EPERM is returned if the thread's task still exists, and
1177 is marked as exited or zombie, as well as other
1178 conditions, so in that case, confirm the status in
1179 /proc/PID/status. */
1181 || (err
== EPERM
&& linux_proc_pid_is_gone (lwpid
)))
1183 if (debug_linux_nat
)
1185 fprintf_unfiltered (gdb_stdlog
,
1186 "Cannot attach to lwp %d: "
1187 "thread is gone (%d: %s)\n",
1188 lwpid
, err
, safe_strerror (err
));
1193 warning (_("Cannot attach to lwp %d: %s"),
1195 linux_ptrace_attach_fail_reason_string (ptid
,
1201 if (debug_linux_nat
)
1202 fprintf_unfiltered (gdb_stdlog
,
1203 "PTRACE_ATTACH %s, 0, 0 (OK)\n",
1204 target_pid_to_str (ptid
));
1206 lp
= add_lwp (ptid
);
1209 /* The next time we wait for this LWP we'll see a SIGSTOP as
1210 PTRACE_ATTACH brings it to a halt. */
1213 /* We need to wait for a stop before being able to make the
1214 next ptrace call on this LWP. */
1215 lp
->must_set_ptrace_flags
= 1;
1224 linux_nat_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1226 struct lwp_info
*lp
;
1230 /* Make sure we report all signals during attach. */
1231 linux_nat_pass_signals (ops
, 0, NULL
);
1235 linux_ops
->to_attach (ops
, args
, from_tty
);
1237 CATCH (ex
, RETURN_MASK_ERROR
)
1239 pid_t pid
= parse_pid_to_attach (args
);
1240 struct buffer buffer
;
1241 char *message
, *buffer_s
;
1243 message
= xstrdup (ex
.message
);
1244 make_cleanup (xfree
, message
);
1246 buffer_init (&buffer
);
1247 linux_ptrace_attach_fail_reason (pid
, &buffer
);
1249 buffer_grow_str0 (&buffer
, "");
1250 buffer_s
= buffer_finish (&buffer
);
1251 make_cleanup (xfree
, buffer_s
);
1253 if (*buffer_s
!= '\0')
1254 throw_error (ex
.error
, "warning: %s\n%s", buffer_s
, message
);
1256 throw_error (ex
.error
, "%s", message
);
1260 /* The ptrace base target adds the main thread with (pid,0,0)
1261 format. Decorate it with lwp info. */
1262 ptid
= ptid_build (ptid_get_pid (inferior_ptid
),
1263 ptid_get_pid (inferior_ptid
),
1265 thread_change_ptid (inferior_ptid
, ptid
);
1267 /* Add the initial process as the first LWP to the list. */
1268 lp
= add_initial_lwp (ptid
);
1270 status
= linux_nat_post_attach_wait (lp
->ptid
, 1, &lp
->cloned
,
1272 if (!WIFSTOPPED (status
))
1274 if (WIFEXITED (status
))
1276 int exit_code
= WEXITSTATUS (status
);
1278 target_terminal_ours ();
1279 target_mourn_inferior ();
1281 error (_("Unable to attach: program exited normally."));
1283 error (_("Unable to attach: program exited with code %d."),
1286 else if (WIFSIGNALED (status
))
1288 enum gdb_signal signo
;
1290 target_terminal_ours ();
1291 target_mourn_inferior ();
1293 signo
= gdb_signal_from_host (WTERMSIG (status
));
1294 error (_("Unable to attach: program terminated with signal "
1296 gdb_signal_to_name (signo
),
1297 gdb_signal_to_string (signo
));
1300 internal_error (__FILE__
, __LINE__
,
1301 _("unexpected status %d for PID %ld"),
1302 status
, (long) ptid_get_lwp (ptid
));
1307 /* Save the wait status to report later. */
1309 if (debug_linux_nat
)
1310 fprintf_unfiltered (gdb_stdlog
,
1311 "LNA: waitpid %ld, saving status %s\n",
1312 (long) ptid_get_pid (lp
->ptid
), status_to_str (status
));
1314 lp
->status
= status
;
1316 /* We must attach to every LWP. If /proc is mounted, use that to
1317 find them now. The inferior may be using raw clone instead of
1318 using pthreads. But even if it is using pthreads, thread_db
1319 walks structures in the inferior's address space to find the list
1320 of threads/LWPs, and those structures may well be corrupted.
1321 Note that once thread_db is loaded, we'll still use it to list
1322 threads and associate pthread info with each LWP. */
1323 linux_proc_attach_tgid_threads (ptid_get_pid (lp
->ptid
),
1324 attach_proc_task_lwp_callback
);
1326 if (target_can_async_p ())
1327 target_async (inferior_event_handler
, 0);
1330 /* Get pending status of LP. */
1332 get_pending_status (struct lwp_info
*lp
, int *status
)
1334 enum gdb_signal signo
= GDB_SIGNAL_0
;
1336 /* If we paused threads momentarily, we may have stored pending
1337 events in lp->status or lp->waitstatus (see stop_wait_callback),
1338 and GDB core hasn't seen any signal for those threads.
1339 Otherwise, the last signal reported to the core is found in the
1340 thread object's stop_signal.
1342 There's a corner case that isn't handled here at present. Only
1343 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1344 stop_signal make sense as a real signal to pass to the inferior.
1345 Some catchpoint related events, like
1346 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1347 to GDB_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1348 those traps are debug API (ptrace in our case) related and
1349 induced; the inferior wouldn't see them if it wasn't being
1350 traced. Hence, we should never pass them to the inferior, even
1351 when set to pass state. Since this corner case isn't handled by
1352 infrun.c when proceeding with a signal, for consistency, neither
1353 do we handle it here (or elsewhere in the file we check for
1354 signal pass state). Normally SIGTRAP isn't set to pass state, so
1355 this is really a corner case. */
1357 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
1358 signo
= GDB_SIGNAL_0
; /* a pending ptrace event, not a real signal. */
1359 else if (lp
->status
)
1360 signo
= gdb_signal_from_host (WSTOPSIG (lp
->status
));
1361 else if (non_stop
&& !is_executing (lp
->ptid
))
1363 struct thread_info
*tp
= find_thread_ptid (lp
->ptid
);
1365 signo
= tp
->suspend
.stop_signal
;
1369 struct target_waitstatus last
;
1372 get_last_target_status (&last_ptid
, &last
);
1374 if (ptid_get_lwp (lp
->ptid
) == ptid_get_lwp (last_ptid
))
1376 struct thread_info
*tp
= find_thread_ptid (lp
->ptid
);
1378 signo
= tp
->suspend
.stop_signal
;
1384 if (signo
== GDB_SIGNAL_0
)
1386 if (debug_linux_nat
)
1387 fprintf_unfiltered (gdb_stdlog
,
1388 "GPT: lwp %s has no pending signal\n",
1389 target_pid_to_str (lp
->ptid
));
1391 else if (!signal_pass_state (signo
))
1393 if (debug_linux_nat
)
1394 fprintf_unfiltered (gdb_stdlog
,
1395 "GPT: lwp %s had signal %s, "
1396 "but it is in no pass state\n",
1397 target_pid_to_str (lp
->ptid
),
1398 gdb_signal_to_string (signo
));
1402 *status
= W_STOPCODE (gdb_signal_to_host (signo
));
1404 if (debug_linux_nat
)
1405 fprintf_unfiltered (gdb_stdlog
,
1406 "GPT: lwp %s has pending signal %s\n",
1407 target_pid_to_str (lp
->ptid
),
1408 gdb_signal_to_string (signo
));
1415 detach_callback (struct lwp_info
*lp
, void *data
)
1417 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1419 if (debug_linux_nat
&& lp
->status
)
1420 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
1421 strsignal (WSTOPSIG (lp
->status
)),
1422 target_pid_to_str (lp
->ptid
));
1424 /* If there is a pending SIGSTOP, get rid of it. */
1427 if (debug_linux_nat
)
1428 fprintf_unfiltered (gdb_stdlog
,
1429 "DC: Sending SIGCONT to %s\n",
1430 target_pid_to_str (lp
->ptid
));
1432 kill_lwp (ptid_get_lwp (lp
->ptid
), SIGCONT
);
1436 /* We don't actually detach from the LWP that has an id equal to the
1437 overall process id just yet. */
1438 if (ptid_get_lwp (lp
->ptid
) != ptid_get_pid (lp
->ptid
))
1442 /* Pass on any pending signal for this LWP. */
1443 get_pending_status (lp
, &status
);
1445 if (linux_nat_prepare_to_resume
!= NULL
)
1446 linux_nat_prepare_to_resume (lp
);
1448 if (ptrace (PTRACE_DETACH
, ptid_get_lwp (lp
->ptid
), 0,
1449 WSTOPSIG (status
)) < 0)
1450 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1451 safe_strerror (errno
));
1453 if (debug_linux_nat
)
1454 fprintf_unfiltered (gdb_stdlog
,
1455 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1456 target_pid_to_str (lp
->ptid
),
1457 strsignal (WSTOPSIG (status
)));
1459 delete_lwp (lp
->ptid
);
1466 linux_nat_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1470 struct lwp_info
*main_lwp
;
1472 pid
= ptid_get_pid (inferior_ptid
);
1474 /* Don't unregister from the event loop, as there may be other
1475 inferiors running. */
1477 /* Stop all threads before detaching. ptrace requires that the
1478 thread is stopped to sucessfully detach. */
1479 iterate_over_lwps (pid_to_ptid (pid
), stop_callback
, NULL
);
1480 /* ... and wait until all of them have reported back that
1481 they're no longer running. */
1482 iterate_over_lwps (pid_to_ptid (pid
), stop_wait_callback
, NULL
);
1484 iterate_over_lwps (pid_to_ptid (pid
), detach_callback
, NULL
);
1486 /* Only the initial process should be left right now. */
1487 gdb_assert (num_lwps (ptid_get_pid (inferior_ptid
)) == 1);
1489 main_lwp
= find_lwp_pid (pid_to_ptid (pid
));
1491 /* Pass on any pending signal for the last LWP. */
1492 if ((args
== NULL
|| *args
== '\0')
1493 && get_pending_status (main_lwp
, &status
) != -1
1494 && WIFSTOPPED (status
))
1498 /* Put the signal number in ARGS so that inf_ptrace_detach will
1499 pass it along with PTRACE_DETACH. */
1501 xsnprintf (tem
, 8, "%d", (int) WSTOPSIG (status
));
1503 if (debug_linux_nat
)
1504 fprintf_unfiltered (gdb_stdlog
,
1505 "LND: Sending signal %s to %s\n",
1507 target_pid_to_str (main_lwp
->ptid
));
1510 if (linux_nat_prepare_to_resume
!= NULL
)
1511 linux_nat_prepare_to_resume (main_lwp
);
1512 delete_lwp (main_lwp
->ptid
);
1514 if (forks_exist_p ())
1516 /* Multi-fork case. The current inferior_ptid is being detached
1517 from, but there are other viable forks to debug. Detach from
1518 the current fork, and context-switch to the first
1520 linux_fork_detach (args
, from_tty
);
1523 linux_ops
->to_detach (ops
, args
, from_tty
);
1526 /* Resume execution of the inferior process. If STEP is nonzero,
1527 single-step it. If SIGNAL is nonzero, give it that signal. */
1530 linux_resume_one_lwp_throw (struct lwp_info
*lp
, int step
,
1531 enum gdb_signal signo
)
1535 /* stop_pc doubles as the PC the LWP had when it was last resumed.
1536 We only presently need that if the LWP is stepped though (to
1537 handle the case of stepping a breakpoint instruction). */
1540 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
1542 lp
->stop_pc
= regcache_read_pc (regcache
);
1547 if (linux_nat_prepare_to_resume
!= NULL
)
1548 linux_nat_prepare_to_resume (lp
);
1549 linux_ops
->to_resume (linux_ops
, lp
->ptid
, step
, signo
);
1551 /* Successfully resumed. Clear state that no longer makes sense,
1552 and mark the LWP as running. Must not do this before resuming
1553 otherwise if that fails other code will be confused. E.g., we'd
1554 later try to stop the LWP and hang forever waiting for a stop
1555 status. Note that we must not throw after this is cleared,
1556 otherwise handle_zombie_lwp_error would get confused. */
1558 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1559 registers_changed_ptid (lp
->ptid
);
1562 /* Called when we try to resume a stopped LWP and that errors out. If
1563 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
1564 or about to become), discard the error, clear any pending status
1565 the LWP may have, and return true (we'll collect the exit status
1566 soon enough). Otherwise, return false. */
1569 check_ptrace_stopped_lwp_gone (struct lwp_info
*lp
)
1571 /* If we get an error after resuming the LWP successfully, we'd
1572 confuse !T state for the LWP being gone. */
1573 gdb_assert (lp
->stopped
);
1575 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
1576 because even if ptrace failed with ESRCH, the tracee may be "not
1577 yet fully dead", but already refusing ptrace requests. In that
1578 case the tracee has 'R (Running)' state for a little bit
1579 (observed in Linux 3.18). See also the note on ESRCH in the
1580 ptrace(2) man page. Instead, check whether the LWP has any state
1581 other than ptrace-stopped. */
1583 /* Don't assume anything if /proc/PID/status can't be read. */
1584 if (linux_proc_pid_is_trace_stopped_nowarn (ptid_get_lwp (lp
->ptid
)) == 0)
1586 lp
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1588 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
1594 /* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
1595 disappears while we try to resume it. */
1598 linux_resume_one_lwp (struct lwp_info
*lp
, int step
, enum gdb_signal signo
)
1602 linux_resume_one_lwp_throw (lp
, step
, signo
);
1604 CATCH (ex
, RETURN_MASK_ERROR
)
1606 if (!check_ptrace_stopped_lwp_gone (lp
))
1607 throw_exception (ex
);
1615 resume_lwp (struct lwp_info
*lp
, int step
, enum gdb_signal signo
)
1619 struct inferior
*inf
= find_inferior_ptid (lp
->ptid
);
1621 if (inf
->vfork_child
!= NULL
)
1623 if (debug_linux_nat
)
1624 fprintf_unfiltered (gdb_stdlog
,
1625 "RC: Not resuming %s (vfork parent)\n",
1626 target_pid_to_str (lp
->ptid
));
1628 else if (!lwp_status_pending_p (lp
))
1630 if (debug_linux_nat
)
1631 fprintf_unfiltered (gdb_stdlog
,
1632 "RC: Resuming sibling %s, %s, %s\n",
1633 target_pid_to_str (lp
->ptid
),
1634 (signo
!= GDB_SIGNAL_0
1635 ? strsignal (gdb_signal_to_host (signo
))
1637 step
? "step" : "resume");
1639 linux_resume_one_lwp (lp
, step
, signo
);
1643 if (debug_linux_nat
)
1644 fprintf_unfiltered (gdb_stdlog
,
1645 "RC: Not resuming sibling %s (has pending)\n",
1646 target_pid_to_str (lp
->ptid
));
1651 if (debug_linux_nat
)
1652 fprintf_unfiltered (gdb_stdlog
,
1653 "RC: Not resuming sibling %s (not stopped)\n",
1654 target_pid_to_str (lp
->ptid
));
1658 /* Callback for iterate_over_lwps. If LWP is EXCEPT, do nothing.
1659 Resume LWP with the last stop signal, if it is in pass state. */
1662 linux_nat_resume_callback (struct lwp_info
*lp
, void *except
)
1664 enum gdb_signal signo
= GDB_SIGNAL_0
;
1671 struct thread_info
*thread
;
1673 thread
= find_thread_ptid (lp
->ptid
);
1676 signo
= thread
->suspend
.stop_signal
;
1677 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
1681 resume_lwp (lp
, 0, signo
);
1686 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1689 lp
->last_resume_kind
= resume_stop
;
1694 resume_set_callback (struct lwp_info
*lp
, void *data
)
1697 lp
->last_resume_kind
= resume_continue
;
1702 linux_nat_resume (struct target_ops
*ops
,
1703 ptid_t ptid
, int step
, enum gdb_signal signo
)
1705 struct lwp_info
*lp
;
1708 if (debug_linux_nat
)
1709 fprintf_unfiltered (gdb_stdlog
,
1710 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1711 step
? "step" : "resume",
1712 target_pid_to_str (ptid
),
1713 (signo
!= GDB_SIGNAL_0
1714 ? strsignal (gdb_signal_to_host (signo
)) : "0"),
1715 target_pid_to_str (inferior_ptid
));
1717 /* A specific PTID means `step only this process id'. */
1718 resume_many
= (ptid_equal (minus_one_ptid
, ptid
)
1719 || ptid_is_pid (ptid
));
1721 /* Mark the lwps we're resuming as resumed. */
1722 iterate_over_lwps (ptid
, resume_set_callback
, NULL
);
1724 /* See if it's the current inferior that should be handled
1727 lp
= find_lwp_pid (inferior_ptid
);
1729 lp
= find_lwp_pid (ptid
);
1730 gdb_assert (lp
!= NULL
);
1732 /* Remember if we're stepping. */
1733 lp
->last_resume_kind
= step
? resume_step
: resume_continue
;
1735 /* If we have a pending wait status for this thread, there is no
1736 point in resuming the process. But first make sure that
1737 linux_nat_wait won't preemptively handle the event - we
1738 should never take this short-circuit if we are going to
1739 leave LP running, since we have skipped resuming all the
1740 other threads. This bit of code needs to be synchronized
1741 with linux_nat_wait. */
1743 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1746 && WSTOPSIG (lp
->status
)
1747 && sigismember (&pass_mask
, WSTOPSIG (lp
->status
)))
1749 if (debug_linux_nat
)
1750 fprintf_unfiltered (gdb_stdlog
,
1751 "LLR: Not short circuiting for ignored "
1752 "status 0x%x\n", lp
->status
);
1754 /* FIXME: What should we do if we are supposed to continue
1755 this thread with a signal? */
1756 gdb_assert (signo
== GDB_SIGNAL_0
);
1757 signo
= gdb_signal_from_host (WSTOPSIG (lp
->status
));
1762 if (lwp_status_pending_p (lp
))
1764 /* FIXME: What should we do if we are supposed to continue
1765 this thread with a signal? */
1766 gdb_assert (signo
== GDB_SIGNAL_0
);
1768 if (debug_linux_nat
)
1769 fprintf_unfiltered (gdb_stdlog
,
1770 "LLR: Short circuiting for status 0x%x\n",
1773 if (target_can_async_p ())
1775 target_async (inferior_event_handler
, 0);
1776 /* Tell the event loop we have something to process. */
1783 iterate_over_lwps (ptid
, linux_nat_resume_callback
, lp
);
1785 linux_resume_one_lwp (lp
, step
, signo
);
1787 if (debug_linux_nat
)
1788 fprintf_unfiltered (gdb_stdlog
,
1789 "LLR: %s %s, %s (resume event thread)\n",
1790 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1791 target_pid_to_str (ptid
),
1792 (signo
!= GDB_SIGNAL_0
1793 ? strsignal (gdb_signal_to_host (signo
)) : "0"));
1795 if (target_can_async_p ())
1796 target_async (inferior_event_handler
, 0);
1799 /* Send a signal to an LWP. */
1802 kill_lwp (int lwpid
, int signo
)
1804 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1805 fails, then we are not using nptl threads and we should be using kill. */
1807 #ifdef HAVE_TKILL_SYSCALL
1809 static int tkill_failed
;
1816 ret
= syscall (__NR_tkill
, lwpid
, signo
);
1817 if (errno
!= ENOSYS
)
1824 return kill (lwpid
, signo
);
1827 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
1828 event, check if the core is interested in it: if not, ignore the
1829 event, and keep waiting; otherwise, we need to toggle the LWP's
1830 syscall entry/exit status, since the ptrace event itself doesn't
1831 indicate it, and report the trap to higher layers. */
1834 linux_handle_syscall_trap (struct lwp_info
*lp
, int stopping
)
1836 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1837 struct gdbarch
*gdbarch
= target_thread_architecture (lp
->ptid
);
1838 int syscall_number
= (int) gdbarch_get_syscall_number (gdbarch
, lp
->ptid
);
1842 /* If we're stopping threads, there's a SIGSTOP pending, which
1843 makes it so that the LWP reports an immediate syscall return,
1844 followed by the SIGSTOP. Skip seeing that "return" using
1845 PTRACE_CONT directly, and let stop_wait_callback collect the
1846 SIGSTOP. Later when the thread is resumed, a new syscall
1847 entry event. If we didn't do this (and returned 0), we'd
1848 leave a syscall entry pending, and our caller, by using
1849 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1850 itself. Later, when the user re-resumes this LWP, we'd see
1851 another syscall entry event and we'd mistake it for a return.
1853 If stop_wait_callback didn't force the SIGSTOP out of the LWP
1854 (leaving immediately with LWP->signalled set, without issuing
1855 a PTRACE_CONT), it would still be problematic to leave this
1856 syscall enter pending, as later when the thread is resumed,
1857 it would then see the same syscall exit mentioned above,
1858 followed by the delayed SIGSTOP, while the syscall didn't
1859 actually get to execute. It seems it would be even more
1860 confusing to the user. */
1862 if (debug_linux_nat
)
1863 fprintf_unfiltered (gdb_stdlog
,
1864 "LHST: ignoring syscall %d "
1865 "for LWP %ld (stopping threads), "
1866 "resuming with PTRACE_CONT for SIGSTOP\n",
1868 ptid_get_lwp (lp
->ptid
));
1870 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
1871 ptrace (PTRACE_CONT
, ptid_get_lwp (lp
->ptid
), 0, 0);
1876 if (catch_syscall_enabled ())
1878 /* Always update the entry/return state, even if this particular
1879 syscall isn't interesting to the core now. In async mode,
1880 the user could install a new catchpoint for this syscall
1881 between syscall enter/return, and we'll need to know to
1882 report a syscall return if that happens. */
1883 lp
->syscall_state
= (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
1884 ? TARGET_WAITKIND_SYSCALL_RETURN
1885 : TARGET_WAITKIND_SYSCALL_ENTRY
);
1887 if (catching_syscall_number (syscall_number
))
1889 /* Alright, an event to report. */
1890 ourstatus
->kind
= lp
->syscall_state
;
1891 ourstatus
->value
.syscall_number
= syscall_number
;
1893 if (debug_linux_nat
)
1894 fprintf_unfiltered (gdb_stdlog
,
1895 "LHST: stopping for %s of syscall %d"
1898 == TARGET_WAITKIND_SYSCALL_ENTRY
1899 ? "entry" : "return",
1901 ptid_get_lwp (lp
->ptid
));
1905 if (debug_linux_nat
)
1906 fprintf_unfiltered (gdb_stdlog
,
1907 "LHST: ignoring %s of syscall %d "
1909 lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
1910 ? "entry" : "return",
1912 ptid_get_lwp (lp
->ptid
));
1916 /* If we had been syscall tracing, and hence used PT_SYSCALL
1917 before on this LWP, it could happen that the user removes all
1918 syscall catchpoints before we get to process this event.
1919 There are two noteworthy issues here:
1921 - When stopped at a syscall entry event, resuming with
1922 PT_STEP still resumes executing the syscall and reports a
1925 - Only PT_SYSCALL catches syscall enters. If we last
1926 single-stepped this thread, then this event can't be a
1927 syscall enter. If we last single-stepped this thread, this
1928 has to be a syscall exit.
1930 The points above mean that the next resume, be it PT_STEP or
1931 PT_CONTINUE, can not trigger a syscall trace event. */
1932 if (debug_linux_nat
)
1933 fprintf_unfiltered (gdb_stdlog
,
1934 "LHST: caught syscall event "
1935 "with no syscall catchpoints."
1936 " %d for LWP %ld, ignoring\n",
1938 ptid_get_lwp (lp
->ptid
));
1939 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
1942 /* The core isn't interested in this event. For efficiency, avoid
1943 stopping all threads only to have the core resume them all again.
1944 Since we're not stopping threads, if we're still syscall tracing
1945 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1946 subsequent syscall. Simply resume using the inf-ptrace layer,
1947 which knows when to use PT_SYSCALL or PT_CONTINUE. */
1949 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
1953 /* Handle a GNU/Linux extended wait response. If we see a clone
1954 event, we need to add the new LWP to our list (and not report the
1955 trap to higher layers). This function returns non-zero if the
1956 event should be ignored and we should wait again. If STOPPING is
1957 true, the new LWP remains stopped, otherwise it is continued. */
1960 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
1963 int pid
= ptid_get_lwp (lp
->ptid
);
1964 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1965 int event
= linux_ptrace_get_extended_event (status
);
1967 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1968 || event
== PTRACE_EVENT_CLONE
)
1970 unsigned long new_pid
;
1973 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1975 /* If we haven't already seen the new PID stop, wait for it now. */
1976 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1978 /* The new child has a pending SIGSTOP. We can't affect it until it
1979 hits the SIGSTOP, but we're already attached. */
1980 ret
= my_waitpid (new_pid
, &status
,
1981 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
1983 perror_with_name (_("waiting for new child"));
1984 else if (ret
!= new_pid
)
1985 internal_error (__FILE__
, __LINE__
,
1986 _("wait returned unexpected PID %d"), ret
);
1987 else if (!WIFSTOPPED (status
))
1988 internal_error (__FILE__
, __LINE__
,
1989 _("wait returned unexpected status 0x%x"), status
);
1992 ourstatus
->value
.related_pid
= ptid_build (new_pid
, new_pid
, 0);
1994 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
)
1996 /* The arch-specific native code may need to know about new
1997 forks even if those end up never mapped to an
1999 if (linux_nat_new_fork
!= NULL
)
2000 linux_nat_new_fork (lp
, new_pid
);
2003 if (event
== PTRACE_EVENT_FORK
2004 && linux_fork_checkpointing_p (ptid_get_pid (lp
->ptid
)))
2006 /* Handle checkpointing by linux-fork.c here as a special
2007 case. We don't want the follow-fork-mode or 'catch fork'
2008 to interfere with this. */
2010 /* This won't actually modify the breakpoint list, but will
2011 physically remove the breakpoints from the child. */
2012 detach_breakpoints (ptid_build (new_pid
, new_pid
, 0));
2014 /* Retain child fork in ptrace (stopped) state. */
2015 if (!find_fork_pid (new_pid
))
2018 /* Report as spurious, so that infrun doesn't want to follow
2019 this fork. We're actually doing an infcall in
2021 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
2023 /* Report the stop to the core. */
2027 if (event
== PTRACE_EVENT_FORK
)
2028 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
2029 else if (event
== PTRACE_EVENT_VFORK
)
2030 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
2033 struct lwp_info
*new_lp
;
2035 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2037 if (debug_linux_nat
)
2038 fprintf_unfiltered (gdb_stdlog
,
2039 "LHEW: Got clone event "
2040 "from LWP %d, new child is LWP %ld\n",
2043 new_lp
= add_lwp (ptid_build (ptid_get_pid (lp
->ptid
), new_pid
, 0));
2045 new_lp
->stopped
= 1;
2047 if (WSTOPSIG (status
) != SIGSTOP
)
2049 /* This can happen if someone starts sending signals to
2050 the new thread before it gets a chance to run, which
2051 have a lower number than SIGSTOP (e.g. SIGUSR1).
2052 This is an unlikely case, and harder to handle for
2053 fork / vfork than for clone, so we do not try - but
2054 we handle it for clone events here. We'll send
2055 the other signal on to the thread below. */
2057 new_lp
->signalled
= 1;
2061 struct thread_info
*tp
;
2063 /* When we stop for an event in some other thread, and
2064 pull the thread list just as this thread has cloned,
2065 we'll have seen the new thread in the thread_db list
2066 before handling the CLONE event (glibc's
2067 pthread_create adds the new thread to the thread list
2068 before clone'ing, and has the kernel fill in the
2069 thread's tid on the clone call with
2070 CLONE_PARENT_SETTID). If that happened, and the core
2071 had requested the new thread to stop, we'll have
2072 killed it with SIGSTOP. But since SIGSTOP is not an
2073 RT signal, it can only be queued once. We need to be
2074 careful to not resume the LWP if we wanted it to
2075 stop. In that case, we'll leave the SIGSTOP pending.
2076 It will later be reported as GDB_SIGNAL_0. */
2077 tp
= find_thread_ptid (new_lp
->ptid
);
2078 if (tp
!= NULL
&& tp
->stop_requested
)
2079 new_lp
->last_resume_kind
= resume_stop
;
2084 /* If the thread_db layer is active, let it record the user
2085 level thread id and status, and add the thread to GDB's
2087 if (!thread_db_notice_clone (lp
->ptid
, new_lp
->ptid
))
2089 /* The process is not using thread_db. Add the LWP to
2091 target_post_attach (ptid_get_lwp (new_lp
->ptid
));
2092 add_thread (new_lp
->ptid
);
2097 set_running (new_lp
->ptid
, 1);
2098 set_executing (new_lp
->ptid
, 1);
2099 /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
2101 new_lp
->last_resume_kind
= resume_continue
;
2106 /* We created NEW_LP so it cannot yet contain STATUS. */
2107 gdb_assert (new_lp
->status
== 0);
2109 /* Save the wait status to report later. */
2110 if (debug_linux_nat
)
2111 fprintf_unfiltered (gdb_stdlog
,
2112 "LHEW: waitpid of new LWP %ld, "
2113 "saving status %s\n",
2114 (long) ptid_get_lwp (new_lp
->ptid
),
2115 status_to_str (status
));
2116 new_lp
->status
= status
;
2119 new_lp
->resumed
= !stopping
;
2126 if (event
== PTRACE_EVENT_EXEC
)
2128 if (debug_linux_nat
)
2129 fprintf_unfiltered (gdb_stdlog
,
2130 "LHEW: Got exec event from LWP %ld\n",
2131 ptid_get_lwp (lp
->ptid
));
2133 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
2134 ourstatus
->value
.execd_pathname
2135 = xstrdup (linux_child_pid_to_exec_file (NULL
, pid
));
2137 /* The thread that execed must have been resumed, but, when a
2138 thread execs, it changes its tid to the tgid, and the old
2139 tgid thread might have not been resumed. */
2144 if (event
== PTRACE_EVENT_VFORK_DONE
)
2146 if (current_inferior ()->waiting_for_vfork_done
)
2148 if (debug_linux_nat
)
2149 fprintf_unfiltered (gdb_stdlog
,
2150 "LHEW: Got expected PTRACE_EVENT_"
2151 "VFORK_DONE from LWP %ld: stopping\n",
2152 ptid_get_lwp (lp
->ptid
));
2154 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
2158 if (debug_linux_nat
)
2159 fprintf_unfiltered (gdb_stdlog
,
2160 "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2161 "from LWP %ld: ignoring\n",
2162 ptid_get_lwp (lp
->ptid
));
2166 internal_error (__FILE__
, __LINE__
,
2167 _("unknown ptrace event %d"), event
);
2170 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2174 wait_lwp (struct lwp_info
*lp
)
2178 int thread_dead
= 0;
2181 gdb_assert (!lp
->stopped
);
2182 gdb_assert (lp
->status
== 0);
2184 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2185 block_child_signals (&prev_mask
);
2189 /* If my_waitpid returns 0 it means the __WCLONE vs. non-__WCLONE kind
2190 was right and we should just call sigsuspend. */
2192 pid
= my_waitpid (ptid_get_lwp (lp
->ptid
), &status
, WNOHANG
);
2193 if (pid
== -1 && errno
== ECHILD
)
2194 pid
= my_waitpid (ptid_get_lwp (lp
->ptid
), &status
, __WCLONE
| WNOHANG
);
2195 if (pid
== -1 && errno
== ECHILD
)
2197 /* The thread has previously exited. We need to delete it
2198 now because, for some vendor 2.4 kernels with NPTL
2199 support backported, there won't be an exit event unless
2200 it is the main thread. 2.6 kernels will report an exit
2201 event for each thread that exits, as expected. */
2203 if (debug_linux_nat
)
2204 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
2205 target_pid_to_str (lp
->ptid
));
2210 /* Bugs 10970, 12702.
2211 Thread group leader may have exited in which case we'll lock up in
2212 waitpid if there are other threads, even if they are all zombies too.
2213 Basically, we're not supposed to use waitpid this way.
2214 __WCLONE is not applicable for the leader so we can't use that.
2215 LINUX_NAT_THREAD_ALIVE cannot be used here as it requires a STOPPED
2216 process; it gets ESRCH both for the zombie and for running processes.
2218 As a workaround, check if we're waiting for the thread group leader and
2219 if it's a zombie, and avoid calling waitpid if it is.
2221 This is racy, what if the tgl becomes a zombie right after we check?
2222 Therefore always use WNOHANG with sigsuspend - it is equivalent to
2223 waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
2225 if (ptid_get_pid (lp
->ptid
) == ptid_get_lwp (lp
->ptid
)
2226 && linux_proc_pid_is_zombie (ptid_get_lwp (lp
->ptid
)))
2229 if (debug_linux_nat
)
2230 fprintf_unfiltered (gdb_stdlog
,
2231 "WL: Thread group leader %s vanished.\n",
2232 target_pid_to_str (lp
->ptid
));
2236 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2237 get invoked despite our caller had them intentionally blocked by
2238 block_child_signals. This is sensitive only to the loop of
2239 linux_nat_wait_1 and there if we get called my_waitpid gets called
2240 again before it gets to sigsuspend so we can safely let the handlers
2241 get executed here. */
2243 if (debug_linux_nat
)
2244 fprintf_unfiltered (gdb_stdlog
, "WL: about to sigsuspend\n");
2245 sigsuspend (&suspend_mask
);
2248 restore_child_signals_mask (&prev_mask
);
2252 gdb_assert (pid
== ptid_get_lwp (lp
->ptid
));
2254 if (debug_linux_nat
)
2256 fprintf_unfiltered (gdb_stdlog
,
2257 "WL: waitpid %s received %s\n",
2258 target_pid_to_str (lp
->ptid
),
2259 status_to_str (status
));
2262 /* Check if the thread has exited. */
2263 if (WIFEXITED (status
) || WIFSIGNALED (status
))
2266 if (debug_linux_nat
)
2267 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
2268 target_pid_to_str (lp
->ptid
));
2278 gdb_assert (WIFSTOPPED (status
));
2281 if (lp
->must_set_ptrace_flags
)
2283 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (lp
->ptid
));
2285 linux_enable_event_reporting (ptid_get_lwp (lp
->ptid
), inf
->attach_flag
);
2286 lp
->must_set_ptrace_flags
= 0;
2289 /* Handle GNU/Linux's syscall SIGTRAPs. */
2290 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
2292 /* No longer need the sysgood bit. The ptrace event ends up
2293 recorded in lp->waitstatus if we care for it. We can carry
2294 on handling the event like a regular SIGTRAP from here
2296 status
= W_STOPCODE (SIGTRAP
);
2297 if (linux_handle_syscall_trap (lp
, 1))
2298 return wait_lwp (lp
);
2301 /* Handle GNU/Linux's extended waitstatus for trace events. */
2302 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
2303 && linux_is_extended_waitstatus (status
))
2305 if (debug_linux_nat
)
2306 fprintf_unfiltered (gdb_stdlog
,
2307 "WL: Handling extended status 0x%06x\n",
2309 linux_handle_extended_wait (lp
, status
, 1);
2316 /* Send a SIGSTOP to LP. */
2319 stop_callback (struct lwp_info
*lp
, void *data
)
2321 if (!lp
->stopped
&& !lp
->signalled
)
2325 if (debug_linux_nat
)
2327 fprintf_unfiltered (gdb_stdlog
,
2328 "SC: kill %s **<SIGSTOP>**\n",
2329 target_pid_to_str (lp
->ptid
));
2332 ret
= kill_lwp (ptid_get_lwp (lp
->ptid
), SIGSTOP
);
2333 if (debug_linux_nat
)
2335 fprintf_unfiltered (gdb_stdlog
,
2336 "SC: lwp kill %d %s\n",
2338 errno
? safe_strerror (errno
) : "ERRNO-OK");
2342 gdb_assert (lp
->status
== 0);
2348 /* Request a stop on LWP. */
2351 linux_stop_lwp (struct lwp_info
*lwp
)
2353 stop_callback (lwp
, NULL
);
2356 /* See linux-nat.h */
2359 linux_stop_and_wait_all_lwps (void)
2361 /* Stop all LWP's ... */
2362 iterate_over_lwps (minus_one_ptid
, stop_callback
, NULL
);
2364 /* ... and wait until all of them have reported back that
2365 they're no longer running. */
2366 iterate_over_lwps (minus_one_ptid
, stop_wait_callback
, NULL
);
2369 /* See linux-nat.h */
2372 linux_unstop_all_lwps (void)
2374 iterate_over_lwps (minus_one_ptid
,
2375 resume_stopped_resumed_lwps
, &minus_one_ptid
);
2378 /* Return non-zero if LWP PID has a pending SIGINT. */
2381 linux_nat_has_pending_sigint (int pid
)
2383 sigset_t pending
, blocked
, ignored
;
2385 linux_proc_pending_signals (pid
, &pending
, &blocked
, &ignored
);
2387 if (sigismember (&pending
, SIGINT
)
2388 && !sigismember (&ignored
, SIGINT
))
2394 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2397 set_ignore_sigint (struct lwp_info
*lp
, void *data
)
2399 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2400 flag to consume the next one. */
2401 if (lp
->stopped
&& lp
->status
!= 0 && WIFSTOPPED (lp
->status
)
2402 && WSTOPSIG (lp
->status
) == SIGINT
)
2405 lp
->ignore_sigint
= 1;
2410 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2411 This function is called after we know the LWP has stopped; if the LWP
2412 stopped before the expected SIGINT was delivered, then it will never have
2413 arrived. Also, if the signal was delivered to a shared queue and consumed
2414 by a different thread, it will never be delivered to this LWP. */
2417 maybe_clear_ignore_sigint (struct lwp_info
*lp
)
2419 if (!lp
->ignore_sigint
)
2422 if (!linux_nat_has_pending_sigint (ptid_get_lwp (lp
->ptid
)))
2424 if (debug_linux_nat
)
2425 fprintf_unfiltered (gdb_stdlog
,
2426 "MCIS: Clearing bogus flag for %s\n",
2427 target_pid_to_str (lp
->ptid
));
2428 lp
->ignore_sigint
= 0;
2432 /* Fetch the possible triggered data watchpoint info and store it in
2435 On some archs, like x86, that use debug registers to set
2436 watchpoints, it's possible that the way to know which watched
2437 address trapped, is to check the register that is used to select
2438 which address to watch. Problem is, between setting the watchpoint
2439 and reading back which data address trapped, the user may change
2440 the set of watchpoints, and, as a consequence, GDB changes the
2441 debug registers in the inferior. To avoid reading back a stale
2442 stopped-data-address when that happens, we cache in LP the fact
2443 that a watchpoint trapped, and the corresponding data address, as
2444 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2445 registers meanwhile, we have the cached data we can rely on. */
2448 check_stopped_by_watchpoint (struct lwp_info
*lp
)
2450 struct cleanup
*old_chain
;
2452 if (linux_ops
->to_stopped_by_watchpoint
== NULL
)
2455 old_chain
= save_inferior_ptid ();
2456 inferior_ptid
= lp
->ptid
;
2458 if (linux_ops
->to_stopped_by_watchpoint (linux_ops
))
2460 lp
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
2462 if (linux_ops
->to_stopped_data_address
!= NULL
)
2463 lp
->stopped_data_address_p
=
2464 linux_ops
->to_stopped_data_address (¤t_target
,
2465 &lp
->stopped_data_address
);
2467 lp
->stopped_data_address_p
= 0;
2470 do_cleanups (old_chain
);
2472 return lp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2475 /* Called when the LWP stopped for a trap that could be explained by a
2476 watchpoint or a breakpoint. */
2479 save_sigtrap (struct lwp_info
*lp
)
2481 gdb_assert (lp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
);
2482 gdb_assert (lp
->status
!= 0);
2484 /* Check first if this was a SW/HW breakpoint before checking
2485 watchpoints, because at least s390 can't tell the data address of
2486 hardware watchpoint hits, and the kernel returns
2487 stopped-by-watchpoint as long as there's a watchpoint set. */
2488 if (linux_nat_status_is_event (lp
->status
))
2489 check_stopped_by_breakpoint (lp
);
2491 /* Note that TRAP_HWBKPT can indicate either a hardware breakpoint
2492 or hardware watchpoint. Check which is which if we got
2493 TARGET_STOPPED_BY_HW_BREAKPOINT. */
2494 if (lp
->stop_reason
== TARGET_STOPPED_BY_NO_REASON
2495 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
2496 check_stopped_by_watchpoint (lp
);
2499 /* Returns true if the LWP had stopped for a watchpoint. */
2502 linux_nat_stopped_by_watchpoint (struct target_ops
*ops
)
2504 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2506 gdb_assert (lp
!= NULL
);
2508 return lp
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
2512 linux_nat_stopped_data_address (struct target_ops
*ops
, CORE_ADDR
*addr_p
)
2514 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2516 gdb_assert (lp
!= NULL
);
2518 *addr_p
= lp
->stopped_data_address
;
2520 return lp
->stopped_data_address_p
;
2523 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2526 sigtrap_is_event (int status
)
2528 return WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
;
2531 /* Set alternative SIGTRAP-like events recognizer. If
2532 breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2536 linux_nat_set_status_is_event (struct target_ops
*t
,
2537 int (*status_is_event
) (int status
))
2539 linux_nat_status_is_event
= status_is_event
;
2542 /* Wait until LP is stopped. */
2545 stop_wait_callback (struct lwp_info
*lp
, void *data
)
2547 struct inferior
*inf
= find_inferior_ptid (lp
->ptid
);
2549 /* If this is a vfork parent, bail out, it is not going to report
2550 any SIGSTOP until the vfork is done with. */
2551 if (inf
->vfork_child
!= NULL
)
2558 status
= wait_lwp (lp
);
2562 if (lp
->ignore_sigint
&& WIFSTOPPED (status
)
2563 && WSTOPSIG (status
) == SIGINT
)
2565 lp
->ignore_sigint
= 0;
2568 ptrace (PTRACE_CONT
, ptid_get_lwp (lp
->ptid
), 0, 0);
2570 if (debug_linux_nat
)
2571 fprintf_unfiltered (gdb_stdlog
,
2572 "PTRACE_CONT %s, 0, 0 (%s) "
2573 "(discarding SIGINT)\n",
2574 target_pid_to_str (lp
->ptid
),
2575 errno
? safe_strerror (errno
) : "OK");
2577 return stop_wait_callback (lp
, NULL
);
2580 maybe_clear_ignore_sigint (lp
);
2582 if (WSTOPSIG (status
) != SIGSTOP
)
2584 /* The thread was stopped with a signal other than SIGSTOP. */
2586 if (debug_linux_nat
)
2587 fprintf_unfiltered (gdb_stdlog
,
2588 "SWC: Pending event %s in %s\n",
2589 status_to_str ((int) status
),
2590 target_pid_to_str (lp
->ptid
));
2592 /* Save the sigtrap event. */
2593 lp
->status
= status
;
2594 gdb_assert (lp
->signalled
);
2599 /* We caught the SIGSTOP that we intended to catch, so
2600 there's no SIGSTOP pending. */
2602 if (debug_linux_nat
)
2603 fprintf_unfiltered (gdb_stdlog
,
2604 "SWC: Delayed SIGSTOP caught for %s.\n",
2605 target_pid_to_str (lp
->ptid
));
2607 /* Reset SIGNALLED only after the stop_wait_callback call
2608 above as it does gdb_assert on SIGNALLED. */
2616 /* Return non-zero if LP has a wait status pending. Discard the
2617 pending event and resume the LWP if the event that originally
2618 caused the stop became uninteresting. */
2621 status_callback (struct lwp_info
*lp
, void *data
)
2623 /* Only report a pending wait status if we pretend that this has
2624 indeed been resumed. */
2628 if (!lwp_status_pending_p (lp
))
2631 if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
2632 || lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
)
2634 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
2635 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2639 pc
= regcache_read_pc (regcache
);
2641 if (pc
!= lp
->stop_pc
)
2643 if (debug_linux_nat
)
2644 fprintf_unfiltered (gdb_stdlog
,
2645 "SC: PC of %s changed. was=%s, now=%s\n",
2646 target_pid_to_str (lp
->ptid
),
2647 paddress (target_gdbarch (), lp
->stop_pc
),
2648 paddress (target_gdbarch (), pc
));
2652 #if !USE_SIGTRAP_SIGINFO
2653 else if (!breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
2655 if (debug_linux_nat
)
2656 fprintf_unfiltered (gdb_stdlog
,
2657 "SC: previous breakpoint of %s, at %s gone\n",
2658 target_pid_to_str (lp
->ptid
),
2659 paddress (target_gdbarch (), lp
->stop_pc
));
2667 if (debug_linux_nat
)
2668 fprintf_unfiltered (gdb_stdlog
,
2669 "SC: pending event of %s cancelled.\n",
2670 target_pid_to_str (lp
->ptid
));
2673 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
2681 /* Return non-zero if LP isn't stopped. */
2684 running_callback (struct lwp_info
*lp
, void *data
)
2686 return (!lp
->stopped
2687 || (lwp_status_pending_p (lp
) && lp
->resumed
));
2690 /* Count the LWP's that have had events. */
2693 count_events_callback (struct lwp_info
*lp
, void *data
)
2697 gdb_assert (count
!= NULL
);
2699 /* Select only resumed LWPs that have an event pending. */
2700 if (lp
->resumed
&& lwp_status_pending_p (lp
))
2706 /* Select the LWP (if any) that is currently being single-stepped. */
2709 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
2711 if (lp
->last_resume_kind
== resume_step
2718 /* Returns true if LP has a status pending. */
2721 lwp_status_pending_p (struct lwp_info
*lp
)
2723 /* We check for lp->waitstatus in addition to lp->status, because we
2724 can have pending process exits recorded in lp->status and
2725 W_EXITCODE(0,0) happens to be 0. */
2726 return lp
->status
!= 0 || lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
;
2729 /* Select the Nth LWP that has had an event. */
2732 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
2734 int *selector
= data
;
2736 gdb_assert (selector
!= NULL
);
2738 /* Select only resumed LWPs that have an event pending. */
2739 if (lp
->resumed
&& lwp_status_pending_p (lp
))
2740 if ((*selector
)-- == 0)
2746 /* Called when the LWP got a signal/trap that could be explained by a
2747 software or hardware breakpoint. */
2750 check_stopped_by_breakpoint (struct lwp_info
*lp
)
2752 /* Arrange for a breakpoint to be hit again later. We don't keep
2753 the SIGTRAP status and don't forward the SIGTRAP signal to the
2754 LWP. We will handle the current event, eventually we will resume
2755 this LWP, and this breakpoint will trap again.
2757 If we do not do this, then we run the risk that the user will
2758 delete or disable the breakpoint, but the LWP will have already
2761 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
2762 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2765 #if USE_SIGTRAP_SIGINFO
2769 pc
= regcache_read_pc (regcache
);
2770 sw_bp_pc
= pc
- gdbarch_decr_pc_after_break (gdbarch
);
2772 #if USE_SIGTRAP_SIGINFO
2773 if (linux_nat_get_siginfo (lp
->ptid
, &siginfo
))
2775 if (siginfo
.si_signo
== SIGTRAP
)
2777 if (siginfo
.si_code
== GDB_ARCH_TRAP_BRKPT
)
2779 if (debug_linux_nat
)
2780 fprintf_unfiltered (gdb_stdlog
,
2781 "CSBB: Push back software "
2782 "breakpoint for %s\n",
2783 target_pid_to_str (lp
->ptid
));
2785 /* Back up the PC if necessary. */
2787 regcache_write_pc (regcache
, sw_bp_pc
);
2789 lp
->stop_pc
= sw_bp_pc
;
2790 lp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
2793 else if (siginfo
.si_code
== TRAP_HWBKPT
)
2795 if (debug_linux_nat
)
2796 fprintf_unfiltered (gdb_stdlog
,
2797 "CSBB: Push back hardware "
2798 "breakpoint/watchpoint for %s\n",
2799 target_pid_to_str (lp
->ptid
));
2802 lp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
2808 if ((!lp
->step
|| lp
->stop_pc
== sw_bp_pc
)
2809 && software_breakpoint_inserted_here_p (get_regcache_aspace (regcache
),
2812 /* The LWP was either continued, or stepped a software
2813 breakpoint instruction. */
2814 if (debug_linux_nat
)
2815 fprintf_unfiltered (gdb_stdlog
,
2816 "CB: Push back software breakpoint for %s\n",
2817 target_pid_to_str (lp
->ptid
));
2819 /* Back up the PC if necessary. */
2821 regcache_write_pc (regcache
, sw_bp_pc
);
2823 lp
->stop_pc
= sw_bp_pc
;
2824 lp
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
2828 if (hardware_breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
2830 if (debug_linux_nat
)
2831 fprintf_unfiltered (gdb_stdlog
,
2832 "CB: Push back hardware breakpoint for %s\n",
2833 target_pid_to_str (lp
->ptid
));
2836 lp
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
2845 /* Returns true if the LWP had stopped for a software breakpoint. */
2848 linux_nat_stopped_by_sw_breakpoint (struct target_ops
*ops
)
2850 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2852 gdb_assert (lp
!= NULL
);
2854 return lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
2857 /* Implement the supports_stopped_by_sw_breakpoint method. */
2860 linux_nat_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
2862 return USE_SIGTRAP_SIGINFO
;
2865 /* Returns true if the LWP had stopped for a hardware
2866 breakpoint/watchpoint. */
2869 linux_nat_stopped_by_hw_breakpoint (struct target_ops
*ops
)
2871 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2873 gdb_assert (lp
!= NULL
);
2875 return lp
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
2878 /* Implement the supports_stopped_by_hw_breakpoint method. */
2881 linux_nat_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
2883 return USE_SIGTRAP_SIGINFO
;
2886 /* Select one LWP out of those that have events pending. */
2889 select_event_lwp (ptid_t filter
, struct lwp_info
**orig_lp
, int *status
)
2892 int random_selector
;
2893 struct lwp_info
*event_lp
= NULL
;
2895 /* Record the wait status for the original LWP. */
2896 (*orig_lp
)->status
= *status
;
2898 /* In all-stop, give preference to the LWP that is being
2899 single-stepped. There will be at most one, and it will be the
2900 LWP that the core is most interested in. If we didn't do this,
2901 then we'd have to handle pending step SIGTRAPs somehow in case
2902 the core later continues the previously-stepped thread, as
2903 otherwise we'd report the pending SIGTRAP then, and the core, not
2904 having stepped the thread, wouldn't understand what the trap was
2905 for, and therefore would report it to the user as a random
2909 event_lp
= iterate_over_lwps (filter
,
2910 select_singlestep_lwp_callback
, NULL
);
2911 if (event_lp
!= NULL
)
2913 if (debug_linux_nat
)
2914 fprintf_unfiltered (gdb_stdlog
,
2915 "SEL: Select single-step %s\n",
2916 target_pid_to_str (event_lp
->ptid
));
2920 if (event_lp
== NULL
)
2922 /* Pick one at random, out of those which have had events. */
2924 /* First see how many events we have. */
2925 iterate_over_lwps (filter
, count_events_callback
, &num_events
);
2926 gdb_assert (num_events
> 0);
2928 /* Now randomly pick a LWP out of those that have had
2930 random_selector
= (int)
2931 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2933 if (debug_linux_nat
&& num_events
> 1)
2934 fprintf_unfiltered (gdb_stdlog
,
2935 "SEL: Found %d events, selecting #%d\n",
2936 num_events
, random_selector
);
2938 event_lp
= iterate_over_lwps (filter
,
2939 select_event_lwp_callback
,
2943 if (event_lp
!= NULL
)
2945 /* Switch the event LWP. */
2946 *orig_lp
= event_lp
;
2947 *status
= event_lp
->status
;
2950 /* Flush the wait status for the event LWP. */
2951 (*orig_lp
)->status
= 0;
2954 /* Return non-zero if LP has been resumed. */
2957 resumed_callback (struct lwp_info
*lp
, void *data
)
2962 /* Stop an active thread, verify it still exists, then resume it. If
2963 the thread ends up with a pending status, then it is not resumed,
2964 and *DATA (really a pointer to int), is set. */
2967 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
2971 ptid_t ptid
= lp
->ptid
;
2973 stop_callback (lp
, NULL
);
2974 stop_wait_callback (lp
, NULL
);
2976 /* Resume if the lwp still exists, and the core wanted it
2978 lp
= find_lwp_pid (ptid
);
2981 if (lp
->last_resume_kind
== resume_stop
2982 && !lwp_status_pending_p (lp
))
2984 /* The core wanted the LWP to stop. Even if it stopped
2985 cleanly (with SIGSTOP), leave the event pending. */
2986 if (debug_linux_nat
)
2987 fprintf_unfiltered (gdb_stdlog
,
2988 "SARC: core wanted LWP %ld stopped "
2989 "(leaving SIGSTOP pending)\n",
2990 ptid_get_lwp (lp
->ptid
));
2991 lp
->status
= W_STOPCODE (SIGSTOP
);
2994 if (!lwp_status_pending_p (lp
))
2996 if (debug_linux_nat
)
2997 fprintf_unfiltered (gdb_stdlog
,
2998 "SARC: re-resuming LWP %ld\n",
2999 ptid_get_lwp (lp
->ptid
));
3000 resume_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
3004 if (debug_linux_nat
)
3005 fprintf_unfiltered (gdb_stdlog
,
3006 "SARC: not re-resuming LWP %ld "
3008 ptid_get_lwp (lp
->ptid
));
3015 /* Check if we should go on and pass this event to common code.
3016 Return the affected lwp if we are, or NULL otherwise. */
3018 static struct lwp_info
*
3019 linux_nat_filter_event (int lwpid
, int status
)
3021 struct lwp_info
*lp
;
3022 int event
= linux_ptrace_get_extended_event (status
);
3024 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
3026 /* Check for stop events reported by a process we didn't already
3027 know about - anything not already in our LWP list.
3029 If we're expecting to receive stopped processes after
3030 fork, vfork, and clone events, then we'll just add the
3031 new one to our list and go back to waiting for the event
3032 to be reported - the stopped process might be returned
3033 from waitpid before or after the event is.
3035 But note the case of a non-leader thread exec'ing after the
3036 leader having exited, and gone from our lists. The non-leader
3037 thread changes its tid to the tgid. */
3039 if (WIFSTOPPED (status
) && lp
== NULL
3040 && (WSTOPSIG (status
) == SIGTRAP
&& event
== PTRACE_EVENT_EXEC
))
3042 /* A multi-thread exec after we had seen the leader exiting. */
3043 if (debug_linux_nat
)
3044 fprintf_unfiltered (gdb_stdlog
,
3045 "LLW: Re-adding thread group leader LWP %d.\n",
3048 lp
= add_lwp (ptid_build (lwpid
, lwpid
, 0));
3051 add_thread (lp
->ptid
);
3054 if (WIFSTOPPED (status
) && !lp
)
3056 if (debug_linux_nat
)
3057 fprintf_unfiltered (gdb_stdlog
,
3058 "LHEW: saving LWP %ld status %s in stopped_pids list\n",
3059 (long) lwpid
, status_to_str (status
));
3060 add_to_pid_list (&stopped_pids
, lwpid
, status
);
3064 /* Make sure we don't report an event for the exit of an LWP not in
3065 our list, i.e. not part of the current process. This can happen
3066 if we detach from a program we originally forked and then it
3068 if (!WIFSTOPPED (status
) && !lp
)
3071 /* This LWP is stopped now. (And if dead, this prevents it from
3072 ever being continued.) */
3075 if (WIFSTOPPED (status
) && lp
->must_set_ptrace_flags
)
3077 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (lp
->ptid
));
3079 linux_enable_event_reporting (ptid_get_lwp (lp
->ptid
), inf
->attach_flag
);
3080 lp
->must_set_ptrace_flags
= 0;
3083 /* Handle GNU/Linux's syscall SIGTRAPs. */
3084 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
3086 /* No longer need the sysgood bit. The ptrace event ends up
3087 recorded in lp->waitstatus if we care for it. We can carry
3088 on handling the event like a regular SIGTRAP from here
3090 status
= W_STOPCODE (SIGTRAP
);
3091 if (linux_handle_syscall_trap (lp
, 0))
3095 /* Handle GNU/Linux's extended waitstatus for trace events. */
3096 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
3097 && linux_is_extended_waitstatus (status
))
3099 if (debug_linux_nat
)
3100 fprintf_unfiltered (gdb_stdlog
,
3101 "LLW: Handling extended status 0x%06x\n",
3103 if (linux_handle_extended_wait (lp
, status
, 0))
3107 /* Check if the thread has exited. */
3108 if (WIFEXITED (status
) || WIFSIGNALED (status
))
3110 if (num_lwps (ptid_get_pid (lp
->ptid
)) > 1)
3112 /* If this is the main thread, we must stop all threads and
3113 verify if they are still alive. This is because in the
3114 nptl thread model on Linux 2.4, there is no signal issued
3115 for exiting LWPs other than the main thread. We only get
3116 the main thread exit signal once all child threads have
3117 already exited. If we stop all the threads and use the
3118 stop_wait_callback to check if they have exited we can
3119 determine whether this signal should be ignored or
3120 whether it means the end of the debugged application,
3121 regardless of which threading model is being used. */
3122 if (ptid_get_pid (lp
->ptid
) == ptid_get_lwp (lp
->ptid
))
3124 iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp
->ptid
)),
3125 stop_and_resume_callback
, NULL
);
3128 if (debug_linux_nat
)
3129 fprintf_unfiltered (gdb_stdlog
,
3130 "LLW: %s exited.\n",
3131 target_pid_to_str (lp
->ptid
));
3133 if (num_lwps (ptid_get_pid (lp
->ptid
)) > 1)
3135 /* If there is at least one more LWP, then the exit signal
3136 was not the end of the debugged application and should be
3143 gdb_assert (lp
->resumed
);
3145 if (debug_linux_nat
)
3146 fprintf_unfiltered (gdb_stdlog
,
3147 "Process %ld exited\n",
3148 ptid_get_lwp (lp
->ptid
));
3150 /* This was the last lwp in the process. Since events are
3151 serialized to GDB core, we may not be able report this one
3152 right now, but GDB core and the other target layers will want
3153 to be notified about the exit code/signal, leave the status
3154 pending for the next time we're able to report it. */
3156 /* Dead LWP's aren't expected to reported a pending sigstop. */
3159 /* Store the pending event in the waitstatus, because
3160 W_EXITCODE(0,0) == 0. */
3161 store_waitstatus (&lp
->waitstatus
, status
);
3165 /* Check if the current LWP has previously exited. In the nptl
3166 thread model, LWPs other than the main thread do not issue
3167 signals when they exit so we must check whenever the thread has
3168 stopped. A similar check is made in stop_wait_callback(). */
3169 if (num_lwps (ptid_get_pid (lp
->ptid
)) > 1 && !linux_thread_alive (lp
->ptid
))
3171 ptid_t ptid
= pid_to_ptid (ptid_get_pid (lp
->ptid
));
3173 if (debug_linux_nat
)
3174 fprintf_unfiltered (gdb_stdlog
,
3175 "LLW: %s exited.\n",
3176 target_pid_to_str (lp
->ptid
));
3180 /* Make sure there is at least one thread running. */
3181 gdb_assert (iterate_over_lwps (ptid
, running_callback
, NULL
));
3183 /* Discard the event. */
3187 /* Make sure we don't report a SIGSTOP that we sent ourselves in
3188 an attempt to stop an LWP. */
3190 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
3192 if (debug_linux_nat
)
3193 fprintf_unfiltered (gdb_stdlog
,
3194 "LLW: Delayed SIGSTOP caught for %s.\n",
3195 target_pid_to_str (lp
->ptid
));
3199 if (lp
->last_resume_kind
!= resume_stop
)
3201 /* This is a delayed SIGSTOP. */
3203 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
3204 if (debug_linux_nat
)
3205 fprintf_unfiltered (gdb_stdlog
,
3206 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
3208 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3209 target_pid_to_str (lp
->ptid
));
3211 gdb_assert (lp
->resumed
);
3213 /* Discard the event. */
3218 /* Make sure we don't report a SIGINT that we have already displayed
3219 for another thread. */
3220 if (lp
->ignore_sigint
3221 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGINT
)
3223 if (debug_linux_nat
)
3224 fprintf_unfiltered (gdb_stdlog
,
3225 "LLW: Delayed SIGINT caught for %s.\n",
3226 target_pid_to_str (lp
->ptid
));
3228 /* This is a delayed SIGINT. */
3229 lp
->ignore_sigint
= 0;
3231 linux_resume_one_lwp (lp
, lp
->step
, GDB_SIGNAL_0
);
3232 if (debug_linux_nat
)
3233 fprintf_unfiltered (gdb_stdlog
,
3234 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3236 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3237 target_pid_to_str (lp
->ptid
));
3238 gdb_assert (lp
->resumed
);
3240 /* Discard the event. */
3244 /* Don't report signals that GDB isn't interested in, such as
3245 signals that are neither printed nor stopped upon. Stopping all
3246 threads can be a bit time-consuming so if we want decent
3247 performance with heavily multi-threaded programs, especially when
3248 they're using a high frequency timer, we'd better avoid it if we
3250 if (WIFSTOPPED (status
))
3252 enum gdb_signal signo
= gdb_signal_from_host (WSTOPSIG (status
));
3256 /* Only do the below in all-stop, as we currently use SIGSTOP
3257 to implement target_stop (see linux_nat_stop) in
3259 if (signo
== GDB_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
3261 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3262 forwarded to the entire process group, that is, all LWPs
3263 will receive it - unless they're using CLONE_THREAD to
3264 share signals. Since we only want to report it once, we
3265 mark it as ignored for all LWPs except this one. */
3266 iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp
->ptid
)),
3267 set_ignore_sigint
, NULL
);
3268 lp
->ignore_sigint
= 0;
3271 maybe_clear_ignore_sigint (lp
);
3274 /* When using hardware single-step, we need to report every signal.
3275 Otherwise, signals in pass_mask may be short-circuited
3276 except signals that might be caused by a breakpoint. */
3278 && WSTOPSIG (status
) && sigismember (&pass_mask
, WSTOPSIG (status
))
3279 && !linux_wstatus_maybe_breakpoint (status
))
3281 linux_resume_one_lwp (lp
, lp
->step
, signo
);
3282 if (debug_linux_nat
)
3283 fprintf_unfiltered (gdb_stdlog
,
3284 "LLW: %s %s, %s (preempt 'handle')\n",
3286 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3287 target_pid_to_str (lp
->ptid
),
3288 (signo
!= GDB_SIGNAL_0
3289 ? strsignal (gdb_signal_to_host (signo
))
3295 /* An interesting event. */
3297 lp
->status
= status
;
3302 /* Detect zombie thread group leaders, and "exit" them. We can't reap
3303 their exits until all other threads in the group have exited. */
3306 check_zombie_leaders (void)
3308 struct inferior
*inf
;
3312 struct lwp_info
*leader_lp
;
3317 leader_lp
= find_lwp_pid (pid_to_ptid (inf
->pid
));
3318 if (leader_lp
!= NULL
3319 /* Check if there are other threads in the group, as we may
3320 have raced with the inferior simply exiting. */
3321 && num_lwps (inf
->pid
) > 1
3322 && linux_proc_pid_is_zombie (inf
->pid
))
3324 if (debug_linux_nat
)
3325 fprintf_unfiltered (gdb_stdlog
,
3326 "CZL: Thread group leader %d zombie "
3327 "(it exited, or another thread execd).\n",
3330 /* A leader zombie can mean one of two things:
3332 - It exited, and there's an exit status pending
3333 available, or only the leader exited (not the whole
3334 program). In the latter case, we can't waitpid the
3335 leader's exit status until all other threads are gone.
3337 - There are 3 or more threads in the group, and a thread
3338 other than the leader exec'd. On an exec, the Linux
3339 kernel destroys all other threads (except the execing
3340 one) in the thread group, and resets the execing thread's
3341 tid to the tgid. No exit notification is sent for the
3342 execing thread -- from the ptracer's perspective, it
3343 appears as though the execing thread just vanishes.
3344 Until we reap all other threads except the leader and the
3345 execing thread, the leader will be zombie, and the
3346 execing thread will be in `D (disc sleep)'. As soon as
3347 all other threads are reaped, the execing thread changes
3348 it's tid to the tgid, and the previous (zombie) leader
3349 vanishes, giving place to the "new" leader. We could try
3350 distinguishing the exit and exec cases, by waiting once
3351 more, and seeing if something comes out, but it doesn't
3352 sound useful. The previous leader _does_ go away, and
3353 we'll re-add the new one once we see the exec event
3354 (which is just the same as what would happen if the
3355 previous leader did exit voluntarily before some other
3358 if (debug_linux_nat
)
3359 fprintf_unfiltered (gdb_stdlog
,
3360 "CZL: Thread group leader %d vanished.\n",
3362 exit_lwp (leader_lp
);
3368 linux_nat_wait_1 (struct target_ops
*ops
,
3369 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3373 enum resume_kind last_resume_kind
;
3374 struct lwp_info
*lp
;
3377 if (debug_linux_nat
)
3378 fprintf_unfiltered (gdb_stdlog
, "LLW: enter\n");
3380 /* The first time we get here after starting a new inferior, we may
3381 not have added it to the LWP list yet - this is the earliest
3382 moment at which we know its PID. */
3383 if (ptid_is_pid (inferior_ptid
))
3385 /* Upgrade the main thread's ptid. */
3386 thread_change_ptid (inferior_ptid
,
3387 ptid_build (ptid_get_pid (inferior_ptid
),
3388 ptid_get_pid (inferior_ptid
), 0));
3390 lp
= add_initial_lwp (inferior_ptid
);
3394 /* Make sure SIGCHLD is blocked until the sigsuspend below. */
3395 block_child_signals (&prev_mask
);
3397 /* First check if there is a LWP with a wait status pending. */
3398 lp
= iterate_over_lwps (ptid
, status_callback
, NULL
);
3401 if (debug_linux_nat
)
3402 fprintf_unfiltered (gdb_stdlog
,
3403 "LLW: Using pending wait status %s for %s.\n",
3404 status_to_str (lp
->status
),
3405 target_pid_to_str (lp
->ptid
));
3408 if (!target_is_async_p ())
3410 /* Causes SIGINT to be passed on to the attached process. */
3414 /* But if we don't find a pending event, we'll have to wait. Always
3415 pull all events out of the kernel. We'll randomly select an
3416 event LWP out of all that have events, to prevent starvation. */
3422 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3425 - If the thread group leader exits while other threads in the
3426 thread group still exist, waitpid(TGID, ...) hangs. That
3427 waitpid won't return an exit status until the other threads
3428 in the group are reapped.
3430 - When a non-leader thread execs, that thread just vanishes
3431 without reporting an exit (so we'd hang if we waited for it
3432 explicitly in that case). The exec event is reported to
3436 lwpid
= my_waitpid (-1, &status
, __WCLONE
| WNOHANG
);
3437 if (lwpid
== 0 || (lwpid
== -1 && errno
== ECHILD
))
3438 lwpid
= my_waitpid (-1, &status
, WNOHANG
);
3440 if (debug_linux_nat
)
3441 fprintf_unfiltered (gdb_stdlog
,
3442 "LNW: waitpid(-1, ...) returned %d, %s\n",
3443 lwpid
, errno
? safe_strerror (errno
) : "ERRNO-OK");
3447 if (debug_linux_nat
)
3449 fprintf_unfiltered (gdb_stdlog
,
3450 "LLW: waitpid %ld received %s\n",
3451 (long) lwpid
, status_to_str (status
));
3454 linux_nat_filter_event (lwpid
, status
);
3455 /* Retry until nothing comes out of waitpid. A single
3456 SIGCHLD can indicate more than one child stopped. */
3460 /* Now that we've pulled all events out of the kernel, resume
3461 LWPs that don't have an interesting event to report. */
3462 iterate_over_lwps (minus_one_ptid
,
3463 resume_stopped_resumed_lwps
, &minus_one_ptid
);
3465 /* ... and find an LWP with a status to report to the core, if
3467 lp
= iterate_over_lwps (ptid
, status_callback
, NULL
);
3471 /* Check for zombie thread group leaders. Those can't be reaped
3472 until all other threads in the thread group are. */
3473 check_zombie_leaders ();
3475 /* If there are no resumed children left, bail. We'd be stuck
3476 forever in the sigsuspend call below otherwise. */
3477 if (iterate_over_lwps (ptid
, resumed_callback
, NULL
) == NULL
)
3479 if (debug_linux_nat
)
3480 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (no resumed LWP)\n");
3482 ourstatus
->kind
= TARGET_WAITKIND_NO_RESUMED
;
3484 if (!target_is_async_p ())
3485 clear_sigint_trap ();
3487 restore_child_signals_mask (&prev_mask
);
3488 return minus_one_ptid
;
3491 /* No interesting event to report to the core. */
3493 if (target_options
& TARGET_WNOHANG
)
3495 if (debug_linux_nat
)
3496 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
3498 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3499 restore_child_signals_mask (&prev_mask
);
3500 return minus_one_ptid
;
3503 /* We shouldn't end up here unless we want to try again. */
3504 gdb_assert (lp
== NULL
);
3506 /* Block until we get an event reported with SIGCHLD. */
3507 if (debug_linux_nat
)
3508 fprintf_unfiltered (gdb_stdlog
, "LNW: about to sigsuspend\n");
3509 sigsuspend (&suspend_mask
);
3512 if (!target_is_async_p ())
3513 clear_sigint_trap ();
3517 status
= lp
->status
;
3522 /* Now stop all other LWP's ... */
3523 iterate_over_lwps (minus_one_ptid
, stop_callback
, NULL
);
3525 /* ... and wait until all of them have reported back that
3526 they're no longer running. */
3527 iterate_over_lwps (minus_one_ptid
, stop_wait_callback
, NULL
);
3530 /* If we're not waiting for a specific LWP, choose an event LWP from
3531 among those that have had events. Giving equal priority to all
3532 LWPs that have had events helps prevent starvation. */
3533 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
3534 select_event_lwp (ptid
, &lp
, &status
);
3536 gdb_assert (lp
!= NULL
);
3538 /* Now that we've selected our final event LWP, un-adjust its PC if
3539 it was a software breakpoint, and we can't reliably support the
3540 "stopped by software breakpoint" stop reason. */
3541 if (lp
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
3542 && !USE_SIGTRAP_SIGINFO
)
3544 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
3545 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3546 int decr_pc
= gdbarch_decr_pc_after_break (gdbarch
);
3552 pc
= regcache_read_pc (regcache
);
3553 regcache_write_pc (regcache
, pc
+ decr_pc
);
3557 /* We'll need this to determine whether to report a SIGSTOP as
3558 GDB_SIGNAL_0. Need to take a copy because resume_clear_callback
3560 last_resume_kind
= lp
->last_resume_kind
;
3564 /* In all-stop, from the core's perspective, all LWPs are now
3565 stopped until a new resume action is sent over. */
3566 iterate_over_lwps (minus_one_ptid
, resume_clear_callback
, NULL
);
3570 resume_clear_callback (lp
, NULL
);
3573 if (linux_nat_status_is_event (status
))
3575 if (debug_linux_nat
)
3576 fprintf_unfiltered (gdb_stdlog
,
3577 "LLW: trap ptid is %s.\n",
3578 target_pid_to_str (lp
->ptid
));
3581 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3583 *ourstatus
= lp
->waitstatus
;
3584 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
3587 store_waitstatus (ourstatus
, status
);
3589 if (debug_linux_nat
)
3590 fprintf_unfiltered (gdb_stdlog
, "LLW: exit\n");
3592 restore_child_signals_mask (&prev_mask
);
3594 if (last_resume_kind
== resume_stop
3595 && ourstatus
->kind
== TARGET_WAITKIND_STOPPED
3596 && WSTOPSIG (status
) == SIGSTOP
)
3598 /* A thread that has been requested to stop by GDB with
3599 target_stop, and it stopped cleanly, so report as SIG0. The
3600 use of SIGSTOP is an implementation detail. */
3601 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
3604 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
3605 || ourstatus
->kind
== TARGET_WAITKIND_SIGNALLED
)
3608 lp
->core
= linux_common_core_of_thread (lp
->ptid
);
3613 /* Resume LWPs that are currently stopped without any pending status
3614 to report, but are resumed from the core's perspective. */
3617 resume_stopped_resumed_lwps (struct lwp_info
*lp
, void *data
)
3619 ptid_t
*wait_ptid_p
= data
;
3623 && !lwp_status_pending_p (lp
))
3625 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
3626 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3630 CORE_ADDR pc
= regcache_read_pc (regcache
);
3631 int leave_stopped
= 0;
3633 /* Don't bother if there's a breakpoint at PC that we'd hit
3634 immediately, and we're not waiting for this LWP. */
3635 if (!ptid_match (lp
->ptid
, *wait_ptid_p
))
3637 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
3643 if (debug_linux_nat
)
3644 fprintf_unfiltered (gdb_stdlog
,
3645 "RSRL: resuming stopped-resumed LWP %s at "
3647 target_pid_to_str (lp
->ptid
),
3648 paddress (gdbarch
, pc
),
3651 linux_resume_one_lwp_throw (lp
, lp
->step
, GDB_SIGNAL_0
);
3654 CATCH (ex
, RETURN_MASK_ERROR
)
3656 if (!check_ptrace_stopped_lwp_gone (lp
))
3657 throw_exception (ex
);
3666 linux_nat_wait (struct target_ops
*ops
,
3667 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3672 if (debug_linux_nat
)
3674 char *options_string
;
3676 options_string
= target_options_to_string (target_options
);
3677 fprintf_unfiltered (gdb_stdlog
,
3678 "linux_nat_wait: [%s], [%s]\n",
3679 target_pid_to_str (ptid
),
3681 xfree (options_string
);
3684 /* Flush the async file first. */
3685 if (target_is_async_p ())
3686 async_file_flush ();
3688 /* Resume LWPs that are currently stopped without any pending status
3689 to report, but are resumed from the core's perspective. LWPs get
3690 in this state if we find them stopping at a time we're not
3691 interested in reporting the event (target_wait on a
3692 specific_process, for example, see linux_nat_wait_1), and
3693 meanwhile the event became uninteresting. Don't bother resuming
3694 LWPs we're not going to wait for if they'd stop immediately. */
3696 iterate_over_lwps (minus_one_ptid
, resume_stopped_resumed_lwps
, &ptid
);
3698 event_ptid
= linux_nat_wait_1 (ops
, ptid
, ourstatus
, target_options
);
3700 /* If we requested any event, and something came out, assume there
3701 may be more. If we requested a specific lwp or process, also
3702 assume there may be more. */
3703 if (target_is_async_p ()
3704 && ((ourstatus
->kind
!= TARGET_WAITKIND_IGNORE
3705 && ourstatus
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
3706 || !ptid_equal (ptid
, minus_one_ptid
)))
3713 kill_callback (struct lwp_info
*lp
, void *data
)
3715 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
3718 kill_lwp (ptid_get_lwp (lp
->ptid
), SIGKILL
);
3719 if (debug_linux_nat
)
3721 int save_errno
= errno
;
3723 fprintf_unfiltered (gdb_stdlog
,
3724 "KC: kill (SIGKILL) %s, 0, 0 (%s)\n",
3725 target_pid_to_str (lp
->ptid
),
3726 save_errno
? safe_strerror (save_errno
) : "OK");
3729 /* Some kernels ignore even SIGKILL for processes under ptrace. */
3732 ptrace (PTRACE_KILL
, ptid_get_lwp (lp
->ptid
), 0, 0);
3733 if (debug_linux_nat
)
3735 int save_errno
= errno
;
3737 fprintf_unfiltered (gdb_stdlog
,
3738 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
3739 target_pid_to_str (lp
->ptid
),
3740 save_errno
? safe_strerror (save_errno
) : "OK");
3747 kill_wait_callback (struct lwp_info
*lp
, void *data
)
3751 /* We must make sure that there are no pending events (delayed
3752 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3753 program doesn't interfere with any following debugging session. */
3755 /* For cloned processes we must check both with __WCLONE and
3756 without, since the exit status of a cloned process isn't reported
3762 pid
= my_waitpid (ptid_get_lwp (lp
->ptid
), NULL
, __WCLONE
);
3763 if (pid
!= (pid_t
) -1)
3765 if (debug_linux_nat
)
3766 fprintf_unfiltered (gdb_stdlog
,
3767 "KWC: wait %s received unknown.\n",
3768 target_pid_to_str (lp
->ptid
));
3769 /* The Linux kernel sometimes fails to kill a thread
3770 completely after PTRACE_KILL; that goes from the stop
3771 point in do_fork out to the one in
3772 get_signal_to_deliever and waits again. So kill it
3774 kill_callback (lp
, NULL
);
3777 while (pid
== ptid_get_lwp (lp
->ptid
));
3779 gdb_assert (pid
== -1 && errno
== ECHILD
);
3784 pid
= my_waitpid (ptid_get_lwp (lp
->ptid
), NULL
, 0);
3785 if (pid
!= (pid_t
) -1)
3787 if (debug_linux_nat
)
3788 fprintf_unfiltered (gdb_stdlog
,
3789 "KWC: wait %s received unk.\n",
3790 target_pid_to_str (lp
->ptid
));
3791 /* See the call to kill_callback above. */
3792 kill_callback (lp
, NULL
);
3795 while (pid
== ptid_get_lwp (lp
->ptid
));
3797 gdb_assert (pid
== -1 && errno
== ECHILD
);
3802 linux_nat_kill (struct target_ops
*ops
)
3804 struct target_waitstatus last
;
3808 /* If we're stopped while forking and we haven't followed yet,
3809 kill the other task. We need to do this first because the
3810 parent will be sleeping if this is a vfork. */
3812 get_last_target_status (&last_ptid
, &last
);
3814 if (last
.kind
== TARGET_WAITKIND_FORKED
3815 || last
.kind
== TARGET_WAITKIND_VFORKED
)
3817 ptrace (PT_KILL
, ptid_get_pid (last
.value
.related_pid
), 0, 0);
3820 /* Let the arch-specific native code know this process is
3822 linux_nat_forget_process (ptid_get_pid (last
.value
.related_pid
));
3825 if (forks_exist_p ())
3826 linux_fork_killall ();
3829 ptid_t ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
3831 /* Stop all threads before killing them, since ptrace requires
3832 that the thread is stopped to sucessfully PTRACE_KILL. */
3833 iterate_over_lwps (ptid
, stop_callback
, NULL
);
3834 /* ... and wait until all of them have reported back that
3835 they're no longer running. */
3836 iterate_over_lwps (ptid
, stop_wait_callback
, NULL
);
3838 /* Kill all LWP's ... */
3839 iterate_over_lwps (ptid
, kill_callback
, NULL
);
3841 /* ... and wait until we've flushed all events. */
3842 iterate_over_lwps (ptid
, kill_wait_callback
, NULL
);
3845 target_mourn_inferior ();
3849 linux_nat_mourn_inferior (struct target_ops
*ops
)
3851 int pid
= ptid_get_pid (inferior_ptid
);
3853 purge_lwp_list (pid
);
3855 if (! forks_exist_p ())
3856 /* Normal case, no other forks available. */
3857 linux_ops
->to_mourn_inferior (ops
);
3859 /* Multi-fork case. The current inferior_ptid has exited, but
3860 there are other viable forks to debug. Delete the exiting
3861 one and context-switch to the first available. */
3862 linux_fork_mourn_inferior ();
3864 /* Let the arch-specific native code know this process is gone. */
3865 linux_nat_forget_process (pid
);
3868 /* Convert a native/host siginfo object, into/from the siginfo in the
3869 layout of the inferiors' architecture. */
3872 siginfo_fixup (siginfo_t
*siginfo
, gdb_byte
*inf_siginfo
, int direction
)
3876 if (linux_nat_siginfo_fixup
!= NULL
)
3877 done
= linux_nat_siginfo_fixup (siginfo
, inf_siginfo
, direction
);
3879 /* If there was no callback, or the callback didn't do anything,
3880 then just do a straight memcpy. */
3884 memcpy (siginfo
, inf_siginfo
, sizeof (siginfo_t
));
3886 memcpy (inf_siginfo
, siginfo
, sizeof (siginfo_t
));
3890 static enum target_xfer_status
3891 linux_xfer_siginfo (struct target_ops
*ops
, enum target_object object
,
3892 const char *annex
, gdb_byte
*readbuf
,
3893 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
3894 ULONGEST
*xfered_len
)
3898 gdb_byte inf_siginfo
[sizeof (siginfo_t
)];
3900 gdb_assert (object
== TARGET_OBJECT_SIGNAL_INFO
);
3901 gdb_assert (readbuf
|| writebuf
);
3903 pid
= ptid_get_lwp (inferior_ptid
);
3905 pid
= ptid_get_pid (inferior_ptid
);
3907 if (offset
> sizeof (siginfo
))
3908 return TARGET_XFER_E_IO
;
3911 ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
3913 return TARGET_XFER_E_IO
;
3915 /* When GDB is built as a 64-bit application, ptrace writes into
3916 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3917 inferior with a 64-bit GDB should look the same as debugging it
3918 with a 32-bit GDB, we need to convert it. GDB core always sees
3919 the converted layout, so any read/write will have to be done
3921 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
3923 if (offset
+ len
> sizeof (siginfo
))
3924 len
= sizeof (siginfo
) - offset
;
3926 if (readbuf
!= NULL
)
3927 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
3930 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
3932 /* Convert back to ptrace layout before flushing it out. */
3933 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
3936 ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
3938 return TARGET_XFER_E_IO
;
3942 return TARGET_XFER_OK
;
3945 static enum target_xfer_status
3946 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3947 const char *annex
, gdb_byte
*readbuf
,
3948 const gdb_byte
*writebuf
,
3949 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
3951 struct cleanup
*old_chain
;
3952 enum target_xfer_status xfer
;
3954 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
3955 return linux_xfer_siginfo (ops
, object
, annex
, readbuf
, writebuf
,
3956 offset
, len
, xfered_len
);
3958 /* The target is connected but no live inferior is selected. Pass
3959 this request down to a lower stratum (e.g., the executable
3961 if (object
== TARGET_OBJECT_MEMORY
&& ptid_equal (inferior_ptid
, null_ptid
))
3962 return TARGET_XFER_EOF
;
3964 old_chain
= save_inferior_ptid ();
3966 if (ptid_lwp_p (inferior_ptid
))
3967 inferior_ptid
= pid_to_ptid (ptid_get_lwp (inferior_ptid
));
3969 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3970 offset
, len
, xfered_len
);
3972 do_cleanups (old_chain
);
3977 linux_thread_alive (ptid_t ptid
)
3981 gdb_assert (ptid_lwp_p (ptid
));
3983 /* Send signal 0 instead of anything ptrace, because ptracing a
3984 running thread errors out claiming that the thread doesn't
3986 err
= kill_lwp (ptid_get_lwp (ptid
), 0);
3988 if (debug_linux_nat
)
3989 fprintf_unfiltered (gdb_stdlog
,
3990 "LLTA: KILL(SIG0) %s (%s)\n",
3991 target_pid_to_str (ptid
),
3992 err
? safe_strerror (tmp_errno
) : "OK");
4001 linux_nat_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4003 return linux_thread_alive (ptid
);
4007 linux_nat_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
4009 static char buf
[64];
4011 if (ptid_lwp_p (ptid
)
4012 && (ptid_get_pid (ptid
) != ptid_get_lwp (ptid
)
4013 || num_lwps (ptid_get_pid (ptid
)) > 1))
4015 snprintf (buf
, sizeof (buf
), "LWP %ld", ptid_get_lwp (ptid
));
4019 return normal_pid_to_str (ptid
);
4023 linux_nat_thread_name (struct target_ops
*self
, struct thread_info
*thr
)
4025 int pid
= ptid_get_pid (thr
->ptid
);
4026 long lwp
= ptid_get_lwp (thr
->ptid
);
4027 #define FORMAT "/proc/%d/task/%ld/comm"
4028 char buf
[sizeof (FORMAT
) + 30];
4030 char *result
= NULL
;
4032 snprintf (buf
, sizeof (buf
), FORMAT
, pid
, lwp
);
4033 comm_file
= gdb_fopen_cloexec (buf
, "r");
4036 /* Not exported by the kernel, so we define it here. */
4038 static char line
[COMM_LEN
+ 1];
4040 if (fgets (line
, sizeof (line
), comm_file
))
4042 char *nl
= strchr (line
, '\n');
4059 /* Accepts an integer PID; Returns a string representing a file that
4060 can be opened to get the symbols for the child process. */
4063 linux_child_pid_to_exec_file (struct target_ops
*self
, int pid
)
4065 static char buf
[PATH_MAX
];
4066 char name
[PATH_MAX
];
4068 xsnprintf (name
, PATH_MAX
, "/proc/%d/exe", pid
);
4069 memset (buf
, 0, PATH_MAX
);
4070 if (readlink (name
, buf
, PATH_MAX
- 1) <= 0)
4076 /* Implement the to_xfer_partial interface for memory reads using the /proc
4077 filesystem. Because we can use a single read() call for /proc, this
4078 can be much more efficient than banging away at PTRACE_PEEKTEXT,
4079 but it doesn't support writes. */
4081 static enum target_xfer_status
4082 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4083 const char *annex
, gdb_byte
*readbuf
,
4084 const gdb_byte
*writebuf
,
4085 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
4091 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
4094 /* Don't bother for one word. */
4095 if (len
< 3 * sizeof (long))
4096 return TARGET_XFER_EOF
;
4098 /* We could keep this file open and cache it - possibly one per
4099 thread. That requires some juggling, but is even faster. */
4100 xsnprintf (filename
, sizeof filename
, "/proc/%d/mem",
4101 ptid_get_pid (inferior_ptid
));
4102 fd
= gdb_open_cloexec (filename
, O_RDONLY
| O_LARGEFILE
, 0);
4104 return TARGET_XFER_EOF
;
4106 /* If pread64 is available, use it. It's faster if the kernel
4107 supports it (only one syscall), and it's 64-bit safe even on
4108 32-bit platforms (for instance, SPARC debugging a SPARC64
4111 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
4113 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
4122 return TARGET_XFER_EOF
;
4126 return TARGET_XFER_OK
;
4131 /* Enumerate spufs IDs for process PID. */
4133 spu_enumerate_spu_ids (int pid
, gdb_byte
*buf
, ULONGEST offset
, ULONGEST len
)
4135 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
4137 LONGEST written
= 0;
4140 struct dirent
*entry
;
4142 xsnprintf (path
, sizeof path
, "/proc/%d/fd", pid
);
4143 dir
= opendir (path
);
4148 while ((entry
= readdir (dir
)) != NULL
)
4154 fd
= atoi (entry
->d_name
);
4158 xsnprintf (path
, sizeof path
, "/proc/%d/fd/%d", pid
, fd
);
4159 if (stat (path
, &st
) != 0)
4161 if (!S_ISDIR (st
.st_mode
))
4164 if (statfs (path
, &stfs
) != 0)
4166 if (stfs
.f_type
!= SPUFS_MAGIC
)
4169 if (pos
>= offset
&& pos
+ 4 <= offset
+ len
)
4171 store_unsigned_integer (buf
+ pos
- offset
, 4, byte_order
, fd
);
4181 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
4182 object type, using the /proc file system. */
4184 static enum target_xfer_status
4185 linux_proc_xfer_spu (struct target_ops
*ops
, enum target_object object
,
4186 const char *annex
, gdb_byte
*readbuf
,
4187 const gdb_byte
*writebuf
,
4188 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
4193 int pid
= ptid_get_pid (inferior_ptid
);
4198 return TARGET_XFER_E_IO
;
4201 LONGEST l
= spu_enumerate_spu_ids (pid
, readbuf
, offset
, len
);
4204 return TARGET_XFER_E_IO
;
4206 return TARGET_XFER_EOF
;
4209 *xfered_len
= (ULONGEST
) l
;
4210 return TARGET_XFER_OK
;
4215 xsnprintf (buf
, sizeof buf
, "/proc/%d/fd/%s", pid
, annex
);
4216 fd
= gdb_open_cloexec (buf
, writebuf
? O_WRONLY
: O_RDONLY
, 0);
4218 return TARGET_XFER_E_IO
;
4221 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
4224 return TARGET_XFER_EOF
;
4228 ret
= write (fd
, writebuf
, (size_t) len
);
4230 ret
= read (fd
, readbuf
, (size_t) len
);
4235 return TARGET_XFER_E_IO
;
4237 return TARGET_XFER_EOF
;
4240 *xfered_len
= (ULONGEST
) ret
;
4241 return TARGET_XFER_OK
;
4246 /* Parse LINE as a signal set and add its set bits to SIGS. */
4249 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
4251 int len
= strlen (line
) - 1;
4255 if (line
[len
] != '\n')
4256 error (_("Could not parse signal set: %s"), line
);
4264 if (*p
>= '0' && *p
<= '9')
4266 else if (*p
>= 'a' && *p
<= 'f')
4267 digit
= *p
- 'a' + 10;
4269 error (_("Could not parse signal set: %s"), line
);
4274 sigaddset (sigs
, signum
+ 1);
4276 sigaddset (sigs
, signum
+ 2);
4278 sigaddset (sigs
, signum
+ 3);
4280 sigaddset (sigs
, signum
+ 4);
4286 /* Find process PID's pending signals from /proc/pid/status and set
4290 linux_proc_pending_signals (int pid
, sigset_t
*pending
,
4291 sigset_t
*blocked
, sigset_t
*ignored
)
4294 char buffer
[PATH_MAX
], fname
[PATH_MAX
];
4295 struct cleanup
*cleanup
;
4297 sigemptyset (pending
);
4298 sigemptyset (blocked
);
4299 sigemptyset (ignored
);
4300 xsnprintf (fname
, sizeof fname
, "/proc/%d/status", pid
);
4301 procfile
= gdb_fopen_cloexec (fname
, "r");
4302 if (procfile
== NULL
)
4303 error (_("Could not open %s"), fname
);
4304 cleanup
= make_cleanup_fclose (procfile
);
4306 while (fgets (buffer
, PATH_MAX
, procfile
) != NULL
)
4308 /* Normal queued signals are on the SigPnd line in the status
4309 file. However, 2.6 kernels also have a "shared" pending
4310 queue for delivering signals to a thread group, so check for
4313 Unfortunately some Red Hat kernels include the shared pending
4314 queue but not the ShdPnd status field. */
4316 if (startswith (buffer
, "SigPnd:\t"))
4317 add_line_to_sigset (buffer
+ 8, pending
);
4318 else if (startswith (buffer
, "ShdPnd:\t"))
4319 add_line_to_sigset (buffer
+ 8, pending
);
4320 else if (startswith (buffer
, "SigBlk:\t"))
4321 add_line_to_sigset (buffer
+ 8, blocked
);
4322 else if (startswith (buffer
, "SigIgn:\t"))
4323 add_line_to_sigset (buffer
+ 8, ignored
);
4326 do_cleanups (cleanup
);
4329 static enum target_xfer_status
4330 linux_nat_xfer_osdata (struct target_ops
*ops
, enum target_object object
,
4331 const char *annex
, gdb_byte
*readbuf
,
4332 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
4333 ULONGEST
*xfered_len
)
4335 gdb_assert (object
== TARGET_OBJECT_OSDATA
);
4337 *xfered_len
= linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
4338 if (*xfered_len
== 0)
4339 return TARGET_XFER_EOF
;
4341 return TARGET_XFER_OK
;
4344 static enum target_xfer_status
4345 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4346 const char *annex
, gdb_byte
*readbuf
,
4347 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
4348 ULONGEST
*xfered_len
)
4350 enum target_xfer_status xfer
;
4352 if (object
== TARGET_OBJECT_AUXV
)
4353 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
4354 offset
, len
, xfered_len
);
4356 if (object
== TARGET_OBJECT_OSDATA
)
4357 return linux_nat_xfer_osdata (ops
, object
, annex
, readbuf
, writebuf
,
4358 offset
, len
, xfered_len
);
4360 if (object
== TARGET_OBJECT_SPU
)
4361 return linux_proc_xfer_spu (ops
, object
, annex
, readbuf
, writebuf
,
4362 offset
, len
, xfered_len
);
4364 /* GDB calculates all the addresses in possibly larget width of the address.
4365 Address width needs to be masked before its final use - either by
4366 linux_proc_xfer_partial or inf_ptrace_xfer_partial.
4368 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
4370 if (object
== TARGET_OBJECT_MEMORY
)
4372 int addr_bit
= gdbarch_addr_bit (target_gdbarch ());
4374 if (addr_bit
< (sizeof (ULONGEST
) * HOST_CHAR_BIT
))
4375 offset
&= ((ULONGEST
) 1 << addr_bit
) - 1;
4378 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
4379 offset
, len
, xfered_len
);
4380 if (xfer
!= TARGET_XFER_EOF
)
4383 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
4384 offset
, len
, xfered_len
);
4388 cleanup_target_stop (void *arg
)
4390 ptid_t
*ptid
= (ptid_t
*) arg
;
4392 gdb_assert (arg
!= NULL
);
4395 target_resume (*ptid
, 0, GDB_SIGNAL_0
);
4398 static VEC(static_tracepoint_marker_p
) *
4399 linux_child_static_tracepoint_markers_by_strid (struct target_ops
*self
,
4402 char s
[IPA_CMD_BUF_SIZE
];
4403 struct cleanup
*old_chain
;
4404 int pid
= ptid_get_pid (inferior_ptid
);
4405 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
4406 struct static_tracepoint_marker
*marker
= NULL
;
4408 ptid_t ptid
= ptid_build (pid
, 0, 0);
4413 memcpy (s
, "qTfSTM", sizeof ("qTfSTM"));
4414 s
[sizeof ("qTfSTM")] = 0;
4416 agent_run_command (pid
, s
, strlen (s
) + 1);
4418 old_chain
= make_cleanup (free_current_marker
, &marker
);
4419 make_cleanup (cleanup_target_stop
, &ptid
);
4424 marker
= XCNEW (struct static_tracepoint_marker
);
4428 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
4430 if (strid
== NULL
|| strcmp (strid
, marker
->str_id
) == 0)
4432 VEC_safe_push (static_tracepoint_marker_p
,
4438 release_static_tracepoint_marker (marker
);
4439 memset (marker
, 0, sizeof (*marker
));
4442 while (*p
++ == ','); /* comma-separated list */
4444 memcpy (s
, "qTsSTM", sizeof ("qTsSTM"));
4445 s
[sizeof ("qTsSTM")] = 0;
4446 agent_run_command (pid
, s
, strlen (s
) + 1);
4450 do_cleanups (old_chain
);
4455 /* Create a prototype generic GNU/Linux target. The client can override
4456 it with local methods. */
4459 linux_target_install_ops (struct target_ops
*t
)
4461 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
4462 t
->to_remove_fork_catchpoint
= linux_child_remove_fork_catchpoint
;
4463 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
4464 t
->to_remove_vfork_catchpoint
= linux_child_remove_vfork_catchpoint
;
4465 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
4466 t
->to_remove_exec_catchpoint
= linux_child_remove_exec_catchpoint
;
4467 t
->to_set_syscall_catchpoint
= linux_child_set_syscall_catchpoint
;
4468 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
4469 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
4470 t
->to_post_attach
= linux_child_post_attach
;
4471 t
->to_follow_fork
= linux_child_follow_fork
;
4473 super_xfer_partial
= t
->to_xfer_partial
;
4474 t
->to_xfer_partial
= linux_xfer_partial
;
4476 t
->to_static_tracepoint_markers_by_strid
4477 = linux_child_static_tracepoint_markers_by_strid
;
4483 struct target_ops
*t
;
4485 t
= inf_ptrace_target ();
4486 linux_target_install_ops (t
);
4492 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
4494 struct target_ops
*t
;
4496 t
= inf_ptrace_trad_target (register_u_offset
);
4497 linux_target_install_ops (t
);
4502 /* target_is_async_p implementation. */
4505 linux_nat_is_async_p (struct target_ops
*ops
)
4507 return linux_is_async_p ();
4510 /* target_can_async_p implementation. */
4513 linux_nat_can_async_p (struct target_ops
*ops
)
4515 /* NOTE: palves 2008-03-21: We're only async when the user requests
4516 it explicitly with the "set target-async" command.
4517 Someday, linux will always be async. */
4518 return target_async_permitted
;
4522 linux_nat_supports_non_stop (struct target_ops
*self
)
4527 /* True if we want to support multi-process. To be removed when GDB
4528 supports multi-exec. */
4530 int linux_multi_process
= 1;
4533 linux_nat_supports_multi_process (struct target_ops
*self
)
4535 return linux_multi_process
;
4539 linux_nat_supports_disable_randomization (struct target_ops
*self
)
4541 #ifdef HAVE_PERSONALITY
4548 static int async_terminal_is_ours
= 1;
4550 /* target_terminal_inferior implementation.
4552 This is a wrapper around child_terminal_inferior to add async support. */
4555 linux_nat_terminal_inferior (struct target_ops
*self
)
4557 /* Like target_terminal_inferior, use target_can_async_p, not
4558 target_is_async_p, since at this point the target is not async
4559 yet. If it can async, then we know it will become async prior to
4561 if (!target_can_async_p ())
4563 /* Async mode is disabled. */
4564 child_terminal_inferior (self
);
4568 child_terminal_inferior (self
);
4570 /* Calls to target_terminal_*() are meant to be idempotent. */
4571 if (!async_terminal_is_ours
)
4574 delete_file_handler (input_fd
);
4575 async_terminal_is_ours
= 0;
4579 /* target_terminal_ours implementation.
4581 This is a wrapper around child_terminal_ours to add async support (and
4582 implement the target_terminal_ours vs target_terminal_ours_for_output
4583 distinction). child_terminal_ours is currently no different than
4584 child_terminal_ours_for_output.
4585 We leave target_terminal_ours_for_output alone, leaving it to
4586 child_terminal_ours_for_output. */
4589 linux_nat_terminal_ours (struct target_ops
*self
)
4591 /* GDB should never give the terminal to the inferior if the
4592 inferior is running in the background (run&, continue&, etc.),
4593 but claiming it sure should. */
4594 child_terminal_ours (self
);
4596 if (async_terminal_is_ours
)
4599 clear_sigint_trap ();
4600 add_file_handler (input_fd
, stdin_event_handler
, 0);
4601 async_terminal_is_ours
= 1;
4604 static void (*async_client_callback
) (enum inferior_event_type event_type
,
4606 static void *async_client_context
;
4608 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4609 so we notice when any child changes state, and notify the
4610 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4611 above to wait for the arrival of a SIGCHLD. */
4614 sigchld_handler (int signo
)
4616 int old_errno
= errno
;
4618 if (debug_linux_nat
)
4619 ui_file_write_async_safe (gdb_stdlog
,
4620 "sigchld\n", sizeof ("sigchld\n") - 1);
4622 if (signo
== SIGCHLD
4623 && linux_nat_event_pipe
[0] != -1)
4624 async_file_mark (); /* Let the event loop know that there are
4625 events to handle. */
4630 /* Callback registered with the target events file descriptor. */
4633 handle_target_event (int error
, gdb_client_data client_data
)
4635 (*async_client_callback
) (INF_REG_EVENT
, async_client_context
);
4638 /* Create/destroy the target events pipe. Returns previous state. */
4641 linux_async_pipe (int enable
)
4643 int previous
= linux_is_async_p ();
4645 if (previous
!= enable
)
4649 /* Block child signals while we create/destroy the pipe, as
4650 their handler writes to it. */
4651 block_child_signals (&prev_mask
);
4655 if (gdb_pipe_cloexec (linux_nat_event_pipe
) == -1)
4656 internal_error (__FILE__
, __LINE__
,
4657 "creating event pipe failed.");
4659 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
4660 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
4664 close (linux_nat_event_pipe
[0]);
4665 close (linux_nat_event_pipe
[1]);
4666 linux_nat_event_pipe
[0] = -1;
4667 linux_nat_event_pipe
[1] = -1;
4670 restore_child_signals_mask (&prev_mask
);
4676 /* target_async implementation. */
4679 linux_nat_async (struct target_ops
*ops
,
4680 void (*callback
) (enum inferior_event_type event_type
,
4684 if (callback
!= NULL
)
4686 async_client_callback
= callback
;
4687 async_client_context
= context
;
4688 if (!linux_async_pipe (1))
4690 add_file_handler (linux_nat_event_pipe
[0],
4691 handle_target_event
, NULL
);
4692 /* There may be pending events to handle. Tell the event loop
4699 async_client_callback
= callback
;
4700 async_client_context
= context
;
4701 delete_file_handler (linux_nat_event_pipe
[0]);
4702 linux_async_pipe (0);
4707 /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4711 linux_nat_stop_lwp (struct lwp_info
*lwp
, void *data
)
4715 if (debug_linux_nat
)
4716 fprintf_unfiltered (gdb_stdlog
,
4717 "LNSL: running -> suspending %s\n",
4718 target_pid_to_str (lwp
->ptid
));
4721 if (lwp
->last_resume_kind
== resume_stop
)
4723 if (debug_linux_nat
)
4724 fprintf_unfiltered (gdb_stdlog
,
4725 "linux-nat: already stopping LWP %ld at "
4727 ptid_get_lwp (lwp
->ptid
));
4731 stop_callback (lwp
, NULL
);
4732 lwp
->last_resume_kind
= resume_stop
;
4736 /* Already known to be stopped; do nothing. */
4738 if (debug_linux_nat
)
4740 if (find_thread_ptid (lwp
->ptid
)->stop_requested
)
4741 fprintf_unfiltered (gdb_stdlog
,
4742 "LNSL: already stopped/stop_requested %s\n",
4743 target_pid_to_str (lwp
->ptid
));
4745 fprintf_unfiltered (gdb_stdlog
,
4746 "LNSL: already stopped/no "
4747 "stop_requested yet %s\n",
4748 target_pid_to_str (lwp
->ptid
));
4755 linux_nat_stop (struct target_ops
*self
, ptid_t ptid
)
4758 iterate_over_lwps (ptid
, linux_nat_stop_lwp
, NULL
);
4760 linux_ops
->to_stop (linux_ops
, ptid
);
4764 linux_nat_close (struct target_ops
*self
)
4766 /* Unregister from the event loop. */
4767 if (linux_nat_is_async_p (self
))
4768 linux_nat_async (self
, NULL
, NULL
);
4770 if (linux_ops
->to_close
)
4771 linux_ops
->to_close (linux_ops
);
4776 /* When requests are passed down from the linux-nat layer to the
4777 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4778 used. The address space pointer is stored in the inferior object,
4779 but the common code that is passed such ptid can't tell whether
4780 lwpid is a "main" process id or not (it assumes so). We reverse
4781 look up the "main" process id from the lwp here. */
4783 static struct address_space
*
4784 linux_nat_thread_address_space (struct target_ops
*t
, ptid_t ptid
)
4786 struct lwp_info
*lwp
;
4787 struct inferior
*inf
;
4790 if (ptid_get_lwp (ptid
) == 0)
4792 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
4794 lwp
= find_lwp_pid (ptid
);
4795 pid
= ptid_get_pid (lwp
->ptid
);
4799 /* A (pid,lwpid,0) ptid. */
4800 pid
= ptid_get_pid (ptid
);
4803 inf
= find_inferior_pid (pid
);
4804 gdb_assert (inf
!= NULL
);
4808 /* Return the cached value of the processor core for thread PTID. */
4811 linux_nat_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
4813 struct lwp_info
*info
= find_lwp_pid (ptid
);
4821 linux_nat_add_target (struct target_ops
*t
)
4823 /* Save the provided single-threaded target. We save this in a separate
4824 variable because another target we've inherited from (e.g. inf-ptrace)
4825 may have saved a pointer to T; we want to use it for the final
4826 process stratum target. */
4827 linux_ops_saved
= *t
;
4828 linux_ops
= &linux_ops_saved
;
4830 /* Override some methods for multithreading. */
4831 t
->to_create_inferior
= linux_nat_create_inferior
;
4832 t
->to_attach
= linux_nat_attach
;
4833 t
->to_detach
= linux_nat_detach
;
4834 t
->to_resume
= linux_nat_resume
;
4835 t
->to_wait
= linux_nat_wait
;
4836 t
->to_pass_signals
= linux_nat_pass_signals
;
4837 t
->to_xfer_partial
= linux_nat_xfer_partial
;
4838 t
->to_kill
= linux_nat_kill
;
4839 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
4840 t
->to_thread_alive
= linux_nat_thread_alive
;
4841 t
->to_pid_to_str
= linux_nat_pid_to_str
;
4842 t
->to_thread_name
= linux_nat_thread_name
;
4843 t
->to_has_thread_control
= tc_schedlock
;
4844 t
->to_thread_address_space
= linux_nat_thread_address_space
;
4845 t
->to_stopped_by_watchpoint
= linux_nat_stopped_by_watchpoint
;
4846 t
->to_stopped_data_address
= linux_nat_stopped_data_address
;
4847 t
->to_stopped_by_sw_breakpoint
= linux_nat_stopped_by_sw_breakpoint
;
4848 t
->to_supports_stopped_by_sw_breakpoint
= linux_nat_supports_stopped_by_sw_breakpoint
;
4849 t
->to_stopped_by_hw_breakpoint
= linux_nat_stopped_by_hw_breakpoint
;
4850 t
->to_supports_stopped_by_hw_breakpoint
= linux_nat_supports_stopped_by_hw_breakpoint
;
4852 t
->to_can_async_p
= linux_nat_can_async_p
;
4853 t
->to_is_async_p
= linux_nat_is_async_p
;
4854 t
->to_supports_non_stop
= linux_nat_supports_non_stop
;
4855 t
->to_async
= linux_nat_async
;
4856 t
->to_terminal_inferior
= linux_nat_terminal_inferior
;
4857 t
->to_terminal_ours
= linux_nat_terminal_ours
;
4859 super_close
= t
->to_close
;
4860 t
->to_close
= linux_nat_close
;
4862 /* Methods for non-stop support. */
4863 t
->to_stop
= linux_nat_stop
;
4865 t
->to_supports_multi_process
= linux_nat_supports_multi_process
;
4867 t
->to_supports_disable_randomization
4868 = linux_nat_supports_disable_randomization
;
4870 t
->to_core_of_thread
= linux_nat_core_of_thread
;
4872 /* We don't change the stratum; this target will sit at
4873 process_stratum and thread_db will set at thread_stratum. This
4874 is a little strange, since this is a multi-threaded-capable
4875 target, but we want to be on the stack below thread_db, and we
4876 also want to be used for single-threaded processes. */
4881 /* Register a method to call whenever a new thread is attached. */
4883 linux_nat_set_new_thread (struct target_ops
*t
,
4884 void (*new_thread
) (struct lwp_info
*))
4886 /* Save the pointer. We only support a single registered instance
4887 of the GNU/Linux native target, so we do not need to map this to
4889 linux_nat_new_thread
= new_thread
;
4892 /* See declaration in linux-nat.h. */
4895 linux_nat_set_new_fork (struct target_ops
*t
,
4896 linux_nat_new_fork_ftype
*new_fork
)
4898 /* Save the pointer. */
4899 linux_nat_new_fork
= new_fork
;
4902 /* See declaration in linux-nat.h. */
4905 linux_nat_set_forget_process (struct target_ops
*t
,
4906 linux_nat_forget_process_ftype
*fn
)
4908 /* Save the pointer. */
4909 linux_nat_forget_process_hook
= fn
;
4912 /* See declaration in linux-nat.h. */
4915 linux_nat_forget_process (pid_t pid
)
4917 if (linux_nat_forget_process_hook
!= NULL
)
4918 linux_nat_forget_process_hook (pid
);
4921 /* Register a method that converts a siginfo object between the layout
4922 that ptrace returns, and the layout in the architecture of the
4925 linux_nat_set_siginfo_fixup (struct target_ops
*t
,
4926 int (*siginfo_fixup
) (siginfo_t
*,
4930 /* Save the pointer. */
4931 linux_nat_siginfo_fixup
= siginfo_fixup
;
4934 /* Register a method to call prior to resuming a thread. */
4937 linux_nat_set_prepare_to_resume (struct target_ops
*t
,
4938 void (*prepare_to_resume
) (struct lwp_info
*))
4940 /* Save the pointer. */
4941 linux_nat_prepare_to_resume
= prepare_to_resume
;
4944 /* See linux-nat.h. */
4947 linux_nat_get_siginfo (ptid_t ptid
, siginfo_t
*siginfo
)
4951 pid
= ptid_get_lwp (ptid
);
4953 pid
= ptid_get_pid (ptid
);
4956 ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, siginfo
);
4959 memset (siginfo
, 0, sizeof (*siginfo
));
4965 /* See nat/linux-nat.h. */
4968 current_lwp_ptid (void)
4970 gdb_assert (ptid_lwp_p (inferior_ptid
));
4971 return inferior_ptid
;
4974 /* Provide a prototype to silence -Wmissing-prototypes. */
4975 extern initialize_file_ftype _initialize_linux_nat
;
4978 _initialize_linux_nat (void)
4980 add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance
,
4981 &debug_linux_nat
, _("\
4982 Set debugging of GNU/Linux lwp module."), _("\
4983 Show debugging of GNU/Linux lwp module."), _("\
4984 Enables printf debugging output."),
4986 show_debug_linux_nat
,
4987 &setdebuglist
, &showdebuglist
);
4989 /* Save this mask as the default. */
4990 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
4992 /* Install a SIGCHLD handler. */
4993 sigchld_action
.sa_handler
= sigchld_handler
;
4994 sigemptyset (&sigchld_action
.sa_mask
);
4995 sigchld_action
.sa_flags
= SA_RESTART
;
4997 /* Make it the default. */
4998 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
5000 /* Make sure we don't block SIGCHLD during a sigsuspend. */
5001 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
5002 sigdelset (&suspend_mask
, SIGCHLD
);
5004 sigemptyset (&blocked_mask
);
5006 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to
5007 support read-only process state. */
5008 linux_ptrace_set_additional_flags (PTRACE_O_TRACESYSGOOD
5009 | PTRACE_O_TRACEVFORKDONE
5010 | PTRACE_O_TRACEVFORK
5011 | PTRACE_O_TRACEFORK
5012 | PTRACE_O_TRACEEXEC
);
5016 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5017 the GNU/Linux Threads library and therefore doesn't really belong
5020 /* Read variable NAME in the target and return its value if found.
5021 Otherwise return zero. It is assumed that the type of the variable
5025 get_signo (const char *name
)
5027 struct bound_minimal_symbol ms
;
5030 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
5031 if (ms
.minsym
== NULL
)
5034 if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
5035 sizeof (signo
)) != 0)
5041 /* Return the set of signals used by the threads library in *SET. */
5044 lin_thread_get_thread_signals (sigset_t
*set
)
5046 struct sigaction action
;
5047 int restart
, cancel
;
5049 sigemptyset (&blocked_mask
);
5052 restart
= get_signo ("__pthread_sig_restart");
5053 cancel
= get_signo ("__pthread_sig_cancel");
5055 /* LinuxThreads normally uses the first two RT signals, but in some legacy
5056 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
5057 not provide any way for the debugger to query the signal numbers -
5058 fortunately they don't change! */
5061 restart
= __SIGRTMIN
;
5064 cancel
= __SIGRTMIN
+ 1;
5066 sigaddset (set
, restart
);
5067 sigaddset (set
, cancel
);
5069 /* The GNU/Linux Threads library makes terminating threads send a
5070 special "cancel" signal instead of SIGCHLD. Make sure we catch
5071 those (to prevent them from terminating GDB itself, which is
5072 likely to be their default action) and treat them the same way as
5075 action
.sa_handler
= sigchld_handler
;
5076 sigemptyset (&action
.sa_mask
);
5077 action
.sa_flags
= SA_RESTART
;
5078 sigaction (cancel
, &action
, NULL
);
5080 /* We block the "cancel" signal throughout this code ... */
5081 sigaddset (&blocked_mask
, cancel
);
5082 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
5084 /* ... except during a sigsuspend. */
5085 sigdelset (&suspend_mask
, cancel
);