6df4d0dab3e21cb5e0577c993b90a3f9372c6def
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 PIDGET0(PID) (((PID) & 0xffff))
108 #define PIDGET(PID) ((PIDGET0 (PID) == 0xffff) ? -1 : PIDGET0 (PID))
109 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
112 #define THREAD_FLAG 0x80000000
113 #define is_lwp(pid) (((pid) & THREAD_FLAG) == 0 && TIDGET (pid))
114 #define GET_LWP(pid) TIDGET (pid)
115 #define GET_PID(pid) PIDGET (pid)
116 #define BUILD_LWP(tid, pid) MERGEPID (pid, tid)
118 #define is_cloned(pid) (GET_LWP (pid) != GET_PID (pid))
120 /* If the last reported event was a SIGTRAP, this variable is set to
121 the process id of the LWP/thread that got it. */
125 /* This module's target-specific operations. */
126 static struct target_ops lin_lwp_ops
;
128 /* The standard child operations. */
129 extern struct target_ops child_ops
;
131 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
132 any cloned processes with a single call to waitpid, we have to use
133 the WNOHANG flag and call waitpid in a loop. To optimize
134 things a bit we use `sigsuspend' to wake us up when a process has
135 something to report (it will send us a SIGCHLD if it has). To make
136 this work we have to juggle with the signal mask. We save the
137 original signal mask such that we can restore it before creating a
138 new process in order to avoid blocking certain signals in the
139 inferior. We then block SIGCHLD during the waitpid/sigsuspend
142 /* Original signal mask. */
143 static sigset_t normal_mask
;
145 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
146 _initialize_lin_lwp. */
147 static sigset_t suspend_mask
;
149 /* Signals to block to make that sigsuspend work. */
150 static sigset_t blocked_mask
;
153 /* Prototypes for local functions. */
154 static void lin_lwp_mourn_inferior (void);
157 /* Initialize the list of LWPs. */
162 struct lwp_info
*lp
, *lpnext
;
164 for (lp
= lwp_list
; lp
; lp
= lpnext
)
175 /* Add the LWP specified by PID to the list. If this causes the
176 number of LWPs to become larger than one, go into "threaded" mode.
177 Return a pointer to the structure describing the new LWP. */
179 static struct lwp_info
*
180 add_lwp (ptid_t ptid
)
184 gdb_assert (is_lwp (ptid
));
186 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
188 memset (lp
, 0, sizeof (struct lwp_info
));
200 /* Remove the LWP specified by PID from the list. */
203 delete_lwp (ptid_t ptid
)
205 struct lwp_info
*lp
, *lpprev
;
209 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
210 if (ptid_equal (lp
->ptid
, ptid
))
216 /* We don't go back to "non-threaded" mode if the number of threads
217 becomes less than two. */
221 lpprev
->next
= lp
->next
;
228 /* Return a pointer to the structure describing the LWP corresponding
229 to PID. If no corresponding LWP could be found, return NULL. */
231 static struct lwp_info
*
232 find_lwp_pid (ptid_t ptid
)
238 lwp
= GET_LWP (ptid
);
240 lwp
= GET_PID (ptid
);
242 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
243 if (lwp
== GET_LWP (lp
->ptid
))
249 /* Call CALLBACK with its second argument set to DATA for every LWP in
250 the list. If CALLBACK returns 1 for a particular LWP, return a
251 pointer to the structure describing that LWP immediately.
252 Otherwise return NULL. */
255 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
259 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
260 if ((*callback
) (lp
, data
))
267 /* Helper functions. */
270 restore_inferior_ptid (void *arg
)
272 ptid_t
*saved_ptid_ptr
= arg
;
273 inferior_ptid
= *saved_ptid_ptr
;
277 static struct cleanup
*
278 save_inferior_ptid (void)
280 ptid_t
*saved_ptid_ptr
;
282 saved_ptid_ptr
= xmalloc (sizeof (ptid_t
));
283 *saved_ptid_ptr
= inferior_ptid
;
284 return make_cleanup (restore_inferior_ptid
, saved_ptid_ptr
);
288 /* Implementation of the PREPARE_TO_PROCEED hook for the Linux LWP
291 Note that this implementation is potentially redundant now that
292 default_prepare_to_proceed() has been added. */
295 lin_lwp_prepare_to_proceed (void)
297 if (! ptid_equal (trap_ptid
, null_ptid
)
298 && ! ptid_equal (inferior_ptid
, trap_ptid
))
300 /* Switched over from TRAP_PID. */
301 CORE_ADDR stop_pc
= read_pc ();
304 /* Avoid switching where it wouldn't do any good, i.e. if both
305 threads are at the same breakpoint. */
306 trap_pc
= read_pc_pid (trap_ptid
);
307 if (trap_pc
!= stop_pc
&& breakpoint_here_p (trap_pc
))
309 /* User hasn't deleted the breakpoint. Return non-zero, and
310 switch back to TRAP_PID. */
311 inferior_ptid
= trap_ptid
;
313 /* FIXME: Is this stuff really necessary? */
314 flush_cached_frames ();
315 registers_changed ();
327 lin_lwp_open (char *args
, int from_tty
)
329 push_target (&lin_lwp_ops
);
333 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
334 a message telling the user that a new LWP has been added to the
338 lin_lwp_attach_lwp (ptid_t ptid
, int verbose
)
342 gdb_assert (is_lwp (ptid
));
345 printf_filtered ("[New %s]\n", target_pid_to_str (ptid
));
347 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
348 error ("Can't attach %s: %s", target_pid_to_str (ptid
), strerror (errno
));
355 lin_lwp_attach (char *args
, int from_tty
)
357 /* FIXME: We should probably accept a list of process id's, and
358 attach all of them. */
359 error("Not implemented yet");
363 lin_lwp_detach (char *args
, int from_tty
)
365 /* FIXME: Provide implementation when we implement lin_lwp_attach. */
366 error ("Not implemented yet");
370 struct private_thread_info
375 /* Return non-zero if TP corresponds to the LWP specified by DATA
376 (which is assumed to be a pointer to a `struct lwp_info'. */
379 find_lwp_callback (struct thread_info
*tp
, void *data
)
381 struct lwp_info
*lp
= data
;
383 if (tp
->private->lwpid
== GET_LWP (lp
->ptid
))
392 resume_callback (struct lwp_info
*lp
, void *data
)
394 if (lp
->stopped
&& lp
->status
== 0)
396 struct thread_info
*tp
;
399 /* FIXME: kettenis/2000-08-26: This should really be handled
400 properly by core GDB. */
402 tp
= find_thread_pid (lp
->ptid
);
404 tp
= iterate_over_threads (find_lwp_callback
, lp
);
407 /* If we were previously stepping the thread, and now continue
408 the thread we must invalidate the stepping range. However,
409 if there is a step_resume breakpoint for this thread, we must
410 preserve the stepping range to make it possible to continue
411 stepping once we hit it. */
412 if (tp
->step_range_end
&& tp
->step_resume_breakpoint
== NULL
)
414 gdb_assert (lp
->step
);
415 tp
->step_range_start
= tp
->step_range_end
= 0;
419 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), 0, TARGET_SIGNAL_0
);
428 lin_lwp_resume (ptid_t ptid
, int step
, enum target_signal signo
)
433 /* Apparently the interpretation of PID is dependent on STEP: If
434 STEP is non-zero, a specific PID means `step only this process
435 id'. But if STEP is zero, then PID means `continue *all*
436 processes, but give the signal only to this one'. */
437 resume_all
= (PIDGET (ptid
) == -1) || !step
;
439 /* If PID is -1, it's the current inferior that should be
441 if (PIDGET (ptid
) == -1)
442 ptid
= inferior_ptid
;
444 lp
= find_lwp_pid (ptid
);
447 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
449 /* Remember if we're stepping. */
452 /* If we have a pending wait status for this thread, there is no
453 point in resuming the process. */
456 /* FIXME: What should we do if we are supposed to continue
457 this thread with a signal? */
458 gdb_assert (signo
== TARGET_SIGNAL_0
);
462 /* Mark LWP as not stopped to prevent it from being continued by
468 iterate_over_lwps (resume_callback
, NULL
);
470 child_resume (ptid
, step
, signo
);
474 /* Send a SIGSTOP to LP. */
477 stop_callback (struct lwp_info
*lp
, void *data
)
479 if (! lp
->stopped
&& ! lp
->signalled
)
483 ret
= kill (GET_LWP (lp
->ptid
), SIGSTOP
);
484 gdb_assert (ret
== 0);
487 gdb_assert (lp
->status
== 0);
493 /* Wait until LP is stopped. */
496 stop_wait_callback (struct lwp_info
*lp
, void *data
)
498 if (! lp
->stopped
&& lp
->signalled
)
503 gdb_assert (lp
->status
== 0);
505 pid
= waitpid (GET_LWP (lp
->ptid
), &status
,
506 is_cloned (lp
->ptid
) ? __WCLONE
: 0);
507 if (pid
== -1 && errno
== ECHILD
)
508 /* OK, the proccess has disappeared. We'll catch the actual
509 exit event in lin_lwp_wait. */
512 gdb_assert (pid
== GET_LWP (lp
->ptid
));
514 if (WIFEXITED (status
) || WIFSIGNALED (status
))
516 gdb_assert (num_lwps
> 1);
518 if (in_thread_list (lp
->ptid
))
520 /* Core GDB cannot deal with us deleting the current
522 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
523 delete_thread (lp
->ptid
);
524 printf_unfiltered ("[%s exited]\n",
525 target_pid_to_str (lp
->ptid
));
528 fprintf_unfiltered (gdb_stdlog
,
529 "%s exited.\n", target_pid_to_str (lp
->ptid
));
531 delete_lwp (lp
->ptid
);
535 gdb_assert (WIFSTOPPED (status
));
538 if (WSTOPSIG (status
) != SIGSTOP
)
540 if (WSTOPSIG (status
) == SIGTRAP
541 && breakpoint_inserted_here_p (read_pc_pid (pid_to_ptid (pid
))
542 - DECR_PC_AFTER_BREAK
))
544 /* If a LWP other than the LWP that we're reporting an
545 event for has hit a GDB breakpoint (as opposed to
546 some random trap signal), then just arrange for it to
547 hit it again later. We don't keep the SIGTRAP status
548 and don't forward the SIGTRAP signal to the LWP. We
549 will handle the current event, eventually we will
550 resume all LWPs, and this one will get its breakpoint
553 If we do not do this, then we run the risk that the
554 user will delete or disable the breakpoint, but the
555 thread will have already tripped on it. */
558 fprintf_unfiltered (gdb_stdlog
,
559 "Tripped breakpoint at %lx in LWP %d"
560 " while waiting for SIGSTOP.\n",
561 (long) read_pc_pid (lp
->ptid
), pid
);
563 /* Set the PC to before the trap. */
564 if (DECR_PC_AFTER_BREAK
)
565 write_pc_pid (read_pc_pid (pid_to_ptid (pid
))
566 - DECR_PC_AFTER_BREAK
,
572 fprintf_unfiltered (gdb_stdlog
,
573 "Received %s in LWP %d while waiting for SIGSTOP.\n",
574 strsignal (WSTOPSIG (status
)), pid
);
576 /* The thread was stopped with a signal other than
577 SIGSTOP, and didn't accidentiliy trip a breakpoint.
578 Record the wait status. */
584 /* We caught the SIGSTOP that we intended to catch, so
585 there's no SIGSTOP pending. */
593 /* Return non-zero if LP has a wait status pending. */
596 status_callback (struct lwp_info
*lp
, void *data
)
598 return (lp
->status
!= 0);
601 /* Return non-zero if LP isn't stopped. */
604 running_callback (struct lwp_info
*lp
, void *data
)
606 return (lp
->stopped
== 0);
610 lin_lwp_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
612 struct lwp_info
*lp
= NULL
;
615 pid_t pid
= PIDGET (ptid
);
617 /* Make sure SIGCHLD is blocked. */
618 if (! sigismember (&blocked_mask
, SIGCHLD
))
620 sigaddset (&blocked_mask
, SIGCHLD
);
621 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
626 /* First check if there is a LWP with a wait status pending. */
629 /* Any LWP will do. */
630 lp
= iterate_over_lwps (status_callback
, NULL
);
634 fprintf_unfiltered (gdb_stdlog
,
635 "Using pending wait status for LWP %d.\n",
636 (int) GET_LWP (lp
->ptid
));
642 /* But if we don't fine one, we'll have to wait, and check both
643 cloned and uncloned processes. We start with the cloned
645 options
= __WCLONE
| WNOHANG
;
647 else if (is_lwp (ptid
))
650 fprintf_unfiltered (gdb_stdlog
,
651 "Waiting for specific LWP %d.\n",
652 (int) GET_LWP (ptid
));
654 /* We have a specific LWP to check. */
655 lp
= find_lwp_pid (ptid
);
662 fprintf_unfiltered (gdb_stdlog
,
663 "Using pending wait status for LWP %d.\n",
666 /* If we have to wait, take into account whether PID is a cloned
667 process or not. And we have to convert it to something that
668 the layer beneath us can understand. */
669 options
= is_cloned (lp
->ptid
) ? __WCLONE
: 0;
670 pid
= GET_LWP (ptid
);
673 if (status
&& lp
->signalled
)
675 /* A pending SIGSTOP may interfere with the normal stream of
676 events. In a typical case where interference is a problem,
677 we have a SIGSTOP signal pending for LWP A while
678 single-stepping it, encounter an event in LWP B, and take the
679 pending SIGSTOP while trying to stop LWP A. After processing
680 the event in LWP B, LWP A is continued, and we'll never see
681 the SIGTRAP associated with the last time we were
682 single-stepping LWP A. */
684 /* Resume the thread. It should halt immediately returning the
686 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
690 /* This should catch the pending SIGSTOP. */
691 stop_wait_callback (lp
, NULL
);
694 set_sigint_trap (); /* Causes SIGINT to be passed on to the
702 lwpid
= waitpid (pid
, &status
, options
);
705 gdb_assert (pid
== -1 || lwpid
== pid
);
707 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
710 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
713 gdb_assert (WIFSTOPPED (status
)
714 && WSTOPSIG (status
) == SIGSTOP
);
717 if (! in_thread_list (inferior_ptid
))
719 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
720 GET_PID (inferior_ptid
));
721 add_thread (inferior_ptid
);
724 add_thread (lp
->ptid
);
725 printf_unfiltered ("[New %s]\n",
726 target_pid_to_str (lp
->ptid
));
730 /* Make sure we don't report a TARGET_WAITKIND_EXITED or
731 TARGET_WAITKIND_SIGNALLED event if there are still LWP's
732 left in the process. */
733 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
735 if (in_thread_list (lp
->ptid
))
737 /* Core GDB cannot deal with us deleting the current
739 if (! ptid_equal (lp
->ptid
, inferior_ptid
))
740 delete_thread (lp
->ptid
);
741 printf_unfiltered ("[%s exited]\n",
742 target_pid_to_str (lp
->ptid
));
745 fprintf_unfiltered (gdb_stdlog
,
747 target_pid_to_str (lp
->ptid
));
749 delete_lwp (lp
->ptid
);
751 /* Make sure there is at least one thread running. */
752 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
754 /* Discard the event. */
759 /* Make sure we don't report a SIGSTOP that we sent
760 ourselves in an attempt to stop an LWP. */
761 if (lp
->signalled
&& WIFSTOPPED (status
)
762 && WSTOPSIG (status
) == SIGSTOP
)
765 fprintf_unfiltered (gdb_stdlog
,
766 "Delayed SIGSTOP caught for %s.\n",
767 target_pid_to_str (lp
->ptid
));
769 /* This is a delayed SIGSTOP. */
772 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
776 /* Discard the event. */
786 /* Alternate between checking cloned and uncloned processes. */
789 /* And suspend every time we have checked both. */
790 if (options
& __WCLONE
)
791 sigsuspend (&suspend_mask
);
794 /* We shouldn't end up here unless we want to try again. */
795 gdb_assert (status
== 0);
799 clear_sigint_trap ();
803 /* Don't report signals that GDB isn't interested in, such as
804 signals that are neither printed nor stopped upon. Stopping all
805 threads can be a bit time-consuming so if we want decent
806 performance with heavily multi-threaded programs, especially when
807 they're using a high frequency timer, we'd better avoid it if we
810 if (WIFSTOPPED (status
))
812 int signo
= target_signal_from_host (WSTOPSIG (status
));
814 if (signal_stop_state (signo
) == 0
815 && signal_print_state (signo
) == 0
816 && signal_pass_state (signo
) == 1)
818 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
, signo
);
825 /* This LWP is stopped now. */
828 /* Now stop all other LWP's ... */
829 iterate_over_lwps (stop_callback
, NULL
);
831 /* ... and wait until all of them have reported back that they're no
833 iterate_over_lwps (stop_wait_callback
, NULL
);
835 /* If we're not running in "threaded" mode, we'll report the bare
838 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
839 trap_ptid
= (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
841 trap_ptid
= null_ptid
;
843 store_waitstatus (ourstatus
, status
);
844 return (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
848 kill_callback (struct lwp_info
*lp
, void *data
)
850 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
855 kill_wait_callback (struct lwp_info
*lp
, void *data
)
859 /* We must make sure that there are no pending events (delayed
860 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
861 program doesn't interfere with any following debugging session. */
863 /* For cloned processes we must check both with __WCLONE and
864 without, since the exit status of a cloned process isn't reported
866 if (is_cloned (lp
->ptid
))
870 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
872 while (pid
== GET_LWP (lp
->ptid
));
874 gdb_assert (pid
== -1 && errno
== ECHILD
);
879 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
881 while (pid
== GET_LWP (lp
->ptid
));
883 gdb_assert (pid
== -1 && errno
== ECHILD
);
890 /* Kill all LWP's ... */
891 iterate_over_lwps (kill_callback
, NULL
);
893 /* ... and wait until we've flushed all events. */
894 iterate_over_lwps (kill_wait_callback
, NULL
);
896 target_mourn_inferior ();
900 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
902 struct target_ops
*target_beneath
;
907 target_beneath
= find_target_beneath (&lin_lwp_ops
);
909 target_beneath
= &child_ops
;
911 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
915 lin_lwp_mourn_inferior (void)
917 struct target_ops
*target_beneath
;
921 trap_ptid
= null_ptid
;
923 /* Restore the original signal mask. */
924 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
925 sigemptyset (&blocked_mask
);
928 target_beneath
= find_target_beneath (&lin_lwp_ops
);
930 target_beneath
= &child_ops
;
932 target_beneath
->to_mourn_inferior ();
936 lin_lwp_fetch_registers (int regno
)
938 struct cleanup
*old_chain
= save_inferior_ptid ();
940 if (is_lwp (inferior_ptid
))
941 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
943 fetch_inferior_registers (regno
);
945 do_cleanups (old_chain
);
949 lin_lwp_store_registers (int regno
)
951 struct cleanup
*old_chain
= save_inferior_ptid ();
953 if (is_lwp (inferior_ptid
))
954 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
956 store_inferior_registers (regno
);
958 do_cleanups (old_chain
);
962 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
963 struct mem_attrib
*attrib
,
964 struct target_ops
*target
)
966 struct cleanup
*old_chain
= save_inferior_ptid ();
969 if (is_lwp (inferior_ptid
))
970 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
972 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
974 do_cleanups (old_chain
);
979 lin_lwp_thread_alive (ptid_t ptid
)
981 gdb_assert (is_lwp (ptid
));
984 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
992 lin_lwp_pid_to_str (ptid_t ptid
)
998 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
1002 return normal_pid_to_str (ptid
);
1006 init_lin_lwp_ops (void)
1009 lin_lwp_ops
.to_open
= lin_lwp_open
;
1011 lin_lwp_ops
.to_shortname
= "lwp-layer";
1012 lin_lwp_ops
.to_longname
= "lwp-layer";
1013 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
1014 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
1015 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
1016 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
1017 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
1018 lin_lwp_ops
.to_fetch_registers
= lin_lwp_fetch_registers
;
1019 lin_lwp_ops
.to_store_registers
= lin_lwp_store_registers
;
1020 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1021 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1022 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1023 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1024 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1025 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1026 lin_lwp_ops
.to_stratum
= thread_stratum
;
1027 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1028 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1032 sigchld_handler (int signo
)
1034 /* Do nothing. The only reason for this handler is that it allows
1035 us to use sigsuspend in lin_lwp_wait above to wait for the
1036 arrival of a SIGCHLD. */
1040 _initialize_lin_lwp (void)
1042 struct sigaction action
;
1044 extern void thread_db_init (struct target_ops
*);
1046 init_lin_lwp_ops ();
1047 add_target (&lin_lwp_ops
);
1048 thread_db_init (&lin_lwp_ops
);
1050 /* Save the original signal mask. */
1051 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1053 action
.sa_handler
= sigchld_handler
;
1054 sigemptyset (&action
.sa_mask
);
1055 action
.sa_flags
= 0;
1056 sigaction (SIGCHLD
, &action
, NULL
);
1058 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1059 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1060 sigdelset (&suspend_mask
, SIGCHLD
);
1062 sigemptyset (&blocked_mask
);
1064 add_show_from_set (add_set_cmd ("lin-lwp", no_class
, var_zinteger
,
1065 (char *) &debug_lin_lwp
,
1066 "Set debugging of linux lwp module.\n\
1067 Enables printf debugging output.\n",
1073 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1074 the LinuxThreads library and therefore doesn't really belong here. */
1076 /* Read variable NAME in the target and return its value if found.
1077 Otherwise return zero. It is assumed that the type of the variable
1081 get_signo (const char *name
)
1083 struct minimal_symbol
*ms
;
1086 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1090 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1091 sizeof (signo
)) != 0)
1097 /* Return the set of signals used by the threads library in *SET. */
1100 lin_thread_get_thread_signals (sigset_t
*set
)
1102 struct sigaction action
;
1103 int restart
, cancel
;
1107 restart
= get_signo ("__pthread_sig_restart");
1111 cancel
= get_signo ("__pthread_sig_cancel");
1115 sigaddset (set
, restart
);
1116 sigaddset (set
, cancel
);
1118 /* The LinuxThreads library makes terminating threads send a special
1119 "cancel" signal instead of SIGCHLD. Make sure we catch those (to
1120 prevent them from terminating GDB itself, which is likely to be
1121 their default action) and treat them the same way as SIGCHLD. */
1123 action
.sa_handler
= sigchld_handler
;
1124 sigemptyset (&action
.sa_mask
);
1125 action
.sa_flags
= 0;
1126 sigaction (cancel
, &action
, NULL
);
1128 /* We block the "cancel" signal throughout this code ... */
1129 sigaddset (&blocked_mask
, cancel
);
1130 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1132 /* ... except during a sigsuspend. */
1133 sigdelset (&suspend_mask
, cancel
);