1 /* Multi-threaded debugging support for Linux (LWP layer).
2 Copyright 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include "gdb_assert.h"
26 #include <sys/ptrace.h>
29 #include "gdbthread.h"
35 static int debug_lin_lwp
;
36 extern const char *strsignal (int sig
);
38 /* On Linux there are no real LWP's. The closest thing to LWP's are
39 processes sharing the same VM space. A multi-threaded process is
40 basically a group of such processes. However, such a grouping is
41 almost entirely a user-space issue; the kernel doesn't enforce such
42 a grouping at all (this might change in the future). In general,
43 we'll rely on the threads library (i.e. the LinuxThreads library)
44 to provide such a grouping.
46 It is perfectly well possible to write a multi-threaded application
47 without the assistance of a threads library, by using the clone
48 system call directly. This module should be able to give some
49 rudimentary support for debugging such applications if developers
50 specify the CLONE_PTRACE flag in the clone system call, and are
51 using Linux 2.4 or above.
53 Note that there are some peculiarities in Linux that affect this
56 - In general one should specify the __WCLONE flag to waitpid in
57 order to make it report events for any of the cloned processes
58 (and leave it out for the initial process). However, if a cloned
59 process has exited the exit status is only reported if the
60 __WCLONE flag is absent. Linux 2.4 has a __WALL flag, but we
61 cannot use it since GDB must work on older systems too.
63 - When a traced, cloned process exits and is waited for by the
64 debugger, the kernel reassigns it to the original parent and
65 keeps it around as a "zombie". Somehow, the LinuxThreads library
66 doesn't notice this, which leads to the "zombie problem": When
67 debugged a multi-threaded process that spawns a lot of threads
68 will run out of processes, even if the threads exit, because the
69 "zombies" stay around. */
71 /* Structure describing a LWP. */
74 /* The process id of the LWP. This is a combination of the LWP id
75 and overall process id. */
78 /* Non-zero if this LWP is cloned. In this context "cloned" means
79 that the LWP is reporting to its parent using a signal other than
83 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
87 /* Non-zero if this LWP is stopped. */
90 /* Non-zero if this LWP will be/has been resumed. Note that an LWP
91 can be marked both as stopped and resumed at the same time. This
92 happens if we try to resume an LWP that has a wait status
93 pending. We shouldn't let the LWP run until that wait status has
94 been processed, but we should not report that wait status if GDB
95 didn't try to let the LWP run. */
98 /* If non-zero, a pending wait status. */
101 /* Non-zero if we were stepping this LWP. */
104 /* Next LWP in list. */
105 struct lwp_info
*next
;
108 /* List of known LWPs. */
109 static struct lwp_info
*lwp_list
;
111 /* Number of LWPs in the list. */
114 /* Non-zero if we're running in "threaded" mode. */
118 #define GET_LWP(ptid) ptid_get_lwp (ptid)
119 #define GET_PID(ptid) ptid_get_pid (ptid)
120 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
121 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
123 /* If the last reported event was a SIGTRAP, this variable is set to
124 the process id of the LWP/thread that got it. */
128 /* This module's target-specific operations. */
129 static struct target_ops lin_lwp_ops
;
131 /* The standard child operations. */
132 extern struct target_ops child_ops
;
134 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
135 any cloned processes with a single call to waitpid, we have to use
136 the WNOHANG flag and call waitpid in a loop. To optimize
137 things a bit we use `sigsuspend' to wake us up when a process has
138 something to report (it will send us a SIGCHLD if it has). To make
139 this work we have to juggle with the signal mask. We save the
140 original signal mask such that we can restore it before creating a
141 new process in order to avoid blocking certain signals in the
142 inferior. We then block SIGCHLD during the waitpid/sigsuspend
145 /* Original signal mask. */
146 static sigset_t normal_mask
;
148 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
149 _initialize_lin_lwp. */
150 static sigset_t suspend_mask
;
152 /* Signals to block to make that sigsuspend work. */
153 static sigset_t blocked_mask
;
156 /* Prototypes for local functions. */
157 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
159 /* Convert wait status STATUS to a string. Used for printing debug
163 status_to_str (int status
)
167 if (WIFSTOPPED (status
))
168 snprintf (buf
, sizeof (buf
), "%s (stopped)",
169 strsignal (WSTOPSIG (status
)));
170 else if (WIFSIGNALED (status
))
171 snprintf (buf
, sizeof (buf
), "%s (terminated)",
172 strsignal (WSTOPSIG (status
)));
174 snprintf (buf
, sizeof (buf
), "%d (exited)",
175 WEXITSTATUS (status
));
180 /* Initialize the list of LWPs. Note that this module, contrary to
181 what GDB's generic threads layer does for its thread list,
182 re-initializes the LWP lists whenever we mourn or detach (which
183 doesn't involve mourning) the inferior. */
188 struct lwp_info
*lp
, *lpnext
;
190 for (lp
= lwp_list
; lp
; lp
= lpnext
)
201 /* Add the LWP specified by PID to the list. If this causes the
202 number of LWPs to become larger than one, go into "threaded" mode.
203 Return a pointer to the structure describing the new LWP. */
205 static struct lwp_info
*
206 add_lwp (ptid_t ptid
)
210 gdb_assert (is_lwp (ptid
));
212 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
214 memset (lp
, 0, sizeof (struct lwp_info
));
226 /* Remove the LWP specified by PID from the list. */
229 delete_lwp (ptid_t ptid
)
231 struct lwp_info
*lp
, *lpprev
;
235 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
236 if (ptid_equal (lp
->ptid
, ptid
))
242 /* We don't go back to "non-threaded" mode if the number of threads
243 becomes less than two. */
247 lpprev
->next
= lp
->next
;
254 /* Return a pointer to the structure describing the LWP corresponding
255 to PID. If no corresponding LWP could be found, return NULL. */
257 static struct lwp_info
*
258 find_lwp_pid (ptid_t ptid
)
264 lwp
= GET_LWP (ptid
);
266 lwp
= GET_PID (ptid
);
268 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
269 if (lwp
== GET_LWP (lp
->ptid
))
275 /* Call CALLBACK with its second argument set to DATA for every LWP in
276 the list. If CALLBACK returns 1 for a particular LWP, return a
277 pointer to the structure describing that LWP immediately.
278 Otherwise return NULL. */
281 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
283 struct lwp_info
*lp
, *lpnext
;
285 for (lp
= lwp_list
; lp
; lp
= lpnext
)
288 if ((*callback
) (lp
, data
))
296 /* Implementation of the PREPARE_TO_PROCEED hook for the Linux LWP
299 Note that this implementation is potentially redundant now that
300 default_prepare_to_proceed() has been added.
302 FIXME This may not support switching threads after Ctrl-C
303 correctly. The default implementation does support this. */
306 lin_lwp_prepare_to_proceed (void)
308 if (! ptid_equal (trap_ptid
, null_ptid
)
309 && ! ptid_equal (inferior_ptid
, trap_ptid
))
311 /* Switched over from TRAP_PID. */
312 CORE_ADDR stop_pc
= read_pc ();
315 /* Avoid switching where it wouldn't do any good, i.e. if both
316 threads are at the same breakpoint. */
317 trap_pc
= read_pc_pid (trap_ptid
);
318 if (trap_pc
!= stop_pc
&& breakpoint_here_p (trap_pc
))
320 /* User hasn't deleted the breakpoint. Return non-zero, and
321 switch back to TRAP_PID. */
322 inferior_ptid
= trap_ptid
;
324 /* FIXME: Is this stuff really necessary? */
325 flush_cached_frames ();
326 registers_changed ();
338 lin_lwp_open (char *args
, int from_tty
)
340 push_target (&lin_lwp_ops
);
344 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
345 a message telling the user that a new LWP has been added to the
349 lin_lwp_attach_lwp (ptid_t ptid
, int verbose
)
353 gdb_assert (is_lwp (ptid
));
356 printf_filtered ("[New %s]\n", target_pid_to_str (ptid
));
358 lp
= find_lwp_pid (ptid
);
362 /* We assume that we're already attached to any LWP that has an
363 id equal to the overall process id. */
364 if (GET_LWP (ptid
) != GET_PID (ptid
))
369 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
370 error ("Can't attach %s: %s", target_pid_to_str (ptid
),
373 pid
= waitpid (GET_LWP (ptid
), &status
, 0);
374 if (pid
== -1 && errno
== ECHILD
)
376 /* Try again with __WCLONE to check cloned processes. */
377 pid
= waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
381 gdb_assert (pid
== GET_LWP (ptid
)
382 && WIFSTOPPED (status
) && WSTOPSIG (status
));
389 lin_lwp_attach (char *args
, int from_tty
)
395 /* FIXME: We should probably accept a list of process id's, and
396 attach all of them. */
397 child_ops
.to_attach (args
, from_tty
);
399 /* Add the initial process as the first LWP to the list. */
400 lp
= add_lwp (BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
)));
402 /* Make sure the initial process is stopped. The user-level threads
403 layer might want to poke around in the inferior, and that won't
404 work if things haven't stabilized yet. */
405 pid
= waitpid (GET_PID (inferior_ptid
), &status
, 0);
406 if (pid
== -1 && errno
== ECHILD
)
408 warning ("%s is a cloned process", target_pid_to_str (inferior_ptid
));
410 /* Try again with __WCLONE to check cloned processes. */
411 pid
= waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
415 gdb_assert (pid
== GET_PID (inferior_ptid
)
416 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
420 /* Fake the SIGSTOP that core GDB expects. */
421 lp
->status
= W_STOPCODE (SIGSTOP
);
426 detach_callback (struct lwp_info
*lp
, void *data
)
428 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
430 if (debug_lin_lwp
&& lp
->status
)
431 fprintf_unfiltered (gdb_stdlog
, "Pending %s for LWP %ld on detach.\n",
432 strsignal (WSTOPSIG (lp
->status
)), GET_LWP (lp
->ptid
));
434 while (lp
->signalled
&& lp
->stopped
)
436 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
437 WSTOPSIG (lp
->status
)) < 0)
438 error ("Can't continue %s: %s", target_pid_to_str (lp
->ptid
),
444 stop_wait_callback (lp
, NULL
);
446 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
449 /* We don't actually detach from the LWP that has an id equal to the
450 overall process id just yet. */
451 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
453 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
454 WSTOPSIG (lp
->status
)) < 0)
455 error ("Can't detach %s: %s", target_pid_to_str (lp
->ptid
),
458 delete_lwp (lp
->ptid
);
465 lin_lwp_detach (char *args
, int from_tty
)
467 iterate_over_lwps (detach_callback
, NULL
);
469 /* Only the initial process should be left right now. */
470 gdb_assert (num_lwps
== 1);
472 trap_ptid
= null_ptid
;
474 /* Destroy LWP info; it's no longer valid. */
477 /* Restore the original signal mask. */
478 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
479 sigemptyset (&blocked_mask
);
481 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
482 child_ops
.to_detach (args
, from_tty
);
486 struct private_thread_info
491 /* Return non-zero if TP corresponds to the LWP specified by DATA
492 (which is assumed to be a pointer to a `struct lwp_info'. */
495 find_lwp_callback (struct thread_info
*tp
, void *data
)
497 struct lwp_info
*lp
= data
;
499 if (tp
->private->lwpid
== GET_LWP (lp
->ptid
))
508 resume_callback (struct lwp_info
*lp
, void *data
)
510 if (lp
->stopped
&& lp
->status
== 0)
512 struct thread_info
*tp
;
515 /* FIXME: kettenis/2000-08-26: This should really be handled
516 properly by core GDB. */
518 tp
= find_thread_pid (lp
->ptid
);
520 tp
= iterate_over_threads (find_lwp_callback
, lp
);
523 /* If we were previously stepping the thread, and now continue
524 the thread we must invalidate the stepping range. However,
525 if there is a step_resume breakpoint for this thread, we must
526 preserve the stepping range to make it possible to continue
527 stepping once we hit it. */
528 if (tp
->step_range_end
&& tp
->step_resume_breakpoint
== NULL
)
530 gdb_assert (lp
->step
);
531 tp
->step_range_start
= tp
->step_range_end
= 0;
535 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), 0, TARGET_SIGNAL_0
);
544 resume_clear_callback (struct lwp_info
*lp
, void *data
)
551 resume_set_callback (struct lwp_info
*lp
, void *data
)
558 lin_lwp_resume (ptid_t ptid
, int step
, enum target_signal signo
)
563 /* Apparently the interpretation of PID is dependent on STEP: If
564 STEP is non-zero, a specific PID means `step only this process
565 id'. But if STEP is zero, then PID means `continue *all*
566 processes, but give the signal only to this one'. */
567 resume_all
= (PIDGET (ptid
) == -1) || !step
;
570 iterate_over_lwps (resume_set_callback
, NULL
);
572 iterate_over_lwps (resume_clear_callback
, NULL
);
574 /* If PID is -1, it's the current inferior that should be
575 handled specially. */
576 if (PIDGET (ptid
) == -1)
577 ptid
= inferior_ptid
;
579 lp
= find_lwp_pid (ptid
);
582 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
584 /* Remember if we're stepping. */
587 /* Mark this LWP as resumed. */
590 /* If we have a pending wait status for this thread, there is no
591 point in resuming the process. */
594 /* FIXME: What should we do if we are supposed to continue
595 this thread with a signal? */
596 gdb_assert (signo
== TARGET_SIGNAL_0
);
600 /* Mark LWP as not stopped to prevent it from being continued by
606 iterate_over_lwps (resume_callback
, NULL
);
608 child_resume (ptid
, step
, signo
);
612 /* Send a SIGSTOP to LP. */
615 stop_callback (struct lwp_info
*lp
, void *data
)
617 if (! lp
->stopped
&& ! lp
->signalled
)
621 ret
= kill (GET_LWP (lp
->ptid
), SIGSTOP
);
622 gdb_assert (ret
== 0);
625 gdb_assert (lp
->status
== 0);
631 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
632 a pointer to a set of signals to be flushed immediately. */
635 stop_wait_callback (struct lwp_info
*lp
, void *data
)
637 sigset_t
*flush_mask
= data
;
639 if (! lp
->stopped
&& lp
->signalled
)
644 gdb_assert (lp
->status
== 0);
646 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, lp
->cloned
? __WCLONE
: 0);
647 if (pid
== -1 && errno
== ECHILD
)
648 /* OK, the proccess has disappeared. We'll catch the actual
649 exit event in lin_lwp_wait. */
652 gdb_assert (pid
== GET_LWP (lp
->ptid
));
654 if (WIFEXITED (status
) || WIFSIGNALED (status
))
656 gdb_assert (num_lwps
> 1);
658 if (in_thread_list (lp
->ptid
))
660 /* Core GDB cannot deal with us deleting the current
662 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
663 delete_thread (lp
->ptid
);
664 printf_unfiltered ("[%s exited]\n",
665 target_pid_to_str (lp
->ptid
));
668 fprintf_unfiltered (gdb_stdlog
,
669 "%s exited.\n", target_pid_to_str (lp
->ptid
));
671 delete_lwp (lp
->ptid
);
675 gdb_assert (WIFSTOPPED (status
));
677 /* Ignore any signals in FLUSH_MASK. */
678 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
680 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
681 return stop_wait_callback (lp
, flush_mask
);
684 if (WSTOPSIG (status
) != SIGSTOP
)
686 if (WSTOPSIG (status
) == SIGTRAP
)
688 /* If a LWP other than the LWP that we're reporting an
689 event for has hit a GDB breakpoint (as opposed to
690 some random trap signal), then just arrange for it to
691 hit it again later. We don't keep the SIGTRAP status
692 and don't forward the SIGTRAP signal to the LWP. We
693 will handle the current event, eventually we will
694 resume all LWPs, and this one will get its breakpoint
697 If we do not do this, then we run the risk that the
698 user will delete or disable the breakpoint, but the
699 thread will have already tripped on it. */
701 /* Now resume this LWP and get the SIGSTOP event. */
702 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
705 fprintf_unfiltered (gdb_stderr
,
706 "SWC: Candidate SIGTRAP event in %ld\n",
709 /* Hold the SIGTRAP for handling by lin_lwp_wait. */
710 stop_wait_callback (lp
, data
);
711 /* If there's another event, throw it back into the queue. */
713 kill (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
714 /* Save the sigtrap event. */
720 /* The thread was stopped with a signal other than
721 SIGSTOP, and didn't accidentally trip a breakpoint. */
725 fprintf_unfiltered (gdb_stderr
,
726 "SWC: Pending event %d in %ld\n",
727 WSTOPSIG (status
), GET_LWP (lp
->ptid
));
729 /* Now resume this LWP and get the SIGSTOP event. */
730 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
732 /* Hold this event/waitstatus while we check to see if
733 there are any more (we still want to get that SIGSTOP). */
734 stop_wait_callback (lp
, data
);
735 /* If the lp->status field is still empty, use it to hold
736 this event. If not, then this event must be returned
737 to the event queue of the LWP. */
741 kill (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
747 /* We caught the SIGSTOP that we intended to catch, so
748 there's no SIGSTOP pending. */
757 /* Return non-zero if LP has a wait status pending. */
760 status_callback (struct lwp_info
*lp
, void *data
)
762 /* Only report a pending wait status if we pretend that this has
763 indeed been resumed. */
764 return (lp
->status
!= 0 && lp
->resumed
);
767 /* Return non-zero if LP isn't stopped. */
770 running_callback (struct lwp_info
*lp
, void *data
)
772 return (lp
->stopped
== 0);
775 /* Count the LWP's that have had events. */
778 count_events_callback (struct lwp_info
*lp
, void *data
)
782 gdb_assert (count
!= NULL
);
784 /* Count only LWPs that have a SIGTRAP event pending. */
786 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
792 /* Select the LWP (if any) that is currently being single-stepped. */
795 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
797 if (lp
->step
&& lp
->status
!= 0)
803 /* Select the Nth LWP that has had a SIGTRAP event. */
806 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
808 int *selector
= data
;
810 gdb_assert (selector
!= NULL
);
812 /* Select only LWPs that have a SIGTRAP event pending. */
814 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
815 if ((*selector
)-- == 0)
822 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
824 struct lwp_info
*event_lp
= data
;
826 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
830 /* If a LWP other than the LWP that we're reporting an event for has
831 hit a GDB breakpoint (as opposed to some random trap signal),
832 then just arrange for it to hit it again later. We don't keep
833 the SIGTRAP status and don't forward the SIGTRAP signal to the
834 LWP. We will handle the current event, eventually we will resume
835 all LWPs, and this one will get its breakpoint trap again.
837 If we do not do this, then we run the risk that the user will
838 delete or disable the breakpoint, but the LWP will have already
842 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
843 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
844 DECR_PC_AFTER_BREAK
))
847 fprintf_unfiltered (gdb_stdlog
,
848 "Push back breakpoint for LWP %ld\n",
851 /* Back up the PC if necessary. */
852 if (DECR_PC_AFTER_BREAK
)
853 write_pc_pid (read_pc_pid (lp
->ptid
) - DECR_PC_AFTER_BREAK
, lp
->ptid
);
855 /* Throw away the SIGTRAP. */
862 /* Select one LWP out of those that have events pending. */
865 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
869 struct lwp_info
*event_lp
;
871 /* Record the wait status for the origional LWP. */
872 (*orig_lp
)->status
= *status
;
874 /* Give preference to any LWP that is being single-stepped. */
875 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
876 if (event_lp
!= NULL
)
879 fprintf_unfiltered (gdb_stdlog
,
880 "Select single-step LWP %ld\n",
881 GET_LWP (event_lp
->ptid
));
885 /* No single-stepping LWP. Select one at random, out of those
886 which have had SIGTRAP events. */
888 /* First see how many SIGTRAP events we have. */
889 iterate_over_lwps (count_events_callback
, &num_events
);
891 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
892 random_selector
= (int)
893 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
895 if (debug_lin_lwp
&& num_events
> 1)
896 fprintf_unfiltered (gdb_stdlog
,
897 "Found %d SIGTRAP events, selecting #%d\n",
898 num_events
, random_selector
);
900 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
904 if (event_lp
!= NULL
)
906 /* Switch the event LWP. */
908 *status
= event_lp
->status
;
911 /* Flush the wait status for the event LWP. */
912 (*orig_lp
)->status
= 0;
915 /* Return non-zero if LP has been resumed. */
918 resumed_callback (struct lwp_info
*lp
, void *data
)
925 /* We need to override child_wait to support attaching to cloned
926 processes, since a normal wait (as done by the default version)
927 ignores those processes. */
929 /* Wait for child PTID to do something. Return id of the child,
930 minus_one_ptid in case of error; store status into *OURSTATUS. */
933 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
941 set_sigint_trap (); /* Causes SIGINT to be passed on to the
945 pid
= waitpid (GET_PID (ptid
), &status
, 0);
946 if (pid
== -1 && errno
== ECHILD
)
947 /* Try again with __WCLONE to check cloned processes. */
948 pid
= waitpid (GET_PID (ptid
), &status
, __WCLONE
);
952 clear_sigint_trap ();
954 while (pid
== -1 && errno
== EINTR
);
958 warning ("Child process unexpectedly missing: %s", strerror (errno
));
960 /* Claim it exited with unknown signal. */
961 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
962 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
963 return minus_one_ptid
;
966 store_waitstatus (ourstatus
, status
);
967 return pid_to_ptid (pid
);
973 lin_lwp_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
975 struct lwp_info
*lp
= NULL
;
978 pid_t pid
= PIDGET (ptid
);
981 sigemptyset (&flush_mask
);
983 /* Make sure SIGCHLD is blocked. */
984 if (! sigismember (&blocked_mask
, SIGCHLD
))
986 sigaddset (&blocked_mask
, SIGCHLD
);
987 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
992 /* Make sure there is at least one LWP that has been resumed, at
993 least if there are any LWPs at all. */
994 gdb_assert (num_lwps
== 0 || iterate_over_lwps (resumed_callback
, NULL
));
996 /* First check if there is a LWP with a wait status pending. */
999 /* Any LWP that's been resumed will do. */
1000 lp
= iterate_over_lwps (status_callback
, NULL
);
1003 status
= lp
->status
;
1006 if (debug_lin_lwp
&& status
)
1007 fprintf_unfiltered (gdb_stdlog
,
1008 "Using pending wait status %s for LWP %ld.\n",
1009 status_to_str (status
), GET_LWP (lp
->ptid
));
1012 /* But if we don't fine one, we'll have to wait, and check both
1013 cloned and uncloned processes. We start with the cloned
1015 options
= __WCLONE
| WNOHANG
;
1017 else if (is_lwp (ptid
))
1020 fprintf_unfiltered (gdb_stdlog
,
1021 "Waiting for specific LWP %ld.\n",
1024 /* We have a specific LWP to check. */
1025 lp
= find_lwp_pid (ptid
);
1027 status
= lp
->status
;
1030 if (debug_lin_lwp
&& status
)
1031 fprintf_unfiltered (gdb_stdlog
,
1032 "Using pending wait status %s for LWP %ld.\n",
1033 status_to_str (status
), GET_LWP (lp
->ptid
));
1035 /* If we have to wait, take into account whether PID is a cloned
1036 process or not. And we have to convert it to something that
1037 the layer beneath us can understand. */
1038 options
= lp
->cloned
? __WCLONE
: 0;
1039 pid
= GET_LWP (ptid
);
1042 if (status
&& lp
->signalled
)
1044 /* A pending SIGSTOP may interfere with the normal stream of
1045 events. In a typical case where interference is a problem,
1046 we have a SIGSTOP signal pending for LWP A while
1047 single-stepping it, encounter an event in LWP B, and take the
1048 pending SIGSTOP while trying to stop LWP A. After processing
1049 the event in LWP B, LWP A is continued, and we'll never see
1050 the SIGTRAP associated with the last time we were
1051 single-stepping LWP A. */
1053 /* Resume the thread. It should halt immediately returning the
1055 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1058 gdb_assert (lp
->resumed
);
1060 /* This should catch the pending SIGSTOP. */
1061 stop_wait_callback (lp
, NULL
);
1064 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1065 attached process. */
1072 lwpid
= waitpid (pid
, &status
, options
);
1075 gdb_assert (pid
== -1 || lwpid
== pid
);
1077 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1080 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1081 if (options
& __WCLONE
)
1086 gdb_assert (WIFSTOPPED (status
)
1087 && WSTOPSIG (status
) == SIGSTOP
);
1090 if (! in_thread_list (inferior_ptid
))
1092 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1093 GET_PID (inferior_ptid
));
1094 add_thread (inferior_ptid
);
1097 add_thread (lp
->ptid
);
1098 printf_unfiltered ("[New %s]\n",
1099 target_pid_to_str (lp
->ptid
));
1103 /* Make sure we don't report a TARGET_WAITKIND_EXITED or
1104 TARGET_WAITKIND_SIGNALLED event if there are still LWP's
1105 left in the process. */
1106 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1108 if (in_thread_list (lp
->ptid
))
1110 /* Core GDB cannot deal with us deleting the current
1112 if (! ptid_equal (lp
->ptid
, inferior_ptid
))
1113 delete_thread (lp
->ptid
);
1114 printf_unfiltered ("[%s exited]\n",
1115 target_pid_to_str (lp
->ptid
));
1118 fprintf_unfiltered (gdb_stdlog
,
1120 target_pid_to_str (lp
->ptid
));
1122 delete_lwp (lp
->ptid
);
1124 /* Make sure there is at least one thread running. */
1125 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1127 /* Discard the event. */
1132 /* Make sure we don't report a SIGSTOP that we sent
1133 ourselves in an attempt to stop an LWP. */
1134 if (lp
->signalled
&& WIFSTOPPED (status
)
1135 && WSTOPSIG (status
) == SIGSTOP
)
1138 fprintf_unfiltered (gdb_stdlog
,
1139 "Delayed SIGSTOP caught for %s.\n",
1140 target_pid_to_str (lp
->ptid
));
1142 /* This is a delayed SIGSTOP. */
1145 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1148 gdb_assert (lp
->resumed
);
1150 /* Discard the event. */
1160 /* Alternate between checking cloned and uncloned processes. */
1161 options
^= __WCLONE
;
1163 /* And suspend every time we have checked both. */
1164 if (options
& __WCLONE
)
1165 sigsuspend (&suspend_mask
);
1168 /* We shouldn't end up here unless we want to try again. */
1169 gdb_assert (status
== 0);
1172 clear_sigio_trap ();
1173 clear_sigint_trap ();
1177 /* Don't report signals that GDB isn't interested in, such as
1178 signals that are neither printed nor stopped upon. Stopping all
1179 threads can be a bit time-consuming so if we want decent
1180 performance with heavily multi-threaded programs, especially when
1181 they're using a high frequency timer, we'd better avoid it if we
1184 if (WIFSTOPPED (status
))
1186 int signo
= target_signal_from_host (WSTOPSIG (status
));
1188 if (signal_stop_state (signo
) == 0
1189 && signal_print_state (signo
) == 0
1190 && signal_pass_state (signo
) == 1)
1192 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
1193 here? It is not clear we should. GDB may not expect
1194 other threads to run. On the other hand, not resuming
1195 newly attached threads may cause an unwanted delay in
1196 getting them running. */
1197 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
, signo
);
1203 if (signo
== TARGET_SIGNAL_INT
1204 && signal_pass_state (signo
) == 0)
1206 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
1207 forwarded to the entire process group, that is, all LWP's
1208 will receive it. Since we only want to report it once,
1209 we try to flush it from all LWPs except this one. */
1210 sigaddset (&flush_mask
, SIGINT
);
1214 /* This LWP is stopped now. */
1218 fprintf_unfiltered (gdb_stdlog
, "Candidate event %s in LWP %ld.\n",
1219 status_to_str (status
), GET_LWP (lp
->ptid
));
1221 /* Now stop all other LWP's ... */
1222 iterate_over_lwps (stop_callback
, NULL
);
1224 /* ... and wait until all of them have reported back that they're no
1226 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
1228 /* If we're not waiting for a specific LWP, choose an event LWP from
1229 among those that have had events. Giving equal priority to all
1230 LWPs that have had events helps prevent starvation. */
1232 select_event_lwp (&lp
, &status
);
1234 /* Now that we've selected our final event LWP, cancel any
1235 breakpoints in other LWPs that have hit a GDB breakpoint. See
1236 the comment in cancel_breakpoints_callback to find out why. */
1237 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
1239 /* If we're not running in "threaded" mode, we'll report the bare
1242 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1244 trap_ptid
= (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1246 fprintf_unfiltered (gdb_stdlog
,
1247 "LLW: trap_ptid is %ld\n",
1248 GET_LWP (trap_ptid
));
1251 trap_ptid
= null_ptid
;
1253 store_waitstatus (ourstatus
, status
);
1254 return (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1258 kill_callback (struct lwp_info
*lp
, void *data
)
1260 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
1265 kill_wait_callback (struct lwp_info
*lp
, void *data
)
1269 /* We must make sure that there are no pending events (delayed
1270 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
1271 program doesn't interfere with any following debugging session. */
1273 /* For cloned processes we must check both with __WCLONE and
1274 without, since the exit status of a cloned process isn't reported
1280 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
1282 while (pid
== GET_LWP (lp
->ptid
));
1284 gdb_assert (pid
== -1 && errno
== ECHILD
);
1289 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
1291 while (pid
== GET_LWP (lp
->ptid
));
1293 gdb_assert (pid
== -1 && errno
== ECHILD
);
1300 /* Kill all LWP's ... */
1301 iterate_over_lwps (kill_callback
, NULL
);
1303 /* ... and wait until we've flushed all events. */
1304 iterate_over_lwps (kill_wait_callback
, NULL
);
1306 target_mourn_inferior ();
1310 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
1312 child_ops
.to_create_inferior (exec_file
, allargs
, env
);
1316 lin_lwp_mourn_inferior (void)
1318 trap_ptid
= null_ptid
;
1320 /* Destroy LWP info; it's no longer valid. */
1323 /* Restore the original signal mask. */
1324 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1325 sigemptyset (&blocked_mask
);
1327 child_ops
.to_mourn_inferior ();
1331 lin_lwp_fetch_registers (int regno
)
1333 struct cleanup
*old_chain
= save_inferior_ptid ();
1335 if (is_lwp (inferior_ptid
))
1336 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1338 fetch_inferior_registers (regno
);
1340 do_cleanups (old_chain
);
1344 lin_lwp_store_registers (int regno
)
1346 struct cleanup
*old_chain
= save_inferior_ptid ();
1348 if (is_lwp (inferior_ptid
))
1349 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1351 store_inferior_registers (regno
);
1353 do_cleanups (old_chain
);
1357 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1358 struct mem_attrib
*attrib
,
1359 struct target_ops
*target
)
1361 struct cleanup
*old_chain
= save_inferior_ptid ();
1364 if (is_lwp (inferior_ptid
))
1365 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1367 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1369 do_cleanups (old_chain
);
1374 lin_lwp_thread_alive (ptid_t ptid
)
1376 gdb_assert (is_lwp (ptid
));
1379 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
1387 lin_lwp_pid_to_str (ptid_t ptid
)
1389 static char buf
[64];
1393 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
1397 return normal_pid_to_str (ptid
);
1401 init_lin_lwp_ops (void)
1404 lin_lwp_ops
.to_open
= lin_lwp_open
;
1406 lin_lwp_ops
.to_shortname
= "lwp-layer";
1407 lin_lwp_ops
.to_longname
= "lwp-layer";
1408 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
1409 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
1410 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
1411 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
1412 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
1413 lin_lwp_ops
.to_fetch_registers
= lin_lwp_fetch_registers
;
1414 lin_lwp_ops
.to_store_registers
= lin_lwp_store_registers
;
1415 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1416 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1417 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1418 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1419 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1420 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1421 lin_lwp_ops
.to_stratum
= thread_stratum
;
1422 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1423 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1427 sigchld_handler (int signo
)
1429 /* Do nothing. The only reason for this handler is that it allows
1430 us to use sigsuspend in lin_lwp_wait above to wait for the
1431 arrival of a SIGCHLD. */
1435 _initialize_lin_lwp (void)
1437 struct sigaction action
;
1439 extern void thread_db_init (struct target_ops
*);
1441 init_lin_lwp_ops ();
1442 add_target (&lin_lwp_ops
);
1443 thread_db_init (&lin_lwp_ops
);
1445 /* Save the original signal mask. */
1446 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1448 action
.sa_handler
= sigchld_handler
;
1449 sigemptyset (&action
.sa_mask
);
1450 action
.sa_flags
= 0;
1451 sigaction (SIGCHLD
, &action
, NULL
);
1453 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1454 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1455 sigdelset (&suspend_mask
, SIGCHLD
);
1457 sigemptyset (&blocked_mask
);
1459 add_show_from_set (add_set_cmd ("lin-lwp", no_class
, var_zinteger
,
1460 (char *) &debug_lin_lwp
,
1461 "Set debugging of linux lwp module.\n\
1462 Enables printf debugging output.\n",
1468 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1469 the LinuxThreads library and therefore doesn't really belong here. */
1471 /* Read variable NAME in the target and return its value if found.
1472 Otherwise return zero. It is assumed that the type of the variable
1476 get_signo (const char *name
)
1478 struct minimal_symbol
*ms
;
1481 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1485 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1486 sizeof (signo
)) != 0)
1492 /* Return the set of signals used by the threads library in *SET. */
1495 lin_thread_get_thread_signals (sigset_t
*set
)
1497 struct sigaction action
;
1498 int restart
, cancel
;
1502 restart
= get_signo ("__pthread_sig_restart");
1506 cancel
= get_signo ("__pthread_sig_cancel");
1510 sigaddset (set
, restart
);
1511 sigaddset (set
, cancel
);
1513 /* The LinuxThreads library makes terminating threads send a special
1514 "cancel" signal instead of SIGCHLD. Make sure we catch those (to
1515 prevent them from terminating GDB itself, which is likely to be
1516 their default action) and treat them the same way as SIGCHLD. */
1518 action
.sa_handler
= sigchld_handler
;
1519 sigemptyset (&action
.sa_mask
);
1520 action
.sa_flags
= 0;
1521 sigaction (cancel
, &action
, NULL
);
1523 /* We block the "cancel" signal throughout this code ... */
1524 sigaddset (&blocked_mask
, cancel
);
1525 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1527 /* ... except during a sigsuspend. */
1528 sigdelset (&suspend_mask
, cancel
);