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"
34 extern int debug_linux_threads
;
35 extern const char *strsignal (int sig
);
37 /* On Linux there are no real LWP's. The closest thing to LWP's are
38 processes sharing the same VM space. A multi-threaded process is
39 basically a group of such processes. However, such a grouping is
40 almost entirely a user-space issue; the kernel doesn't enforce such
41 a grouping at all (this might change in the future). In general,
42 we'll rely on the threads library (i.e. the LinuxThreads library)
43 to provide such a grouping.
45 It is perfectly well possible to write a multi-threaded application
46 without the assistance of a threads library, by using the clone
47 system call directly. This module should be able to give some
48 rudimentary support for debugging such applications if developers
49 specify the CLONE_PTRACE flag in the clone system call, and are
50 using Linux 2.4 or above.
52 Note that there are some peculiarities in Linux that affect this
55 - In general one should specify the __WCLONE flag to waitpid in
56 order to make it report events for any of the cloned processes
57 (and leave it out for the initial process). However, if a cloned
58 process has exited the exit status is only reported if the
59 __WCLONE flag is absent. Linux 2.4 has a __WALL flag, but we
60 cannot use it since GDB must work on older systems too.
62 - When a traced, cloned process exits and is waited for by the
63 debugger, the kernel reassigns it to the original parent and
64 keeps it around as a "zombie". Somehow, the LinuxThreads library
65 doesn't notice this, which leads to the "zombie problem": When
66 debugged a multi-threaded process that spawns a lot of threads
67 will run out of processes, even if the threads exit, because the
68 "zombies" stay around. */
70 /* Structure describing a LWP. */
73 /* The process id of the LWP. This is a combination of the LWP id
74 and overall process id. */
77 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
81 /* Non-zero if this LWP is stopped. */
84 /* If non-zero, a pending wait status. */
87 /* Non-zero if we were stepping this LWP. */
90 /* Next LWP in list. */
91 struct lwp_info
*next
;
94 /* List of known LWPs. */
95 static struct lwp_info
*lwp_list
;
97 /* Number of LWPs in the list. */
100 /* Non-zero if we're running in "threaded" mode. */
105 #define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
106 #define PIDGET(PID) (((PID) & 0xffff))
107 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
110 #define THREAD_FLAG 0x80000000
111 #define is_lwp(pid) (((pid) & THREAD_FLAG) == 0 && TIDGET (pid))
112 #define GET_LWP(pid) TIDGET (pid)
113 #define GET_PID(pid) PIDGET (pid)
114 #define BUILD_LWP(tid, pid) MERGEPID (pid, tid)
116 #define is_cloned(pid) (GET_LWP (pid) != GET_PID (pid))
118 /* If the last reported event was a SIGTRAP, this variable is set to
119 the process id of the LWP/thread that got it. */
123 /* This module's target-specific operations. */
124 static struct target_ops lin_lwp_ops
;
126 /* The standard child operations. */
127 extern struct target_ops child_ops
;
129 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
130 any cloned processes with a single call to waitpid, we have to use
131 the WNOHANG flag and call waitpid in a loop. To optimize
132 things a bit we use `sigsuspend' to wake us up when a process has
133 something to report (it will send us a SIGCHLD if it has). To make
134 this work we have to juggle with the signal mask. We save the
135 original signal mask such that we can restore it before creating a
136 new process in order to avoid blocking certain signals in the
137 inferior. We then block SIGCHLD during the waitpid/sigsuspend
140 /* Original signal mask. */
141 static sigset_t normal_mask
;
143 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
144 _initialize_lin_lwp. */
145 static sigset_t suspend_mask
;
147 /* Signals to block to make that sigsuspend work. */
148 static sigset_t blocked_mask
;
151 /* Prototypes for local functions. */
152 static void lin_lwp_mourn_inferior (void);
155 /* Initialize the list of LWPs. */
160 struct lwp_info
*lp
, *lpnext
;
162 for (lp
= lwp_list
; lp
; lp
= lpnext
)
173 /* Add the LWP specified by PID to the list. If this causes the
174 number of LWPs to become larger than one, go into "threaded" mode.
175 Return a pointer to the structure describing the new LWP. */
177 static struct lwp_info
*
182 gdb_assert (is_lwp (pid
));
184 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
186 memset (lp
, 0, sizeof (struct lwp_info
));
198 /* Remove the LWP specified by PID from the list. */
203 struct lwp_info
*lp
, *lpprev
;
207 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
214 /* We don't go back to "non-threaded" mode if the number of threads
215 becomes less than two. */
219 lpprev
->next
= lp
->next
;
226 /* Return a pointer to the structure describing the LWP corresponding
227 to PID. If no corresponding LWP could be found, return NULL. */
229 static struct lwp_info
*
230 find_lwp_pid (int pid
)
237 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
238 if (pid
== GET_LWP (lp
->pid
))
244 /* Call CALLBACK with its second argument set to DATA for every LWP in
245 the list. If CALLBACK returns 1 for a particular LWP, return a
246 pointer to the structure describing that LWP immediately.
247 Otherwise return NULL. */
250 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
254 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
255 if ((*callback
) (lp
, data
))
262 /* Helper functions. */
265 restore_inferior_pid (void *arg
)
267 int *saved_pid_ptr
= arg
;
268 inferior_pid
= *saved_pid_ptr
;
272 static struct cleanup
*
273 save_inferior_pid (void)
277 saved_pid_ptr
= xmalloc (sizeof (int));
278 *saved_pid_ptr
= inferior_pid
;
279 return make_cleanup (restore_inferior_pid
, saved_pid_ptr
);
283 /* Implementation of the PREPARE_TO_PROCEED hook for the Linux LWP
286 Note that this implementation is potentially redundant now that
287 default_prepare_to_proceed() has been added. */
290 lin_lwp_prepare_to_proceed (void)
292 if (trap_pid
&& inferior_pid
!= trap_pid
)
294 /* Switched over from TRAP_PID. */
295 CORE_ADDR stop_pc
= read_pc ();
298 /* Avoid switching where it wouldn't do any good, i.e. if both
299 threads are at the same breakpoint. */
300 trap_pc
= read_pc_pid (trap_pid
);
301 if (trap_pc
!= stop_pc
&& breakpoint_here_p (trap_pc
))
303 /* User hasn't deleted the breakpoint. Return non-zero, and
304 switch back to TRAP_PID. */
305 inferior_pid
= trap_pid
;
307 /* FIXME: Is this stuff really necessary? */
308 flush_cached_frames ();
309 registers_changed ();
321 lin_lwp_open (char *args
, int from_tty
)
323 push_target (&lin_lwp_ops
);
327 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
328 a message telling the user that a new LWP has been added to the
332 lin_lwp_attach_lwp (int pid
, int verbose
)
336 gdb_assert (is_lwp (pid
));
339 printf_filtered ("[New %s]\n", target_pid_to_str (pid
));
341 if (ptrace (PTRACE_ATTACH
, GET_LWP (pid
), 0, 0) < 0)
342 error ("Can't attach %s: %s", target_pid_to_str (pid
), strerror (errno
));
349 lin_lwp_attach (char *args
, int from_tty
)
351 /* FIXME: We should probably accept a list of process id's, and
352 attach all of them. */
353 error("Not implemented yet");
357 lin_lwp_detach (char *args
, int from_tty
)
359 /* FIXME: Provide implementation when we implement lin_lwp_attach. */
360 error ("Not implemented yet");
364 struct private_thread_info
369 /* Return non-zero if TP corresponds to the LWP specified by DATA
370 (which is assumed to be a pointer to a `struct lwp_info'. */
373 find_lwp_callback (struct thread_info
*tp
, void *data
)
375 struct lwp_info
*lp
= data
;
377 if (tp
->private->lwpid
== GET_LWP (lp
->pid
))
386 resume_callback (struct lwp_info
*lp
, void *data
)
388 if (lp
->stopped
&& lp
->status
== 0)
390 struct thread_info
*tp
;
393 /* FIXME: kettenis/2000-08-26: This should really be handled
394 properly by core GDB. */
396 tp
= find_thread_pid (lp
->pid
);
398 tp
= iterate_over_threads (find_lwp_callback
, lp
);
401 /* If we were previously stepping the thread, and now continue
402 the thread we must invalidate the stepping range. However,
403 if there is a step_resume breakpoint for this thread, we must
404 preserve the stepping range to make it possible to continue
405 stepping once we hit it. */
406 if (tp
->step_range_end
&& tp
->step_resume_breakpoint
== NULL
)
408 gdb_assert (lp
->step
);
409 tp
->step_range_start
= tp
->step_range_end
= 0;
413 child_resume (GET_LWP (lp
->pid
), 0, TARGET_SIGNAL_0
);
422 lin_lwp_resume (int pid
, int step
, enum target_signal signo
)
427 /* Apparently the interpretation of PID is dependent on STEP: If
428 STEP is non-zero, a specific PID means `step only this process
429 id'. But if STEP is zero, then PID means `continue *all*
430 processes, but give the signal only to this one'. */
431 resume_all
= (pid
== -1) || !step
;
433 /* If PID is -1, it's the current inferior that should be
438 lp
= find_lwp_pid (pid
);
441 pid
= GET_LWP (lp
->pid
);
443 /* Remember if we're stepping. */
446 /* If we have a pending wait status for this thread, there is no
447 point in resuming the process. */
450 /* FIXME: What should we do if we are supposed to continue
451 this thread with a signal? */
452 gdb_assert (signo
== TARGET_SIGNAL_0
);
456 /* Mark LWP as not stopped to prevent it from being continued by
462 iterate_over_lwps (resume_callback
, NULL
);
464 child_resume (pid
, step
, signo
);
468 /* Send a SIGSTOP to LP. */
471 stop_callback (struct lwp_info
*lp
, void *data
)
473 if (! lp
->stopped
&& ! lp
->signalled
)
477 ret
= kill (GET_LWP (lp
->pid
), SIGSTOP
);
478 gdb_assert (ret
== 0);
481 gdb_assert (lp
->status
== 0);
487 /* Wait until LP is stopped. */
490 stop_wait_callback (struct lwp_info
*lp
, void *data
)
492 if (! lp
->stopped
&& lp
->signalled
)
497 gdb_assert (lp
->status
== 0);
499 pid
= waitpid (GET_LWP (lp
->pid
), &status
,
500 is_cloned (lp
->pid
) ? __WCLONE
: 0);
501 if (pid
== -1 && errno
== ECHILD
)
502 /* OK, the proccess has disappeared. We'll catch the actual
503 exit event in lin_lwp_wait. */
506 gdb_assert (pid
== GET_LWP (lp
->pid
));
508 if (WIFEXITED (status
) || WIFSIGNALED (status
))
510 gdb_assert (num_lwps
> 1);
512 if (in_thread_list (lp
->pid
))
514 /* Core GDB cannot deal with us deleting the current
516 if (lp
->pid
!= inferior_pid
)
517 delete_thread (lp
->pid
);
518 printf_unfiltered ("[%s exited]\n",
519 target_pid_to_str (lp
->pid
));
521 if (debug_linux_threads
)
522 printf ("%s exited.\n", target_pid_to_str (lp
->pid
));
524 delete_lwp (lp
->pid
);
528 gdb_assert (WIFSTOPPED (status
));
531 if (WSTOPSIG (status
) != SIGSTOP
)
533 if (WSTOPSIG (status
) == SIGTRAP
534 && breakpoint_inserted_here_p (read_pc_pid (pid
)
535 - DECR_PC_AFTER_BREAK
))
537 /* If a LWP other than the LWP that we're reporting an
538 event for has hit a GDB breakpoint (as opposed to
539 some random trap signal), then just arrange for it to
540 hit it again later. We don't keep the SIGTRAP status
541 and don't forward the SIGTRAP signal to the LWP. We
542 will handle the current event, eventually we will
543 resume all LWPs, and this one will get its breakpoint
546 If we do not do this, then we run the risk that the
547 user will delete or disable the breakpoint, but the
548 thread will have already tripped on it. */
550 if (debug_linux_threads
)
551 printf ("Tripped breakpoint at %lx in LWP %d"
552 " while waiting for SIGSTOP.\n",
553 (long) read_pc_pid (lp
->pid
), pid
);
555 /* Set the PC to before the trap. */
556 if (DECR_PC_AFTER_BREAK
)
557 write_pc_pid (read_pc_pid (pid
) - DECR_PC_AFTER_BREAK
, pid
);
561 if (debug_linux_threads
)
562 printf ("Received %s in LWP %d while waiting for SIGSTOP.\n",
563 strsignal (WSTOPSIG (status
)), pid
);
564 /* The thread was stopped with a signal other than
565 SIGSTOP, and didn't accidentiliy trip a breakpoint.
566 Record the wait status. */
572 /* We caught the SIGSTOP that we intended to catch, so
573 there's no SIGSTOP pending. */
581 /* Return non-zero if LP has a wait status pending. */
584 status_callback (struct lwp_info
*lp
, void *data
)
586 return (lp
->status
!= 0);
589 /* Return non-zero if LP isn't stopped. */
592 running_callback (struct lwp_info
*lp
, void *data
)
594 return (lp
->stopped
== 0);
598 lin_lwp_wait (int pid
, struct target_waitstatus
*ourstatus
)
600 struct lwp_info
*lp
= NULL
;
604 /* Make sure SIGCHLD is blocked. */
605 if (! sigismember (&blocked_mask
, SIGCHLD
))
607 sigaddset (&blocked_mask
, SIGCHLD
);
608 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
613 /* First check if there is a LWP with a wait status pending. */
616 /* Any LWP will do. */
617 lp
= iterate_over_lwps (status_callback
, NULL
);
620 if (debug_linux_threads
)
621 printf ("Using pending wait status for LWP %d.\n",
627 /* But if we don't fine one, we'll have to wait, and check both
628 cloned and uncloned processes. We start with the cloned
630 options
= __WCLONE
| WNOHANG
;
632 else if (is_lwp (pid
))
634 if (debug_linux_threads
)
635 printf ("Waiting for specific LWP %d.\n", GET_LWP (pid
));
637 /* We have a specific LWP to check. */
638 lp
= find_lwp_pid (GET_LWP (pid
));
642 if (debug_linux_threads
)
644 printf ("Using pending wait status for LWP %d.\n",
647 /* If we have to wait, take into account whether PID is a cloned
648 process or not. And we have to convert it to something that
649 the layer beneath us can understand. */
650 options
= is_cloned (lp
->pid
) ? __WCLONE
: 0;
654 if (status
&& lp
->signalled
)
656 /* A pending SIGSTOP may interfere with the normal stream of
657 events. In a typical case where interference is a problem,
658 we have a SIGSTOP signal pending for LWP A while
659 single-stepping it, encounter an event in LWP B, and take the
660 pending SIGSTOP while trying to stop LWP A. After processing
661 the event in LWP B, LWP A is continued, and we'll never see
662 the SIGTRAP associated with the last time we were
663 single-stepping LWP A. */
665 /* Resume the thread. It should halt immediately returning the
667 child_resume (GET_LWP (lp
->pid
), lp
->step
, TARGET_SIGNAL_0
);
670 /* This should catch the pending SIGSTOP. */
671 stop_wait_callback (lp
, NULL
);
674 set_sigint_trap (); /* Causes SIGINT to be passed on to the
682 lwpid
= waitpid (pid
, &status
, options
);
685 gdb_assert (pid
== -1 || lwpid
== pid
);
687 lp
= find_lwp_pid (lwpid
);
690 lp
= add_lwp (BUILD_LWP (lwpid
, inferior_pid
));
693 gdb_assert (WIFSTOPPED (status
)
694 && WSTOPSIG (status
) == SIGSTOP
);
697 if (! in_thread_list (inferior_pid
))
699 inferior_pid
= BUILD_LWP (inferior_pid
, inferior_pid
);
700 add_thread (inferior_pid
);
703 add_thread (lp
->pid
);
704 printf_unfiltered ("[New %s]\n",
705 target_pid_to_str (lp
->pid
));
709 /* Make sure we don't report a TARGET_WAITKIND_EXITED or
710 TARGET_WAITKIND_SIGNALLED event if there are still LWP's
711 left in the process. */
712 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
714 if (in_thread_list (lp
->pid
))
716 /* Core GDB cannot deal with us deleting the current
718 if (lp
->pid
!= inferior_pid
)
719 delete_thread (lp
->pid
);
720 printf_unfiltered ("[%s exited]\n",
721 target_pid_to_str (lp
->pid
));
723 if (debug_linux_threads
)
724 printf ("%s exited.\n", target_pid_to_str (lp
->pid
));
726 delete_lwp (lp
->pid
);
728 /* Make sure there is at least one thread running. */
729 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
731 /* Discard the event. */
736 /* Make sure we don't report a SIGSTOP that we sent
737 ourselves in an attempt to stop an LWP. */
738 if (lp
->signalled
&& WIFSTOPPED (status
)
739 && WSTOPSIG (status
) == SIGSTOP
)
741 if (debug_linux_threads
)
742 printf ("Delayed SIGSTOP caught for %s.\n",
743 target_pid_to_str (lp
->pid
));
745 /* This is a delayed SIGSTOP. */
748 child_resume (GET_LWP (lp
->pid
), lp
->step
, TARGET_SIGNAL_0
);
751 /* Discard the event. */
761 /* Alternate between checking cloned and uncloned processes. */
764 /* And suspend every time we have checked both. */
765 if (options
& __WCLONE
)
766 sigsuspend (&suspend_mask
);
769 /* We shouldn't end up here unless we want to try again. */
770 gdb_assert (status
== 0);
774 clear_sigint_trap ();
778 /* Don't report signals that GDB isn't interested in, such as
779 signals that are neither printed nor stopped upon. Stopping all
780 threads can be a bit time-consuming so if we want decent
781 performance with heavily multi-threaded programs, especially when
782 they're using a high frequency timer, we'd better avoid it if we
785 if (WIFSTOPPED (status
))
787 int signo
= target_signal_from_host (WSTOPSIG (status
));
789 if (signal_stop_state (signo
) == 0
790 && signal_print_state (signo
) == 0
791 && signal_pass_state (signo
) == 1)
793 child_resume (GET_LWP (lp
->pid
), lp
->step
, signo
);
800 /* This LWP is stopped now. */
803 /* Now stop all other LWP's ... */
804 iterate_over_lwps (stop_callback
, NULL
);
806 /* ... and wait until all of them have reported back that they're no
808 iterate_over_lwps (stop_wait_callback
, NULL
);
810 /* If we're not running in "threaded" mode, we'll report the bare
813 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
814 trap_pid
= (threaded
? lp
->pid
: GET_LWP (lp
->pid
));
818 store_waitstatus (ourstatus
, status
);
819 return (threaded
? lp
->pid
: GET_LWP (lp
->pid
));
823 kill_callback (struct lwp_info
*lp
, void *data
)
825 ptrace (PTRACE_KILL
, GET_LWP (lp
->pid
), 0, 0);
830 kill_wait_callback (struct lwp_info
*lp
, void *data
)
834 /* We must make sure that there are no pending events (delayed
835 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
836 program doesn't interfere with any following debugging session. */
838 /* For cloned processes we must check both with __WCLONE and
839 without, since the exit status of a cloned process isn't reported
841 if (is_cloned (lp
->pid
))
845 pid
= waitpid (GET_LWP (lp
->pid
), NULL
, __WCLONE
);
847 while (pid
== GET_LWP (lp
->pid
));
849 gdb_assert (pid
== -1 && errno
== ECHILD
);
854 pid
= waitpid (GET_LWP (lp
->pid
), NULL
, 0);
856 while (pid
== GET_LWP (lp
->pid
));
858 gdb_assert (pid
== -1 && errno
== ECHILD
);
865 /* Kill all LWP's ... */
866 iterate_over_lwps (kill_callback
, NULL
);
868 /* ... and wait until we've flushed all events. */
869 iterate_over_lwps (kill_wait_callback
, NULL
);
871 target_mourn_inferior ();
875 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
877 struct target_ops
*target_beneath
;
882 target_beneath
= find_target_beneath (&lin_lwp_ops
);
884 target_beneath
= &child_ops
;
886 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
890 lin_lwp_mourn_inferior (void)
892 struct target_ops
*target_beneath
;
898 /* Restore the original signal mask. */
899 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
900 sigemptyset (&blocked_mask
);
903 target_beneath
= find_target_beneath (&lin_lwp_ops
);
905 target_beneath
= &child_ops
;
907 target_beneath
->to_mourn_inferior ();
911 lin_lwp_fetch_registers (int regno
)
913 struct cleanup
*old_chain
= save_inferior_pid ();
915 if (is_lwp (inferior_pid
))
916 inferior_pid
= GET_LWP (inferior_pid
);
918 fetch_inferior_registers (regno
);
920 do_cleanups (old_chain
);
924 lin_lwp_store_registers (int regno
)
926 struct cleanup
*old_chain
= save_inferior_pid ();
928 if (is_lwp (inferior_pid
))
929 inferior_pid
= GET_LWP (inferior_pid
);
931 store_inferior_registers (regno
);
933 do_cleanups (old_chain
);
937 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
938 struct mem_attrib
*attrib
,
939 struct target_ops
*target
)
941 struct cleanup
*old_chain
= save_inferior_pid ();
944 if (is_lwp (inferior_pid
))
945 inferior_pid
= GET_LWP (inferior_pid
);
947 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
949 do_cleanups (old_chain
);
954 lin_lwp_thread_alive (int pid
)
956 gdb_assert (is_lwp (pid
));
959 ptrace (PTRACE_PEEKUSER
, GET_LWP (pid
), 0, 0);
967 lin_lwp_pid_to_str (int pid
)
973 snprintf (buf
, sizeof (buf
), "LWP %d", GET_LWP (pid
));
977 return normal_pid_to_str (pid
);
981 init_lin_lwp_ops (void)
984 lin_lwp_ops
.to_open
= lin_lwp_open
;
986 lin_lwp_ops
.to_shortname
= "lwp-layer";
987 lin_lwp_ops
.to_longname
= "lwp-layer";
988 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
989 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
990 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
991 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
992 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
993 lin_lwp_ops
.to_fetch_registers
= lin_lwp_fetch_registers
;
994 lin_lwp_ops
.to_store_registers
= lin_lwp_store_registers
;
995 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
996 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
997 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
998 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
999 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1000 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1001 lin_lwp_ops
.to_stratum
= thread_stratum
;
1002 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1003 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1007 sigchld_handler (int signo
)
1009 /* Do nothing. The only reason for this handler is that it allows
1010 us to use sigsuspend in lin_lwp_wait above to wait for the
1011 arrival of a SIGCHLD. */
1015 _initialize_lin_lwp (void)
1017 struct sigaction action
;
1019 extern void thread_db_init (struct target_ops
*);
1021 init_lin_lwp_ops ();
1022 add_target (&lin_lwp_ops
);
1023 thread_db_init (&lin_lwp_ops
);
1025 /* Save the original signal mask. */
1026 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1028 action
.sa_handler
= sigchld_handler
;
1029 sigemptyset (&action
.sa_mask
);
1030 action
.sa_flags
= 0;
1031 sigaction (SIGCHLD
, &action
, NULL
);
1033 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1034 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1035 sigdelset (&suspend_mask
, SIGCHLD
);
1037 sigemptyset (&blocked_mask
);
1041 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1042 the LinuxThreads library and therefore doesn't really belong here. */
1044 /* Read variable NAME in the target and return its value if found.
1045 Otherwise return zero. It is assumed that the type of the variable
1049 get_signo (const char *name
)
1051 struct minimal_symbol
*ms
;
1054 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1058 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1059 sizeof (signo
)) != 0)
1065 /* Return the set of signals used by the threads library in *SET. */
1068 lin_thread_get_thread_signals (sigset_t
*set
)
1070 struct sigaction action
;
1071 int restart
, cancel
;
1075 restart
= get_signo ("__pthread_sig_restart");
1079 cancel
= get_signo ("__pthread_sig_cancel");
1083 sigaddset (set
, restart
);
1084 sigaddset (set
, cancel
);
1086 /* The LinuxThreads library makes terminating threads send a special
1087 "cancel" signal instead of SIGCHLD. Make sure we catch those (to
1088 prevent them from terminating GDB itself, which is likely to be
1089 their default action) and treat them the same way as SIGCHLD. */
1091 action
.sa_handler
= sigchld_handler
;
1092 sigemptyset (&action
.sa_mask
);
1093 action
.sa_flags
= 0;
1094 sigaction (cancel
, &action
, NULL
);
1096 /* We block the "cancel" signal throughout this code ... */
1097 sigaddset (&blocked_mask
, cancel
);
1098 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1100 /* ... except during a sigsuspend. */
1101 sigdelset (&suspend_mask
, cancel
);
This page took 0.067377 seconds and 5 git commands to generate.