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"
37 extern const char *strsignal (int sig
);
40 /* On Linux there are no real LWP's. The closest thing to LWP's are
41 processes sharing the same VM space. A multi-threaded process is
42 basically a group of such processes. However, such a grouping is
43 almost entirely a user-space issue; the kernel doesn't enforce such
44 a grouping at all (this might change in the future). In general,
45 we'll rely on the threads library (i.e. the LinuxThreads library)
46 to provide such a grouping.
48 It is perfectly well possible to write a multi-threaded application
49 without the assistance of a threads library, by using the clone
50 system call directly. This module should be able to give some
51 rudimentary support for debugging such applications if developers
52 specify the CLONE_PTRACE flag in the clone system call, and are
53 using Linux 2.4 or above.
55 Note that there are some peculiarities in Linux that affect this
58 - In general one should specify the __WCLONE flag to waitpid in
59 order to make it report events for any of the cloned processes
60 (and leave it out for the initial process). However, if a cloned
61 process has exited the exit status is only reported if the
62 __WCLONE flag is absent. Linux 2.4 has a __WALL flag, but we
63 cannot use it since GDB must work on older systems too.
65 - When a traced, cloned process exits and is waited for by the
66 debugger, the kernel reassigns it to the original parent and
67 keeps it around as a "zombie". Somehow, the LinuxThreads library
68 doesn't notice this, which leads to the "zombie problem": When
69 debugged a multi-threaded process that spawns a lot of threads
70 will run out of processes, even if the threads exit, because the
71 "zombies" stay around. */
73 /* Structure describing a LWP. */
76 /* The process id of the LWP. This is a combination of the LWP id
77 and overall process id. */
80 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
84 /* Non-zero if this LWP is stopped. */
87 /* If non-zero, a pending wait status. */
90 /* Non-zero if we were stepping this LWP. */
93 /* Next LWP in list. */
94 struct lwp_info
*next
;
97 /* List of known LWPs. */
98 static struct lwp_info
*lwp_list
;
100 /* Number of LWPs in the list. */
103 /* Non-zero if we're running in "threaded" mode. */
108 #define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
109 #define PIDGET(PID) (((PID) & 0xffff))
110 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
113 #define THREAD_FLAG 0x80000000
114 #define is_lwp(pid) (((pid) & THREAD_FLAG) == 0 && TIDGET (pid))
115 #define GET_LWP(pid) TIDGET (pid)
116 #define GET_PID(pid) PIDGET (pid)
117 #define BUILD_LWP(tid, pid) MERGEPID (pid, tid)
119 #define is_cloned(pid) (GET_LWP (pid) != GET_PID (pid))
121 /* If the last reported event was a SIGTRAP, this variable is set to
122 the process id of the LWP/thread that got it. */
126 /* This module's target-specific operations. */
127 static struct target_ops lin_lwp_ops
;
129 /* The standard child operations. */
130 extern struct target_ops child_ops
;
132 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
133 any cloned processes with a single call to waitpid, we have to use
134 the WNOHANG flag and call waitpid in a loop. To optimize
135 things a bit we use `sigsuspend' to wake us up when a process has
136 something to report (it will send us a SIGCHLD if it has). To make
137 this work we have to juggle with the signal mask. We save the
138 original signal mask such that we can restore it before creating a
139 new process in order to avoid blocking certain signals in the
140 inferior. We then block SIGCHLD during the waitpid/sigsuspend
143 /* Original signal mask. */
144 static sigset_t normal_mask
;
146 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
147 _initialize_lin_lwp. */
148 static sigset_t suspend_mask
;
150 /* Signals to block to make that sigsuspend work. */
151 static sigset_t blocked_mask
;
154 /* Prototypes for local functions. */
155 static void lin_lwp_mourn_inferior (void);
158 /* Initialize the list of LWPs. */
163 struct lwp_info
*lp
, *lpnext
;
165 for (lp
= lwp_list
; lp
; lp
= lpnext
)
176 /* Add the LWP specified by PID to the list. If this causes the
177 number of LWPs to become larger than one, go into "threaded" mode.
178 Return a pointer to the structure describing the new LWP. */
180 static struct lwp_info
*
185 gdb_assert (is_lwp (pid
));
187 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
189 memset (lp
, 0, sizeof (struct lwp_info
));
201 /* Remove the LWP specified by PID from the list. */
206 struct lwp_info
*lp
, *lpprev
;
210 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
217 /* We don't go back to "non-threaded" mode if the number of threads
218 becomes less than two. */
222 lpprev
->next
= lp
->next
;
229 /* Return a pointer to the structure describing the LWP corresponding
230 to PID. If no corresponding LWP could be found, return NULL. */
232 static struct lwp_info
*
233 find_lwp_pid (int pid
)
240 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
241 if (pid
== GET_LWP (lp
->pid
))
247 /* Call CALLBACK with its second argument set to DATA for every LWP in
248 the list. If CALLBACK returns 1 for a particular LWP, return a
249 pointer to the structure describing that LWP immediately.
250 Otherwise return NULL. */
253 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
257 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
258 if ((*callback
) (lp
, data
))
265 /* Helper functions. */
268 restore_inferior_pid (void *arg
)
270 int *saved_pid_ptr
= arg
;
271 inferior_pid
= *saved_pid_ptr
;
275 static struct cleanup
*
276 save_inferior_pid (void)
280 saved_pid_ptr
= xmalloc (sizeof (int));
281 *saved_pid_ptr
= inferior_pid
;
282 return make_cleanup (restore_inferior_pid
, saved_pid_ptr
);
286 /* Implementation of the PREPARE_TO_PROCEED hook for the Linux LWP
289 Note that this implementation is potentially redundant now that
290 default_prepare_to_proceed() has been added. */
293 lin_lwp_prepare_to_proceed (void)
295 if (trap_pid
&& inferior_pid
!= trap_pid
)
297 /* Switched over from TRAP_PID. */
298 CORE_ADDR stop_pc
= read_pc ();
301 /* Avoid switching where it wouldn't do any good, i.e. if both
302 threads are at the same breakpoint. */
303 trap_pc
= read_pc_pid (trap_pid
);
304 if (trap_pc
!= stop_pc
&& breakpoint_here_p (trap_pc
))
306 /* User hasn't deleted the breakpoint. Return non-zero, and
307 switch back to TRAP_PID. */
308 inferior_pid
= trap_pid
;
310 /* FIXME: Is this stuff really necessary? */
311 flush_cached_frames ();
312 registers_changed ();
324 lin_lwp_open (char *args
, int from_tty
)
326 push_target (&lin_lwp_ops
);
330 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
331 a message telling the user that a new LWP has been added to the
335 lin_lwp_attach_lwp (int pid
, int verbose
)
339 gdb_assert (is_lwp (pid
));
342 printf_filtered ("[New %s]\n", target_pid_to_str (pid
));
344 if (ptrace (PTRACE_ATTACH
, GET_LWP (pid
), 0, 0) < 0)
345 error ("Can't attach %s: %s", target_pid_to_str (pid
), strerror (errno
));
352 lin_lwp_attach (char *args
, int from_tty
)
354 /* FIXME: We should probably accept a list of process id's, and
355 attach all of them. */
356 error("Not implemented yet");
360 lin_lwp_detach (char *args
, int from_tty
)
362 /* FIXME: Provide implementation when we implement lin_lwp_attach. */
363 error ("Not implemented yet");
367 struct private_thread_info
372 /* Return non-zero if TP corresponds to the LWP specified by DATA
373 (which is assumed to be a pointer to a `struct lwp_info'. */
376 find_lwp_callback (struct thread_info
*tp
, void *data
)
378 struct lwp_info
*lp
= data
;
380 if (tp
->private->lwpid
== GET_LWP (lp
->pid
))
389 resume_callback (struct lwp_info
*lp
, void *data
)
391 if (lp
->stopped
&& lp
->status
== 0)
393 struct thread_info
*tp
;
396 /* FIXME: kettenis/2000-08-26: This should really be handled
397 properly by core GDB. */
399 tp
= find_thread_pid (lp
->pid
);
401 tp
= iterate_over_threads (find_lwp_callback
, lp
);
404 /* If we were previously stepping the thread, and now continue
405 the thread we must invalidate the stepping range. However,
406 if there is a step_resume breakpoint for this thread, we must
407 preserve the stepping range to make it possible to continue
408 stepping once we hit it. */
409 if (tp
->step_range_end
&& tp
->step_resume_breakpoint
== NULL
)
411 gdb_assert (lp
->step
);
412 tp
->step_range_start
= tp
->step_range_end
= 0;
416 child_resume (GET_LWP (lp
->pid
), 0, TARGET_SIGNAL_0
);
425 lin_lwp_resume (int pid
, int step
, enum target_signal signo
)
430 /* Apparently the interpretation of PID is dependent on STEP: If
431 STEP is non-zero, a specific PID means `step only this process
432 id'. But if STEP is zero, then PID means `continue *all*
433 processes, but give the signal only to this one'. */
434 resume_all
= (pid
== -1) || !step
;
436 /* If PID is -1, it's the current inferior that should be
441 lp
= find_lwp_pid (pid
);
444 pid
= GET_LWP (lp
->pid
);
446 /* Remember if we're stepping. */
449 /* If we have a pending wait status for this thread, there is no
450 point in resuming the process. */
453 /* FIXME: What should we do if we are supposed to continue
454 this thread with a signal? */
455 gdb_assert (signo
== TARGET_SIGNAL_0
);
459 /* Mark LWP as not stopped to prevent it from being continued by
465 iterate_over_lwps (resume_callback
, NULL
);
467 child_resume (pid
, step
, signo
);
471 /* Send a SIGSTOP to LP. */
474 stop_callback (struct lwp_info
*lp
, void *data
)
476 if (! lp
->stopped
&& ! lp
->signalled
)
480 ret
= kill (GET_LWP (lp
->pid
), SIGSTOP
);
481 gdb_assert (ret
== 0);
484 gdb_assert (lp
->status
== 0);
490 /* Wait until LP is stopped. */
493 stop_wait_callback (struct lwp_info
*lp
, void *data
)
495 if (! lp
->stopped
&& lp
->signalled
)
500 gdb_assert (lp
->status
== 0);
502 pid
= waitpid (GET_LWP (lp
->pid
), &status
,
503 is_cloned (lp
->pid
) ? __WCLONE
: 0);
504 if (pid
== -1 && errno
== ECHILD
)
505 /* OK, the proccess has disappeared. We'll catch the actual
506 exit event in lin_lwp_wait. */
509 gdb_assert (pid
== GET_LWP (lp
->pid
));
511 if (WIFEXITED (status
) || WIFSIGNALED (status
))
513 gdb_assert (num_lwps
> 1);
515 if (in_thread_list (lp
->pid
))
517 /* Core GDB cannot deal with us deleting the current
519 if (lp
->pid
!= inferior_pid
)
520 delete_thread (lp
->pid
);
521 printf_unfiltered ("[%s exited]\n",
522 target_pid_to_str (lp
->pid
));
525 printf ("%s exited.\n", target_pid_to_str (lp
->pid
));
527 delete_lwp (lp
->pid
);
531 gdb_assert (WIFSTOPPED (status
));
534 if (WSTOPSIG (status
) != SIGSTOP
)
536 if (WSTOPSIG (status
) == SIGTRAP
537 && breakpoint_inserted_here_p (read_pc_pid (pid
)
538 - DECR_PC_AFTER_BREAK
))
540 /* If a LWP other than the LWP that we're reporting an
541 event for has hit a GDB breakpoint (as opposed to
542 some random trap signal), then just arrange for it to
543 hit it again later. We don't keep the SIGTRAP status
544 and don't forward the SIGTRAP signal to the LWP. We
545 will handle the current event, eventually we will
546 resume all LWPs, and this one will get its breakpoint
549 If we do not do this, then we run the risk that the
550 user will delete or disable the breakpoint, but the
551 thread will have already tripped on it. */
553 printf ("Tripped breakpoint at %lx in LWP %d"
554 " while waiting for SIGSTOP.\n",
555 (long) read_pc_pid (lp
->pid
), pid
);
557 /* Set the PC to before the trap. */
558 if (DECR_PC_AFTER_BREAK
)
559 write_pc_pid (read_pc_pid (pid
) - DECR_PC_AFTER_BREAK
, pid
);
564 printf ("Received %s in LWP %d while waiting for SIGSTOP.\n",
565 strsignal (WSTOPSIG (status
)), pid
);
567 /* The thread was stopped with a signal other than
568 SIGSTOP, and didn't accidentiliy trip a breakpoint.
569 Record the wait status. */
575 /* We caught the SIGSTOP that we intended to catch, so
576 there's no SIGSTOP pending. */
584 /* Return non-zero if LP has a wait status pending. */
587 status_callback (struct lwp_info
*lp
, void *data
)
589 return (lp
->status
!= 0);
592 /* Return non-zero if LP isn't stopped. */
595 running_callback (struct lwp_info
*lp
, void *data
)
597 return (lp
->stopped
== 0);
601 lin_lwp_wait (int pid
, struct target_waitstatus
*ourstatus
)
603 struct lwp_info
*lp
= NULL
;
607 /* Make sure SIGCHLD is blocked. */
608 if (! sigismember (&blocked_mask
, SIGCHLD
))
610 sigaddset (&blocked_mask
, SIGCHLD
);
611 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
616 /* First check if there is a LWP with a wait status pending. */
619 /* Any LWP will do. */
620 lp
= iterate_over_lwps (status_callback
, NULL
);
624 printf ("Using pending wait status for LWP %d.\n",
631 /* But if we don't fine one, we'll have to wait, and check both
632 cloned and uncloned processes. We start with the cloned
634 options
= __WCLONE
| WNOHANG
;
636 else if (is_lwp (pid
))
639 printf ("Waiting for specific LWP %d.\n", GET_LWP (pid
));
641 /* We have a specific LWP to check. */
642 lp
= find_lwp_pid (GET_LWP (pid
));
648 printf ("Using pending wait status for LWP %d.\n",
652 /* If we have to wait, take into account whether PID is a cloned
653 process or not. And we have to convert it to something that
654 the layer beneath us can understand. */
655 options
= is_cloned (lp
->pid
) ? __WCLONE
: 0;
659 if (status
&& lp
->signalled
)
661 /* A pending SIGSTOP may interfere with the normal stream of
662 events. In a typical case where interference is a problem,
663 we have a SIGSTOP signal pending for LWP A while
664 single-stepping it, encounter an event in LWP B, and take the
665 pending SIGSTOP while trying to stop LWP A. After processing
666 the event in LWP B, LWP A is continued, and we'll never see
667 the SIGTRAP associated with the last time we were
668 single-stepping LWP A. */
670 /* Resume the thread. It should halt immediately returning the
672 child_resume (GET_LWP (lp
->pid
), lp
->step
, TARGET_SIGNAL_0
);
675 /* This should catch the pending SIGSTOP. */
676 stop_wait_callback (lp
, NULL
);
679 set_sigint_trap (); /* Causes SIGINT to be passed on to the
687 lwpid
= waitpid (pid
, &status
, options
);
690 gdb_assert (pid
== -1 || lwpid
== pid
);
692 lp
= find_lwp_pid (lwpid
);
695 lp
= add_lwp (BUILD_LWP (lwpid
, inferior_pid
));
698 gdb_assert (WIFSTOPPED (status
)
699 && WSTOPSIG (status
) == SIGSTOP
);
702 if (! in_thread_list (inferior_pid
))
704 inferior_pid
= BUILD_LWP (inferior_pid
, inferior_pid
);
705 add_thread (inferior_pid
);
708 add_thread (lp
->pid
);
709 printf_unfiltered ("[New %s]\n",
710 target_pid_to_str (lp
->pid
));
714 /* Make sure we don't report a TARGET_WAITKIND_EXITED or
715 TARGET_WAITKIND_SIGNALLED event if there are still LWP's
716 left in the process. */
717 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
719 if (in_thread_list (lp
->pid
))
721 /* Core GDB cannot deal with us deleting the current
723 if (lp
->pid
!= inferior_pid
)
724 delete_thread (lp
->pid
);
725 printf_unfiltered ("[%s exited]\n",
726 target_pid_to_str (lp
->pid
));
729 printf ("%s exited.\n", target_pid_to_str (lp
->pid
));
731 delete_lwp (lp
->pid
);
733 /* Make sure there is at least one thread running. */
734 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
736 /* Discard the event. */
741 /* Make sure we don't report a SIGSTOP that we sent
742 ourselves in an attempt to stop an LWP. */
743 if (lp
->signalled
&& WIFSTOPPED (status
)
744 && WSTOPSIG (status
) == SIGSTOP
)
747 printf ("Delayed SIGSTOP caught for %s.\n",
748 target_pid_to_str (lp
->pid
));
750 /* This is a delayed SIGSTOP. */
753 child_resume (GET_LWP (lp
->pid
), lp
->step
, TARGET_SIGNAL_0
);
756 /* Discard the event. */
766 /* Alternate between checking cloned and uncloned processes. */
769 /* And suspend every time we have checked both. */
770 if (options
& __WCLONE
)
771 sigsuspend (&suspend_mask
);
774 /* We shouldn't end up here unless we want to try again. */
775 gdb_assert (status
== 0);
779 clear_sigint_trap ();
783 /* Don't report signals that GDB isn't interested in, such as
784 signals that are neither printed nor stopped upon. Stopping all
785 threads can be a bit time-consuming so if we want decent
786 performance with heavily multi-threaded programs, especially when
787 they're using a high frequency timer, we'd better avoid it if we
790 if (WIFSTOPPED (status
))
792 int signo
= target_signal_from_host (WSTOPSIG (status
));
794 if (signal_stop_state (signo
) == 0
795 && signal_print_state (signo
) == 0
796 && signal_pass_state (signo
) == 1)
798 child_resume (GET_LWP (lp
->pid
), lp
->step
, signo
);
805 /* This LWP is stopped now. */
808 /* Now stop all other LWP's ... */
809 iterate_over_lwps (stop_callback
, NULL
);
811 /* ... and wait until all of them have reported back that they're no
813 iterate_over_lwps (stop_wait_callback
, NULL
);
815 /* If we're not running in "threaded" mode, we'll report the bare
818 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
819 trap_pid
= (threaded
? lp
->pid
: GET_LWP (lp
->pid
));
823 store_waitstatus (ourstatus
, status
);
824 return (threaded
? lp
->pid
: GET_LWP (lp
->pid
));
828 kill_callback (struct lwp_info
*lp
, void *data
)
830 ptrace (PTRACE_KILL
, GET_LWP (lp
->pid
), 0, 0);
835 kill_wait_callback (struct lwp_info
*lp
, void *data
)
839 /* We must make sure that there are no pending events (delayed
840 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
841 program doesn't interfere with any following debugging session. */
843 /* For cloned processes we must check both with __WCLONE and
844 without, since the exit status of a cloned process isn't reported
846 if (is_cloned (lp
->pid
))
850 pid
= waitpid (GET_LWP (lp
->pid
), NULL
, __WCLONE
);
852 while (pid
== GET_LWP (lp
->pid
));
854 gdb_assert (pid
== -1 && errno
== ECHILD
);
859 pid
= waitpid (GET_LWP (lp
->pid
), NULL
, 0);
861 while (pid
== GET_LWP (lp
->pid
));
863 gdb_assert (pid
== -1 && errno
== ECHILD
);
870 /* Kill all LWP's ... */
871 iterate_over_lwps (kill_callback
, NULL
);
873 /* ... and wait until we've flushed all events. */
874 iterate_over_lwps (kill_wait_callback
, NULL
);
876 target_mourn_inferior ();
880 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
882 struct target_ops
*target_beneath
;
887 target_beneath
= find_target_beneath (&lin_lwp_ops
);
889 target_beneath
= &child_ops
;
891 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
895 lin_lwp_mourn_inferior (void)
897 struct target_ops
*target_beneath
;
903 /* Restore the original signal mask. */
904 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
905 sigemptyset (&blocked_mask
);
908 target_beneath
= find_target_beneath (&lin_lwp_ops
);
910 target_beneath
= &child_ops
;
912 target_beneath
->to_mourn_inferior ();
916 lin_lwp_fetch_registers (int regno
)
918 struct cleanup
*old_chain
= save_inferior_pid ();
920 if (is_lwp (inferior_pid
))
921 inferior_pid
= GET_LWP (inferior_pid
);
923 fetch_inferior_registers (regno
);
925 do_cleanups (old_chain
);
929 lin_lwp_store_registers (int regno
)
931 struct cleanup
*old_chain
= save_inferior_pid ();
933 if (is_lwp (inferior_pid
))
934 inferior_pid
= GET_LWP (inferior_pid
);
936 store_inferior_registers (regno
);
938 do_cleanups (old_chain
);
942 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
943 struct mem_attrib
*attrib
,
944 struct target_ops
*target
)
946 struct cleanup
*old_chain
= save_inferior_pid ();
949 if (is_lwp (inferior_pid
))
950 inferior_pid
= GET_LWP (inferior_pid
);
952 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
954 do_cleanups (old_chain
);
959 lin_lwp_thread_alive (int pid
)
961 gdb_assert (is_lwp (pid
));
964 ptrace (PTRACE_PEEKUSER
, GET_LWP (pid
), 0, 0);
972 lin_lwp_pid_to_str (int pid
)
978 snprintf (buf
, sizeof (buf
), "LWP %d", GET_LWP (pid
));
982 return normal_pid_to_str (pid
);
986 init_lin_lwp_ops (void)
989 lin_lwp_ops
.to_open
= lin_lwp_open
;
991 lin_lwp_ops
.to_shortname
= "lwp-layer";
992 lin_lwp_ops
.to_longname
= "lwp-layer";
993 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
994 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
995 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
996 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
997 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
998 lin_lwp_ops
.to_fetch_registers
= lin_lwp_fetch_registers
;
999 lin_lwp_ops
.to_store_registers
= lin_lwp_store_registers
;
1000 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1001 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1002 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1003 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1004 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1005 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1006 lin_lwp_ops
.to_stratum
= thread_stratum
;
1007 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1008 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1012 sigchld_handler (int signo
)
1014 /* Do nothing. The only reason for this handler is that it allows
1015 us to use sigsuspend in lin_lwp_wait above to wait for the
1016 arrival of a SIGCHLD. */
1020 _initialize_lin_lwp (void)
1022 struct sigaction action
;
1024 extern void thread_db_init (struct target_ops
*);
1026 init_lin_lwp_ops ();
1027 add_target (&lin_lwp_ops
);
1028 thread_db_init (&lin_lwp_ops
);
1030 /* Save the original signal mask. */
1031 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1033 action
.sa_handler
= sigchld_handler
;
1034 sigemptyset (&action
.sa_mask
);
1035 action
.sa_flags
= 0;
1036 sigaction (SIGCHLD
, &action
, NULL
);
1038 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1039 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1040 sigdelset (&suspend_mask
, SIGCHLD
);
1042 sigemptyset (&blocked_mask
);
1046 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1047 the LinuxThreads library and therefore doesn't really belong here. */
1049 /* Read variable NAME in the target and return its value if found.
1050 Otherwise return zero. It is assumed that the type of the variable
1054 get_signo (const char *name
)
1056 struct minimal_symbol
*ms
;
1059 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1063 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1064 sizeof (signo
)) != 0)
1070 /* Return the set of signals used by the threads library in *SET. */
1073 lin_thread_get_thread_signals (sigset_t
*set
)
1075 struct sigaction action
;
1076 int restart
, cancel
;
1080 restart
= get_signo ("__pthread_sig_restart");
1084 cancel
= get_signo ("__pthread_sig_cancel");
1088 sigaddset (set
, restart
);
1089 sigaddset (set
, cancel
);
1091 /* The LinuxThreads library makes terminating threads send a special
1092 "cancel" signal instead of SIGCHLD. Make sure we catch those (to
1093 prevent them from terminating GDB itself, which is likely to be
1094 their default action) and treat them the same way as SIGCHLD. */
1096 action
.sa_handler
= sigchld_handler
;
1097 sigemptyset (&action
.sa_mask
);
1098 action
.sa_flags
= 0;
1099 sigaction (cancel
, &action
, NULL
);
1101 /* We block the "cancel" signal throughout this code ... */
1102 sigaddset (&blocked_mask
, cancel
);
1103 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1105 /* ... except during a sigsuspend. */
1106 sigdelset (&suspend_mask
, cancel
);