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 we sent this LWP a SIGSTOP (but the LWP didn't report
82 /* Non-zero if this LWP is stopped. */
85 /* If non-zero, a pending wait status. */
88 /* Non-zero if we were stepping this LWP. */
91 /* Next LWP in list. */
92 struct lwp_info
*next
;
95 /* List of known LWPs. */
96 static struct lwp_info
*lwp_list
;
98 /* Number of LWPs in the list. */
101 /* Non-zero if we're running in "threaded" mode. */
106 #define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
107 #define PIDGET(PID) (((PID) & 0xffff))
108 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
111 #define THREAD_FLAG 0x80000000
112 #define is_lwp(pid) (((pid) & THREAD_FLAG) == 0 && TIDGET (pid))
113 #define GET_LWP(pid) TIDGET (pid)
114 #define GET_PID(pid) PIDGET (pid)
115 #define BUILD_LWP(tid, pid) MERGEPID (pid, tid)
117 #define is_cloned(pid) (GET_LWP (pid) != GET_PID (pid))
119 /* If the last reported event was a SIGTRAP, this variable is set to
120 the process id of the LWP/thread that got it. */
124 /* This module's target-specific operations. */
125 static struct target_ops lin_lwp_ops
;
127 /* The standard child operations. */
128 extern struct target_ops child_ops
;
130 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
131 any cloned processes with a single call to waitpid, we have to use
132 the WNOHANG flag and call waitpid in a loop. To optimize
133 things a bit we use `sigsuspend' to wake us up when a process has
134 something to report (it will send us a SIGCHLD if it has). To make
135 this work we have to juggle with the signal mask. We save the
136 original signal mask such that we can restore it before creating a
137 new process in order to avoid blocking certain signals in the
138 inferior. We then block SIGCHLD during the waitpid/sigsuspend
141 /* Original signal mask. */
142 static sigset_t normal_mask
;
144 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
145 _initialize_lin_lwp. */
146 static sigset_t suspend_mask
;
148 /* Signals to block to make that sigsuspend work. */
149 static sigset_t blocked_mask
;
152 /* Prototypes for local functions. */
153 static void lin_lwp_mourn_inferior (void);
156 /* Initialize the list of LWPs. */
161 struct lwp_info
*lp
, *lpnext
;
163 for (lp
= lwp_list
; lp
; lp
= lpnext
)
174 /* Add the LWP specified by PID to the list. If this causes the
175 number of LWPs to become larger than one, go into "threaded" mode.
176 Return a pointer to the structure describing the new LWP. */
178 static struct lwp_info
*
183 gdb_assert (is_lwp (pid
));
185 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
187 memset (lp
, 0, sizeof (struct lwp_info
));
199 /* Remove the LWP specified by PID from the list. */
204 struct lwp_info
*lp
, *lpprev
;
208 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
215 /* We don't go back to "non-threaded" mode if the number of threads
216 becomes less than two. */
220 lpprev
->next
= lp
->next
;
227 /* Return a pointer to the structure describing the LWP corresponding
228 to PID. If no corresponding LWP could be found, return NULL. */
230 static struct lwp_info
*
231 find_lwp_pid (int pid
)
238 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
239 if (pid
== GET_LWP (lp
->pid
))
245 /* Call CALLBACK with its second argument set to DATA for every LWP in
246 the list. If CALLBACK returns 1 for a particular LWP, return a
247 pointer to the structure describing that LWP immediately.
248 Otherwise return NULL. */
251 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
255 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
256 if ((*callback
) (lp
, data
))
263 /* Helper functions. */
266 restore_inferior_pid (void *arg
)
268 int *saved_pid_ptr
= arg
;
269 inferior_pid
= *saved_pid_ptr
;
273 static struct cleanup
*
274 save_inferior_pid (void)
278 saved_pid_ptr
= xmalloc (sizeof (int));
279 *saved_pid_ptr
= inferior_pid
;
280 return make_cleanup (restore_inferior_pid
, saved_pid_ptr
);
284 /* Implementation of the PREPARE_TO_PROCEED hook for the Linux LWP
287 Note that this implementation is potentially redundant now that
288 default_prepare_to_proceed() has been added. */
291 lin_lwp_prepare_to_proceed (void)
293 if (trap_pid
&& inferior_pid
!= trap_pid
)
295 /* Switched over from TRAP_PID. */
296 CORE_ADDR stop_pc
= read_pc ();
299 /* Avoid switching where it wouldn't do any good, i.e. if both
300 threads are at the same breakpoint. */
301 trap_pc
= read_pc_pid (trap_pid
);
302 if (trap_pc
!= stop_pc
&& breakpoint_here_p (trap_pc
))
304 /* User hasn't deleted the breakpoint. Return non-zero, and
305 switch back to TRAP_PID. */
306 inferior_pid
= trap_pid
;
308 /* FIXME: Is this stuff really necessary? */
309 flush_cached_frames ();
310 registers_changed ();
322 lin_lwp_open (char *args
, int from_tty
)
324 push_target (&lin_lwp_ops
);
328 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
329 a message telling the user that a new LWP has been added to the
333 lin_lwp_attach_lwp (int pid
, int verbose
)
337 gdb_assert (is_lwp (pid
));
340 printf_filtered ("[New %s]\n", target_pid_to_str (pid
));
342 if (ptrace (PTRACE_ATTACH
, GET_LWP (pid
), 0, 0) < 0)
343 error ("Can't attach %s: %s", target_pid_to_str (pid
), strerror (errno
));
350 lin_lwp_attach (char *args
, int from_tty
)
352 /* FIXME: We should probably accept a list of process id's, and
353 attach all of them. */
354 error("Not implemented yet");
358 lin_lwp_detach (char *args
, int from_tty
)
360 /* FIXME: Provide implementation when we implement lin_lwp_attach. */
361 error ("Not implemented yet");
365 struct private_thread_info
370 /* Return non-zero if TP corresponds to the LWP specified by DATA
371 (which is assumed to be a pointer to a `struct lwp_info'. */
374 find_lwp_callback (struct thread_info
*tp
, void *data
)
376 struct lwp_info
*lp
= data
;
378 if (tp
->private->lwpid
== GET_LWP (lp
->pid
))
387 resume_callback (struct lwp_info
*lp
, void *data
)
389 if (lp
->stopped
&& lp
->status
== 0)
391 struct thread_info
*tp
;
394 /* FIXME: kettenis/2000-08-26: This should really be handled
395 properly by core GDB. */
397 tp
= find_thread_pid (lp
->pid
);
399 tp
= iterate_over_threads (find_lwp_callback
, lp
);
402 /* If we were previously stepping the thread, and now continue
403 the thread we must invalidate the stepping range. However,
404 if there is a step_resume breakpoint for this thread, we must
405 preserve the stepping range to make it possible to continue
406 stepping once we hit it. */
407 if (tp
->step_range_end
&& tp
->step_resume_breakpoint
== NULL
)
409 gdb_assert (lp
->step
);
410 tp
->step_range_start
= tp
->step_range_end
= 0;
414 child_resume (GET_LWP (lp
->pid
), 0, TARGET_SIGNAL_0
);
423 lin_lwp_resume (int pid
, int step
, enum target_signal signo
)
428 /* Apparently the interpretation of PID is dependent on STEP: If
429 STEP is non-zero, a specific PID means `step only this process
430 id'. But if STEP is zero, then PID means `continue *all*
431 processes, but give the signal only to this one'. */
432 resume_all
= (pid
== -1) || !step
;
434 /* If PID is -1, it's the current inferior that should be
439 lp
= find_lwp_pid (pid
);
442 pid
= GET_LWP (lp
->pid
);
444 /* Remember if we're stepping. */
447 /* If we have a pending wait status for this thread, there is no
448 point in resuming the process. */
451 /* FIXME: What should we do if we are supposed to continue
452 this thread with a signal? */
453 gdb_assert (signo
== TARGET_SIGNAL_0
);
457 /* Mark LWP as not stopped to prevent it from being continued by
463 iterate_over_lwps (resume_callback
, NULL
);
465 child_resume (pid
, step
, signo
);
469 /* Send a SIGSTOP to LP. */
472 stop_callback (struct lwp_info
*lp
, void *data
)
474 if (! lp
->stopped
&& ! lp
->signalled
)
478 ret
= kill (GET_LWP (lp
->pid
), SIGSTOP
);
479 gdb_assert (ret
== 0);
482 gdb_assert (lp
->status
== 0);
488 /* Wait until LP is stopped. */
491 stop_wait_callback (struct lwp_info
*lp
, void *data
)
493 if (! lp
->stopped
&& lp
->signalled
)
498 gdb_assert (lp
->status
== 0);
500 pid
= waitpid (GET_LWP (lp
->pid
), &status
,
501 is_cloned (lp
->pid
) ? __WCLONE
: 0);
502 if (pid
== -1 && errno
== ECHILD
)
503 /* OK, the proccess has disappeared. We'll catch the actual
504 exit event in lin_lwp_wait. */
507 gdb_assert (pid
== GET_LWP (lp
->pid
));
509 if (WIFEXITED (status
) || WIFSIGNALED (status
))
511 gdb_assert (num_lwps
> 1);
513 if (in_thread_list (lp
->pid
))
515 /* Core GDB cannot deal with us deleting the current
517 if (lp
->pid
!= inferior_pid
)
518 delete_thread (lp
->pid
);
519 printf_unfiltered ("[%s exited]\n",
520 target_pid_to_str (lp
->pid
));
523 printf ("%s exited.\n", target_pid_to_str (lp
->pid
));
525 delete_lwp (lp
->pid
);
529 gdb_assert (WIFSTOPPED (status
));
532 if (WSTOPSIG (status
) != SIGSTOP
)
534 if (WSTOPSIG (status
) == SIGTRAP
535 && breakpoint_inserted_here_p (read_pc_pid (pid
)
536 - DECR_PC_AFTER_BREAK
))
538 /* If a LWP other than the LWP that we're reporting an
539 event for has hit a GDB breakpoint (as opposed to
540 some random trap signal), then just arrange for it to
541 hit it again later. We don't keep the SIGTRAP status
542 and don't forward the SIGTRAP signal to the LWP. We
543 will handle the current event, eventually we will
544 resume all LWPs, and this one will get its breakpoint
547 If we do not do this, then we run the risk that the
548 user will delete or disable the breakpoint, but the
549 thread will have already tripped on it. */
552 printf ("Tripped breakpoint at %lx in LWP %d"
553 " while waiting for SIGSTOP.\n",
554 (long) read_pc_pid (lp
->pid
), pid
);
556 /* Set the PC to before the trap. */
557 if (DECR_PC_AFTER_BREAK
)
558 write_pc_pid (read_pc_pid (pid
) - DECR_PC_AFTER_BREAK
, pid
);
563 printf ("Received %s in LWP %d while waiting for SIGSTOP.\n",
564 strsignal (WSTOPSIG (status
)), pid
);
566 /* The thread was stopped with a signal other than
567 SIGSTOP, and didn't accidentiliy trip a breakpoint.
568 Record the wait status. */
574 /* We caught the SIGSTOP that we intended to catch, so
575 there's no SIGSTOP pending. */
583 /* Return non-zero if LP has a wait status pending. */
586 status_callback (struct lwp_info
*lp
, void *data
)
588 return (lp
->status
!= 0);
591 /* Return non-zero if LP isn't stopped. */
594 running_callback (struct lwp_info
*lp
, void *data
)
596 return (lp
->stopped
== 0);
600 lin_lwp_wait (int pid
, struct target_waitstatus
*ourstatus
)
602 struct lwp_info
*lp
= NULL
;
606 /* Make sure SIGCHLD is blocked. */
607 if (! sigismember (&blocked_mask
, SIGCHLD
))
609 sigaddset (&blocked_mask
, SIGCHLD
);
610 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
615 /* First check if there is a LWP with a wait status pending. */
618 /* Any LWP will do. */
619 lp
= iterate_over_lwps (status_callback
, NULL
);
623 printf ("Using pending wait status for LWP %d.\n",
630 /* But if we don't fine one, we'll have to wait, and check both
631 cloned and uncloned processes. We start with the cloned
633 options
= __WCLONE
| WNOHANG
;
635 else if (is_lwp (pid
))
638 printf ("Waiting for specific LWP %d.\n", GET_LWP (pid
));
640 /* We have a specific LWP to check. */
641 lp
= find_lwp_pid (GET_LWP (pid
));
648 printf ("Using pending wait status for LWP %d.\n",
651 /* If we have to wait, take into account whether PID is a cloned
652 process or not. And we have to convert it to something that
653 the layer beneath us can understand. */
654 options
= is_cloned (lp
->pid
) ? __WCLONE
: 0;
658 if (status
&& lp
->signalled
)
660 /* A pending SIGSTOP may interfere with the normal stream of
661 events. In a typical case where interference is a problem,
662 we have a SIGSTOP signal pending for LWP A while
663 single-stepping it, encounter an event in LWP B, and take the
664 pending SIGSTOP while trying to stop LWP A. After processing
665 the event in LWP B, LWP A is continued, and we'll never see
666 the SIGTRAP associated with the last time we were
667 single-stepping LWP A. */
669 /* Resume the thread. It should halt immediately returning the
671 child_resume (GET_LWP (lp
->pid
), lp
->step
, TARGET_SIGNAL_0
);
674 /* This should catch the pending SIGSTOP. */
675 stop_wait_callback (lp
, NULL
);
678 set_sigint_trap (); /* Causes SIGINT to be passed on to the
686 lwpid
= waitpid (pid
, &status
, options
);
689 gdb_assert (pid
== -1 || lwpid
== pid
);
691 lp
= find_lwp_pid (lwpid
);
694 lp
= add_lwp (BUILD_LWP (lwpid
, inferior_pid
));
697 gdb_assert (WIFSTOPPED (status
)
698 && WSTOPSIG (status
) == SIGSTOP
);
701 if (! in_thread_list (inferior_pid
))
703 inferior_pid
= BUILD_LWP (inferior_pid
, inferior_pid
);
704 add_thread (inferior_pid
);
707 add_thread (lp
->pid
);
708 printf_unfiltered ("[New %s]\n",
709 target_pid_to_str (lp
->pid
));
713 /* Make sure we don't report a TARGET_WAITKIND_EXITED or
714 TARGET_WAITKIND_SIGNALLED event if there are still LWP's
715 left in the process. */
716 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
718 if (in_thread_list (lp
->pid
))
720 /* Core GDB cannot deal with us deleting the current
722 if (lp
->pid
!= inferior_pid
)
723 delete_thread (lp
->pid
);
724 printf_unfiltered ("[%s exited]\n",
725 target_pid_to_str (lp
->pid
));
728 printf ("%s exited.\n", target_pid_to_str (lp
->pid
));
730 delete_lwp (lp
->pid
);
732 /* Make sure there is at least one thread running. */
733 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
735 /* Discard the event. */
740 /* Make sure we don't report a SIGSTOP that we sent
741 ourselves in an attempt to stop an LWP. */
742 if (lp
->signalled
&& WIFSTOPPED (status
)
743 && WSTOPSIG (status
) == SIGSTOP
)
746 printf ("Delayed SIGSTOP caught for %s.\n",
747 target_pid_to_str (lp
->pid
));
749 /* This is a delayed SIGSTOP. */
752 child_resume (GET_LWP (lp
->pid
), lp
->step
, TARGET_SIGNAL_0
);
755 /* Discard the event. */
765 /* Alternate between checking cloned and uncloned processes. */
768 /* And suspend every time we have checked both. */
769 if (options
& __WCLONE
)
770 sigsuspend (&suspend_mask
);
773 /* We shouldn't end up here unless we want to try again. */
774 gdb_assert (status
== 0);
778 clear_sigint_trap ();
782 /* Don't report signals that GDB isn't interested in, such as
783 signals that are neither printed nor stopped upon. Stopping all
784 threads can be a bit time-consuming so if we want decent
785 performance with heavily multi-threaded programs, especially when
786 they're using a high frequency timer, we'd better avoid it if we
789 if (WIFSTOPPED (status
))
791 int signo
= target_signal_from_host (WSTOPSIG (status
));
793 if (signal_stop_state (signo
) == 0
794 && signal_print_state (signo
) == 0
795 && signal_pass_state (signo
) == 1)
797 child_resume (GET_LWP (lp
->pid
), lp
->step
, signo
);
804 /* This LWP is stopped now. */
807 /* Now stop all other LWP's ... */
808 iterate_over_lwps (stop_callback
, NULL
);
810 /* ... and wait until all of them have reported back that they're no
812 iterate_over_lwps (stop_wait_callback
, NULL
);
814 /* If we're not running in "threaded" mode, we'll report the bare
817 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
818 trap_pid
= (threaded
? lp
->pid
: GET_LWP (lp
->pid
));
822 store_waitstatus (ourstatus
, status
);
823 return (threaded
? lp
->pid
: GET_LWP (lp
->pid
));
827 kill_callback (struct lwp_info
*lp
, void *data
)
829 ptrace (PTRACE_KILL
, GET_LWP (lp
->pid
), 0, 0);
834 kill_wait_callback (struct lwp_info
*lp
, void *data
)
838 /* We must make sure that there are no pending events (delayed
839 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
840 program doesn't interfere with any following debugging session. */
842 /* For cloned processes we must check both with __WCLONE and
843 without, since the exit status of a cloned process isn't reported
845 if (is_cloned (lp
->pid
))
849 pid
= waitpid (GET_LWP (lp
->pid
), NULL
, __WCLONE
);
851 while (pid
== GET_LWP (lp
->pid
));
853 gdb_assert (pid
== -1 && errno
== ECHILD
);
858 pid
= waitpid (GET_LWP (lp
->pid
), NULL
, 0);
860 while (pid
== GET_LWP (lp
->pid
));
862 gdb_assert (pid
== -1 && errno
== ECHILD
);
869 /* Kill all LWP's ... */
870 iterate_over_lwps (kill_callback
, NULL
);
872 /* ... and wait until we've flushed all events. */
873 iterate_over_lwps (kill_wait_callback
, NULL
);
875 target_mourn_inferior ();
879 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
881 struct target_ops
*target_beneath
;
886 target_beneath
= find_target_beneath (&lin_lwp_ops
);
888 target_beneath
= &child_ops
;
890 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
894 lin_lwp_mourn_inferior (void)
896 struct target_ops
*target_beneath
;
902 /* Restore the original signal mask. */
903 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
904 sigemptyset (&blocked_mask
);
907 target_beneath
= find_target_beneath (&lin_lwp_ops
);
909 target_beneath
= &child_ops
;
911 target_beneath
->to_mourn_inferior ();
915 lin_lwp_fetch_registers (int regno
)
917 struct cleanup
*old_chain
= save_inferior_pid ();
919 if (is_lwp (inferior_pid
))
920 inferior_pid
= GET_LWP (inferior_pid
);
922 fetch_inferior_registers (regno
);
924 do_cleanups (old_chain
);
928 lin_lwp_store_registers (int regno
)
930 struct cleanup
*old_chain
= save_inferior_pid ();
932 if (is_lwp (inferior_pid
))
933 inferior_pid
= GET_LWP (inferior_pid
);
935 store_inferior_registers (regno
);
937 do_cleanups (old_chain
);
941 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
942 struct mem_attrib
*attrib
,
943 struct target_ops
*target
)
945 struct cleanup
*old_chain
= save_inferior_pid ();
948 if (is_lwp (inferior_pid
))
949 inferior_pid
= GET_LWP (inferior_pid
);
951 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
953 do_cleanups (old_chain
);
958 lin_lwp_thread_alive (int pid
)
960 gdb_assert (is_lwp (pid
));
963 ptrace (PTRACE_PEEKUSER
, GET_LWP (pid
), 0, 0);
971 lin_lwp_pid_to_str (int pid
)
977 snprintf (buf
, sizeof (buf
), "LWP %d", GET_LWP (pid
));
981 return normal_pid_to_str (pid
);
985 init_lin_lwp_ops (void)
988 lin_lwp_ops
.to_open
= lin_lwp_open
;
990 lin_lwp_ops
.to_shortname
= "lwp-layer";
991 lin_lwp_ops
.to_longname
= "lwp-layer";
992 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
993 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
994 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
995 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
996 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
997 lin_lwp_ops
.to_fetch_registers
= lin_lwp_fetch_registers
;
998 lin_lwp_ops
.to_store_registers
= lin_lwp_store_registers
;
999 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1000 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1001 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1002 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1003 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1004 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1005 lin_lwp_ops
.to_stratum
= thread_stratum
;
1006 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1007 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1011 sigchld_handler (int signo
)
1013 /* Do nothing. The only reason for this handler is that it allows
1014 us to use sigsuspend in lin_lwp_wait above to wait for the
1015 arrival of a SIGCHLD. */
1019 _initialize_lin_lwp (void)
1021 struct sigaction action
;
1023 extern void thread_db_init (struct target_ops
*);
1025 init_lin_lwp_ops ();
1026 add_target (&lin_lwp_ops
);
1027 thread_db_init (&lin_lwp_ops
);
1029 /* Save the original signal mask. */
1030 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1032 action
.sa_handler
= sigchld_handler
;
1033 sigemptyset (&action
.sa_mask
);
1034 action
.sa_flags
= 0;
1035 sigaction (SIGCHLD
, &action
, NULL
);
1037 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1038 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1039 sigdelset (&suspend_mask
, SIGCHLD
);
1041 sigemptyset (&blocked_mask
);
1043 add_show_from_set (add_set_cmd ("lin-lwp", no_class
, var_zinteger
,
1044 (char *) &debug_lin_lwp
,
1045 "Set debugging of linux lwp module.\n\
1046 Enables printf debugging output.\n",
1052 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1053 the LinuxThreads library and therefore doesn't really belong here. */
1055 /* Read variable NAME in the target and return its value if found.
1056 Otherwise return zero. It is assumed that the type of the variable
1060 get_signo (const char *name
)
1062 struct minimal_symbol
*ms
;
1065 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1069 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1070 sizeof (signo
)) != 0)
1076 /* Return the set of signals used by the threads library in *SET. */
1079 lin_thread_get_thread_signals (sigset_t
*set
)
1081 struct sigaction action
;
1082 int restart
, cancel
;
1086 restart
= get_signo ("__pthread_sig_restart");
1090 cancel
= get_signo ("__pthread_sig_cancel");
1094 sigaddset (set
, restart
);
1095 sigaddset (set
, cancel
);
1097 /* The LinuxThreads library makes terminating threads send a special
1098 "cancel" signal instead of SIGCHLD. Make sure we catch those (to
1099 prevent them from terminating GDB itself, which is likely to be
1100 their default action) and treat them the same way as SIGCHLD. */
1102 action
.sa_handler
= sigchld_handler
;
1103 sigemptyset (&action
.sa_mask
);
1104 action
.sa_flags
= 0;
1105 sigaction (cancel
, &action
, NULL
);
1107 /* We block the "cancel" signal throughout this code ... */
1108 sigaddset (&blocked_mask
, cancel
);
1109 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1111 /* ... except during a sigsuspend. */
1112 sigdelset (&suspend_mask
, cancel
);