1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
26 #include "gdb_assert.h"
27 #ifdef HAVE_TKILL_SYSCALL
29 #include <sys/syscall.h>
31 #include <sys/ptrace.h>
32 #include "linux-nat.h"
33 #include "linux-fork.h"
34 #include "gdbthread.h"
38 #include "inf-ptrace.h"
40 #include <sys/param.h> /* for MAXPATHLEN */
41 #include <sys/procfs.h> /* for elf_gregset etc. */
42 #include "elf-bfd.h" /* for elfcore_write_* */
43 #include "gregset.h" /* for gregset */
44 #include "gdbcore.h" /* for get_exec_file */
45 #include <ctype.h> /* for isdigit */
46 #include "gdbthread.h" /* for struct thread_info etc. */
47 #include "gdb_stat.h" /* for struct stat */
48 #include <fcntl.h> /* for O_RDONLY */
50 #include "event-loop.h"
51 #include "event-top.h"
57 /* If the system headers did not provide the constants, hard-code the normal
59 #ifndef PTRACE_EVENT_FORK
61 #define PTRACE_SETOPTIONS 0x4200
62 #define PTRACE_GETEVENTMSG 0x4201
64 /* options set using PTRACE_SETOPTIONS */
65 #define PTRACE_O_TRACESYSGOOD 0x00000001
66 #define PTRACE_O_TRACEFORK 0x00000002
67 #define PTRACE_O_TRACEVFORK 0x00000004
68 #define PTRACE_O_TRACECLONE 0x00000008
69 #define PTRACE_O_TRACEEXEC 0x00000010
70 #define PTRACE_O_TRACEVFORKDONE 0x00000020
71 #define PTRACE_O_TRACEEXIT 0x00000040
73 /* Wait extended result codes for the above trace options. */
74 #define PTRACE_EVENT_FORK 1
75 #define PTRACE_EVENT_VFORK 2
76 #define PTRACE_EVENT_CLONE 3
77 #define PTRACE_EVENT_EXEC 4
78 #define PTRACE_EVENT_VFORK_DONE 5
79 #define PTRACE_EVENT_EXIT 6
81 #endif /* PTRACE_EVENT_FORK */
83 /* We can't always assume that this flag is available, but all systems
84 with the ptrace event handlers also have __WALL, so it's safe to use
87 #define __WALL 0x40000000 /* Wait for any child. */
90 #ifndef PTRACE_GETSIGINFO
91 #define PTRACE_GETSIGINFO 0x4202
94 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
95 the use of the multi-threaded target. */
96 static struct target_ops
*linux_ops
;
97 static struct target_ops linux_ops_saved
;
99 /* The method to call, if any, when a new thread is attached. */
100 static void (*linux_nat_new_thread
) (ptid_t
);
102 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
103 Called by our to_xfer_partial. */
104 static LONGEST (*super_xfer_partial
) (struct target_ops
*,
106 const char *, gdb_byte
*,
110 static int debug_linux_nat
;
112 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
113 struct cmd_list_element
*c
, const char *value
)
115 fprintf_filtered (file
, _("Debugging of GNU/Linux lwp module is %s.\n"),
119 static int debug_linux_nat_async
= 0;
121 show_debug_linux_nat_async (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
, const char *value
)
124 fprintf_filtered (file
, _("Debugging of GNU/Linux async lwp module is %s.\n"),
128 static int linux_parent_pid
;
130 struct simple_pid_list
134 struct simple_pid_list
*next
;
136 struct simple_pid_list
*stopped_pids
;
138 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
139 can not be used, 1 if it can. */
141 static int linux_supports_tracefork_flag
= -1;
143 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
144 PTRACE_O_TRACEVFORKDONE. */
146 static int linux_supports_tracevforkdone_flag
= -1;
148 /* Async mode support */
150 /* To listen to target events asynchronously, we install a SIGCHLD
151 handler whose duty is to call waitpid (-1, ..., WNOHANG) to get all
152 the pending events into a pipe. Whenever we're ready to handle
153 events asynchronously, this pipe is registered as the waitable file
154 handle in the event loop. When we get to entry target points
155 coming out of the common code (target_wait, target_resume, ...),
156 that are going to call waitpid, we block SIGCHLD signals, and
157 remove all the events placed in the pipe into a local queue. All
158 the subsequent calls to my_waitpid (a waitpid wrapper) check this
159 local queue first. */
161 /* True if async mode is currently on. */
162 static int linux_nat_async_enabled
;
164 /* Zero if the async mode, although enabled, is masked, which means
165 linux_nat_wait should behave as if async mode was off. */
166 static int linux_nat_async_mask_value
= 1;
168 /* The read/write ends of the pipe registered as waitable file in the
170 static int linux_nat_event_pipe
[2] = { -1, -1 };
172 /* Number of queued events in the pipe. */
173 static volatile int linux_nat_num_queued_events
;
175 /* If async mode is on, true if we're listening for events; false if
176 target events are blocked. */
177 static int linux_nat_async_events_enabled
;
179 static int linux_nat_async_events (int enable
);
180 static void pipe_to_local_event_queue (void);
181 static void local_event_queue_to_pipe (void);
182 static void linux_nat_event_pipe_push (int pid
, int status
, int options
);
183 static int linux_nat_event_pipe_pop (int* ptr_status
, int* ptr_options
);
184 static void linux_nat_set_async_mode (int on
);
185 static void linux_nat_async (void (*callback
)
186 (enum inferior_event_type event_type
, void *context
),
188 static int linux_nat_async_mask (int mask
);
190 /* Captures the result of a successful waitpid call, along with the
191 options used in that call. */
192 struct waitpid_result
197 struct waitpid_result
*next
;
200 /* A singly-linked list of the results of the waitpid calls performed
201 in the async SIGCHLD handler. */
202 static struct waitpid_result
*waitpid_queue
= NULL
;
205 queued_waitpid (int pid
, int *status
, int flags
)
207 struct waitpid_result
*msg
= waitpid_queue
, *prev
= NULL
;
209 if (debug_linux_nat_async
)
210 fprintf_unfiltered (gdb_stdlog
,
212 QWPID: linux_nat_async_events_enabled(%d), linux_nat_num_queued_events(%d)\n",
213 linux_nat_async_events_enabled
,
214 linux_nat_num_queued_events
);
218 for (; msg
; prev
= msg
, msg
= msg
->next
)
219 if (pid
== -1 || pid
== msg
->pid
)
222 else if (flags
& __WCLONE
)
224 for (; msg
; prev
= msg
, msg
= msg
->next
)
225 if (msg
->options
& __WCLONE
226 && (pid
== -1 || pid
== msg
->pid
))
231 for (; msg
; prev
= msg
, msg
= msg
->next
)
232 if ((msg
->options
& __WCLONE
) == 0
233 && (pid
== -1 || pid
== msg
->pid
))
242 prev
->next
= msg
->next
;
244 waitpid_queue
= msg
->next
;
248 *status
= msg
->status
;
251 if (debug_linux_nat_async
)
252 fprintf_unfiltered (gdb_stdlog
, "QWPID: pid(%d), status(%x)\n",
259 if (debug_linux_nat_async
)
260 fprintf_unfiltered (gdb_stdlog
, "QWPID: miss\n");
268 push_waitpid (int pid
, int status
, int options
)
270 struct waitpid_result
*event
, *new_event
;
272 new_event
= xmalloc (sizeof (*new_event
));
273 new_event
->pid
= pid
;
274 new_event
->status
= status
;
275 new_event
->options
= options
;
276 new_event
->next
= NULL
;
280 for (event
= waitpid_queue
;
281 event
&& event
->next
;
285 event
->next
= new_event
;
288 waitpid_queue
= new_event
;
291 /* Drain all queued event of PID. If PID is -1, the effect is of
292 draining all events. */
294 drain_queued_events (int pid
)
296 while (queued_waitpid (pid
, NULL
, __WALL
) != -1)
301 /* Trivial list manipulation functions to keep track of a list of
302 new stopped processes. */
304 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
306 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
308 new_pid
->status
= status
;
309 new_pid
->next
= *listp
;
314 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *status
)
316 struct simple_pid_list
**p
;
318 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
319 if ((*p
)->pid
== pid
)
321 struct simple_pid_list
*next
= (*p
)->next
;
322 *status
= (*p
)->status
;
331 linux_record_stopped_pid (int pid
, int status
)
333 add_to_pid_list (&stopped_pids
, pid
, status
);
337 /* A helper function for linux_test_for_tracefork, called after fork (). */
340 linux_tracefork_child (void)
344 ptrace (PTRACE_TRACEME
, 0, 0, 0);
345 kill (getpid (), SIGSTOP
);
350 /* Wrapper function for waitpid which handles EINTR, and checks for
351 locally queued events. */
354 my_waitpid (int pid
, int *status
, int flags
)
358 /* There should be no concurrent calls to waitpid. */
359 gdb_assert (!linux_nat_async_events_enabled
);
361 ret
= queued_waitpid (pid
, status
, flags
);
367 ret
= waitpid (pid
, status
, flags
);
369 while (ret
== -1 && errno
== EINTR
);
374 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
376 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
377 we know that the feature is not available. This may change the tracing
378 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
380 However, if it succeeds, we don't know for sure that the feature is
381 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
382 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
383 fork tracing, and let it fork. If the process exits, we assume that we
384 can't use TRACEFORK; if we get the fork notification, and we can extract
385 the new child's PID, then we assume that we can. */
388 linux_test_for_tracefork (int original_pid
)
390 int child_pid
, ret
, status
;
393 linux_supports_tracefork_flag
= 0;
394 linux_supports_tracevforkdone_flag
= 0;
396 ret
= ptrace (PTRACE_SETOPTIONS
, original_pid
, 0, PTRACE_O_TRACEFORK
);
402 perror_with_name (("fork"));
405 linux_tracefork_child ();
407 ret
= my_waitpid (child_pid
, &status
, 0);
409 perror_with_name (("waitpid"));
410 else if (ret
!= child_pid
)
411 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret
);
412 if (! WIFSTOPPED (status
))
413 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status
);
415 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
418 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
421 warning (_("linux_test_for_tracefork: failed to kill child"));
425 ret
= my_waitpid (child_pid
, &status
, 0);
426 if (ret
!= child_pid
)
427 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
428 else if (!WIFSIGNALED (status
))
429 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
430 "killed child"), status
);
435 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
436 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0,
437 PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORKDONE
);
438 linux_supports_tracevforkdone_flag
= (ret
== 0);
440 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
442 warning (_("linux_test_for_tracefork: failed to resume child"));
444 ret
= my_waitpid (child_pid
, &status
, 0);
446 if (ret
== child_pid
&& WIFSTOPPED (status
)
447 && status
>> 16 == PTRACE_EVENT_FORK
)
450 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
451 if (ret
== 0 && second_pid
!= 0)
455 linux_supports_tracefork_flag
= 1;
456 my_waitpid (second_pid
, &second_status
, 0);
457 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
459 warning (_("linux_test_for_tracefork: failed to kill second child"));
460 my_waitpid (second_pid
, &status
, 0);
464 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
465 "(%d, status 0x%x)"), ret
, status
);
467 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
469 warning (_("linux_test_for_tracefork: failed to kill child"));
470 my_waitpid (child_pid
, &status
, 0);
473 /* Return non-zero iff we have tracefork functionality available.
474 This function also sets linux_supports_tracefork_flag. */
477 linux_supports_tracefork (int pid
)
479 if (linux_supports_tracefork_flag
== -1)
480 linux_test_for_tracefork (pid
);
481 return linux_supports_tracefork_flag
;
485 linux_supports_tracevforkdone (int pid
)
487 if (linux_supports_tracefork_flag
== -1)
488 linux_test_for_tracefork (pid
);
489 return linux_supports_tracevforkdone_flag
;
494 linux_enable_event_reporting (ptid_t ptid
)
496 int pid
= ptid_get_lwp (ptid
);
500 pid
= ptid_get_pid (ptid
);
502 if (! linux_supports_tracefork (pid
))
505 options
= PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEEXEC
506 | PTRACE_O_TRACECLONE
;
507 if (linux_supports_tracevforkdone (pid
))
508 options
|= PTRACE_O_TRACEVFORKDONE
;
510 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
511 read-only process state. */
513 ptrace (PTRACE_SETOPTIONS
, pid
, 0, options
);
517 linux_child_post_attach (int pid
)
519 linux_enable_event_reporting (pid_to_ptid (pid
));
520 check_for_thread_db ();
524 linux_child_post_startup_inferior (ptid_t ptid
)
526 linux_enable_event_reporting (ptid
);
527 check_for_thread_db ();
531 linux_child_follow_fork (struct target_ops
*ops
, int follow_child
)
534 struct target_waitstatus last_status
;
536 int parent_pid
, child_pid
;
538 if (target_can_async_p ())
539 target_async (NULL
, 0);
541 get_last_target_status (&last_ptid
, &last_status
);
542 has_vforked
= (last_status
.kind
== TARGET_WAITKIND_VFORKED
);
543 parent_pid
= ptid_get_lwp (last_ptid
);
545 parent_pid
= ptid_get_pid (last_ptid
);
546 child_pid
= last_status
.value
.related_pid
;
550 /* We're already attached to the parent, by default. */
552 /* Before detaching from the child, remove all breakpoints from
553 it. (This won't actually modify the breakpoint list, but will
554 physically remove the breakpoints from the child.) */
555 /* If we vforked this will remove the breakpoints from the parent
556 also, but they'll be reinserted below. */
557 detach_breakpoints (child_pid
);
559 /* Detach new forked process? */
562 if (info_verbose
|| debug_linux_nat
)
564 target_terminal_ours ();
565 fprintf_filtered (gdb_stdlog
,
566 "Detaching after fork from child process %d.\n",
570 ptrace (PTRACE_DETACH
, child_pid
, 0, 0);
574 struct fork_info
*fp
;
575 /* Retain child fork in ptrace (stopped) state. */
576 fp
= find_fork_pid (child_pid
);
578 fp
= add_fork (child_pid
);
579 fork_save_infrun_state (fp
, 0);
584 gdb_assert (linux_supports_tracefork_flag
>= 0);
585 if (linux_supports_tracevforkdone (0))
589 ptrace (PTRACE_CONT
, parent_pid
, 0, 0);
590 my_waitpid (parent_pid
, &status
, __WALL
);
591 if ((status
>> 16) != PTRACE_EVENT_VFORK_DONE
)
592 warning (_("Unexpected waitpid result %06x when waiting for "
593 "vfork-done"), status
);
597 /* We can't insert breakpoints until the child has
598 finished with the shared memory region. We need to
599 wait until that happens. Ideal would be to just
601 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
602 - waitpid (parent_pid, &status, __WALL);
603 However, most architectures can't handle a syscall
604 being traced on the way out if it wasn't traced on
607 We might also think to loop, continuing the child
608 until it exits or gets a SIGTRAP. One problem is
609 that the child might call ptrace with PTRACE_TRACEME.
611 There's no simple and reliable way to figure out when
612 the vforked child will be done with its copy of the
613 shared memory. We could step it out of the syscall,
614 two instructions, let it go, and then single-step the
615 parent once. When we have hardware single-step, this
616 would work; with software single-step it could still
617 be made to work but we'd have to be able to insert
618 single-step breakpoints in the child, and we'd have
619 to insert -just- the single-step breakpoint in the
620 parent. Very awkward.
622 In the end, the best we can do is to make sure it
623 runs for a little while. Hopefully it will be out of
624 range of any breakpoints we reinsert. Usually this
625 is only the single-step breakpoint at vfork's return
631 /* Since we vforked, breakpoints were removed in the parent
632 too. Put them back. */
633 reattach_breakpoints (parent_pid
);
638 char child_pid_spelling
[40];
640 /* Needed to keep the breakpoint lists in sync. */
642 detach_breakpoints (child_pid
);
644 /* Before detaching from the parent, remove all breakpoints from it. */
645 remove_breakpoints ();
647 if (info_verbose
|| debug_linux_nat
)
649 target_terminal_ours ();
650 fprintf_filtered (gdb_stdlog
,
651 "Attaching after fork to child process %d.\n",
655 /* If we're vforking, we may want to hold on to the parent until
656 the child exits or execs. At exec time we can remove the old
657 breakpoints from the parent and detach it; at exit time we
658 could do the same (or even, sneakily, resume debugging it - the
659 child's exec has failed, or something similar).
661 This doesn't clean up "properly", because we can't call
662 target_detach, but that's OK; if the current target is "child",
663 then it doesn't need any further cleanups, and lin_lwp will
664 generally not encounter vfork (vfork is defined to fork
667 The holding part is very easy if we have VFORKDONE events;
668 but keeping track of both processes is beyond GDB at the
669 moment. So we don't expose the parent to the rest of GDB.
670 Instead we quietly hold onto it until such time as we can
674 linux_parent_pid
= parent_pid
;
675 else if (!detach_fork
)
677 struct fork_info
*fp
;
678 /* Retain parent fork in ptrace (stopped) state. */
679 fp
= find_fork_pid (parent_pid
);
681 fp
= add_fork (parent_pid
);
682 fork_save_infrun_state (fp
, 0);
685 target_detach (NULL
, 0);
687 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
689 /* Reinstall ourselves, since we might have been removed in
690 target_detach (which does other necessary cleanup). */
693 linux_nat_switch_fork (inferior_ptid
);
694 check_for_thread_db ();
696 /* Reset breakpoints in the child as appropriate. */
697 follow_inferior_reset_breakpoints ();
700 if (target_can_async_p ())
701 target_async (inferior_event_handler
, 0);
708 linux_child_insert_fork_catchpoint (int pid
)
710 if (! linux_supports_tracefork (pid
))
711 error (_("Your system does not support fork catchpoints."));
715 linux_child_insert_vfork_catchpoint (int pid
)
717 if (!linux_supports_tracefork (pid
))
718 error (_("Your system does not support vfork catchpoints."));
722 linux_child_insert_exec_catchpoint (int pid
)
724 if (!linux_supports_tracefork (pid
))
725 error (_("Your system does not support exec catchpoints."));
728 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
729 are processes sharing the same VM space. A multi-threaded process
730 is basically a group of such processes. However, such a grouping
731 is almost entirely a user-space issue; the kernel doesn't enforce
732 such a grouping at all (this might change in the future). In
733 general, we'll rely on the threads library (i.e. the GNU/Linux
734 Threads library) to provide such a grouping.
736 It is perfectly well possible to write a multi-threaded application
737 without the assistance of a threads library, by using the clone
738 system call directly. This module should be able to give some
739 rudimentary support for debugging such applications if developers
740 specify the CLONE_PTRACE flag in the clone system call, and are
741 using the Linux kernel 2.4 or above.
743 Note that there are some peculiarities in GNU/Linux that affect
746 - In general one should specify the __WCLONE flag to waitpid in
747 order to make it report events for any of the cloned processes
748 (and leave it out for the initial process). However, if a cloned
749 process has exited the exit status is only reported if the
750 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
751 we cannot use it since GDB must work on older systems too.
753 - When a traced, cloned process exits and is waited for by the
754 debugger, the kernel reassigns it to the original parent and
755 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
756 library doesn't notice this, which leads to the "zombie problem":
757 When debugged a multi-threaded process that spawns a lot of
758 threads will run out of processes, even if the threads exit,
759 because the "zombies" stay around. */
761 /* List of known LWPs. */
762 struct lwp_info
*lwp_list
;
764 /* Number of LWPs in the list. */
768 /* If the last reported event was a SIGTRAP, this variable is set to
769 the process id of the LWP/thread that got it. */
773 /* Since we cannot wait (in linux_nat_wait) for the initial process and
774 any cloned processes with a single call to waitpid, we have to use
775 the WNOHANG flag and call waitpid in a loop. To optimize
776 things a bit we use `sigsuspend' to wake us up when a process has
777 something to report (it will send us a SIGCHLD if it has). To make
778 this work we have to juggle with the signal mask. We save the
779 original signal mask such that we can restore it before creating a
780 new process in order to avoid blocking certain signals in the
781 inferior. We then block SIGCHLD during the waitpid/sigsuspend
784 /* Original signal mask. */
785 static sigset_t normal_mask
;
787 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
788 _initialize_linux_nat. */
789 static sigset_t suspend_mask
;
791 /* SIGCHLD action for synchronous mode. */
792 struct sigaction sync_sigchld_action
;
794 /* SIGCHLD action for asynchronous mode. */
795 static struct sigaction async_sigchld_action
;
798 /* Prototypes for local functions. */
799 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
800 static int linux_nat_thread_alive (ptid_t ptid
);
801 static char *linux_child_pid_to_exec_file (int pid
);
803 /* Convert wait status STATUS to a string. Used for printing debug
807 status_to_str (int status
)
811 if (WIFSTOPPED (status
))
812 snprintf (buf
, sizeof (buf
), "%s (stopped)",
813 strsignal (WSTOPSIG (status
)));
814 else if (WIFSIGNALED (status
))
815 snprintf (buf
, sizeof (buf
), "%s (terminated)",
816 strsignal (WSTOPSIG (status
)));
818 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
823 /* Initialize the list of LWPs. Note that this module, contrary to
824 what GDB's generic threads layer does for its thread list,
825 re-initializes the LWP lists whenever we mourn or detach (which
826 doesn't involve mourning) the inferior. */
831 struct lwp_info
*lp
, *lpnext
;
833 for (lp
= lwp_list
; lp
; lp
= lpnext
)
843 /* Add the LWP specified by PID to the list. Return a pointer to the
844 structure describing the new LWP. The LWP should already be stopped
845 (with an exception for the very first LWP). */
847 static struct lwp_info
*
848 add_lwp (ptid_t ptid
)
852 gdb_assert (is_lwp (ptid
));
854 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
856 memset (lp
, 0, sizeof (struct lwp_info
));
858 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
866 if (num_lwps
> 1 && linux_nat_new_thread
!= NULL
)
867 linux_nat_new_thread (ptid
);
872 /* Remove the LWP specified by PID from the list. */
875 delete_lwp (ptid_t ptid
)
877 struct lwp_info
*lp
, *lpprev
;
881 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
882 if (ptid_equal (lp
->ptid
, ptid
))
891 lpprev
->next
= lp
->next
;
898 /* Return a pointer to the structure describing the LWP corresponding
899 to PID. If no corresponding LWP could be found, return NULL. */
901 static struct lwp_info
*
902 find_lwp_pid (ptid_t ptid
)
908 lwp
= GET_LWP (ptid
);
910 lwp
= GET_PID (ptid
);
912 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
913 if (lwp
== GET_LWP (lp
->ptid
))
919 /* Call CALLBACK with its second argument set to DATA for every LWP in
920 the list. If CALLBACK returns 1 for a particular LWP, return a
921 pointer to the structure describing that LWP immediately.
922 Otherwise return NULL. */
925 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
927 struct lwp_info
*lp
, *lpnext
;
929 for (lp
= lwp_list
; lp
; lp
= lpnext
)
932 if ((*callback
) (lp
, data
))
939 /* Update our internal state when changing from one fork (checkpoint,
940 et cetera) to another indicated by NEW_PTID. We can only switch
941 single-threaded applications, so we only create one new LWP, and
942 the previous list is discarded. */
945 linux_nat_switch_fork (ptid_t new_ptid
)
950 lp
= add_lwp (new_ptid
);
954 /* Record a PTID for later deletion. */
959 struct saved_ptids
*next
;
961 static struct saved_ptids
*threads_to_delete
;
964 record_dead_thread (ptid_t ptid
)
966 struct saved_ptids
*p
= xmalloc (sizeof (struct saved_ptids
));
968 p
->next
= threads_to_delete
;
969 threads_to_delete
= p
;
972 /* Delete any dead threads which are not the current thread. */
977 struct saved_ptids
**p
= &threads_to_delete
;
980 if (! ptid_equal ((*p
)->ptid
, inferior_ptid
))
982 struct saved_ptids
*tmp
= *p
;
983 delete_thread (tmp
->ptid
);
991 /* Handle the exit of a single thread LP. */
994 exit_lwp (struct lwp_info
*lp
)
996 if (in_thread_list (lp
->ptid
))
998 if (print_thread_events
)
999 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp
->ptid
));
1001 /* Core GDB cannot deal with us deleting the current thread. */
1002 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1003 delete_thread (lp
->ptid
);
1005 record_dead_thread (lp
->ptid
);
1008 delete_lwp (lp
->ptid
);
1011 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
1012 a message telling the user that a new LWP has been added to the
1013 process. Return 0 if successful or -1 if the new LWP could not
1017 lin_lwp_attach_lwp (ptid_t ptid
)
1019 struct lwp_info
*lp
;
1020 int async_events_were_enabled
= 0;
1022 gdb_assert (is_lwp (ptid
));
1024 if (target_can_async_p ())
1025 async_events_were_enabled
= linux_nat_async_events (0);
1027 lp
= find_lwp_pid (ptid
);
1029 /* We assume that we're already attached to any LWP that has an id
1030 equal to the overall process id, and to any LWP that is already
1031 in our list of LWPs. If we're not seeing exit events from threads
1032 and we've had PID wraparound since we last tried to stop all threads,
1033 this assumption might be wrong; fortunately, this is very unlikely
1035 if (GET_LWP (ptid
) != GET_PID (ptid
) && lp
== NULL
)
1041 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
1043 /* If we fail to attach to the thread, issue a warning,
1044 but continue. One way this can happen is if thread
1045 creation is interrupted; as of Linux kernel 2.6.19, a
1046 bug may place threads in the thread list and then fail
1048 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
1049 safe_strerror (errno
));
1053 if (debug_linux_nat
)
1054 fprintf_unfiltered (gdb_stdlog
,
1055 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1056 target_pid_to_str (ptid
));
1058 pid
= my_waitpid (GET_LWP (ptid
), &status
, 0);
1059 if (pid
== -1 && errno
== ECHILD
)
1061 /* Try again with __WCLONE to check cloned processes. */
1062 pid
= my_waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
1066 gdb_assert (pid
== GET_LWP (ptid
)
1067 && WIFSTOPPED (status
) && WSTOPSIG (status
));
1070 lp
= add_lwp (ptid
);
1071 lp
->cloned
= cloned
;
1073 target_post_attach (pid
);
1077 if (debug_linux_nat
)
1079 fprintf_unfiltered (gdb_stdlog
,
1080 "LLAL: waitpid %s received %s\n",
1081 target_pid_to_str (ptid
),
1082 status_to_str (status
));
1087 /* We assume that the LWP representing the original process is
1088 already stopped. Mark it as stopped in the data structure
1089 that the GNU/linux ptrace layer uses to keep track of
1090 threads. Note that this won't have already been done since
1091 the main thread will have, we assume, been stopped by an
1092 attach from a different layer. */
1094 lp
= add_lwp (ptid
);
1098 if (async_events_were_enabled
)
1099 linux_nat_async_events (1);
1105 linux_nat_create_inferior (char *exec_file
, char *allargs
, char **env
,
1108 int saved_async
= 0;
1110 /* The fork_child mechanism is synchronous and calls target_wait, so
1111 we have to mask the async mode. */
1113 if (target_can_async_p ())
1114 saved_async
= linux_nat_async_mask (0);
1117 /* Restore the original signal mask. */
1118 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1119 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1120 suspend_mask
= normal_mask
;
1121 sigdelset (&suspend_mask
, SIGCHLD
);
1124 linux_ops
->to_create_inferior (exec_file
, allargs
, env
, from_tty
);
1127 linux_nat_async_mask (saved_async
);
1131 linux_nat_attach (char *args
, int from_tty
)
1133 struct lwp_info
*lp
;
1138 /* FIXME: We should probably accept a list of process id's, and
1139 attach all of them. */
1140 linux_ops
->to_attach (args
, from_tty
);
1142 if (!target_can_async_p ())
1144 /* Restore the original signal mask. */
1145 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1146 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1147 suspend_mask
= normal_mask
;
1148 sigdelset (&suspend_mask
, SIGCHLD
);
1151 /* Make sure the initial process is stopped. The user-level threads
1152 layer might want to poke around in the inferior, and that won't
1153 work if things haven't stabilized yet. */
1154 pid
= my_waitpid (GET_PID (inferior_ptid
), &status
, 0);
1155 if (pid
== -1 && errno
== ECHILD
)
1157 warning (_("%s is a cloned process"), target_pid_to_str (inferior_ptid
));
1159 /* Try again with __WCLONE to check cloned processes. */
1160 pid
= my_waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
1164 gdb_assert (pid
== GET_PID (inferior_ptid
)
1165 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
1167 /* Add the initial process as the first LWP to the list. */
1168 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
));
1169 lp
= add_lwp (inferior_ptid
);
1170 lp
->cloned
= cloned
;
1174 /* Fake the SIGSTOP that core GDB expects. */
1175 lp
->status
= W_STOPCODE (SIGSTOP
);
1177 if (debug_linux_nat
)
1178 fprintf_unfiltered (gdb_stdlog
,
1179 "LNA: waitpid %ld, faking SIGSTOP\n", (long) pid
);
1180 if (target_can_async_p ())
1182 /* Wake event loop with special token, to get to WFI. */
1183 linux_nat_event_pipe_push (-1, -1, -1);
1184 /* Register in the event loop. */
1185 target_async (inferior_event_handler
, 0);
1190 detach_callback (struct lwp_info
*lp
, void *data
)
1192 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1194 if (debug_linux_nat
&& lp
->status
)
1195 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
1196 strsignal (WSTOPSIG (lp
->status
)),
1197 target_pid_to_str (lp
->ptid
));
1199 while (lp
->signalled
&& lp
->stopped
)
1202 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
1203 WSTOPSIG (lp
->status
)) < 0)
1204 error (_("Can't continue %s: %s"), target_pid_to_str (lp
->ptid
),
1205 safe_strerror (errno
));
1207 if (debug_linux_nat
)
1208 fprintf_unfiltered (gdb_stdlog
,
1209 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
1210 target_pid_to_str (lp
->ptid
),
1211 status_to_str (lp
->status
));
1216 /* FIXME drow/2003-08-26: There was a call to stop_wait_callback
1217 here. But since lp->signalled was cleared above,
1218 stop_wait_callback didn't do anything; the process was left
1219 running. Shouldn't we be waiting for it to stop?
1220 I've removed the call, since stop_wait_callback now does do
1221 something when called with lp->signalled == 0. */
1223 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1226 /* We don't actually detach from the LWP that has an id equal to the
1227 overall process id just yet. */
1228 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
1231 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
1232 WSTOPSIG (lp
->status
)) < 0)
1233 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1234 safe_strerror (errno
));
1236 if (debug_linux_nat
)
1237 fprintf_unfiltered (gdb_stdlog
,
1238 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1239 target_pid_to_str (lp
->ptid
),
1240 strsignal (WSTOPSIG (lp
->status
)));
1242 drain_queued_events (GET_LWP (lp
->ptid
));
1243 delete_lwp (lp
->ptid
);
1250 linux_nat_detach (char *args
, int from_tty
)
1253 if (target_can_async_p ())
1254 linux_nat_async (NULL
, 0);
1256 iterate_over_lwps (detach_callback
, NULL
);
1258 /* Only the initial process should be left right now. */
1259 gdb_assert (num_lwps
== 1);
1261 trap_ptid
= null_ptid
;
1263 /* Destroy LWP info; it's no longer valid. */
1266 pid
= GET_PID (inferior_ptid
);
1267 inferior_ptid
= pid_to_ptid (pid
);
1268 linux_ops
->to_detach (args
, from_tty
);
1270 if (target_can_async_p ())
1271 drain_queued_events (pid
);
1277 resume_callback (struct lwp_info
*lp
, void *data
)
1279 if (lp
->stopped
&& lp
->status
== 0)
1281 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
1282 0, TARGET_SIGNAL_0
);
1283 if (debug_linux_nat
)
1284 fprintf_unfiltered (gdb_stdlog
,
1285 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1286 target_pid_to_str (lp
->ptid
));
1289 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1296 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1303 resume_set_callback (struct lwp_info
*lp
, void *data
)
1310 linux_nat_resume (ptid_t ptid
, int step
, enum target_signal signo
)
1312 struct lwp_info
*lp
;
1315 if (debug_linux_nat
)
1316 fprintf_unfiltered (gdb_stdlog
,
1317 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1318 step
? "step" : "resume",
1319 target_pid_to_str (ptid
),
1320 signo
? strsignal (signo
) : "0",
1321 target_pid_to_str (inferior_ptid
));
1325 if (target_can_async_p ())
1326 /* Block events while we're here. */
1327 linux_nat_async_events (0);
1329 /* A specific PTID means `step only this process id'. */
1330 resume_all
= (PIDGET (ptid
) == -1);
1333 iterate_over_lwps (resume_set_callback
, NULL
);
1335 iterate_over_lwps (resume_clear_callback
, NULL
);
1337 /* If PID is -1, it's the current inferior that should be
1338 handled specially. */
1339 if (PIDGET (ptid
) == -1)
1340 ptid
= inferior_ptid
;
1342 lp
= find_lwp_pid (ptid
);
1343 gdb_assert (lp
!= NULL
);
1345 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
1347 /* Remember if we're stepping. */
1350 /* Mark this LWP as resumed. */
1353 /* If we have a pending wait status for this thread, there is no
1354 point in resuming the process. But first make sure that
1355 linux_nat_wait won't preemptively handle the event - we
1356 should never take this short-circuit if we are going to
1357 leave LP running, since we have skipped resuming all the
1358 other threads. This bit of code needs to be synchronized
1359 with linux_nat_wait. */
1361 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1363 int saved_signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1365 if (signal_stop_state (saved_signo
) == 0
1366 && signal_print_state (saved_signo
) == 0
1367 && signal_pass_state (saved_signo
) == 1)
1369 if (debug_linux_nat
)
1370 fprintf_unfiltered (gdb_stdlog
,
1371 "LLR: Not short circuiting for ignored "
1372 "status 0x%x\n", lp
->status
);
1374 /* FIXME: What should we do if we are supposed to continue
1375 this thread with a signal? */
1376 gdb_assert (signo
== TARGET_SIGNAL_0
);
1377 signo
= saved_signo
;
1384 /* FIXME: What should we do if we are supposed to continue
1385 this thread with a signal? */
1386 gdb_assert (signo
== TARGET_SIGNAL_0
);
1388 if (debug_linux_nat
)
1389 fprintf_unfiltered (gdb_stdlog
,
1390 "LLR: Short circuiting for status 0x%x\n",
1393 if (target_can_async_p ())
1395 /* Wake event loop with special token, to get to WFI. */
1396 linux_nat_event_pipe_push (-1, -1, -1);
1398 target_async (inferior_event_handler
, 0);
1403 /* Mark LWP as not stopped to prevent it from being continued by
1408 iterate_over_lwps (resume_callback
, NULL
);
1410 linux_ops
->to_resume (ptid
, step
, signo
);
1411 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1413 if (debug_linux_nat
)
1414 fprintf_unfiltered (gdb_stdlog
,
1415 "LLR: %s %s, %s (resume event thread)\n",
1416 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1417 target_pid_to_str (ptid
),
1418 signo
? strsignal (signo
) : "0");
1420 if (target_can_async_p ())
1422 target_executing
= 1;
1423 target_async (inferior_event_handler
, 0);
1427 /* Issue kill to specified lwp. */
1429 static int tkill_failed
;
1432 kill_lwp (int lwpid
, int signo
)
1436 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1437 fails, then we are not using nptl threads and we should be using kill. */
1439 #ifdef HAVE_TKILL_SYSCALL
1442 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
1443 if (errno
!= ENOSYS
)
1450 return kill (lwpid
, signo
);
1453 /* Handle a GNU/Linux extended wait response. If we see a clone
1454 event, we need to add the new LWP to our list (and not report the
1455 trap to higher layers). This function returns non-zero if the
1456 event should be ignored and we should wait again. If STOPPING is
1457 true, the new LWP remains stopped, otherwise it is continued. */
1460 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
1463 int pid
= GET_LWP (lp
->ptid
);
1464 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1465 struct lwp_info
*new_lp
= NULL
;
1466 int event
= status
>> 16;
1468 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1469 || event
== PTRACE_EVENT_CLONE
)
1471 unsigned long new_pid
;
1474 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1476 /* If we haven't already seen the new PID stop, wait for it now. */
1477 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1479 /* The new child has a pending SIGSTOP. We can't affect it until it
1480 hits the SIGSTOP, but we're already attached. */
1481 ret
= my_waitpid (new_pid
, &status
,
1482 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
1484 perror_with_name (_("waiting for new child"));
1485 else if (ret
!= new_pid
)
1486 internal_error (__FILE__
, __LINE__
,
1487 _("wait returned unexpected PID %d"), ret
);
1488 else if (!WIFSTOPPED (status
))
1489 internal_error (__FILE__
, __LINE__
,
1490 _("wait returned unexpected status 0x%x"), status
);
1493 ourstatus
->value
.related_pid
= new_pid
;
1495 if (event
== PTRACE_EVENT_FORK
)
1496 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1497 else if (event
== PTRACE_EVENT_VFORK
)
1498 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1501 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1502 new_lp
= add_lwp (BUILD_LWP (new_pid
, GET_PID (inferior_ptid
)));
1505 if (WSTOPSIG (status
) != SIGSTOP
)
1507 /* This can happen if someone starts sending signals to
1508 the new thread before it gets a chance to run, which
1509 have a lower number than SIGSTOP (e.g. SIGUSR1).
1510 This is an unlikely case, and harder to handle for
1511 fork / vfork than for clone, so we do not try - but
1512 we handle it for clone events here. We'll send
1513 the other signal on to the thread below. */
1515 new_lp
->signalled
= 1;
1521 new_lp
->stopped
= 1;
1524 new_lp
->resumed
= 1;
1525 ptrace (PTRACE_CONT
, lp
->waitstatus
.value
.related_pid
, 0,
1526 status
? WSTOPSIG (status
) : 0);
1529 if (debug_linux_nat
)
1530 fprintf_unfiltered (gdb_stdlog
,
1531 "LHEW: Got clone event from LWP %ld, resuming\n",
1532 GET_LWP (lp
->ptid
));
1533 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1541 if (event
== PTRACE_EVENT_EXEC
)
1543 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1544 ourstatus
->value
.execd_pathname
1545 = xstrdup (linux_child_pid_to_exec_file (pid
));
1547 if (linux_parent_pid
)
1549 detach_breakpoints (linux_parent_pid
);
1550 ptrace (PTRACE_DETACH
, linux_parent_pid
, 0, 0);
1552 linux_parent_pid
= 0;
1558 internal_error (__FILE__
, __LINE__
,
1559 _("unknown ptrace event %d"), event
);
1562 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1566 wait_lwp (struct lwp_info
*lp
)
1570 int thread_dead
= 0;
1572 gdb_assert (!lp
->stopped
);
1573 gdb_assert (lp
->status
== 0);
1575 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, 0);
1576 if (pid
== -1 && errno
== ECHILD
)
1578 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
1579 if (pid
== -1 && errno
== ECHILD
)
1581 /* The thread has previously exited. We need to delete it
1582 now because, for some vendor 2.4 kernels with NPTL
1583 support backported, there won't be an exit event unless
1584 it is the main thread. 2.6 kernels will report an exit
1585 event for each thread that exits, as expected. */
1587 if (debug_linux_nat
)
1588 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
1589 target_pid_to_str (lp
->ptid
));
1595 gdb_assert (pid
== GET_LWP (lp
->ptid
));
1597 if (debug_linux_nat
)
1599 fprintf_unfiltered (gdb_stdlog
,
1600 "WL: waitpid %s received %s\n",
1601 target_pid_to_str (lp
->ptid
),
1602 status_to_str (status
));
1606 /* Check if the thread has exited. */
1607 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1610 if (debug_linux_nat
)
1611 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
1612 target_pid_to_str (lp
->ptid
));
1621 gdb_assert (WIFSTOPPED (status
));
1623 /* Handle GNU/Linux's extended waitstatus for trace events. */
1624 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1626 if (debug_linux_nat
)
1627 fprintf_unfiltered (gdb_stdlog
,
1628 "WL: Handling extended status 0x%06x\n",
1630 if (linux_handle_extended_wait (lp
, status
, 1))
1631 return wait_lwp (lp
);
1637 /* Save the most recent siginfo for LP. This is currently only called
1638 for SIGTRAP; some ports use the si_addr field for
1639 target_stopped_data_address. In the future, it may also be used to
1640 restore the siginfo of requeued signals. */
1643 save_siginfo (struct lwp_info
*lp
)
1646 ptrace (PTRACE_GETSIGINFO
, GET_LWP (lp
->ptid
),
1647 (PTRACE_TYPE_ARG3
) 0, &lp
->siginfo
);
1650 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1653 /* Send a SIGSTOP to LP. */
1656 stop_callback (struct lwp_info
*lp
, void *data
)
1658 if (!lp
->stopped
&& !lp
->signalled
)
1662 if (debug_linux_nat
)
1664 fprintf_unfiltered (gdb_stdlog
,
1665 "SC: kill %s **<SIGSTOP>**\n",
1666 target_pid_to_str (lp
->ptid
));
1669 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
1670 if (debug_linux_nat
)
1672 fprintf_unfiltered (gdb_stdlog
,
1673 "SC: lwp kill %d %s\n",
1675 errno
? safe_strerror (errno
) : "ERRNO-OK");
1679 gdb_assert (lp
->status
== 0);
1685 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
1686 a pointer to a set of signals to be flushed immediately. */
1689 stop_wait_callback (struct lwp_info
*lp
, void *data
)
1691 sigset_t
*flush_mask
= data
;
1697 status
= wait_lwp (lp
);
1701 /* Ignore any signals in FLUSH_MASK. */
1702 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
1711 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1712 if (debug_linux_nat
)
1713 fprintf_unfiltered (gdb_stdlog
,
1714 "PTRACE_CONT %s, 0, 0 (%s)\n",
1715 target_pid_to_str (lp
->ptid
),
1716 errno
? safe_strerror (errno
) : "OK");
1718 return stop_wait_callback (lp
, flush_mask
);
1721 if (WSTOPSIG (status
) != SIGSTOP
)
1723 if (WSTOPSIG (status
) == SIGTRAP
)
1725 /* If a LWP other than the LWP that we're reporting an
1726 event for has hit a GDB breakpoint (as opposed to
1727 some random trap signal), then just arrange for it to
1728 hit it again later. We don't keep the SIGTRAP status
1729 and don't forward the SIGTRAP signal to the LWP. We
1730 will handle the current event, eventually we will
1731 resume all LWPs, and this one will get its breakpoint
1734 If we do not do this, then we run the risk that the
1735 user will delete or disable the breakpoint, but the
1736 thread will have already tripped on it. */
1738 /* Save the trap's siginfo in case we need it later. */
1741 /* Now resume this LWP and get the SIGSTOP event. */
1743 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1744 if (debug_linux_nat
)
1746 fprintf_unfiltered (gdb_stdlog
,
1747 "PTRACE_CONT %s, 0, 0 (%s)\n",
1748 target_pid_to_str (lp
->ptid
),
1749 errno
? safe_strerror (errno
) : "OK");
1751 fprintf_unfiltered (gdb_stdlog
,
1752 "SWC: Candidate SIGTRAP event in %s\n",
1753 target_pid_to_str (lp
->ptid
));
1755 /* Hold the SIGTRAP for handling by linux_nat_wait. */
1756 stop_wait_callback (lp
, data
);
1757 /* If there's another event, throw it back into the queue. */
1760 if (debug_linux_nat
)
1762 fprintf_unfiltered (gdb_stdlog
,
1763 "SWC: kill %s, %s\n",
1764 target_pid_to_str (lp
->ptid
),
1765 status_to_str ((int) status
));
1767 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
1769 /* Save the sigtrap event. */
1770 lp
->status
= status
;
1775 /* The thread was stopped with a signal other than
1776 SIGSTOP, and didn't accidentally trip a breakpoint. */
1778 if (debug_linux_nat
)
1780 fprintf_unfiltered (gdb_stdlog
,
1781 "SWC: Pending event %s in %s\n",
1782 status_to_str ((int) status
),
1783 target_pid_to_str (lp
->ptid
));
1785 /* Now resume this LWP and get the SIGSTOP event. */
1787 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1788 if (debug_linux_nat
)
1789 fprintf_unfiltered (gdb_stdlog
,
1790 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
1791 target_pid_to_str (lp
->ptid
),
1792 errno
? safe_strerror (errno
) : "OK");
1794 /* Hold this event/waitstatus while we check to see if
1795 there are any more (we still want to get that SIGSTOP). */
1796 stop_wait_callback (lp
, data
);
1797 /* If the lp->status field is still empty, use it to hold
1798 this event. If not, then this event must be returned
1799 to the event queue of the LWP. */
1800 if (lp
->status
== 0)
1801 lp
->status
= status
;
1804 if (debug_linux_nat
)
1806 fprintf_unfiltered (gdb_stdlog
,
1807 "SWC: kill %s, %s\n",
1808 target_pid_to_str (lp
->ptid
),
1809 status_to_str ((int) status
));
1811 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
1818 /* We caught the SIGSTOP that we intended to catch, so
1819 there's no SIGSTOP pending. */
1828 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
1829 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
1832 linux_nat_has_pending (int pid
, sigset_t
*pending
, sigset_t
*flush_mask
)
1834 sigset_t blocked
, ignored
;
1837 linux_proc_pending_signals (pid
, pending
, &blocked
, &ignored
);
1842 for (i
= 1; i
< NSIG
; i
++)
1843 if (sigismember (pending
, i
))
1844 if (!sigismember (flush_mask
, i
)
1845 || sigismember (&blocked
, i
)
1846 || sigismember (&ignored
, i
))
1847 sigdelset (pending
, i
);
1849 if (sigisemptyset (pending
))
1855 /* DATA is interpreted as a mask of signals to flush. If LP has
1856 signals pending, and they are all in the flush mask, then arrange
1857 to flush them. LP should be stopped, as should all other threads
1858 it might share a signal queue with. */
1861 flush_callback (struct lwp_info
*lp
, void *data
)
1863 sigset_t
*flush_mask
= data
;
1864 sigset_t pending
, intersection
, blocked
, ignored
;
1867 /* Normally, when an LWP exits, it is removed from the LWP list. The
1868 last LWP isn't removed till later, however. So if there is only
1869 one LWP on the list, make sure it's alive. */
1870 if (lwp_list
== lp
&& lp
->next
== NULL
)
1871 if (!linux_nat_thread_alive (lp
->ptid
))
1874 /* Just because the LWP is stopped doesn't mean that new signals
1875 can't arrive from outside, so this function must be careful of
1876 race conditions. However, because all threads are stopped, we
1877 can assume that the pending mask will not shrink unless we resume
1878 the LWP, and that it will then get another signal. We can't
1879 control which one, however. */
1883 if (debug_linux_nat
)
1884 printf_unfiltered (_("FC: LP has pending status %06x\n"), lp
->status
);
1885 if (WIFSTOPPED (lp
->status
) && sigismember (flush_mask
, WSTOPSIG (lp
->status
)))
1889 /* While there is a pending signal we would like to flush, continue
1890 the inferior and collect another signal. But if there's already
1891 a saved status that we don't want to flush, we can't resume the
1892 inferior - if it stopped for some other reason we wouldn't have
1893 anywhere to save the new status. In that case, we must leave the
1894 signal unflushed (and possibly generate an extra SIGINT stop).
1895 That's much less bad than losing a signal. */
1896 while (lp
->status
== 0
1897 && linux_nat_has_pending (GET_LWP (lp
->ptid
), &pending
, flush_mask
))
1902 ret
= ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1903 if (debug_linux_nat
)
1904 fprintf_unfiltered (gdb_stderr
,
1905 "FC: Sent PTRACE_CONT, ret %d %d\n", ret
, errno
);
1908 stop_wait_callback (lp
, flush_mask
);
1909 if (debug_linux_nat
)
1910 fprintf_unfiltered (gdb_stderr
,
1911 "FC: Wait finished; saved status is %d\n",
1918 /* Return non-zero if LP has a wait status pending. */
1921 status_callback (struct lwp_info
*lp
, void *data
)
1923 /* Only report a pending wait status if we pretend that this has
1924 indeed been resumed. */
1925 return (lp
->status
!= 0 && lp
->resumed
);
1928 /* Return non-zero if LP isn't stopped. */
1931 running_callback (struct lwp_info
*lp
, void *data
)
1933 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
1936 /* Count the LWP's that have had events. */
1939 count_events_callback (struct lwp_info
*lp
, void *data
)
1943 gdb_assert (count
!= NULL
);
1945 /* Count only LWPs that have a SIGTRAP event pending. */
1947 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
1953 /* Select the LWP (if any) that is currently being single-stepped. */
1956 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
1958 if (lp
->step
&& lp
->status
!= 0)
1964 /* Select the Nth LWP that has had a SIGTRAP event. */
1967 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
1969 int *selector
= data
;
1971 gdb_assert (selector
!= NULL
);
1973 /* Select only LWPs that have a SIGTRAP event pending. */
1975 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
1976 if ((*selector
)-- == 0)
1983 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
1985 struct lwp_info
*event_lp
= data
;
1987 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
1991 /* If a LWP other than the LWP that we're reporting an event for has
1992 hit a GDB breakpoint (as opposed to some random trap signal),
1993 then just arrange for it to hit it again later. We don't keep
1994 the SIGTRAP status and don't forward the SIGTRAP signal to the
1995 LWP. We will handle the current event, eventually we will resume
1996 all LWPs, and this one will get its breakpoint trap again.
1998 If we do not do this, then we run the risk that the user will
1999 delete or disable the breakpoint, but the LWP will have already
2003 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
2004 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
2005 gdbarch_decr_pc_after_break
2008 if (debug_linux_nat
)
2009 fprintf_unfiltered (gdb_stdlog
,
2010 "CBC: Push back breakpoint for %s\n",
2011 target_pid_to_str (lp
->ptid
));
2013 /* Back up the PC if necessary. */
2014 if (gdbarch_decr_pc_after_break (current_gdbarch
))
2015 write_pc_pid (read_pc_pid (lp
->ptid
) - gdbarch_decr_pc_after_break
2019 /* Throw away the SIGTRAP. */
2026 /* Select one LWP out of those that have events pending. */
2029 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
2032 int random_selector
;
2033 struct lwp_info
*event_lp
;
2035 /* Record the wait status for the original LWP. */
2036 (*orig_lp
)->status
= *status
;
2038 /* Give preference to any LWP that is being single-stepped. */
2039 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
2040 if (event_lp
!= NULL
)
2042 if (debug_linux_nat
)
2043 fprintf_unfiltered (gdb_stdlog
,
2044 "SEL: Select single-step %s\n",
2045 target_pid_to_str (event_lp
->ptid
));
2049 /* No single-stepping LWP. Select one at random, out of those
2050 which have had SIGTRAP events. */
2052 /* First see how many SIGTRAP events we have. */
2053 iterate_over_lwps (count_events_callback
, &num_events
);
2055 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2056 random_selector
= (int)
2057 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2059 if (debug_linux_nat
&& num_events
> 1)
2060 fprintf_unfiltered (gdb_stdlog
,
2061 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2062 num_events
, random_selector
);
2064 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
2068 if (event_lp
!= NULL
)
2070 /* Switch the event LWP. */
2071 *orig_lp
= event_lp
;
2072 *status
= event_lp
->status
;
2075 /* Flush the wait status for the event LWP. */
2076 (*orig_lp
)->status
= 0;
2079 /* Return non-zero if LP has been resumed. */
2082 resumed_callback (struct lwp_info
*lp
, void *data
)
2087 /* Stop an active thread, verify it still exists, then resume it. */
2090 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
2092 struct lwp_info
*ptr
;
2094 if (!lp
->stopped
&& !lp
->signalled
)
2096 stop_callback (lp
, NULL
);
2097 stop_wait_callback (lp
, NULL
);
2098 /* Resume if the lwp still exists. */
2099 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
2102 resume_callback (lp
, NULL
);
2103 resume_set_callback (lp
, NULL
);
2109 /* Check if we should go on and pass this event to common code.
2110 Return the affected lwp if we are, or NULL otherwise. */
2111 static struct lwp_info
*
2112 linux_nat_filter_event (int lwpid
, int status
, int options
)
2114 struct lwp_info
*lp
;
2116 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
2118 /* Check for stop events reported by a process we didn't already
2119 know about - anything not already in our LWP list.
2121 If we're expecting to receive stopped processes after
2122 fork, vfork, and clone events, then we'll just add the
2123 new one to our list and go back to waiting for the event
2124 to be reported - the stopped process might be returned
2125 from waitpid before or after the event is. */
2126 if (WIFSTOPPED (status
) && !lp
)
2128 linux_record_stopped_pid (lwpid
, status
);
2132 /* Make sure we don't report an event for the exit of an LWP not in
2133 our list, i.e. not part of the current process. This can happen
2134 if we detach from a program we original forked and then it
2136 if (!WIFSTOPPED (status
) && !lp
)
2139 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
2140 CLONE_PTRACE processes which do not use the thread library -
2141 otherwise we wouldn't find the new LWP this way. That doesn't
2142 currently work, and the following code is currently unreachable
2143 due to the two blocks above. If it's fixed some day, this code
2144 should be broken out into a function so that we can also pick up
2145 LWPs from the new interface. */
2148 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
2149 if (options
& __WCLONE
)
2152 gdb_assert (WIFSTOPPED (status
)
2153 && WSTOPSIG (status
) == SIGSTOP
);
2156 if (!in_thread_list (inferior_ptid
))
2158 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2159 GET_PID (inferior_ptid
));
2160 add_thread (inferior_ptid
);
2163 add_thread (lp
->ptid
);
2166 /* Save the trap's siginfo in case we need it later. */
2167 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2170 /* Handle GNU/Linux's extended waitstatus for trace events. */
2171 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
2173 if (debug_linux_nat
)
2174 fprintf_unfiltered (gdb_stdlog
,
2175 "LLW: Handling extended status 0x%06x\n",
2177 if (linux_handle_extended_wait (lp
, status
, 0))
2181 /* Check if the thread has exited. */
2182 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
2184 /* If this is the main thread, we must stop all threads and
2185 verify if they are still alive. This is because in the nptl
2186 thread model, there is no signal issued for exiting LWPs
2187 other than the main thread. We only get the main thread exit
2188 signal once all child threads have already exited. If we
2189 stop all the threads and use the stop_wait_callback to check
2190 if they have exited we can determine whether this signal
2191 should be ignored or whether it means the end of the debugged
2192 application, regardless of which threading model is being
2194 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
2197 iterate_over_lwps (stop_and_resume_callback
, NULL
);
2200 if (debug_linux_nat
)
2201 fprintf_unfiltered (gdb_stdlog
,
2202 "LLW: %s exited.\n",
2203 target_pid_to_str (lp
->ptid
));
2207 /* If there is at least one more LWP, then the exit signal was
2208 not the end of the debugged application and should be
2212 /* Make sure there is at least one thread running. */
2213 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
2215 /* Discard the event. */
2220 /* Check if the current LWP has previously exited. In the nptl
2221 thread model, LWPs other than the main thread do not issue
2222 signals when they exit so we must check whenever the thread has
2223 stopped. A similar check is made in stop_wait_callback(). */
2224 if (num_lwps
> 1 && !linux_nat_thread_alive (lp
->ptid
))
2226 if (debug_linux_nat
)
2227 fprintf_unfiltered (gdb_stdlog
,
2228 "LLW: %s exited.\n",
2229 target_pid_to_str (lp
->ptid
));
2233 /* Make sure there is at least one thread running. */
2234 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
2236 /* Discard the event. */
2240 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2241 an attempt to stop an LWP. */
2243 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
2245 if (debug_linux_nat
)
2246 fprintf_unfiltered (gdb_stdlog
,
2247 "LLW: Delayed SIGSTOP caught for %s.\n",
2248 target_pid_to_str (lp
->ptid
));
2250 /* This is a delayed SIGSTOP. */
2253 registers_changed ();
2255 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2256 lp
->step
, TARGET_SIGNAL_0
);
2257 if (debug_linux_nat
)
2258 fprintf_unfiltered (gdb_stdlog
,
2259 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2261 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2262 target_pid_to_str (lp
->ptid
));
2265 gdb_assert (lp
->resumed
);
2267 /* Discard the event. */
2271 /* An interesting event. */
2276 /* Get the events stored in the pipe into the local queue, so they are
2277 accessible to queued_waitpid. We need to do this, since it is not
2278 always the case that the event at the head of the pipe is the event
2282 pipe_to_local_event_queue (void)
2284 if (debug_linux_nat_async
)
2285 fprintf_unfiltered (gdb_stdlog
,
2286 "PTLEQ: linux_nat_num_queued_events(%d)\n",
2287 linux_nat_num_queued_events
);
2288 while (linux_nat_num_queued_events
)
2290 int lwpid
, status
, options
;
2292 lwpid
= linux_nat_event_pipe_pop (&status
, &options
);
2293 if (lwpid
== -1 && status
== -1 && options
== -1)
2294 /* Special wake up event loop token. */
2297 gdb_assert (lwpid
> 0);
2298 push_waitpid (lwpid
, status
, options
);
2302 /* Get the unprocessed events stored in the local queue back into the
2303 pipe, so the event loop realizes there's something else to
2307 local_event_queue_to_pipe (void)
2309 struct waitpid_result
*w
= waitpid_queue
;
2312 struct waitpid_result
*next
= w
->next
;
2313 linux_nat_event_pipe_push (w
->pid
,
2319 waitpid_queue
= NULL
;
2321 if (debug_linux_nat_async
)
2322 fprintf_unfiltered (gdb_stdlog
,
2323 "LEQTP: linux_nat_num_queued_events(%d)\n",
2324 linux_nat_num_queued_events
);
2328 linux_nat_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
2330 struct lwp_info
*lp
= NULL
;
2333 pid_t pid
= PIDGET (ptid
);
2334 sigset_t flush_mask
;
2336 if (debug_linux_nat_async
)
2337 fprintf_unfiltered (gdb_stdlog
, "LLW: enter\n");
2339 /* The first time we get here after starting a new inferior, we may
2340 not have added it to the LWP list yet - this is the earliest
2341 moment at which we know its PID. */
2344 gdb_assert (!is_lwp (inferior_ptid
));
2346 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2347 GET_PID (inferior_ptid
));
2348 lp
= add_lwp (inferior_ptid
);
2352 sigemptyset (&flush_mask
);
2354 if (target_can_async_p ())
2355 /* Block events while we're here. */
2356 target_async (NULL
, 0);
2360 /* Make sure there is at least one LWP that has been resumed. */
2361 gdb_assert (iterate_over_lwps (resumed_callback
, NULL
));
2363 /* First check if there is a LWP with a wait status pending. */
2366 /* Any LWP that's been resumed will do. */
2367 lp
= iterate_over_lwps (status_callback
, NULL
);
2370 status
= lp
->status
;
2373 if (debug_linux_nat
&& status
)
2374 fprintf_unfiltered (gdb_stdlog
,
2375 "LLW: Using pending wait status %s for %s.\n",
2376 status_to_str (status
),
2377 target_pid_to_str (lp
->ptid
));
2380 /* But if we don't find one, we'll have to wait, and check both
2381 cloned and uncloned processes. We start with the cloned
2383 options
= __WCLONE
| WNOHANG
;
2385 else if (is_lwp (ptid
))
2387 if (debug_linux_nat
)
2388 fprintf_unfiltered (gdb_stdlog
,
2389 "LLW: Waiting for specific LWP %s.\n",
2390 target_pid_to_str (ptid
));
2392 /* We have a specific LWP to check. */
2393 lp
= find_lwp_pid (ptid
);
2395 status
= lp
->status
;
2398 if (debug_linux_nat
&& status
)
2399 fprintf_unfiltered (gdb_stdlog
,
2400 "LLW: Using pending wait status %s for %s.\n",
2401 status_to_str (status
),
2402 target_pid_to_str (lp
->ptid
));
2404 /* If we have to wait, take into account whether PID is a cloned
2405 process or not. And we have to convert it to something that
2406 the layer beneath us can understand. */
2407 options
= lp
->cloned
? __WCLONE
: 0;
2408 pid
= GET_LWP (ptid
);
2411 if (status
&& lp
->signalled
)
2413 /* A pending SIGSTOP may interfere with the normal stream of
2414 events. In a typical case where interference is a problem,
2415 we have a SIGSTOP signal pending for LWP A while
2416 single-stepping it, encounter an event in LWP B, and take the
2417 pending SIGSTOP while trying to stop LWP A. After processing
2418 the event in LWP B, LWP A is continued, and we'll never see
2419 the SIGTRAP associated with the last time we were
2420 single-stepping LWP A. */
2422 /* Resume the thread. It should halt immediately returning the
2424 registers_changed ();
2425 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2426 lp
->step
, TARGET_SIGNAL_0
);
2427 if (debug_linux_nat
)
2428 fprintf_unfiltered (gdb_stdlog
,
2429 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
2430 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2431 target_pid_to_str (lp
->ptid
));
2433 gdb_assert (lp
->resumed
);
2435 /* This should catch the pending SIGSTOP. */
2436 stop_wait_callback (lp
, NULL
);
2439 if (!target_can_async_p ())
2441 /* Causes SIGINT to be passed on to the attached process. */
2450 if (target_can_async_p ())
2451 /* In async mode, don't ever block. Only look at the locally
2453 lwpid
= queued_waitpid (pid
, &status
, options
);
2455 lwpid
= my_waitpid (pid
, &status
, options
);
2459 gdb_assert (pid
== -1 || lwpid
== pid
);
2461 if (debug_linux_nat
)
2463 fprintf_unfiltered (gdb_stdlog
,
2464 "LLW: waitpid %ld received %s\n",
2465 (long) lwpid
, status_to_str (status
));
2468 lp
= linux_nat_filter_event (lwpid
, status
, options
);
2471 /* A discarded event. */
2481 /* Alternate between checking cloned and uncloned processes. */
2482 options
^= __WCLONE
;
2484 /* And every time we have checked both:
2485 In async mode, return to event loop;
2486 In sync mode, suspend waiting for a SIGCHLD signal. */
2487 if (options
& __WCLONE
)
2489 if (target_can_async_p ())
2491 /* No interesting event. */
2492 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2494 /* Get ready for the next event. */
2495 target_async (inferior_event_handler
, 0);
2497 if (debug_linux_nat_async
)
2498 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
2500 return minus_one_ptid
;
2503 sigsuspend (&suspend_mask
);
2507 /* We shouldn't end up here unless we want to try again. */
2508 gdb_assert (status
== 0);
2511 if (!target_can_async_p ())
2513 clear_sigio_trap ();
2514 clear_sigint_trap ();
2519 /* Don't report signals that GDB isn't interested in, such as
2520 signals that are neither printed nor stopped upon. Stopping all
2521 threads can be a bit time-consuming so if we want decent
2522 performance with heavily multi-threaded programs, especially when
2523 they're using a high frequency timer, we'd better avoid it if we
2526 if (WIFSTOPPED (status
))
2528 int signo
= target_signal_from_host (WSTOPSIG (status
));
2530 /* If we get a signal while single-stepping, we may need special
2531 care, e.g. to skip the signal handler. Defer to common code. */
2533 && signal_stop_state (signo
) == 0
2534 && signal_print_state (signo
) == 0
2535 && signal_pass_state (signo
) == 1)
2537 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2538 here? It is not clear we should. GDB may not expect
2539 other threads to run. On the other hand, not resuming
2540 newly attached threads may cause an unwanted delay in
2541 getting them running. */
2542 registers_changed ();
2543 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2545 if (debug_linux_nat
)
2546 fprintf_unfiltered (gdb_stdlog
,
2547 "LLW: %s %s, %s (preempt 'handle')\n",
2549 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2550 target_pid_to_str (lp
->ptid
),
2551 signo
? strsignal (signo
) : "0");
2557 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
2559 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2560 forwarded to the entire process group, that is, all LWP's
2561 will receive it. Since we only want to report it once,
2562 we try to flush it from all LWPs except this one. */
2563 sigaddset (&flush_mask
, SIGINT
);
2567 /* This LWP is stopped now. */
2570 if (debug_linux_nat
)
2571 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
2572 status_to_str (status
), target_pid_to_str (lp
->ptid
));
2574 /* Now stop all other LWP's ... */
2575 iterate_over_lwps (stop_callback
, NULL
);
2577 /* ... and wait until all of them have reported back that they're no
2579 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
2580 iterate_over_lwps (flush_callback
, &flush_mask
);
2582 /* If we're not waiting for a specific LWP, choose an event LWP from
2583 among those that have had events. Giving equal priority to all
2584 LWPs that have had events helps prevent starvation. */
2586 select_event_lwp (&lp
, &status
);
2588 /* Now that we've selected our final event LWP, cancel any
2589 breakpoints in other LWPs that have hit a GDB breakpoint. See
2590 the comment in cancel_breakpoints_callback to find out why. */
2591 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
2593 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2595 trap_ptid
= lp
->ptid
;
2596 if (debug_linux_nat
)
2597 fprintf_unfiltered (gdb_stdlog
,
2598 "LLW: trap_ptid is %s.\n",
2599 target_pid_to_str (trap_ptid
));
2602 trap_ptid
= null_ptid
;
2604 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
2606 *ourstatus
= lp
->waitstatus
;
2607 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
2610 store_waitstatus (ourstatus
, status
);
2612 /* Get ready for the next event. */
2613 if (target_can_async_p ())
2614 target_async (inferior_event_handler
, 0);
2616 if (debug_linux_nat_async
)
2617 fprintf_unfiltered (gdb_stdlog
, "LLW: exit\n");
2623 kill_callback (struct lwp_info
*lp
, void *data
)
2626 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
2627 if (debug_linux_nat
)
2628 fprintf_unfiltered (gdb_stdlog
,
2629 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
2630 target_pid_to_str (lp
->ptid
),
2631 errno
? safe_strerror (errno
) : "OK");
2637 kill_wait_callback (struct lwp_info
*lp
, void *data
)
2641 /* We must make sure that there are no pending events (delayed
2642 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
2643 program doesn't interfere with any following debugging session. */
2645 /* For cloned processes we must check both with __WCLONE and
2646 without, since the exit status of a cloned process isn't reported
2652 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
2653 if (pid
!= (pid_t
) -1)
2655 if (debug_linux_nat
)
2656 fprintf_unfiltered (gdb_stdlog
,
2657 "KWC: wait %s received unknown.\n",
2658 target_pid_to_str (lp
->ptid
));
2659 /* The Linux kernel sometimes fails to kill a thread
2660 completely after PTRACE_KILL; that goes from the stop
2661 point in do_fork out to the one in
2662 get_signal_to_deliever and waits again. So kill it
2664 kill_callback (lp
, NULL
);
2667 while (pid
== GET_LWP (lp
->ptid
));
2669 gdb_assert (pid
== -1 && errno
== ECHILD
);
2674 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
2675 if (pid
!= (pid_t
) -1)
2677 if (debug_linux_nat
)
2678 fprintf_unfiltered (gdb_stdlog
,
2679 "KWC: wait %s received unk.\n",
2680 target_pid_to_str (lp
->ptid
));
2681 /* See the call to kill_callback above. */
2682 kill_callback (lp
, NULL
);
2685 while (pid
== GET_LWP (lp
->ptid
));
2687 gdb_assert (pid
== -1 && errno
== ECHILD
);
2692 linux_nat_kill (void)
2694 struct target_waitstatus last
;
2698 if (target_can_async_p ())
2699 target_async (NULL
, 0);
2701 /* If we're stopped while forking and we haven't followed yet,
2702 kill the other task. We need to do this first because the
2703 parent will be sleeping if this is a vfork. */
2705 get_last_target_status (&last_ptid
, &last
);
2707 if (last
.kind
== TARGET_WAITKIND_FORKED
2708 || last
.kind
== TARGET_WAITKIND_VFORKED
)
2710 ptrace (PT_KILL
, last
.value
.related_pid
, 0, 0);
2714 if (forks_exist_p ())
2716 linux_fork_killall ();
2717 drain_queued_events (-1);
2721 /* Kill all LWP's ... */
2722 iterate_over_lwps (kill_callback
, NULL
);
2724 /* ... and wait until we've flushed all events. */
2725 iterate_over_lwps (kill_wait_callback
, NULL
);
2728 target_mourn_inferior ();
2732 linux_nat_mourn_inferior (void)
2734 trap_ptid
= null_ptid
;
2736 /* Destroy LWP info; it's no longer valid. */
2739 if (! forks_exist_p ())
2741 /* Normal case, no other forks available. */
2742 if (target_can_async_p ())
2743 linux_nat_async (NULL
, 0);
2744 linux_ops
->to_mourn_inferior ();
2747 /* Multi-fork case. The current inferior_ptid has exited, but
2748 there are other viable forks to debug. Delete the exiting
2749 one and context-switch to the first available. */
2750 linux_fork_mourn_inferior ();
2754 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2755 const char *annex
, gdb_byte
*readbuf
,
2756 const gdb_byte
*writebuf
,
2757 ULONGEST offset
, LONGEST len
)
2759 struct cleanup
*old_chain
= save_inferior_ptid ();
2762 if (is_lwp (inferior_ptid
))
2763 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
2765 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
2768 do_cleanups (old_chain
);
2773 linux_nat_thread_alive (ptid_t ptid
)
2775 gdb_assert (is_lwp (ptid
));
2778 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
2779 if (debug_linux_nat
)
2780 fprintf_unfiltered (gdb_stdlog
,
2781 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
2782 target_pid_to_str (ptid
),
2783 errno
? safe_strerror (errno
) : "OK");
2785 /* Not every Linux kernel implements PTRACE_PEEKUSER. But we can
2786 handle that case gracefully since ptrace will first do a lookup
2787 for the process based upon the passed-in pid. If that fails we
2788 will get either -ESRCH or -EPERM, otherwise the child exists and
2790 if (errno
== ESRCH
|| errno
== EPERM
)
2797 linux_nat_pid_to_str (ptid_t ptid
)
2799 static char buf
[64];
2801 if (lwp_list
&& lwp_list
->next
&& is_lwp (ptid
))
2803 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
2807 return normal_pid_to_str (ptid
);
2811 sigchld_handler (int signo
)
2813 if (linux_nat_async_enabled
2814 && linux_nat_async_events_enabled
2815 && signo
== SIGCHLD
)
2816 /* It is *always* a bug to hit this. */
2817 internal_error (__FILE__
, __LINE__
,
2818 "sigchld_handler called when async events are enabled");
2820 /* Do nothing. The only reason for this handler is that it allows
2821 us to use sigsuspend in linux_nat_wait above to wait for the
2822 arrival of a SIGCHLD. */
2825 /* Accepts an integer PID; Returns a string representing a file that
2826 can be opened to get the symbols for the child process. */
2829 linux_child_pid_to_exec_file (int pid
)
2831 char *name1
, *name2
;
2833 name1
= xmalloc (MAXPATHLEN
);
2834 name2
= xmalloc (MAXPATHLEN
);
2835 make_cleanup (xfree
, name1
);
2836 make_cleanup (xfree
, name2
);
2837 memset (name2
, 0, MAXPATHLEN
);
2839 sprintf (name1
, "/proc/%d/exe", pid
);
2840 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
2846 /* Service function for corefiles and info proc. */
2849 read_mapping (FILE *mapfile
,
2854 char *device
, long long *inode
, char *filename
)
2856 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
2857 addr
, endaddr
, permissions
, offset
, device
, inode
);
2860 if (ret
> 0 && ret
!= EOF
)
2862 /* Eat everything up to EOL for the filename. This will prevent
2863 weird filenames (such as one with embedded whitespace) from
2864 confusing this code. It also makes this code more robust in
2865 respect to annotations the kernel may add after the filename.
2867 Note the filename is used for informational purposes
2869 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
2872 return (ret
!= 0 && ret
!= EOF
);
2875 /* Fills the "to_find_memory_regions" target vector. Lists the memory
2876 regions in the inferior for a corefile. */
2879 linux_nat_find_memory_regions (int (*func
) (CORE_ADDR
,
2881 int, int, int, void *), void *obfd
)
2883 long long pid
= PIDGET (inferior_ptid
);
2884 char mapsfilename
[MAXPATHLEN
];
2886 long long addr
, endaddr
, size
, offset
, inode
;
2887 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
2888 int read
, write
, exec
;
2891 /* Compose the filename for the /proc memory map, and open it. */
2892 sprintf (mapsfilename
, "/proc/%lld/maps", pid
);
2893 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
2894 error (_("Could not open %s."), mapsfilename
);
2897 fprintf_filtered (gdb_stdout
,
2898 "Reading memory regions from %s\n", mapsfilename
);
2900 /* Now iterate until end-of-file. */
2901 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
2902 &offset
, &device
[0], &inode
, &filename
[0]))
2904 size
= endaddr
- addr
;
2906 /* Get the segment's permissions. */
2907 read
= (strchr (permissions
, 'r') != 0);
2908 write
= (strchr (permissions
, 'w') != 0);
2909 exec
= (strchr (permissions
, 'x') != 0);
2913 fprintf_filtered (gdb_stdout
,
2914 "Save segment, %lld bytes at 0x%s (%c%c%c)",
2915 size
, paddr_nz (addr
),
2917 write
? 'w' : ' ', exec
? 'x' : ' ');
2919 fprintf_filtered (gdb_stdout
, " for %s", filename
);
2920 fprintf_filtered (gdb_stdout
, "\n");
2923 /* Invoke the callback function to create the corefile
2925 func (addr
, size
, read
, write
, exec
, obfd
);
2931 /* Records the thread's register state for the corefile note
2935 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
2936 char *note_data
, int *note_size
)
2938 gdb_gregset_t gregs
;
2939 gdb_fpregset_t fpregs
;
2940 #ifdef FILL_FPXREGSET
2941 gdb_fpxregset_t fpxregs
;
2943 unsigned long lwp
= ptid_get_lwp (ptid
);
2944 struct regcache
*regcache
= get_thread_regcache (ptid
);
2945 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2946 const struct regset
*regset
;
2948 struct cleanup
*old_chain
;
2950 old_chain
= save_inferior_ptid ();
2951 inferior_ptid
= ptid
;
2952 target_fetch_registers (regcache
, -1);
2953 do_cleanups (old_chain
);
2955 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
2957 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
2958 sizeof (gregs
))) != NULL
2959 && regset
->collect_regset
!= NULL
)
2960 regset
->collect_regset (regset
, regcache
, -1,
2961 &gregs
, sizeof (gregs
));
2963 fill_gregset (regcache
, &gregs
, -1);
2965 note_data
= (char *) elfcore_write_prstatus (obfd
,
2969 stop_signal
, &gregs
);
2972 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
2973 sizeof (fpregs
))) != NULL
2974 && regset
->collect_regset
!= NULL
)
2975 regset
->collect_regset (regset
, regcache
, -1,
2976 &fpregs
, sizeof (fpregs
));
2978 fill_fpregset (regcache
, &fpregs
, -1);
2980 note_data
= (char *) elfcore_write_prfpreg (obfd
,
2983 &fpregs
, sizeof (fpregs
));
2985 #ifdef FILL_FPXREGSET
2987 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg-xfp",
2988 sizeof (fpxregs
))) != NULL
2989 && regset
->collect_regset
!= NULL
)
2990 regset
->collect_regset (regset
, regcache
, -1,
2991 &fpxregs
, sizeof (fpxregs
));
2993 fill_fpxregset (regcache
, &fpxregs
, -1);
2995 note_data
= (char *) elfcore_write_prxfpreg (obfd
,
2998 &fpxregs
, sizeof (fpxregs
));
3003 struct linux_nat_corefile_thread_data
3011 /* Called by gdbthread.c once per thread. Records the thread's
3012 register state for the corefile note section. */
3015 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
3017 struct linux_nat_corefile_thread_data
*args
= data
;
3019 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
3028 /* Records the register state for the corefile note section. */
3031 linux_nat_do_registers (bfd
*obfd
, ptid_t ptid
,
3032 char *note_data
, int *note_size
)
3034 return linux_nat_do_thread_registers (obfd
,
3035 ptid_build (ptid_get_pid (inferior_ptid
),
3036 ptid_get_pid (inferior_ptid
),
3038 note_data
, note_size
);
3041 /* Fills the "to_make_corefile_note" target vector. Builds the note
3042 section for a corefile, and returns it in a malloc buffer. */
3045 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
3047 struct linux_nat_corefile_thread_data thread_args
;
3048 struct cleanup
*old_chain
;
3049 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
3050 char fname
[16] = { '\0' };
3051 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
3052 char psargs
[80] = { '\0' };
3053 char *note_data
= NULL
;
3054 ptid_t current_ptid
= inferior_ptid
;
3058 if (get_exec_file (0))
3060 strncpy (fname
, strrchr (get_exec_file (0), '/') + 1, sizeof (fname
));
3061 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3062 if (get_inferior_args ())
3065 char *psargs_end
= psargs
+ sizeof (psargs
);
3067 /* linux_elfcore_write_prpsinfo () handles zero unterminated
3069 string_end
= memchr (psargs
, 0, sizeof (psargs
));
3070 if (string_end
!= NULL
)
3072 *string_end
++ = ' ';
3073 strncpy (string_end
, get_inferior_args (),
3074 psargs_end
- string_end
);
3077 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
3079 note_size
, fname
, psargs
);
3082 /* Dump information for threads. */
3083 thread_args
.obfd
= obfd
;
3084 thread_args
.note_data
= note_data
;
3085 thread_args
.note_size
= note_size
;
3086 thread_args
.num_notes
= 0;
3087 iterate_over_lwps (linux_nat_corefile_thread_callback
, &thread_args
);
3088 if (thread_args
.num_notes
== 0)
3090 /* iterate_over_threads didn't come up with any threads; just
3091 use inferior_ptid. */
3092 note_data
= linux_nat_do_registers (obfd
, inferior_ptid
,
3093 note_data
, note_size
);
3097 note_data
= thread_args
.note_data
;
3100 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
3104 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
3105 "CORE", NT_AUXV
, auxv
, auxv_len
);
3109 make_cleanup (xfree
, note_data
);
3113 /* Implement the "info proc" command. */
3116 linux_nat_info_proc_cmd (char *args
, int from_tty
)
3118 long long pid
= PIDGET (inferior_ptid
);
3121 char buffer
[MAXPATHLEN
];
3122 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
3135 /* Break up 'args' into an argv array. */
3136 if ((argv
= buildargv (args
)) == NULL
)
3139 make_cleanup_freeargv (argv
);
3141 while (argv
!= NULL
&& *argv
!= NULL
)
3143 if (isdigit (argv
[0][0]))
3145 pid
= strtoul (argv
[0], NULL
, 10);
3147 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
3151 else if (strcmp (argv
[0], "status") == 0)
3155 else if (strcmp (argv
[0], "stat") == 0)
3159 else if (strcmp (argv
[0], "cmd") == 0)
3163 else if (strncmp (argv
[0], "exe", strlen (argv
[0])) == 0)
3167 else if (strcmp (argv
[0], "cwd") == 0)
3171 else if (strncmp (argv
[0], "all", strlen (argv
[0])) == 0)
3177 /* [...] (future options here) */
3182 error (_("No current process: you must name one."));
3184 sprintf (fname1
, "/proc/%lld", pid
);
3185 if (stat (fname1
, &dummy
) != 0)
3186 error (_("No /proc directory: '%s'"), fname1
);
3188 printf_filtered (_("process %lld\n"), pid
);
3189 if (cmdline_f
|| all
)
3191 sprintf (fname1
, "/proc/%lld/cmdline", pid
);
3192 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3194 fgets (buffer
, sizeof (buffer
), procfile
);
3195 printf_filtered ("cmdline = '%s'\n", buffer
);
3199 warning (_("unable to open /proc file '%s'"), fname1
);
3203 sprintf (fname1
, "/proc/%lld/cwd", pid
);
3204 memset (fname2
, 0, sizeof (fname2
));
3205 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
3206 printf_filtered ("cwd = '%s'\n", fname2
);
3208 warning (_("unable to read link '%s'"), fname1
);
3212 sprintf (fname1
, "/proc/%lld/exe", pid
);
3213 memset (fname2
, 0, sizeof (fname2
));
3214 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
3215 printf_filtered ("exe = '%s'\n", fname2
);
3217 warning (_("unable to read link '%s'"), fname1
);
3219 if (mappings_f
|| all
)
3221 sprintf (fname1
, "/proc/%lld/maps", pid
);
3222 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3224 long long addr
, endaddr
, size
, offset
, inode
;
3225 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
3227 printf_filtered (_("Mapped address spaces:\n\n"));
3228 if (gdbarch_addr_bit (current_gdbarch
) == 32)
3230 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3233 " Size", " Offset", "objfile");
3237 printf_filtered (" %18s %18s %10s %10s %7s\n",
3240 " Size", " Offset", "objfile");
3243 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
3244 &offset
, &device
[0], &inode
, &filename
[0]))
3246 size
= endaddr
- addr
;
3248 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
3249 calls here (and possibly above) should be abstracted
3250 out into their own functions? Andrew suggests using
3251 a generic local_address_string instead to print out
3252 the addresses; that makes sense to me, too. */
3254 if (gdbarch_addr_bit (current_gdbarch
) == 32)
3256 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3257 (unsigned long) addr
, /* FIXME: pr_addr */
3258 (unsigned long) endaddr
,
3260 (unsigned int) offset
,
3261 filename
[0] ? filename
: "");
3265 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3266 (unsigned long) addr
, /* FIXME: pr_addr */
3267 (unsigned long) endaddr
,
3269 (unsigned int) offset
,
3270 filename
[0] ? filename
: "");
3277 warning (_("unable to open /proc file '%s'"), fname1
);
3279 if (status_f
|| all
)
3281 sprintf (fname1
, "/proc/%lld/status", pid
);
3282 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3284 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
3285 puts_filtered (buffer
);
3289 warning (_("unable to open /proc file '%s'"), fname1
);
3293 sprintf (fname1
, "/proc/%lld/stat", pid
);
3294 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3300 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3301 printf_filtered (_("Process: %d\n"), itmp
);
3302 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
3303 printf_filtered (_("Exec file: %s\n"), buffer
);
3304 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
3305 printf_filtered (_("State: %c\n"), ctmp
);
3306 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3307 printf_filtered (_("Parent process: %d\n"), itmp
);
3308 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3309 printf_filtered (_("Process group: %d\n"), itmp
);
3310 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3311 printf_filtered (_("Session id: %d\n"), itmp
);
3312 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3313 printf_filtered (_("TTY: %d\n"), itmp
);
3314 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3315 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
3316 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3317 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
3318 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3319 printf_filtered (_("Minor faults (no memory page): %lu\n"),
3320 (unsigned long) ltmp
);
3321 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3322 printf_filtered (_("Minor faults, children: %lu\n"),
3323 (unsigned long) ltmp
);
3324 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3325 printf_filtered (_("Major faults (memory page faults): %lu\n"),
3326 (unsigned long) ltmp
);
3327 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3328 printf_filtered (_("Major faults, children: %lu\n"),
3329 (unsigned long) ltmp
);
3330 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3331 printf_filtered (_("utime: %ld\n"), ltmp
);
3332 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3333 printf_filtered (_("stime: %ld\n"), ltmp
);
3334 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3335 printf_filtered (_("utime, children: %ld\n"), ltmp
);
3336 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3337 printf_filtered (_("stime, children: %ld\n"), ltmp
);
3338 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3339 printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
3341 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3342 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
3343 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3344 printf_filtered (_("jiffies until next timeout: %lu\n"),
3345 (unsigned long) ltmp
);
3346 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3347 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
3348 (unsigned long) ltmp
);
3349 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3350 printf_filtered (_("start time (jiffies since system boot): %ld\n"),
3352 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3353 printf_filtered (_("Virtual memory size: %lu\n"),
3354 (unsigned long) ltmp
);
3355 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3356 printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp
);
3357 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3358 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
3359 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3360 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
3361 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3362 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
3363 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3364 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
3365 #if 0 /* Don't know how architecture-dependent the rest is...
3366 Anyway the signal bitmap info is available from "status". */
3367 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3368 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
3369 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3370 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
3371 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3372 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
3373 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3374 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
3375 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3376 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
3377 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3378 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
3379 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3380 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
3385 warning (_("unable to open /proc file '%s'"), fname1
);
3389 /* Implement the to_xfer_partial interface for memory reads using the /proc
3390 filesystem. Because we can use a single read() call for /proc, this
3391 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3392 but it doesn't support writes. */
3395 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3396 const char *annex
, gdb_byte
*readbuf
,
3397 const gdb_byte
*writebuf
,
3398 ULONGEST offset
, LONGEST len
)
3404 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
3407 /* Don't bother for one word. */
3408 if (len
< 3 * sizeof (long))
3411 /* We could keep this file open and cache it - possibly one per
3412 thread. That requires some juggling, but is even faster. */
3413 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
3414 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
3418 /* If pread64 is available, use it. It's faster if the kernel
3419 supports it (only one syscall), and it's 64-bit safe even on
3420 32-bit platforms (for instance, SPARC debugging a SPARC64
3423 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
3425 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
3435 /* Parse LINE as a signal set and add its set bits to SIGS. */
3438 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
3440 int len
= strlen (line
) - 1;
3444 if (line
[len
] != '\n')
3445 error (_("Could not parse signal set: %s"), line
);
3453 if (*p
>= '0' && *p
<= '9')
3455 else if (*p
>= 'a' && *p
<= 'f')
3456 digit
= *p
- 'a' + 10;
3458 error (_("Could not parse signal set: %s"), line
);
3463 sigaddset (sigs
, signum
+ 1);
3465 sigaddset (sigs
, signum
+ 2);
3467 sigaddset (sigs
, signum
+ 3);
3469 sigaddset (sigs
, signum
+ 4);
3475 /* Find process PID's pending signals from /proc/pid/status and set
3479 linux_proc_pending_signals (int pid
, sigset_t
*pending
, sigset_t
*blocked
, sigset_t
*ignored
)
3482 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
3485 sigemptyset (pending
);
3486 sigemptyset (blocked
);
3487 sigemptyset (ignored
);
3488 sprintf (fname
, "/proc/%d/status", pid
);
3489 procfile
= fopen (fname
, "r");
3490 if (procfile
== NULL
)
3491 error (_("Could not open %s"), fname
);
3493 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
3495 /* Normal queued signals are on the SigPnd line in the status
3496 file. However, 2.6 kernels also have a "shared" pending
3497 queue for delivering signals to a thread group, so check for
3500 Unfortunately some Red Hat kernels include the shared pending
3501 queue but not the ShdPnd status field. */
3503 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
3504 add_line_to_sigset (buffer
+ 8, pending
);
3505 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
3506 add_line_to_sigset (buffer
+ 8, pending
);
3507 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
3508 add_line_to_sigset (buffer
+ 8, blocked
);
3509 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
3510 add_line_to_sigset (buffer
+ 8, ignored
);
3517 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3518 const char *annex
, gdb_byte
*readbuf
,
3519 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3523 if (object
== TARGET_OBJECT_AUXV
)
3524 return procfs_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
3527 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3532 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3536 /* Create a prototype generic GNU/Linux target. The client can override
3537 it with local methods. */
3540 linux_target_install_ops (struct target_ops
*t
)
3542 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
3543 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
3544 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
3545 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
3546 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
3547 t
->to_post_attach
= linux_child_post_attach
;
3548 t
->to_follow_fork
= linux_child_follow_fork
;
3549 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
3550 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
3552 super_xfer_partial
= t
->to_xfer_partial
;
3553 t
->to_xfer_partial
= linux_xfer_partial
;
3559 struct target_ops
*t
;
3561 t
= inf_ptrace_target ();
3562 linux_target_install_ops (t
);
3568 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
3570 struct target_ops
*t
;
3572 t
= inf_ptrace_trad_target (register_u_offset
);
3573 linux_target_install_ops (t
);
3578 /* Controls if async mode is permitted. */
3579 static int linux_async_permitted
= 0;
3581 /* The set command writes to this variable. If the inferior is
3582 executing, linux_nat_async_permitted is *not* updated. */
3583 static int linux_async_permitted_1
= 0;
3586 set_maintenance_linux_async_permitted (char *args
, int from_tty
,
3587 struct cmd_list_element
*c
)
3589 if (target_has_execution
)
3591 linux_async_permitted_1
= linux_async_permitted
;
3592 error (_("Cannot change this setting while the inferior is running."));
3595 linux_async_permitted
= linux_async_permitted_1
;
3596 linux_nat_set_async_mode (linux_async_permitted
);
3600 show_maintenance_linux_async_permitted (struct ui_file
*file
, int from_tty
,
3601 struct cmd_list_element
*c
, const char *value
)
3603 fprintf_filtered (file
, _("\
3604 Controlling the GNU/Linux inferior in asynchronous mode is %s.\n"),
3608 /* target_is_async_p implementation. */
3611 linux_nat_is_async_p (void)
3613 /* NOTE: palves 2008-03-21: We're only async when the user requests
3614 it explicitly with the "maintenance set linux-async" command.
3615 Someday, linux will always be async. */
3616 if (!linux_async_permitted
)
3622 /* target_can_async_p implementation. */
3625 linux_nat_can_async_p (void)
3627 /* NOTE: palves 2008-03-21: We're only async when the user requests
3628 it explicitly with the "maintenance set linux-async" command.
3629 Someday, linux will always be async. */
3630 if (!linux_async_permitted
)
3633 /* See target.h/target_async_mask. */
3634 return linux_nat_async_mask_value
;
3637 /* target_async_mask implementation. */
3640 linux_nat_async_mask (int mask
)
3643 current_state
= linux_nat_async_mask_value
;
3645 if (current_state
!= mask
)
3649 linux_nat_async (NULL
, 0);
3650 linux_nat_async_mask_value
= mask
;
3651 /* We're in sync mode. Make sure SIGCHLD isn't handled by
3652 async_sigchld_handler when we come out of sigsuspend in
3654 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
3658 /* Restore the async handler. */
3659 sigaction (SIGCHLD
, &async_sigchld_action
, NULL
);
3660 linux_nat_async_mask_value
= mask
;
3661 linux_nat_async (inferior_event_handler
, 0);
3665 return current_state
;
3668 /* Pop an event from the event pipe. */
3671 linux_nat_event_pipe_pop (int* ptr_status
, int* ptr_options
)
3673 struct waitpid_result event
= {0};
3678 ret
= read (linux_nat_event_pipe
[0], &event
, sizeof (event
));
3680 while (ret
== -1 && errno
== EINTR
);
3682 gdb_assert (ret
== sizeof (event
));
3684 *ptr_status
= event
.status
;
3685 *ptr_options
= event
.options
;
3687 linux_nat_num_queued_events
--;
3692 /* Push an event into the event pipe. */
3695 linux_nat_event_pipe_push (int pid
, int status
, int options
)
3698 struct waitpid_result event
= {0};
3700 event
.status
= status
;
3701 event
.options
= options
;
3705 ret
= write (linux_nat_event_pipe
[1], &event
, sizeof (event
));
3706 gdb_assert ((ret
== -1 && errno
== EINTR
) || ret
== sizeof (event
));
3707 } while (ret
== -1 && errno
== EINTR
);
3709 linux_nat_num_queued_events
++;
3713 get_pending_events (void)
3715 int status
, options
, pid
;
3717 if (!linux_nat_async_enabled
|| !linux_nat_async_events_enabled
)
3718 internal_error (__FILE__
, __LINE__
,
3719 "get_pending_events called with async masked");
3724 options
= __WCLONE
| WNOHANG
;
3728 pid
= waitpid (-1, &status
, options
);
3730 while (pid
== -1 && errno
== EINTR
);
3737 pid
= waitpid (-1, &status
, options
);
3739 while (pid
== -1 && errno
== EINTR
);
3743 /* No more children reporting events. */
3746 if (debug_linux_nat_async
)
3747 fprintf_unfiltered (gdb_stdlog
, "\
3748 get_pending_events: pid(%d), status(%x), options (%x)\n",
3749 pid
, status
, options
);
3751 linux_nat_event_pipe_push (pid
, status
, options
);
3754 if (debug_linux_nat_async
)
3755 fprintf_unfiltered (gdb_stdlog
, "\
3756 get_pending_events: linux_nat_num_queued_events(%d)\n",
3757 linux_nat_num_queued_events
);
3760 /* SIGCHLD handler for async mode. */
3763 async_sigchld_handler (int signo
)
3765 if (debug_linux_nat_async
)
3766 fprintf_unfiltered (gdb_stdlog
, "async_sigchld_handler\n");
3768 get_pending_events ();
3771 /* Enable or disable async SIGCHLD handling. */
3774 linux_nat_async_events (int enable
)
3776 int current_state
= linux_nat_async_events_enabled
;
3778 if (debug_linux_nat_async
)
3779 fprintf_unfiltered (gdb_stdlog
,
3780 "LNAE: enable(%d): linux_nat_async_events_enabled(%d), "
3781 "linux_nat_num_queued_events(%d)\n",
3782 enable
, linux_nat_async_events_enabled
,
3783 linux_nat_num_queued_events
);
3785 if (current_state
!= enable
)
3788 sigemptyset (&mask
);
3789 sigaddset (&mask
, SIGCHLD
);
3792 /* Unblock target events. */
3793 linux_nat_async_events_enabled
= 1;
3795 local_event_queue_to_pipe ();
3796 /* While in masked async, we may have not collected all the
3797 pending events. Get them out now. */
3798 get_pending_events ();
3799 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
3803 /* Block target events. */
3804 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
3805 linux_nat_async_events_enabled
= 0;
3806 /* Get events out of queue, and make them available to
3807 queued_waitpid / my_waitpid. */
3808 pipe_to_local_event_queue ();
3812 return current_state
;
3815 static int async_terminal_is_ours
= 1;
3817 /* target_terminal_inferior implementation. */
3820 linux_nat_terminal_inferior (void)
3822 if (!target_is_async_p ())
3824 /* Async mode is disabled. */
3825 terminal_inferior ();
3829 /* GDB should never give the terminal to the inferior, if the
3830 inferior is running in the background (run&, continue&, etc.).
3831 This check can be removed when the common code is fixed. */
3832 if (!sync_execution
)
3835 terminal_inferior ();
3837 if (!async_terminal_is_ours
)
3840 delete_file_handler (input_fd
);
3841 async_terminal_is_ours
= 0;
3845 /* target_terminal_ours implementation. */
3848 linux_nat_terminal_ours (void)
3850 if (!target_is_async_p ())
3852 /* Async mode is disabled. */
3857 /* GDB should never give the terminal to the inferior if the
3858 inferior is running in the background (run&, continue&, etc.),
3859 but claiming it sure should. */
3862 if (!sync_execution
)
3865 if (async_terminal_is_ours
)
3868 clear_sigint_trap ();
3869 add_file_handler (input_fd
, stdin_event_handler
, 0);
3870 async_terminal_is_ours
= 1;
3873 static void (*async_client_callback
) (enum inferior_event_type event_type
,
3875 static void *async_client_context
;
3878 linux_nat_async_file_handler (int error
, gdb_client_data client_data
)
3880 async_client_callback (INF_REG_EVENT
, async_client_context
);
3883 /* target_async implementation. */
3886 linux_nat_async (void (*callback
) (enum inferior_event_type event_type
,
3887 void *context
), void *context
)
3889 if (linux_nat_async_mask_value
== 0 || !linux_nat_async_enabled
)
3890 internal_error (__FILE__
, __LINE__
,
3891 "Calling target_async when async is masked");
3893 if (callback
!= NULL
)
3895 async_client_callback
= callback
;
3896 async_client_context
= context
;
3897 add_file_handler (linux_nat_event_pipe
[0],
3898 linux_nat_async_file_handler
, NULL
);
3900 linux_nat_async_events (1);
3904 async_client_callback
= callback
;
3905 async_client_context
= context
;
3907 linux_nat_async_events (0);
3908 delete_file_handler (linux_nat_event_pipe
[0]);
3913 /* Enable/Disable async mode. */
3916 linux_nat_set_async_mode (int on
)
3918 if (linux_nat_async_enabled
!= on
)
3922 gdb_assert (waitpid_queue
== NULL
);
3923 sigaction (SIGCHLD
, &async_sigchld_action
, NULL
);
3925 if (pipe (linux_nat_event_pipe
) == -1)
3926 internal_error (__FILE__
, __LINE__
,
3927 "creating event pipe failed.");
3929 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
3930 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
3934 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
3936 drain_queued_events (-1);
3938 linux_nat_num_queued_events
= 0;
3939 close (linux_nat_event_pipe
[0]);
3940 close (linux_nat_event_pipe
[1]);
3941 linux_nat_event_pipe
[0] = linux_nat_event_pipe
[1] = -1;
3945 linux_nat_async_enabled
= on
;
3949 linux_nat_add_target (struct target_ops
*t
)
3951 /* Save the provided single-threaded target. We save this in a separate
3952 variable because another target we've inherited from (e.g. inf-ptrace)
3953 may have saved a pointer to T; we want to use it for the final
3954 process stratum target. */
3955 linux_ops_saved
= *t
;
3956 linux_ops
= &linux_ops_saved
;
3958 /* Override some methods for multithreading. */
3959 t
->to_create_inferior
= linux_nat_create_inferior
;
3960 t
->to_attach
= linux_nat_attach
;
3961 t
->to_detach
= linux_nat_detach
;
3962 t
->to_resume
= linux_nat_resume
;
3963 t
->to_wait
= linux_nat_wait
;
3964 t
->to_xfer_partial
= linux_nat_xfer_partial
;
3965 t
->to_kill
= linux_nat_kill
;
3966 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
3967 t
->to_thread_alive
= linux_nat_thread_alive
;
3968 t
->to_pid_to_str
= linux_nat_pid_to_str
;
3969 t
->to_has_thread_control
= tc_schedlock
;
3971 t
->to_can_async_p
= linux_nat_can_async_p
;
3972 t
->to_is_async_p
= linux_nat_is_async_p
;
3973 t
->to_async
= linux_nat_async
;
3974 t
->to_async_mask
= linux_nat_async_mask
;
3975 t
->to_terminal_inferior
= linux_nat_terminal_inferior
;
3976 t
->to_terminal_ours
= linux_nat_terminal_ours
;
3978 /* We don't change the stratum; this target will sit at
3979 process_stratum and thread_db will set at thread_stratum. This
3980 is a little strange, since this is a multi-threaded-capable
3981 target, but we want to be on the stack below thread_db, and we
3982 also want to be used for single-threaded processes. */
3986 /* TODO: Eliminate this and have libthread_db use
3987 find_target_beneath. */
3991 /* Register a method to call whenever a new thread is attached. */
3993 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
3995 /* Save the pointer. We only support a single registered instance
3996 of the GNU/Linux native target, so we do not need to map this to
3998 linux_nat_new_thread
= new_thread
;
4001 /* Return the saved siginfo associated with PTID. */
4003 linux_nat_get_siginfo (ptid_t ptid
)
4005 struct lwp_info
*lp
= find_lwp_pid (ptid
);
4007 gdb_assert (lp
!= NULL
);
4009 return &lp
->siginfo
;
4013 _initialize_linux_nat (void)
4017 add_info ("proc", linux_nat_info_proc_cmd
, _("\
4018 Show /proc process information about any running process.\n\
4019 Specify any process id, or use the program being debugged by default.\n\
4020 Specify any of the following keywords for detailed info:\n\
4021 mappings -- list of mapped memory regions.\n\
4022 stat -- list a bunch of random process info.\n\
4023 status -- list a different bunch of random process info.\n\
4024 all -- list all available /proc info."));
4026 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance
,
4027 &debug_linux_nat
, _("\
4028 Set debugging of GNU/Linux lwp module."), _("\
4029 Show debugging of GNU/Linux lwp module."), _("\
4030 Enables printf debugging output."),
4032 show_debug_linux_nat
,
4033 &setdebuglist
, &showdebuglist
);
4035 add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance
,
4036 &debug_linux_nat_async
, _("\
4037 Set debugging of GNU/Linux async lwp module."), _("\
4038 Show debugging of GNU/Linux async lwp module."), _("\
4039 Enables printf debugging output."),
4041 show_debug_linux_nat_async
,
4042 &setdebuglist
, &showdebuglist
);
4044 add_setshow_boolean_cmd ("linux-async", class_maintenance
,
4045 &linux_async_permitted_1
, _("\
4046 Set whether gdb controls the GNU/Linux inferior in asynchronous mode."), _("\
4047 Show whether gdb controls the GNU/Linux inferior in asynchronous mode."), _("\
4048 Tells gdb whether to control the GNU/Linux inferior in asynchronous mode."),
4049 set_maintenance_linux_async_permitted
,
4050 show_maintenance_linux_async_permitted
,
4051 &maintenance_set_cmdlist
,
4052 &maintenance_show_cmdlist
);
4054 /* Block SIGCHLD by default. Doing this early prevents it getting
4055 unblocked if an exception is thrown due to an error while the
4056 inferior is starting (sigsetjmp/siglongjmp). */
4057 sigemptyset (&mask
);
4058 sigaddset (&mask
, SIGCHLD
);
4059 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4061 /* Save this mask as the default. */
4062 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
4064 /* The synchronous SIGCHLD handler. */
4065 sync_sigchld_action
.sa_handler
= sigchld_handler
;
4066 sigemptyset (&sync_sigchld_action
.sa_mask
);
4067 sync_sigchld_action
.sa_flags
= SA_RESTART
;
4069 /* Make it the default. */
4070 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
4072 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4073 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
4074 sigdelset (&suspend_mask
, SIGCHLD
);
4076 /* SIGCHLD handler for async mode. */
4077 async_sigchld_action
.sa_handler
= async_sigchld_handler
;
4078 sigemptyset (&async_sigchld_action
.sa_mask
);
4079 async_sigchld_action
.sa_flags
= SA_RESTART
;
4081 /* Install the default mode. */
4082 linux_nat_set_async_mode (linux_async_permitted
);
4086 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4087 the GNU/Linux Threads library and therefore doesn't really belong
4090 /* Read variable NAME in the target and return its value if found.
4091 Otherwise return zero. It is assumed that the type of the variable
4095 get_signo (const char *name
)
4097 struct minimal_symbol
*ms
;
4100 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
4104 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
4105 sizeof (signo
)) != 0)
4111 /* Return the set of signals used by the threads library in *SET. */
4114 lin_thread_get_thread_signals (sigset_t
*set
)
4116 struct sigaction action
;
4117 int restart
, cancel
;
4118 sigset_t blocked_mask
;
4120 sigemptyset (&blocked_mask
);
4123 restart
= get_signo ("__pthread_sig_restart");
4124 cancel
= get_signo ("__pthread_sig_cancel");
4126 /* LinuxThreads normally uses the first two RT signals, but in some legacy
4127 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
4128 not provide any way for the debugger to query the signal numbers -
4129 fortunately they don't change! */
4132 restart
= __SIGRTMIN
;
4135 cancel
= __SIGRTMIN
+ 1;
4137 sigaddset (set
, restart
);
4138 sigaddset (set
, cancel
);
4140 /* The GNU/Linux Threads library makes terminating threads send a
4141 special "cancel" signal instead of SIGCHLD. Make sure we catch
4142 those (to prevent them from terminating GDB itself, which is
4143 likely to be their default action) and treat them the same way as
4146 action
.sa_handler
= sigchld_handler
;
4147 sigemptyset (&action
.sa_mask
);
4148 action
.sa_flags
= SA_RESTART
;
4149 sigaction (cancel
, &action
, NULL
);
4151 /* We block the "cancel" signal throughout this code ... */
4152 sigaddset (&blocked_mask
, cancel
);
4153 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
4155 /* ... except during a sigsuspend. */
4156 sigdelset (&suspend_mask
, cancel
);