1 /* Low level interface for debugging GNU/Linux threads for GDB,
3 Copyright 1998, 1999 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This module implements the debugging interface of the linuxthreads package
22 of the glibc. This package implements a simple clone()-based implementation
23 of Posix threads for Linux. To use this module, be sure that you have at
24 least the version of the linuxthreads package that holds the support of
25 GDB (currently 0.8 included in the glibc-2.0.7).
27 Right now, the linuxthreads package does not care of priority scheduling,
28 so, neither this module does; In particular, the threads are resumed
29 in any order, which could lead to different scheduling than the one
30 happening when GDB does not control the execution.
32 The latest point is that ptrace(PT_ATTACH, ...) is intrusive in Linux:
33 When a process is attached, then the attaching process becomes the current
34 parent of the attached process, and the old parent has lost this child.
35 If the old parent does a wait[...](), then this child is no longer
36 considered by the kernel as a child of the old parent, thus leading to
37 results of the call different when the child is attached and when it's not.
39 A fix has been submitted to the Linux community to solve this problem,
40 which consequences are not visible to the application itself, but on the
41 process which may wait() for the completion of the application (mostly,
42 it may consider that the application no longer exists (errno == ECHILD),
43 although it does, and thus being unable to get the exit status and resource
44 usage of the child. If by chance, it is able to wait() for the application
45 after it has died (by receiving first a SIGCHILD, and then doing a wait(),
46 then the exit status and resource usage may be wrong, because the
47 linuxthreads package heavily relies on wait() synchronization to keep
50 #include <sys/types.h> /* for pid_t */
51 #include <sys/ptrace.h> /* for PT_* flags */
52 #include <sys/wait.h> /* for WUNTRACED and __WCLONE flags */
53 #include <signal.h> /* for struct sigaction and NSIG */
54 #include <sys/utsname.h>
60 #include "gdbthread.h"
63 #include "breakpoint.h"
66 #define PT_ATTACH PTRACE_ATTACH
69 #define PT_KILL PTRACE_KILL
72 #define PT_READ_U PTRACE_PEEKUSR
76 #define LINUXTHREAD_NSIG NSIG
79 #define LINUXTHREAD_NSIG _NSIG
83 extern int child_suppress_run
; /* make inftarg.c non-runnable */
84 struct target_ops linuxthreads_ops
; /* Forward declaration */
85 extern struct target_ops child_ops
; /* target vector for inftarg.c */
87 static CORE_ADDR linuxthreads_handles
; /* array of linuxthreads handles */
88 static CORE_ADDR linuxthreads_manager
; /* pid of linuxthreads manager thread */
89 static CORE_ADDR linuxthreads_initial
; /* pid of linuxthreads initial thread */
90 static CORE_ADDR linuxthreads_debug
; /* linuxthreads internal debug flag */
91 static CORE_ADDR linuxthreads_num
; /* number of valid handle entries */
93 static int linuxthreads_max
; /* Maximum number of linuxthreads.
94 Zero if this executable doesn't use
95 threads, or wasn't linked with a
96 debugger-friendly version of the
97 linuxthreads library. */
99 static int linuxthreads_sizeof_handle
; /* size of a linuxthreads handle */
100 static int linuxthreads_offset_descr
; /* h_descr offset of the linuxthreads
102 static int linuxthreads_offset_pid
; /* p_pid offset of the linuxthreads
105 static int linuxthreads_manager_pid
; /* manager pid */
106 static int linuxthreads_initial_pid
; /* initial pid */
108 /* These variables form a bag of threads with interesting status. If
109 wait_thread (PID) finds that PID stopped for some interesting
110 reason (i.e. anything other than stopped with SIGSTOP), then it
111 records its status in this queue. linuxthreads_wait and
112 linuxthreads_find_trap extract processes from here. */
113 static int *linuxthreads_wait_pid
; /* wait array of pid */
114 static int *linuxthreads_wait_status
; /* wait array of status */
115 static int linuxthreads_wait_last
; /* index of last valid elt in
116 linuxthreads_wait_{pid,status} */
118 static sigset_t linuxthreads_wait_mask
; /* sigset with SIGCHLD */
120 static int linuxthreads_step_pid
; /* current stepped pid */
121 static int linuxthreads_step_signo
; /* current stepped target signal */
122 static int linuxthreads_exit_status
; /* exit status of initial thread */
124 static int linuxthreads_inferior_pid
; /* temporary internal inferior pid */
125 static int linuxthreads_breakpoint_pid
; /* last pid that hit a breakpoint */
126 static int linuxthreads_attach_pending
; /* attach command without wait */
128 static int linuxthreads_breakpoints_inserted
; /* any breakpoints inserted */
130 /* LinuxThreads uses certain signals for communication between
131 processes; we need to tell GDB to pass them through silently to the
132 inferior. The LinuxThreads library has global variables we can
133 read containing the relevant signal numbers, but since the signal
134 numbers are chosen at run-time, those variables aren't initialized
135 until the shared library's constructors have had a chance to run. */
137 struct linuxthreads_signal
{
139 /* The name of the LinuxThreads library variable that contains
140 the signal number. */
143 /* True if this variable must exist for us to debug properly. */
146 /* The variable's address in the inferior, or zero if the
147 LinuxThreads library hasn't been loaded into this inferior yet. */
150 /* The signal number, or zero if we don't know yet (either because
151 we haven't found the variable, or it hasn't been initialized).
152 This is an actual target signal number that you could pass to
153 `kill', not a GDB signal number. */
156 /* GDB's original settings for `stop' and `print' for this signal.
157 We restore them when the user selects a different executable.
158 Invariant: if sig->signal != 0, then sig->{stop,print} contain
159 the original settings. */
163 struct linuxthreads_signal linuxthreads_sig_restart
= {
164 "__pthread_sig_restart", 1, 0, 0, 0
166 struct linuxthreads_signal linuxthreads_sig_cancel
= {
167 "__pthread_sig_cancel", 1, 0, 0, 0
169 struct linuxthreads_signal linuxthreads_sig_debug
= {
170 "__pthread_sig_debug", 0, 0, 0, 0
173 /* A table of breakpoint locations, one per PID. */
174 static struct linuxthreads_breakpoint
{
175 CORE_ADDR pc
; /* PC of breakpoint */
176 int pid
; /* pid of breakpoint */
177 int step
; /* whether the pc has been reached after sstep */
178 } *linuxthreads_breakpoint_zombie
; /* Zombie breakpoints array */
179 static int linuxthreads_breakpoint_last
; /* Last zombie breakpoint */
181 /* linuxthreads_{insert,remove}_breakpoint pass the breakpoint address
182 to {insert,remove}_breakpoint via this variable, since
183 iterate_active_threads doesn't provide any way to pass values
184 through to the worker function. */
185 static CORE_ADDR linuxthreads_breakpoint_addr
;
187 #define REMOVE_BREAKPOINT_ZOMBIE(_i) \
189 if ((_i) < linuxthreads_breakpoint_last) \
190 linuxthreads_breakpoint_zombie[(_i)] = \
191 linuxthreads_breakpoint_zombie[linuxthreads_breakpoint_last]; \
192 linuxthreads_breakpoint_last--; \
197 #ifndef PTRACE_XFER_TYPE
198 #define PTRACE_XFER_TYPE int
200 /* Check to see if the given thread is alive. */
202 linuxthreads_thread_alive (pid
)
206 return ptrace (PT_READ_U
, pid
, (PTRACE_ARG3_TYPE
)0, 0) >= 0 || errno
== 0;
209 /* On detach(), find a SIGTRAP status. If stop is non-zero, find a
212 Make sure PID is ready to run, and free of interference from our
213 efforts to debug it (e.g., pending SIGSTOP or SIGTRAP signals). If
214 STOP is zero, just look for a SIGTRAP. If STOP is non-zero, look
215 for a SIGSTOP, too. Return non-zero if PID is alive and ready to
216 run; return zero if PID is dead.
218 PID may or may not be stopped at the moment, and we may or may not
219 have waited for it already. We check the linuxthreads_wait bag in
220 case we've already got a status for it. We may possibly wait for
223 PID may have signals waiting to be delivered. If they're caused by
224 our efforts to debug it, accept them with wait, but don't pass them
225 through to PID. Do pass all other signals through. */
227 linuxthreads_find_trap (pid
, stop
)
237 /* PID may have any number of signals pending. The kernel will
238 report each of them to us via wait, and then it's up to us to
239 pass them along to the process via ptrace, if we so choose.
241 We need to paw through the whole set until we've found a SIGTRAP
242 (or a SIGSTOP, if `stop' is set). We don't pass the SIGTRAP (or
243 SIGSTOP) through, but we do re-send all the others, so PID will
244 receive them when we resume it. */
245 int *wstatus
= alloca (LINUXTHREAD_NSIG
* sizeof (int));
248 /* Look at the pending status */
249 for (i
= linuxthreads_wait_last
; i
>= 0; i
--)
250 if (linuxthreads_wait_pid
[i
] == pid
)
252 status
= linuxthreads_wait_status
[i
];
254 /* Delete the i'th member of the table. Since the table is
255 unordered, we can do this simply by copying the table's
256 last element to the i'th position, and shrinking the table
258 if (i
< linuxthreads_wait_last
)
260 linuxthreads_wait_status
[i
] =
261 linuxthreads_wait_status
[linuxthreads_wait_last
];
262 linuxthreads_wait_pid
[i
] =
263 linuxthreads_wait_pid
[linuxthreads_wait_last
];
265 linuxthreads_wait_last
--;
267 if (!WIFSTOPPED(status
)) /* Thread has died */
270 if (WSTOPSIG(status
) == SIGTRAP
)
277 else if (WSTOPSIG(status
) == SIGSTOP
)
293 /* Make sure that we'll find what we're looking for. */
300 /* Catch all status until SIGTRAP and optionally SIGSTOP show up. */
303 child_resume (pid
, 1, TARGET_SIGNAL_0
);
307 rpid
= waitpid (pid
, &status
, __WCLONE
);
313 /* There are a few reasons the wait call above may have
314 failed. If the thread manager dies, its children get
315 reparented, and this interferes with GDB waiting for
316 them, in some cases. Another possibility is that the
317 initial thread was not cloned, so calling wait with
318 __WCLONE won't find it. I think neither of these should
319 occur in modern Linux kernels --- they don't seem to in
321 rpid
= waitpid (pid
, &status
, 0);
325 perror_with_name ("waitpid");
328 if (!WIFSTOPPED(status
)) /* Thread has died */
331 if (WSTOPSIG(status
) == SIGTRAP
)
332 if (!stop
|| found_stop
)
336 else if (WSTOPSIG(status
) != SIGSTOP
)
337 wstatus
[last
++] = status
;
345 /* Resend any other signals we noticed to the thread, to be received
346 when we continue it. */
348 kill (pid
, WSTOPSIG(wstatus
[last
]));
353 /* Cleanup stub for save_inferior_pid. */
355 restore_inferior_pid (arg
)
362 /* Register a cleanup to restore the value of inferior_pid. */
363 static struct cleanup
*
366 return make_cleanup (restore_inferior_pid
, (void *) inferior_pid
);
370 sigchld_handler (signo
)
373 /* This handler is used to get an EINTR while doing waitpid()
374 when an event is received */
377 /* Have we already collected a wait status for PID in the
378 linuxthreads_wait bag? */
380 linuxthreads_pending_status (pid
)
384 for (i
= linuxthreads_wait_last
; i
>= 0; i
--)
385 if (linuxthreads_wait_pid
[i
] == pid
)
391 /* Internal linuxthreads signal management */
393 /* Check in OBJFILE for the variable that holds the number for signal SIG.
394 We assume that we've already found other LinuxThreads-ish variables
395 in OBJFILE, so we complain if it's required, but not there.
396 Return true iff things are okay. */
398 find_signal_var (sig
, objfile
)
399 struct linuxthreads_signal
*sig
;
400 struct objfile
*objfile
;
402 struct minimal_symbol
*ms
= lookup_minimal_symbol (sig
->var
, NULL
, objfile
);
408 fprintf_unfiltered (gdb_stderr
,
409 "Unable to find linuxthreads symbol \"%s\"\n",
420 sig
->addr
= SYMBOL_VALUE_ADDRESS (ms
);
426 find_all_signal_vars (objfile
)
427 struct objfile
*objfile
;
429 return ( find_signal_var (&linuxthreads_sig_restart
, objfile
)
430 && find_signal_var (&linuxthreads_sig_cancel
, objfile
)
431 && find_signal_var (&linuxthreads_sig_debug
, objfile
));
434 /* A struct complaint isn't appropriate here. */
435 static int complained_cannot_determine_thread_signal_number
= 0;
437 /* Check to see if the variable holding the signal number for SIG has
438 been initialized yet. If it has, tell GDB to pass that signal
439 through to the inferior silently. */
441 check_signal_number (sig
)
442 struct linuxthreads_signal
*sig
;
447 /* We already know this signal number. */
451 /* We don't know the variable's address yet. */
454 if (target_read_memory (sig
->addr
, (char *)&num
, sizeof (num
))
457 /* If this happens once, it'll probably happen for all the
458 signals, so only complain once. */
459 if (! complained_cannot_determine_thread_signal_number
)
460 warning ("Cannot determine thread signal number; "
461 "GDB may report spurious signals.");
462 complained_cannot_determine_thread_signal_number
= 1;
467 /* It hasn't been initialized yet. */
470 /* We know sig->signal was zero, and is becoming non-zero, so it's
471 okay to sample GDB's original settings. */
473 sig
->stop
= signal_stop_update (target_signal_from_host (num
), 0);
474 sig
->print
= signal_print_update (target_signal_from_host (num
), 0);
479 check_all_signal_numbers ()
481 /* If this isn't a LinuxThreads program, quit early. */
482 if (! linuxthreads_max
)
485 check_signal_number (&linuxthreads_sig_restart
);
486 check_signal_number (&linuxthreads_sig_cancel
);
487 check_signal_number (&linuxthreads_sig_debug
);
489 /* handle linuxthread exit */
490 if (linuxthreads_sig_debug
.signal
491 || linuxthreads_sig_restart
.signal
)
493 struct sigaction sact
;
495 sact
.sa_handler
= sigchld_handler
;
496 sigemptyset(&sact
.sa_mask
);
498 if (linuxthreads_sig_debug
.signal
> 0)
499 sigaction(linuxthreads_sig_cancel
.signal
, &sact
, NULL
);
501 sigaction(linuxthreads_sig_restart
.signal
, &sact
, NULL
);
506 /* Restore GDB's original settings for SIG.
507 This should only be called when we're no longer sure if we're
508 talking to an executable that uses LinuxThreads, so we clear the
509 signal number and variable address too. */
512 struct linuxthreads_signal
*sig
;
517 /* We know sig->signal was non-zero, and is becoming zero, so it's
518 okay to restore GDB's original settings. */
519 signal_stop_update (target_signal_from_host (sig
->signal
), sig
->stop
);
520 signal_print_update (target_signal_from_host (sig
->signal
), sig
->print
);
527 /* Restore GDB's original settings for all LinuxThreads signals.
528 This should only be called when we're no longer sure if we're
529 talking to an executable that uses LinuxThreads, so we clear the
530 signal number and variable address too. */
532 restore_all_signals ()
534 restore_signal (&linuxthreads_sig_restart
);
535 restore_signal (&linuxthreads_sig_cancel
);
536 restore_signal (&linuxthreads_sig_debug
);
538 /* If it happens again, we should complain again. */
539 complained_cannot_determine_thread_signal_number
= 0;
545 /* Apply FUNC to the pid of each active thread. This consults the
546 inferior's handle table to find active threads.
548 If ALL is non-zero, process all threads.
549 If ALL is zero, skip threads with pending status. */
551 iterate_active_threads (func
, all
)
560 read_memory (linuxthreads_num
, (char *)&num
, sizeof (int));
562 for (i
= 0; i
< linuxthreads_max
&& num
> 0; i
++)
564 read_memory (linuxthreads_handles
+
565 linuxthreads_sizeof_handle
* i
+ linuxthreads_offset_descr
,
566 (char *)&descr
, sizeof (void *));
570 read_memory (descr
+ linuxthreads_offset_pid
,
571 (char *)&pid
, sizeof (pid_t
));
572 if (pid
> 0 && pid
!= linuxthreads_manager_pid
573 && (all
|| (!linuxthreads_pending_status (pid
))))
580 /* Insert a thread breakpoint at linuxthreads_breakpoint_addr.
581 This is the worker function for linuxthreads_insert_breakpoint,
582 which passes it to iterate_active_threads. */
584 insert_breakpoint (pid
)
589 /* Remove (if any) the positive zombie breakpoint. */
590 for (j
= linuxthreads_breakpoint_last
; j
>= 0; j
--)
591 if (linuxthreads_breakpoint_zombie
[j
].pid
== pid
)
593 if ((linuxthreads_breakpoint_zombie
[j
].pc
- DECR_PC_AFTER_BREAK
594 == linuxthreads_breakpoint_addr
)
595 && !linuxthreads_breakpoint_zombie
[j
].step
)
596 REMOVE_BREAKPOINT_ZOMBIE(j
);
601 /* Note that we're about to remove a thread breakpoint at
602 linuxthreads_breakpoint_addr.
604 This is the worker function for linuxthreads_remove_breakpoint,
605 which passes it to iterate_active_threads. The actual work of
606 overwriting the breakpoint instruction is done by
607 child_ops.to_remove_breakpoint; here, we simply create a zombie
608 breakpoint if the thread's PC is pointing at the breakpoint being
611 remove_breakpoint (pid
)
616 /* Insert a positive zombie breakpoint (if needed). */
617 for (j
= 0; j
<= linuxthreads_breakpoint_last
; j
++)
618 if (linuxthreads_breakpoint_zombie
[j
].pid
== pid
)
621 if (in_thread_list (pid
) && linuxthreads_thread_alive (pid
))
623 CORE_ADDR pc
= read_pc_pid (pid
);
624 if (linuxthreads_breakpoint_addr
== pc
- DECR_PC_AFTER_BREAK
625 && j
> linuxthreads_breakpoint_last
)
627 linuxthreads_breakpoint_zombie
[j
].pid
= pid
;
628 linuxthreads_breakpoint_zombie
[j
].pc
= pc
;
629 linuxthreads_breakpoint_zombie
[j
].step
= 0;
630 linuxthreads_breakpoint_last
++;
640 if (in_thread_list (pid
))
641 ptrace (PT_KILL
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
646 /* Resume a thread */
651 if (pid
!= inferior_pid
652 && in_thread_list (pid
)
653 && linuxthreads_thread_alive (pid
))
654 if (pid
== linuxthreads_step_pid
)
655 child_resume (pid
, 1, linuxthreads_step_signo
);
657 child_resume (pid
, 0, TARGET_SIGNAL_0
);
660 /* Detach a thread */
665 if (in_thread_list (pid
) && linuxthreads_thread_alive (pid
))
667 /* Remove pending SIGTRAP and SIGSTOP */
668 linuxthreads_find_trap (pid
, 1);
671 detach (TARGET_SIGNAL_0
);
672 inferior_pid
= linuxthreads_manager_pid
;
681 if (pid
!= inferior_pid
)
682 if (in_thread_list (pid
))
684 else if (ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0) == 0)
686 if (!linuxthreads_attach_pending
)
687 printf_unfiltered ("[New %s]\n", target_pid_to_str (pid
));
689 if (linuxthreads_sig_debug
.signal
)
690 /* After a new thread in glibc 2.1 signals gdb its existence,
691 it suspends itself and wait for linuxthreads_sig_restart,
692 now we can wake up it. */
693 kill (pid
, linuxthreads_sig_restart
.signal
);
696 perror_with_name ("ptrace in stop_thread");
699 /* Wait for a thread */
707 if (pid
!= inferior_pid
&& in_thread_list (pid
))
711 /* Get first pid status. */
712 rpid
= waitpid(pid
, &status
, __WCLONE
);
718 /* There are two reasons this might have failed:
720 1) PID is the initial thread, which wasn't cloned, so
721 passing the __WCLONE flag to waitpid prevented us from
724 2) The manager thread is the parent of all but the
725 initial thread; if it dies, the children will all be
726 reparented to init, which will wait for them. This means
727 our call to waitpid won't find them.
729 Actually, based on a casual look at the 2.0.36 kernel
730 code, I don't think either of these cases happen. But I
731 don't have things set up for remotely debugging the
732 kernel, so I'm not sure. And perhaps older kernels
734 rpid
= waitpid(pid
, &status
, 0);
737 if (errno
!= EINTR
&& linuxthreads_thread_alive (pid
))
738 perror_with_name ("waitpid");
740 /* the thread is dead. */
743 if (!WIFSTOPPED(status
) || WSTOPSIG(status
) != SIGSTOP
)
745 linuxthreads_wait_pid
[++linuxthreads_wait_last
] = pid
;
746 linuxthreads_wait_status
[linuxthreads_wait_last
] = status
;
751 /* Walk through the linuxthreads handles in order to detect all
752 threads and stop them */
754 update_stop_threads (test_pid
)
757 struct cleanup
*old_chain
= NULL
;
759 check_all_signal_numbers ();
761 if (linuxthreads_manager_pid
== 0)
763 if (linuxthreads_manager
)
765 if (test_pid
> 0 && test_pid
!= inferior_pid
)
767 old_chain
= save_inferior_pid ();
768 inferior_pid
= test_pid
;
770 read_memory (linuxthreads_manager
,
771 (char *)&linuxthreads_manager_pid
, sizeof (pid_t
));
773 if (linuxthreads_initial
)
775 if (test_pid
> 0 && test_pid
!= inferior_pid
)
777 old_chain
= save_inferior_pid ();
778 inferior_pid
= test_pid
;
780 read_memory(linuxthreads_initial
,
781 (char *)&linuxthreads_initial_pid
, sizeof (pid_t
));
785 if (linuxthreads_manager_pid
!= 0)
787 if (old_chain
== NULL
&& test_pid
> 0 &&
788 test_pid
!= inferior_pid
&& linuxthreads_thread_alive (test_pid
))
790 old_chain
= save_inferior_pid ();
791 inferior_pid
= test_pid
;
794 if (linuxthreads_thread_alive (inferior_pid
))
798 if (test_pid
!= linuxthreads_manager_pid
799 && !linuxthreads_pending_status (linuxthreads_manager_pid
))
801 stop_thread (linuxthreads_manager_pid
);
802 wait_thread (linuxthreads_manager_pid
);
804 if (!in_thread_list (test_pid
))
806 if (!linuxthreads_attach_pending
)
807 printf_unfiltered ("[New %s]\n",
808 target_pid_to_str (test_pid
));
809 add_thread (test_pid
);
810 if (linuxthreads_sig_debug
.signal
811 && inferior_pid
== test_pid
)
812 /* After a new thread in glibc 2.1 signals gdb its
813 existence, it suspends itself and wait for
814 linuxthreads_sig_restart, now we can wake up
816 kill (test_pid
, linuxthreads_sig_restart
.signal
);
819 iterate_active_threads (stop_thread
, 0);
820 iterate_active_threads (wait_thread
, 0);
824 if (old_chain
!= NULL
)
825 do_cleanups (old_chain
);
828 /* This routine is called whenever a new symbol table is read in, or when all
829 symbol tables are removed. libpthread can only be initialized when it
830 finds the right variables in libpthread.so. Since it's a shared library,
831 those variables don't show up until the library gets mapped and the symbol
835 linuxthreads_new_objfile (objfile
)
836 struct objfile
*objfile
;
838 struct minimal_symbol
*ms
;
842 /* We're starting an entirely new executable, so we can no
843 longer be sure that it uses LinuxThreads. Restore the signal
844 flags to their original states. */
845 restore_all_signals ();
847 /* Indicate that we don't know anything's address any more. */
848 linuxthreads_max
= 0;
853 /* If we've already found our variables in another objfile, don't
854 bother looking for them again. */
855 if (linuxthreads_max
)
858 if (! lookup_minimal_symbol ("__pthread_initial_thread", NULL
, objfile
))
859 /* This object file isn't the pthreads library. */
862 if ((ms
= lookup_minimal_symbol ("__pthread_threads_debug",
863 NULL
, objfile
)) == NULL
)
865 /* The debugging-aware libpthreads is not present in this objfile */
867 This program seems to use POSIX threads, but the thread library used\n\
868 does not support debugging. This may make using GDB difficult. Don't\n\
869 set breakpoints or single-step through code that might be executed by\n\
870 any thread other than the main thread.");
873 linuxthreads_debug
= SYMBOL_VALUE_ADDRESS (ms
);
875 /* Read internal structures configuration */
876 if ((ms
= lookup_minimal_symbol ("__pthread_sizeof_handle",
877 NULL
, objfile
)) == NULL
878 || target_read_memory (SYMBOL_VALUE_ADDRESS (ms
),
879 (char *)&linuxthreads_sizeof_handle
,
880 sizeof (linuxthreads_sizeof_handle
)) != 0)
882 fprintf_unfiltered (gdb_stderr
,
883 "Unable to find linuxthreads symbol \"%s\"\n",
884 "__pthread_sizeof_handle");
888 if ((ms
= lookup_minimal_symbol ("__pthread_offsetof_descr",
889 NULL
, objfile
)) == NULL
890 || target_read_memory (SYMBOL_VALUE_ADDRESS (ms
),
891 (char *)&linuxthreads_offset_descr
,
892 sizeof (linuxthreads_offset_descr
)) != 0)
894 fprintf_unfiltered (gdb_stderr
,
895 "Unable to find linuxthreads symbol \"%s\"\n",
896 "__pthread_offsetof_descr");
900 if ((ms
= lookup_minimal_symbol ("__pthread_offsetof_pid",
901 NULL
, objfile
)) == NULL
902 || target_read_memory (SYMBOL_VALUE_ADDRESS (ms
),
903 (char *)&linuxthreads_offset_pid
,
904 sizeof (linuxthreads_offset_pid
)) != 0)
906 fprintf_unfiltered (gdb_stderr
,
907 "Unable to find linuxthreads symbol \"%s\"\n",
908 "__pthread_offsetof_pid");
912 if (! find_all_signal_vars (objfile
))
915 /* Read adresses of internal structures to access */
916 if ((ms
= lookup_minimal_symbol ("__pthread_handles",
917 NULL
, objfile
)) == NULL
)
919 fprintf_unfiltered (gdb_stderr
,
920 "Unable to find linuxthreads symbol \"%s\"\n",
921 "__pthread_handles");
924 linuxthreads_handles
= SYMBOL_VALUE_ADDRESS (ms
);
926 if ((ms
= lookup_minimal_symbol ("__pthread_handles_num",
927 NULL
, objfile
)) == NULL
)
929 fprintf_unfiltered (gdb_stderr
,
930 "Unable to find linuxthreads symbol \"%s\"\n",
931 "__pthread_handles_num");
934 linuxthreads_num
= SYMBOL_VALUE_ADDRESS (ms
);
936 if ((ms
= lookup_minimal_symbol ("__pthread_manager_thread",
937 NULL
, objfile
)) == NULL
)
939 fprintf_unfiltered (gdb_stderr
,
940 "Unable to find linuxthreads symbol \"%s\"\n",
941 "__pthread_manager_thread");
944 linuxthreads_manager
= SYMBOL_VALUE_ADDRESS (ms
) + linuxthreads_offset_pid
;
946 if ((ms
= lookup_minimal_symbol ("__pthread_initial_thread",
947 NULL
, objfile
)) == NULL
)
949 fprintf_unfiltered (gdb_stderr
,
950 "Unable to find linuxthreads symbol \"%s\"\n",
951 "__pthread_initial_thread");
954 linuxthreads_initial
= SYMBOL_VALUE_ADDRESS (ms
) + linuxthreads_offset_pid
;
956 /* Search for this last, so it won't be set to a non-zero value unless
957 we successfully found all the symbols above. */
958 if ((ms
= lookup_minimal_symbol ("__pthread_threads_max",
959 NULL
, objfile
)) == NULL
960 || target_read_memory (SYMBOL_VALUE_ADDRESS (ms
),
961 (char *)&linuxthreads_max
,
962 sizeof (linuxthreads_max
)) != 0)
964 fprintf_unfiltered (gdb_stderr
,
965 "Unable to find linuxthreads symbol \"%s\"\n",
966 "__pthread_threads_max");
970 /* Allocate gdb internal structures */
971 linuxthreads_wait_pid
=
972 (int *) xmalloc (sizeof (int) * (linuxthreads_max
+ 1));
973 linuxthreads_wait_status
=
974 (int *) xmalloc (sizeof (int) * (linuxthreads_max
+ 1));
975 linuxthreads_breakpoint_zombie
= (struct linuxthreads_breakpoint
*)
976 xmalloc (sizeof (struct linuxthreads_breakpoint
) * (linuxthreads_max
+ 1));
978 if (inferior_pid
&& !linuxthreads_attach_pending
)
981 target_write_memory (linuxthreads_debug
, (char *)&on
, sizeof (on
));
982 linuxthreads_attach_pending
= 1;
983 update_stop_threads (inferior_pid
);
984 linuxthreads_attach_pending
= 0;
988 /* If we have switched threads from a one that stopped at breakpoint,
989 return 1 otherwise 0. */
992 linuxthreads_prepare_to_proceed (step
)
995 if (!linuxthreads_max
996 || !linuxthreads_manager_pid
997 || !linuxthreads_breakpoint_pid
998 || !breakpoint_here_p (read_pc_pid (linuxthreads_breakpoint_pid
)))
1003 /* Mark the current inferior as single stepping process. */
1004 linuxthreads_step_pid
= inferior_pid
;
1007 linuxthreads_inferior_pid
= linuxthreads_breakpoint_pid
;
1008 return linuxthreads_breakpoint_pid
;
1011 /* Convert a pid to printable form. */
1014 linuxthreads_pid_to_str (pid
)
1017 static char buf
[100];
1019 sprintf (buf
, "%s %d%s", linuxthreads_max
? "Thread" : "Pid", pid
,
1020 (pid
== linuxthreads_manager_pid
) ? " (manager thread)"
1021 : (pid
== linuxthreads_initial_pid
) ? " (initial thread)"
1027 /* Attach to process PID, then initialize for debugging it
1028 and wait for the trace-trap that results from attaching. */
1031 linuxthreads_attach (args
, from_tty
)
1036 error_no_arg ("process-id to attach");
1038 push_target (&linuxthreads_ops
);
1039 linuxthreads_breakpoints_inserted
= 1;
1040 linuxthreads_breakpoint_last
= -1;
1041 linuxthreads_wait_last
= -1;
1042 linuxthreads_exit_status
= __W_STOPCODE(0);
1044 child_ops
.to_attach (args
, from_tty
);
1046 if (linuxthreads_max
)
1047 linuxthreads_attach_pending
= 1;
1050 /* Take a program previously attached to and detaches it.
1051 The program resumes execution and will no longer stop
1052 on signals, etc. We'd better not have left any breakpoints
1053 in the program or it'll die when it hits one. For this
1054 to work, it may be necessary for the process to have been
1055 previously attached. It *might* work if the program was
1056 started via the normal ptrace (PTRACE_TRACEME). */
1059 linuxthreads_detach (args
, from_tty
)
1063 if (linuxthreads_max
)
1068 target_write_memory (linuxthreads_debug
, (char *)&off
, sizeof (off
));
1070 /* Walk through linuxthreads array in order to detach known threads. */
1071 if (linuxthreads_manager_pid
!= 0)
1073 /* Get rid of all positive zombie breakpoints. */
1074 for (i
= 0; i
<= linuxthreads_breakpoint_last
; i
++)
1076 if (linuxthreads_breakpoint_zombie
[i
].step
)
1079 pid
= linuxthreads_breakpoint_zombie
[i
].pid
;
1080 if (!linuxthreads_thread_alive (pid
))
1083 if (linuxthreads_breakpoint_zombie
[i
].pc
!= read_pc_pid (pid
))
1086 /* Continue in STEP mode until the thread pc has moved or
1087 until SIGTRAP is found on the same PC. */
1088 if (linuxthreads_find_trap (pid
, 0)
1089 && linuxthreads_breakpoint_zombie
[i
].pc
== read_pc_pid (pid
))
1090 write_pc_pid (linuxthreads_breakpoint_zombie
[i
].pc
1091 - DECR_PC_AFTER_BREAK
, pid
);
1094 /* Detach thread after thread. */
1095 inferior_pid
= linuxthreads_manager_pid
;
1096 iterate_active_threads (detach_thread
, 1);
1098 /* Remove pending SIGTRAP and SIGSTOP */
1099 linuxthreads_find_trap (inferior_pid
, 1);
1101 linuxthreads_wait_last
= -1;
1102 linuxthreads_exit_status
= __W_STOPCODE(0);
1105 linuxthreads_inferior_pid
= 0;
1106 linuxthreads_breakpoint_pid
= 0;
1107 linuxthreads_step_pid
= 0;
1108 linuxthreads_step_signo
= TARGET_SIGNAL_0
;
1109 linuxthreads_manager_pid
= 0;
1110 linuxthreads_initial_pid
= 0;
1111 linuxthreads_attach_pending
= 0;
1112 init_thread_list (); /* Destroy thread info */
1115 child_ops
.to_detach (args
, from_tty
);
1117 unpush_target (&linuxthreads_ops
);
1120 /* Resume execution of process PID. If STEP is nozero, then
1121 just single step it. If SIGNAL is nonzero, restart it with that
1122 signal activated. */
1125 linuxthreads_resume (pid
, step
, signo
)
1128 enum target_signal signo
;
1130 if (!linuxthreads_max
|| stop_soon_quietly
|| linuxthreads_manager_pid
== 0)
1131 child_ops
.to_resume (pid
, step
, signo
);
1135 if (linuxthreads_inferior_pid
)
1137 /* Prepare resume of the last thread that hit a breakpoint */
1138 linuxthreads_breakpoints_inserted
= 0;
1139 rpid
= linuxthreads_inferior_pid
;
1140 linuxthreads_step_signo
= signo
;
1144 struct cleanup
*old_chain
= NULL
;
1149 linuxthreads_step_pid
= step
? inferior_pid
: 0;
1150 linuxthreads_step_signo
= signo
;
1151 rpid
= inferior_pid
;
1156 if (pid
< 0 || !step
)
1158 linuxthreads_breakpoints_inserted
= 1;
1160 /* Walk through linuxthreads array in order to resume threads */
1161 if (pid
>= 0 && inferior_pid
!= pid
)
1163 old_chain
= save_inferior_pid ();
1167 iterate_active_threads (resume_thread
, 0);
1168 if (linuxthreads_manager_pid
!= inferior_pid
1169 && !linuxthreads_pending_status (linuxthreads_manager_pid
))
1170 resume_thread (linuxthreads_manager_pid
);
1173 linuxthreads_breakpoints_inserted
= 0;
1175 /* Deal with zombie breakpoint */
1176 for (i
= 0; i
<= linuxthreads_breakpoint_last
; i
++)
1177 if (linuxthreads_breakpoint_zombie
[i
].pid
== rpid
)
1179 if (linuxthreads_breakpoint_zombie
[i
].pc
!= read_pc_pid (rpid
))
1181 /* The current pc is out of zombie breakpoint. */
1182 REMOVE_BREAKPOINT_ZOMBIE(i
);
1187 if (old_chain
!= NULL
)
1188 do_cleanups (old_chain
);
1191 /* Resume initial thread. */
1192 if (!linuxthreads_pending_status (rpid
))
1193 child_ops
.to_resume (rpid
, step
, signo
);
1197 /* Wait for any threads to stop. We may have to convert PID from a thread id
1198 to a LWP id, and vice versa on the way out. */
1201 linuxthreads_wait (pid
, ourstatus
)
1203 struct target_waitstatus
*ourstatus
;
1211 if (linuxthreads_max
&& !linuxthreads_breakpoints_inserted
)
1212 wstatus
= alloca (LINUXTHREAD_NSIG
* sizeof (int));
1214 /* See if the inferior has chosen values for its signals yet. By
1215 checking for them here, we can be sure we've updated GDB's signal
1216 handling table before the inferior ever gets one of them. (Well,
1217 before we notice, anyway.) */
1218 check_all_signal_numbers ();
1222 if (!linuxthreads_max
)
1224 else if (!linuxthreads_breakpoints_inserted
)
1226 if (linuxthreads_inferior_pid
)
1227 pid
= linuxthreads_inferior_pid
;
1232 else if (pid
< 0 && linuxthreads_wait_last
>= 0)
1234 status
= linuxthreads_wait_status
[linuxthreads_wait_last
];
1235 rpid
= linuxthreads_wait_pid
[linuxthreads_wait_last
--];
1237 else if (pid
> 0 && linuxthreads_pending_status (pid
))
1239 for (i
= linuxthreads_wait_last
; i
>= 0; i
--)
1240 if (linuxthreads_wait_pid
[i
] == pid
)
1246 status
= linuxthreads_wait_status
[i
];
1248 if (i
< linuxthreads_wait_last
)
1250 linuxthreads_wait_status
[i
] =
1251 linuxthreads_wait_status
[linuxthreads_wait_last
];
1252 linuxthreads_wait_pid
[i
] =
1253 linuxthreads_wait_pid
[linuxthreads_wait_last
];
1255 linuxthreads_wait_last
--;
1266 set_sigint_trap(); /* Causes SIGINT to be passed on to the
1267 attached process. */
1270 sigprocmask(SIG_BLOCK
, &linuxthreads_wait_mask
, &omask
);
1273 rpid
= waitpid (pid
, &status
, __WCLONE
| WNOHANG
);
1278 else if (errno
!= EINTR
)
1283 rpid
= waitpid (pid
, &status
, WNOHANG
);
1289 else if (save_errno
!= 0)
1294 sigprocmask(SIG_SETMASK
, &omask
, NULL
);
1297 clear_sigio_trap ();
1299 clear_sigint_trap();
1303 if (WIFEXITED(linuxthreads_exit_status
))
1305 store_waitstatus (ourstatus
, linuxthreads_exit_status
);
1306 return inferior_pid
;
1311 (gdb_stderr
, "Child process unexpectedly missing: %s.\n",
1312 safe_strerror (save_errno
));
1313 /* Claim it exited with unknown signal. */
1314 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1315 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1320 /* Signals arrive in any order. So get all signals until SIGTRAP
1321 and resend previous ones to be held after. */
1322 if (linuxthreads_max
1323 && !linuxthreads_breakpoints_inserted
1324 && WIFSTOPPED(status
))
1325 if (WSTOPSIG(status
) == SIGTRAP
)
1328 kill (rpid
, WSTOPSIG(wstatus
[last
]));
1330 /* insert negative zombie breakpoint */
1331 for (i
= 0; i
<= linuxthreads_breakpoint_last
; i
++)
1332 if (linuxthreads_breakpoint_zombie
[i
].pid
== rpid
)
1334 if (i
> linuxthreads_breakpoint_last
)
1336 linuxthreads_breakpoint_zombie
[i
].pid
= rpid
;
1337 linuxthreads_breakpoint_last
++;
1339 linuxthreads_breakpoint_zombie
[i
].pc
= read_pc_pid (rpid
);
1340 linuxthreads_breakpoint_zombie
[i
].step
= 1;
1344 if (WSTOPSIG(status
) != SIGSTOP
)
1346 for (i
= 0; i
< last
; i
++)
1347 if (wstatus
[i
] == status
)
1350 wstatus
[last
++] = status
;
1352 child_resume (rpid
, 1, TARGET_SIGNAL_0
);
1355 if (linuxthreads_inferior_pid
)
1356 linuxthreads_inferior_pid
= 0;
1359 if (linuxthreads_max
&& !stop_soon_quietly
)
1361 if (linuxthreads_max
1362 && WIFSTOPPED(status
)
1363 && WSTOPSIG(status
) == SIGSTOP
)
1365 /* Skip SIGSTOP signals. */
1366 if (!linuxthreads_pending_status (rpid
))
1367 if (linuxthreads_step_pid
== rpid
)
1368 child_resume (rpid
, 1, linuxthreads_step_signo
);
1370 child_resume (rpid
, 0, TARGET_SIGNAL_0
);
1374 /* Do no report exit status of cloned threads. */
1375 if (WIFEXITED(status
))
1377 if (rpid
== linuxthreads_initial_pid
)
1378 linuxthreads_exit_status
= status
;
1380 /* Remove any zombie breakpoint. */
1381 for (i
= 0; i
<= linuxthreads_breakpoint_last
; i
++)
1382 if (linuxthreads_breakpoint_zombie
[i
].pid
== rpid
)
1384 REMOVE_BREAKPOINT_ZOMBIE(i
);
1392 /* Deal with zombie breakpoint */
1393 for (i
= 0; i
<= linuxthreads_breakpoint_last
; i
++)
1394 if (linuxthreads_breakpoint_zombie
[i
].pid
== rpid
)
1397 if (i
<= linuxthreads_breakpoint_last
)
1399 /* There is a potential zombie breakpoint */
1400 if (WIFEXITED(status
)
1401 || linuxthreads_breakpoint_zombie
[i
].pc
!= read_pc_pid (rpid
))
1403 /* The current pc is out of zombie breakpoint. */
1404 REMOVE_BREAKPOINT_ZOMBIE(i
);
1406 else if (!linuxthreads_breakpoint_zombie
[i
].step
1407 && WIFSTOPPED(status
) && WSTOPSIG(status
) == SIGTRAP
)
1409 /* This is a real one ==> decrement PC and restart. */
1410 write_pc_pid (linuxthreads_breakpoint_zombie
[i
].pc
1411 - DECR_PC_AFTER_BREAK
, rpid
);
1412 if (linuxthreads_step_pid
== rpid
)
1413 child_resume (rpid
, 1, linuxthreads_step_signo
);
1415 child_resume (rpid
, 0, TARGET_SIGNAL_0
);
1420 /* Walk through linuxthreads array in order to stop them */
1421 if (linuxthreads_breakpoints_inserted
)
1422 update_stop_threads (rpid
);
1425 else if (rpid
!= inferior_pid
)
1428 store_waitstatus (ourstatus
, status
);
1430 if (linuxthreads_attach_pending
&& !stop_soon_quietly
)
1433 target_write_memory (linuxthreads_debug
, (char *)&on
, sizeof (on
));
1434 update_stop_threads (rpid
);
1435 linuxthreads_attach_pending
= 0;
1438 if (linuxthreads_breakpoints_inserted
1439 && WIFSTOPPED(status
)
1440 && WSTOPSIG(status
) == SIGTRAP
)
1441 linuxthreads_breakpoint_pid
= rpid
;
1442 else if (linuxthreads_breakpoint_pid
)
1443 linuxthreads_breakpoint_pid
= 0;
1449 /* Fork an inferior process, and start debugging it with ptrace. */
1452 linuxthreads_create_inferior (exec_file
, allargs
, env
)
1457 if (!exec_file
&& !exec_bfd
)
1459 error ("No executable file specified.\n\
1460 Use the \"file\" or \"exec-file\" command.");
1464 push_target (&linuxthreads_ops
);
1465 linuxthreads_breakpoints_inserted
= 1;
1466 linuxthreads_breakpoint_last
= -1;
1467 linuxthreads_wait_last
= -1;
1468 linuxthreads_exit_status
= __W_STOPCODE(0);
1470 if (linuxthreads_max
)
1471 linuxthreads_attach_pending
= 1;
1473 child_ops
.to_create_inferior (exec_file
, allargs
, env
);
1476 /* Clean up after the inferior dies. */
1479 linuxthreads_mourn_inferior ()
1481 if (linuxthreads_max
)
1484 target_write_memory (linuxthreads_debug
, (char *)&off
, sizeof (off
));
1486 linuxthreads_inferior_pid
= 0;
1487 linuxthreads_breakpoint_pid
= 0;
1488 linuxthreads_step_pid
= 0;
1489 linuxthreads_step_signo
= TARGET_SIGNAL_0
;
1490 linuxthreads_manager_pid
= 0;
1491 linuxthreads_initial_pid
= 0;
1492 linuxthreads_attach_pending
= 0;
1493 init_thread_list(); /* Destroy thread info */
1496 child_ops
.to_mourn_inferior ();
1498 unpush_target (&linuxthreads_ops
);
1501 /* Kill the inferior process */
1504 linuxthreads_kill ()
1509 if (inferior_pid
== 0)
1512 if (linuxthreads_max
&& linuxthreads_manager_pid
!= 0)
1514 /* Remove all threads status. */
1515 inferior_pid
= linuxthreads_manager_pid
;
1516 iterate_active_threads (kill_thread
, 1);
1519 kill_thread (inferior_pid
);
1522 /* doing_quit_force solves a real problem, but I think a properly
1523 placed call to catch_errors would do the trick much more cleanly. */
1524 if (doing_quit_force
>= 0)
1526 if (linuxthreads_max
&& linuxthreads_manager_pid
!= 0)
1528 /* Wait for thread to complete */
1529 while ((rpid
= waitpid (-1, &status
, __WCLONE
)) > 0)
1530 if (!WIFEXITED(status
))
1533 while ((rpid
= waitpid (-1, &status
, 0)) > 0)
1534 if (!WIFEXITED(status
))
1538 while ((rpid
= waitpid (inferior_pid
, &status
, 0)) > 0)
1539 if (!WIFEXITED(status
))
1540 ptrace (PT_KILL
, inferior_pid
, (PTRACE_ARG3_TYPE
) 0, 0);
1544 /* Wait for all threads. */
1546 rpid
= waitpid (-1, &status
, __WCLONE
| WNOHANG
);
1547 while (rpid
> 0 || errno
== EINTR
);
1550 rpid
= waitpid (-1, &status
, WNOHANG
);
1551 while (rpid
> 0 || errno
== EINTR
);
1553 linuxthreads_mourn_inferior ();
1556 /* Insert a breakpoint */
1559 linuxthreads_insert_breakpoint (addr
, contents_cache
)
1561 char *contents_cache
;
1563 if (linuxthreads_max
&& linuxthreads_manager_pid
!= 0)
1565 linuxthreads_breakpoint_addr
= addr
;
1566 iterate_active_threads (insert_breakpoint
, 1);
1567 insert_breakpoint (linuxthreads_manager_pid
);
1570 return child_ops
.to_insert_breakpoint (addr
, contents_cache
);
1573 /* Remove a breakpoint */
1576 linuxthreads_remove_breakpoint (addr
, contents_cache
)
1578 char *contents_cache
;
1580 if (linuxthreads_max
&& linuxthreads_manager_pid
!= 0)
1582 linuxthreads_breakpoint_addr
= addr
;
1583 iterate_active_threads (remove_breakpoint
, 1);
1584 remove_breakpoint (linuxthreads_manager_pid
);
1587 return child_ops
.to_remove_breakpoint (addr
, contents_cache
);
1590 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
1593 linuxthreads_can_run ()
1595 return child_suppress_run
;
1599 init_linuxthreads_ops ()
1601 linuxthreads_ops
.to_shortname
= "linuxthreads";
1602 linuxthreads_ops
.to_longname
= "LINUX threads and pthread.";
1603 linuxthreads_ops
.to_doc
= "LINUX threads and pthread support.";
1604 linuxthreads_ops
.to_attach
= linuxthreads_attach
;
1605 linuxthreads_ops
.to_detach
= linuxthreads_detach
;
1606 linuxthreads_ops
.to_resume
= linuxthreads_resume
;
1607 linuxthreads_ops
.to_wait
= linuxthreads_wait
;
1608 linuxthreads_ops
.to_kill
= linuxthreads_kill
;
1609 linuxthreads_ops
.to_can_run
= linuxthreads_can_run
;
1610 linuxthreads_ops
.to_stratum
= thread_stratum
;
1611 linuxthreads_ops
.to_insert_breakpoint
= linuxthreads_insert_breakpoint
;
1612 linuxthreads_ops
.to_remove_breakpoint
= linuxthreads_remove_breakpoint
;
1613 linuxthreads_ops
.to_create_inferior
= linuxthreads_create_inferior
;
1614 linuxthreads_ops
.to_mourn_inferior
= linuxthreads_mourn_inferior
;
1615 linuxthreads_ops
.to_thread_alive
= linuxthreads_thread_alive
;
1616 linuxthreads_ops
.to_magic
= OPS_MAGIC
;
1620 _initialize_linuxthreads ()
1622 struct sigaction sact
;
1624 init_linuxthreads_ops ();
1625 add_target (&linuxthreads_ops
);
1626 child_suppress_run
= 1;
1628 /* Attach SIGCHLD handler */
1629 sact
.sa_handler
= sigchld_handler
;
1630 sigemptyset (&sact
.sa_mask
);
1632 sigaction (SIGCHLD
, &sact
, NULL
);
1634 /* initialize SIGCHLD mask */
1635 sigemptyset (&linuxthreads_wait_mask
);
1636 sigaddset (&linuxthreads_wait_mask
, SIGCHLD
);