1 /* Multi-threaded debugging support for Linux (LWP layer).
2 Copyright 2000 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"
36 extern const char *strsignal (int sig
);
39 /* On Linux there are no real LWP's. The closest thing to LWP's are
40 processes sharing the same VM space. A multi-threaded process is
41 basically a group of such processes. However, such a grouping is
42 almost entirely a user-space issue; the kernel doesn't enforce such
43 a grouping at all (this might change in the future). In general,
44 we'll rely on the threads library (i.e. the LinuxThreads library)
45 to provide such a grouping.
47 It is perfectly well possible to write a multi-threaded application
48 without the assistance of a threads library, by using the clone
49 system call directly. This module should be able to give some
50 rudimentary support for debugging such applications if developers
51 specify the CLONE_PTRACE flag in the clone system call, and are
52 using Linux 2.4 or above.
54 Note that there are some peculiarities in Linux that affect this
57 - In general one should specify the __WCLONE flag to waitpid in
58 order to make it report events for any of the cloned processes.
59 However, if a cloned process has exited the exit status is only
60 reported if the __WCLONE flag is absent.
62 - When a traced, cloned process exits and is waited for by the
63 debugger, the kernel reassigns it to the origional 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 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
130 _initialize_lin_lwp. */
131 static sigset_t suspend_mask
;
134 /* Prototypes for local functions. */
135 static void lin_lwp_mourn_inferior (void);
138 /* Initialize the list of LWPs. */
143 struct lwp_info
*lp
, *lpnext
;
145 for (lp
= lwp_list
; lp
; lp
= lpnext
)
156 /* Add the LWP specified by PID to the list. If this causes the
157 number of LWPs to become larger than one, go into "threaded" mode.
158 Return a pointer to the structure describing the new LWP. */
160 static struct lwp_info
*
165 gdb_assert (is_lwp (pid
));
167 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
169 memset (lp
, 0, sizeof (struct lwp_info
));
181 /* Remove the LWP specified by PID from the list. */
186 struct lwp_info
*lp
, *lpprev
;
190 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
197 /* We don't go back to "non-threaded" mode if the number of threads
198 becomes less than two. */
202 lpprev
->next
= lp
->next
;
209 /* Return a pointer to the structure describing the LWP corresponding
210 to PID. If no corresponding LWP could be found, return NULL. */
212 static struct lwp_info
*
213 find_lwp_pid (int pid
)
220 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
221 if (pid
== GET_LWP (lp
->pid
))
227 /* Call CALLBACK with its second argument set to DATA for every LWP in
228 the list. If CALLBACK returns 1 for a particular LWP, return a
229 pointer to the structure describing that LWP immediately.
230 Otherwise return NULL. */
233 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
237 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
238 if ((*callback
) (lp
, data
))
245 /* Helper functions. */
248 restore_inferior_pid (void *arg
)
250 int *saved_pid_ptr
= arg
;
251 inferior_pid
= *saved_pid_ptr
;
255 static struct cleanup
*
256 save_inferior_pid (void)
260 saved_pid_ptr
= xmalloc (sizeof (int));
261 *saved_pid_ptr
= inferior_pid
;
262 return make_cleanup (restore_inferior_pid
, saved_pid_ptr
);
266 /* Implementation of the PREPARE_TO_PROCEED hook for the Linux LWP layer. */
269 lin_lwp_prepare_to_proceed (void)
271 if (trap_pid
&& inferior_pid
!= trap_pid
)
273 /* Switched over from TRAP_PID. */
274 CORE_ADDR stop_pc
= read_pc ();
277 /* Avoid switching where it wouldn't do any good, i.e. if both
278 threads are at the same breakpoint. */
279 trap_pc
= read_pc_pid (trap_pid
);
280 if (trap_pc
!= stop_pc
&& breakpoint_here_p (trap_pc
))
282 /* User hasn't deleted the breakpoint. Return non-zero, and
283 switch back to TRAP_PID. */
284 inferior_pid
= trap_pid
;
286 /* FIXME: Is this stuff really necessary? */
287 flush_cached_frames ();
288 registers_changed ();
300 lin_lwp_open (char *args
, int from_tty
)
302 push_target (&lin_lwp_ops
);
306 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
307 a message telling the user that a new LWP has been added to the
311 lin_lwp_attach_lwp (int pid
, int verbose
)
315 gdb_assert (is_lwp (pid
));
318 printf_filtered ("[New %s]\n", target_pid_to_str (pid
));
320 if (ptrace (PTRACE_ATTACH
, GET_LWP (pid
), 0, 0) < 0)
321 error ("Can't attach %s: %s", target_pid_to_str (pid
), strerror (errno
));
328 lin_lwp_attach (char *args
, int from_tty
)
330 /* FIXME: We should probably accept a list of process id's, and
331 attach all of them. */
332 error("Not implemented yet");
336 lin_lwp_detach (char *args
, int from_tty
)
338 /* FIXME: Provide implementation when we implement lin_lwp_attach. */
339 error ("Not implemented yet");
343 struct private_thread_info
348 /* Return non-zero if TP corresponds to the LWP specified by DATA
349 (which is assumed to be a pointer to a `struct lwp_info'. */
352 find_lwp_callback (struct thread_info
*tp
, void *data
)
354 struct lwp_info
*lp
= data
;
356 if (tp
->private->lwpid
== GET_LWP (lp
->pid
))
365 resume_callback (struct lwp_info
*lp
, void *data
)
367 if (lp
->stopped
&& lp
->status
== 0)
369 struct thread_info
*tp
;
372 /* FIXME: kettenis/2000-08-26: This should really be handled
373 properly by core GDB. */
375 tp
= find_thread_pid (lp
->pid
);
377 tp
= iterate_over_threads (find_lwp_callback
, lp
);
380 /* If we were previously stepping the thread, and now continue
381 the thread we must invalidate the stepping range. However,
382 if there is a step_resume breakpoint for this thread, we must
383 preserve the stepping range to make it possible to continue
384 stepping once we hit it. */
385 if (tp
->step_range_end
&& tp
->step_resume_breakpoint
== NULL
)
387 gdb_assert (lp
->step
);
388 tp
->step_range_start
= tp
->step_range_end
= 0;
392 child_resume (GET_LWP (lp
->pid
), 0, TARGET_SIGNAL_0
);
401 lin_lwp_resume (int pid
, int step
, enum target_signal signo
)
406 /* Apparently the interpretation of PID is dependent on STEP: If
407 STEP is non-zero, a specific PID means `step only this process
408 id'. But if STEP is zero, then PID means `continue *all*
409 processes, but give the signal only to this one'. */
410 resume_all
= (pid
== -1) || !step
;
412 /* If PID is -1, it's the current inferior that should be
417 lp
= find_lwp_pid (pid
);
420 pid
= GET_LWP (lp
->pid
);
422 /* Mark LWP as not stopped to prevent it from being continued by
426 /* Remember if we're stepping. */
429 /* If we have a pending wait status for this thread, there is no
430 point in resuming the process. */
433 /* FIXME: What should we do if we are supposed to continue
434 this thread with a signal? */
435 gdb_assert (signo
== TARGET_SIGNAL_0
);
441 iterate_over_lwps (resume_callback
, NULL
);
443 child_resume (pid
, step
, signo
);
447 /* Send a SIGSTOP to LP. */
450 stop_callback (struct lwp_info
*lp
, void *data
)
452 if (! lp
->stopped
&& ! lp
->signalled
)
456 ret
= kill (GET_LWP (lp
->pid
), SIGSTOP
);
457 gdb_assert (ret
== 0);
460 gdb_assert (lp
->status
== 0);
466 /* Wait until LP is stopped. */
469 stop_wait_callback (struct lwp_info
*lp
, void *data
)
471 if (! lp
->stopped
&& lp
->signalled
)
476 gdb_assert (lp
->status
== 0);
478 pid
= waitpid (GET_LWP (lp
->pid
), &status
,
479 is_cloned (lp
->pid
) ? __WCLONE
: 0);
480 if (pid
== -1 && errno
== ECHILD
)
481 /* OK, the proccess has disappeared. We'll catch the actual
482 exit event in lin_lwp_wait. */
485 gdb_assert (pid
== GET_LWP (lp
->pid
));
487 if (WIFEXITED (status
) || WIFSIGNALED (status
))
489 gdb_assert (num_lwps
> 1);
490 gdb_assert (! is_cloned (lp
->pid
));
492 gdb_assert (in_thread_list (lp
->pid
));
493 if (lp
->pid
!= inferior_pid
)
494 delete_thread (lp
->pid
);
495 printf_unfiltered ("[%s exited]\n",
496 target_pid_to_str (lp
->pid
));
498 delete_lwp (lp
->pid
);
502 gdb_assert (WIFSTOPPED (status
));
505 if (WSTOPSIG (status
) != SIGSTOP
)
507 if (WSTOPSIG (status
) == SIGTRAP
508 && breakpoint_inserted_here_p (read_pc_pid (pid
)
509 - DECR_PC_AFTER_BREAK
))
511 /* If a LWP other than the LWP that we're reporting an
512 event for has hit a GDB breakpoint (as opposed to
513 some random trap signal), then just arrange for it to
514 hit it again later. We don't keep the SIGTRAP status
515 and don't forward the SIGTRAP signal to the LWP. We
516 will handle the current event, eventually we will
517 resume all LWPs, and this one will get its breakpoint
520 If we do not do this, then we run the risk that the
521 user will delete or disable the breakpoint, but the
522 thread will have already tripped on it. */
524 printf ("Tripped breakpoint at %lx in LWP %d"
525 " while waiting for SIGSTOP.\n",
526 (long) read_pc_pid (lp
->pid
), pid
);
528 /* Set the PC to before the trap. */
529 if (DECR_PC_AFTER_BREAK
)
530 write_pc_pid (read_pc_pid (pid
) - DECR_PC_AFTER_BREAK
, pid
);
535 printf ("Received %s in LWP %d while waiting for SIGSTOP.\n",
536 strsignal (WSTOPSIG (status
)), pid
);
538 /* The thread was stopped with a signal other than
539 SIGSTOP, and didn't accidentiliy trip a breakpoint.
540 Record the wait status. */
546 /* We caught the SIGSTOP that we intended to catch, so
547 there's no SIGSTOP pending. */
555 /* Return non-zero if LP has a wait status pending. */
558 status_callback (struct lwp_info
*lp
, void *data
)
560 return (lp
->status
!= 0);
563 /* Return non-zero if LP isn't stopped. */
566 running_callback (struct lwp_info
*lp
, void *data
)
568 return (lp
->stopped
== 0);
572 lin_lwp_wait (int pid
, struct target_waitstatus
*ourstatus
)
574 struct lwp_info
*lp
= NULL
;
580 /* First check if there is a LWP with a wait status pending. */
583 /* Any LWP will do. */
584 lp
= iterate_over_lwps (status_callback
, NULL
);
588 printf ("Using pending wait status for LWP %d.\n",
595 /* But if we don't fine one, we'll have to wait, and check both
596 cloned and uncloned processes. We start with the cloned
598 options
= __WCLONE
| WNOHANG
;
600 else if (is_lwp (pid
))
603 printf ("Waiting for specific LWP %d.\n", GET_LWP (pid
));
605 /* We have a specific LWP to check. */
606 lp
= find_lwp_pid (GET_LWP (pid
));
612 printf ("Using pending wait status for LWP %d.\n",
616 /* If we have to wait, take into account whether PID is a cloned
617 process or not. And we have to convert it to something that
618 the layer beneath us can understand. */
619 options
= is_cloned (lp
->pid
) ? __WCLONE
: 0;
623 if (status
&& lp
->signalled
)
625 /* A pending SIGSTOP may interfere with the normal stream of
626 events. In a typical case where interference is a problem,
627 we have a SIGSTOP signal pending for LWP A while
628 single-stepping it, encounter an event in LWP B, and take the
629 pending SIGSTOP while trying to stop LWP A. After processing
630 the event in LWP B, LWP A is continued, and we'll never see
631 the SIGTRAP associated with the last time we were
632 single-stepping LWP A. */
634 /* Resume the thread. It should halt immediately returning the
636 child_resume (GET_LWP (lp
->pid
), lp
->step
, TARGET_SIGNAL_0
);
639 /* This should catch the pending SIGSTOP. */
640 stop_wait_callback (lp
, NULL
);
643 set_sigint_trap (); /* Causes SIGINT to be passed on to the
651 lwpid
= waitpid (pid
, &status
, options
);
654 gdb_assert (pid
== -1 || lwpid
== pid
);
656 lp
= find_lwp_pid (lwpid
);
659 lp
= add_lwp (BUILD_LWP (lwpid
, inferior_pid
));
662 gdb_assert (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
665 if (! in_thread_list (inferior_pid
))
667 inferior_pid
= BUILD_LWP (inferior_pid
, inferior_pid
);
668 add_thread (inferior_pid
);
671 add_thread (lp
->pid
);
672 printf_unfiltered ("[New %s]\n",
673 target_pid_to_str (lp
->pid
));
677 /* Make sure we don't report a TARGET_WAITKIND_EXITED or
678 TARGET_WAITKIND_SIGNALLED event if there are still LWP's
679 left in the process. */
680 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
682 if (in_thread_list (lp
->pid
))
684 /* Core GDB cannot deal with us deeting the current
686 if (lp
->pid
!= inferior_pid
)
687 delete_thread (lp
->pid
);
688 printf_unfiltered ("[%s exited]\n",
689 target_pid_to_str (lp
->pid
));
692 printf ("%s exited.\n", target_pid_to_str (lp
->pid
));
694 delete_lwp (lp
->pid
);
696 /* Make sure there is at least one thread running. */
697 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
699 /* Discard the event. */
704 /* Make sure we don't report a SIGSTOP that we sent
705 ourselves in an attempt to stop an LWP. */
706 if (lp
->signalled
&& WIFSTOPPED (status
)
707 && WSTOPSIG (status
) == SIGSTOP
)
710 printf ("Delayed SIGSTOP caught for %s.\n",
711 target_pid_to_str (lp
->pid
));
713 /* This is a delayed SIGSTOP. */
716 child_resume (GET_LWP (lp
->pid
), lp
->step
, TARGET_SIGNAL_0
);
719 /* Discard the event. */
729 /* Alternate between checking cloned and uncloned processes. */
732 /* And suspend every time we have checked both. */
733 if (options
& __WCLONE
)
734 sigsuspend (&suspend_mask
);
737 /* We shouldn't end up here unless we want to try again. */
738 gdb_assert (status
== 0);
742 clear_sigint_trap ();
746 /* Don't report signals that GDB isn't interested in, such as
747 signals that are neither printed nor stopped upon. Stopping all
748 threads can be a bit time-consuming so if we want decent
749 performance with heavily multi-threaded programs, especially when
750 they're using a high frequency timer, we'd better avoid it if we
753 if (WIFSTOPPED (status
))
755 int signo
= target_signal_from_host (WSTOPSIG (status
));
757 if (signal_stop_state (signo
) == 0
758 && signal_print_state (signo
) == 0
759 && signal_pass_state (signo
) == 1)
761 child_resume (GET_LWP (lp
->pid
), lp
->step
, signo
);
768 /* This LWP is stopped now. */
771 /* Now stop all other LWP's ... */
772 iterate_over_lwps (stop_callback
, NULL
);
774 /* ... and wait until all of them have reported back that they're no
776 iterate_over_lwps (stop_wait_callback
, NULL
);
778 /* If we're not running in "threaded" mode, we'll report the bare
781 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
782 trap_pid
= (threaded
? lp
->pid
: GET_LWP (lp
->pid
));
786 store_waitstatus (ourstatus
, status
);
787 return (threaded
? lp
->pid
: GET_LWP (lp
->pid
));
791 kill_callback (struct lwp_info
*lp
, void *data
)
793 ptrace (PTRACE_KILL
, GET_LWP (lp
->pid
), 0, 0);
798 kill_wait_callback (struct lwp_info
*lp
, void *data
)
802 /* We must make sure that there are no pending events (delayed
803 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
804 program doesn't interfere with any following debugging session. */
806 /* For cloned processes we must check both with __WCLONE and
807 without, since the exit status of a cloned process isn't reported
809 if (is_cloned (lp
->pid
))
813 pid
= waitpid (GET_LWP (lp
->pid
), NULL
, __WCLONE
);
815 while (pid
== GET_LWP (lp
->pid
));
817 gdb_assert (pid
== -1 && errno
== ECHILD
);
822 pid
= waitpid (GET_LWP (lp
->pid
), NULL
, 0);
824 while (pid
== GET_LWP (lp
->pid
));
826 gdb_assert (pid
== -1 && errno
== ECHILD
);
833 /* Kill all LWP's ... */
834 iterate_over_lwps (kill_callback
, NULL
);
836 /* ... and wait until we've flushed all events. */
837 iterate_over_lwps (kill_wait_callback
, NULL
);
839 target_mourn_inferior ();
843 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
845 struct target_ops
*target_beneath
;
850 target_beneath
= find_target_beneath (&lin_lwp_ops
);
852 target_beneath
= &child_ops
;
854 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
858 lin_lwp_mourn_inferior (void)
860 struct target_ops
*target_beneath
;
867 target_beneath
= find_target_beneath (&lin_lwp_ops
);
869 target_beneath
= &child_ops
;
871 target_beneath
->to_mourn_inferior ();
875 lin_lwp_fetch_registers (int regno
)
877 struct cleanup
*old_chain
= save_inferior_pid ();
879 if (is_lwp (inferior_pid
))
880 inferior_pid
= GET_LWP (inferior_pid
);
882 fetch_inferior_registers (regno
);
884 do_cleanups (old_chain
);
888 lin_lwp_store_registers (int regno
)
890 struct cleanup
*old_chain
= save_inferior_pid ();
892 if (is_lwp (inferior_pid
))
893 inferior_pid
= GET_LWP (inferior_pid
);
895 store_inferior_registers (regno
);
897 do_cleanups (old_chain
);
901 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
902 struct target_ops
*target
)
904 struct cleanup
*old_chain
= save_inferior_pid ();
907 if (is_lwp (inferior_pid
))
908 inferior_pid
= GET_LWP (inferior_pid
);
910 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, target
);
912 do_cleanups (old_chain
);
917 lin_lwp_thread_alive (int pid
)
919 gdb_assert (is_lwp (pid
));
922 ptrace (PTRACE_PEEKUSER
, GET_LWP (pid
), 0, 0);
930 lin_lwp_pid_to_str (int pid
)
936 snprintf (buf
, sizeof (buf
), "LWP %d", GET_LWP (pid
));
940 return normal_pid_to_str (pid
);
944 init_lin_lwp_ops (void)
947 lin_lwp_ops
.to_open
= lin_lwp_open
;
949 lin_lwp_ops
.to_shortname
= "lwp-layer";
950 lin_lwp_ops
.to_longname
= "lwp-layer";
951 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
952 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
953 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
954 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
955 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
956 lin_lwp_ops
.to_fetch_registers
= lin_lwp_fetch_registers
;
957 lin_lwp_ops
.to_store_registers
= lin_lwp_store_registers
;
958 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
959 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
960 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
961 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
962 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
963 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
964 lin_lwp_ops
.to_stratum
= thread_stratum
;
965 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
966 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
970 sigchld_handler (int signo
)
972 /* Do nothing. The only reason for this handler is that it allows
973 us to use sigsuspend in lin_lwp_wait above to wait for the
974 arrival of a SIGCHLD. */
978 _initialize_lin_lwp (void)
980 struct sigaction action
;
983 extern void thread_db_init (struct target_ops
*);
986 add_target (&lin_lwp_ops
);
987 thread_db_init (&lin_lwp_ops
);
989 action
.sa_handler
= sigchld_handler
;
990 sigemptyset (&action
.sa_mask
);
992 sigaction (SIGCHLD
, &action
, NULL
);
994 /* We block SIGCHLD throughout this code ... */
996 sigaddset (&mask
, SIGCHLD
);
997 sigprocmask (SIG_BLOCK
, &mask
, &suspend_mask
);
999 /* ... except during a sigsuspend. */
1000 sigdelset (&suspend_mask
, SIGCHLD
);
1004 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1005 the LinuxThreads library and therefore doesn't really belong here. */
1007 /* Read variable NAME in the target and return its value if found.
1008 Otherwise return zero. It is assumed that the type of the variable
1012 get_signo (const char *name
)
1014 struct minimal_symbol
*ms
;
1017 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1021 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1022 sizeof (signo
)) != 0)
1028 /* Return the set of signals used by the threads library in *SET. */
1031 lin_thread_get_thread_signals (sigset_t
*set
)
1038 restart
= get_signo ("__pthread_sig_restart");
1042 cancel
= get_signo ("__pthread_sig_cancel");
1046 sigaddset (set
, restart
);
1047 sigaddset (set
, cancel
);