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"
53 #ifdef HAVE_PERSONALITY
54 # include <sys/personality.h>
55 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
56 # define ADDR_NO_RANDOMIZE 0x0040000
58 #endif /* HAVE_PERSONALITY */
60 /* This comment documents high-level logic of this file.
62 Waiting for events in sync mode
63 ===============================
65 When waiting for an event in a specific thread, we just use waitpid, passing
66 the specific pid, and not passing WNOHANG.
68 When waiting for an event in all threads, waitpid is not quite good. Prior to
69 version 2.4, Linux can either wait for event in main thread, or in secondary
70 threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
71 miss an event. The solution is to use non-blocking waitpid, together with
72 sigsuspend. First, we use non-blocking waitpid to get an event in the main
73 process, if any. Second, we use non-blocking waitpid with the __WCLONED
74 flag to check for events in cloned processes. If nothing is found, we use
75 sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
76 happened to a child process -- and SIGCHLD will be delivered both for events
77 in main debugged process and in cloned processes. As soon as we know there's
78 an event, we get back to calling nonblocking waitpid with and without __WCLONED.
80 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
81 so that we don't miss a signal. If SIGCHLD arrives in between, when it's
82 blocked, the signal becomes pending and sigsuspend immediately
83 notices it and returns.
85 Waiting for events in async mode
86 ================================
88 In async mode, GDB should always be ready to handle both user input and target
89 events, so neither blocking waitpid nor sigsuspend are viable
90 options. Instead, we should notify the GDB main event loop whenever there's
91 unprocessed event from the target. The only way to notify this event loop is
92 to make it wait on input from a pipe, and write something to the pipe whenever
93 there's event. Obviously, if we fail to notify the event loop if there's
94 target event, it's bad. If we notify the event loop when there's no event
95 from target, linux-nat.c will detect that there's no event, actually, and
96 report event of type TARGET_WAITKIND_IGNORE, but it will waste time and
99 The main design point is that every time GDB is outside linux-nat.c, we have a
100 SIGCHLD handler installed that is called when something happens to the target
101 and notifies the GDB event loop. Also, the event is extracted from the target
102 using waitpid and stored for future use. Whenever GDB core decides to handle
103 the event, and calls into linux-nat.c, we disable SIGCHLD and process things
104 as in sync mode, except that before waitpid call we check if there are any
105 previously read events.
107 It could happen that during event processing, we'll try to get more events
108 than there are events in the local queue, which will result to waitpid call.
109 Those waitpid calls, while blocking, are guarantied to always have
110 something for waitpid to return. E.g., stopping a thread with SIGSTOP, and
111 waiting for the lwp to stop.
113 The event loop is notified about new events using a pipe. SIGCHLD handler does
114 waitpid and writes the results in to a pipe. GDB event loop has the other end
115 of the pipe among the sources. When event loop starts to process the event
116 and calls a function in linux-nat.c, all events from the pipe are transferred
117 into a local queue and SIGCHLD is blocked. Further processing goes as in sync
118 mode. Before we return from linux_nat_wait, we transfer all unprocessed events
119 from local queue back to the pipe, so that when we get back to event loop,
120 event loop will notice there's something more to do.
122 SIGCHLD is blocked when we're inside target_wait, so that should we actually
123 want to wait for some more events, SIGCHLD handler does not steal them from
124 us. Technically, it would be possible to add new events to the local queue but
125 it's about the same amount of work as blocking SIGCHLD.
127 This moving of events from pipe into local queue and back into pipe when we
128 enter/leave linux-nat.c is somewhat ugly. Unfortunately, GDB event loop is
129 home-grown and incapable to wait on any queue.
134 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
135 signal is not entirely significant; we just need for a signal to be delivered,
136 so that we can intercept it. SIGSTOP's advantage is that it can not be
137 blocked. A disadvantage is that it is not a real-time signal, so it can only
138 be queued once; we do not keep track of other sources of SIGSTOP.
140 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
141 use them, because they have special behavior when the signal is generated -
142 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
143 kills the entire thread group.
145 A delivered SIGSTOP would stop the entire thread group, not just the thread we
146 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
147 cancel it (by PTRACE_CONT without passing SIGSTOP).
149 We could use a real-time signal instead. This would solve those problems; we
150 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
151 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
152 generates it, and there are races with trying to find a signal that is not
156 #define O_LARGEFILE 0
159 /* If the system headers did not provide the constants, hard-code the normal
161 #ifndef PTRACE_EVENT_FORK
163 #define PTRACE_SETOPTIONS 0x4200
164 #define PTRACE_GETEVENTMSG 0x4201
166 /* options set using PTRACE_SETOPTIONS */
167 #define PTRACE_O_TRACESYSGOOD 0x00000001
168 #define PTRACE_O_TRACEFORK 0x00000002
169 #define PTRACE_O_TRACEVFORK 0x00000004
170 #define PTRACE_O_TRACECLONE 0x00000008
171 #define PTRACE_O_TRACEEXEC 0x00000010
172 #define PTRACE_O_TRACEVFORKDONE 0x00000020
173 #define PTRACE_O_TRACEEXIT 0x00000040
175 /* Wait extended result codes for the above trace options. */
176 #define PTRACE_EVENT_FORK 1
177 #define PTRACE_EVENT_VFORK 2
178 #define PTRACE_EVENT_CLONE 3
179 #define PTRACE_EVENT_EXEC 4
180 #define PTRACE_EVENT_VFORK_DONE 5
181 #define PTRACE_EVENT_EXIT 6
183 #endif /* PTRACE_EVENT_FORK */
185 /* We can't always assume that this flag is available, but all systems
186 with the ptrace event handlers also have __WALL, so it's safe to use
189 #define __WALL 0x40000000 /* Wait for any child. */
192 #ifndef PTRACE_GETSIGINFO
193 #define PTRACE_GETSIGINFO 0x4202
196 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
197 the use of the multi-threaded target. */
198 static struct target_ops
*linux_ops
;
199 static struct target_ops linux_ops_saved
;
201 /* The method to call, if any, when a new thread is attached. */
202 static void (*linux_nat_new_thread
) (ptid_t
);
204 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
205 Called by our to_xfer_partial. */
206 static LONGEST (*super_xfer_partial
) (struct target_ops
*,
208 const char *, gdb_byte
*,
212 static int debug_linux_nat
;
214 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
215 struct cmd_list_element
*c
, const char *value
)
217 fprintf_filtered (file
, _("Debugging of GNU/Linux lwp module is %s.\n"),
221 static int debug_linux_nat_async
= 0;
223 show_debug_linux_nat_async (struct ui_file
*file
, int from_tty
,
224 struct cmd_list_element
*c
, const char *value
)
226 fprintf_filtered (file
, _("Debugging of GNU/Linux async lwp module is %s.\n"),
230 static int disable_randomization
= 1;
233 show_disable_randomization (struct ui_file
*file
, int from_tty
,
234 struct cmd_list_element
*c
, const char *value
)
236 #ifdef HAVE_PERSONALITY
237 fprintf_filtered (file
, _("\
238 Disabling randomization of debuggee's virtual address space is %s.\n"),
240 #else /* !HAVE_PERSONALITY */
242 Disabling randomization of debuggee's virtual address space is unsupported on\n\
243 this platform.\n"), file
);
244 #endif /* !HAVE_PERSONALITY */
248 set_disable_randomization (char *args
, int from_tty
, struct cmd_list_element
*c
)
250 #ifndef HAVE_PERSONALITY
252 Disabling randomization of debuggee's virtual address space is unsupported on\n\
254 #endif /* !HAVE_PERSONALITY */
257 static int linux_parent_pid
;
259 struct simple_pid_list
263 struct simple_pid_list
*next
;
265 struct simple_pid_list
*stopped_pids
;
267 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
268 can not be used, 1 if it can. */
270 static int linux_supports_tracefork_flag
= -1;
272 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
273 PTRACE_O_TRACEVFORKDONE. */
275 static int linux_supports_tracevforkdone_flag
= -1;
277 /* Async mode support */
279 /* True if async mode is currently on. */
280 static int linux_nat_async_enabled
;
282 /* Zero if the async mode, although enabled, is masked, which means
283 linux_nat_wait should behave as if async mode was off. */
284 static int linux_nat_async_mask_value
= 1;
286 /* The read/write ends of the pipe registered as waitable file in the
288 static int linux_nat_event_pipe
[2] = { -1, -1 };
290 /* Number of queued events in the pipe. */
291 static volatile int linux_nat_num_queued_events
;
293 /* The possible SIGCHLD handling states. */
297 /* SIGCHLD disabled, with action set to sigchld_handler, for the
298 sigsuspend in linux_nat_wait. */
300 /* SIGCHLD enabled, with action set to async_sigchld_handler. */
302 /* Set SIGCHLD to default action. Used while creating an
307 /* The current SIGCHLD handling state. */
308 static enum sigchld_state linux_nat_async_events_state
;
310 static enum sigchld_state
linux_nat_async_events (enum sigchld_state enable
);
311 static void pipe_to_local_event_queue (void);
312 static void local_event_queue_to_pipe (void);
313 static void linux_nat_event_pipe_push (int pid
, int status
, int options
);
314 static int linux_nat_event_pipe_pop (int* ptr_status
, int* ptr_options
);
315 static void linux_nat_set_async_mode (int on
);
316 static void linux_nat_async (void (*callback
)
317 (enum inferior_event_type event_type
, void *context
),
319 static int linux_nat_async_mask (int mask
);
320 static int kill_lwp (int lwpid
, int signo
);
322 static int send_sigint_callback (struct lwp_info
*lp
, void *data
);
323 static int stop_callback (struct lwp_info
*lp
, void *data
);
325 /* Captures the result of a successful waitpid call, along with the
326 options used in that call. */
327 struct waitpid_result
332 struct waitpid_result
*next
;
335 /* A singly-linked list of the results of the waitpid calls performed
336 in the async SIGCHLD handler. */
337 static struct waitpid_result
*waitpid_queue
= NULL
;
340 queued_waitpid (int pid
, int *status
, int flags
)
342 struct waitpid_result
*msg
= waitpid_queue
, *prev
= NULL
;
344 if (debug_linux_nat_async
)
345 fprintf_unfiltered (gdb_stdlog
,
347 QWPID: linux_nat_async_events_state(%d), linux_nat_num_queued_events(%d)\n",
348 linux_nat_async_events_state
,
349 linux_nat_num_queued_events
);
353 for (; msg
; prev
= msg
, msg
= msg
->next
)
354 if (pid
== -1 || pid
== msg
->pid
)
357 else if (flags
& __WCLONE
)
359 for (; msg
; prev
= msg
, msg
= msg
->next
)
360 if (msg
->options
& __WCLONE
361 && (pid
== -1 || pid
== msg
->pid
))
366 for (; msg
; prev
= msg
, msg
= msg
->next
)
367 if ((msg
->options
& __WCLONE
) == 0
368 && (pid
== -1 || pid
== msg
->pid
))
377 prev
->next
= msg
->next
;
379 waitpid_queue
= msg
->next
;
383 *status
= msg
->status
;
386 if (debug_linux_nat_async
)
387 fprintf_unfiltered (gdb_stdlog
, "QWPID: pid(%d), status(%x)\n",
394 if (debug_linux_nat_async
)
395 fprintf_unfiltered (gdb_stdlog
, "QWPID: miss\n");
403 push_waitpid (int pid
, int status
, int options
)
405 struct waitpid_result
*event
, *new_event
;
407 new_event
= xmalloc (sizeof (*new_event
));
408 new_event
->pid
= pid
;
409 new_event
->status
= status
;
410 new_event
->options
= options
;
411 new_event
->next
= NULL
;
415 for (event
= waitpid_queue
;
416 event
&& event
->next
;
420 event
->next
= new_event
;
423 waitpid_queue
= new_event
;
426 /* Drain all queued events of PID. If PID is -1, the effect is of
427 draining all events. */
429 drain_queued_events (int pid
)
431 while (queued_waitpid (pid
, NULL
, __WALL
) != -1)
436 /* Trivial list manipulation functions to keep track of a list of
437 new stopped processes. */
439 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
441 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
443 new_pid
->status
= status
;
444 new_pid
->next
= *listp
;
449 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *status
)
451 struct simple_pid_list
**p
;
453 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
454 if ((*p
)->pid
== pid
)
456 struct simple_pid_list
*next
= (*p
)->next
;
457 *status
= (*p
)->status
;
466 linux_record_stopped_pid (int pid
, int status
)
468 add_to_pid_list (&stopped_pids
, pid
, status
);
472 /* A helper function for linux_test_for_tracefork, called after fork (). */
475 linux_tracefork_child (void)
479 ptrace (PTRACE_TRACEME
, 0, 0, 0);
480 kill (getpid (), SIGSTOP
);
485 /* Wrapper function for waitpid which handles EINTR, and checks for
486 locally queued events. */
489 my_waitpid (int pid
, int *status
, int flags
)
493 /* There should be no concurrent calls to waitpid. */
494 gdb_assert (linux_nat_async_events_state
== sigchld_sync
);
496 ret
= queued_waitpid (pid
, status
, flags
);
502 ret
= waitpid (pid
, status
, flags
);
504 while (ret
== -1 && errno
== EINTR
);
509 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
511 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
512 we know that the feature is not available. This may change the tracing
513 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
515 However, if it succeeds, we don't know for sure that the feature is
516 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
517 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
518 fork tracing, and let it fork. If the process exits, we assume that we
519 can't use TRACEFORK; if we get the fork notification, and we can extract
520 the new child's PID, then we assume that we can. */
523 linux_test_for_tracefork (int original_pid
)
525 int child_pid
, ret
, status
;
527 enum sigchld_state async_events_original_state
;
529 async_events_original_state
= linux_nat_async_events (sigchld_sync
);
531 linux_supports_tracefork_flag
= 0;
532 linux_supports_tracevforkdone_flag
= 0;
534 ret
= ptrace (PTRACE_SETOPTIONS
, original_pid
, 0, PTRACE_O_TRACEFORK
);
540 perror_with_name (("fork"));
543 linux_tracefork_child ();
545 ret
= my_waitpid (child_pid
, &status
, 0);
547 perror_with_name (("waitpid"));
548 else if (ret
!= child_pid
)
549 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret
);
550 if (! WIFSTOPPED (status
))
551 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status
);
553 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
556 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
559 warning (_("linux_test_for_tracefork: failed to kill child"));
560 linux_nat_async_events (async_events_original_state
);
564 ret
= my_waitpid (child_pid
, &status
, 0);
565 if (ret
!= child_pid
)
566 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
567 else if (!WIFSIGNALED (status
))
568 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
569 "killed child"), status
);
571 linux_nat_async_events (async_events_original_state
);
575 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
576 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0,
577 PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORKDONE
);
578 linux_supports_tracevforkdone_flag
= (ret
== 0);
580 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
582 warning (_("linux_test_for_tracefork: failed to resume child"));
584 ret
= my_waitpid (child_pid
, &status
, 0);
586 if (ret
== child_pid
&& WIFSTOPPED (status
)
587 && status
>> 16 == PTRACE_EVENT_FORK
)
590 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
591 if (ret
== 0 && second_pid
!= 0)
595 linux_supports_tracefork_flag
= 1;
596 my_waitpid (second_pid
, &second_status
, 0);
597 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
599 warning (_("linux_test_for_tracefork: failed to kill second child"));
600 my_waitpid (second_pid
, &status
, 0);
604 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
605 "(%d, status 0x%x)"), ret
, status
);
607 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
609 warning (_("linux_test_for_tracefork: failed to kill child"));
610 my_waitpid (child_pid
, &status
, 0);
612 linux_nat_async_events (async_events_original_state
);
615 /* Return non-zero iff we have tracefork functionality available.
616 This function also sets linux_supports_tracefork_flag. */
619 linux_supports_tracefork (int pid
)
621 if (linux_supports_tracefork_flag
== -1)
622 linux_test_for_tracefork (pid
);
623 return linux_supports_tracefork_flag
;
627 linux_supports_tracevforkdone (int pid
)
629 if (linux_supports_tracefork_flag
== -1)
630 linux_test_for_tracefork (pid
);
631 return linux_supports_tracevforkdone_flag
;
636 linux_enable_event_reporting (ptid_t ptid
)
638 int pid
= ptid_get_lwp (ptid
);
642 pid
= ptid_get_pid (ptid
);
644 if (! linux_supports_tracefork (pid
))
647 options
= PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEEXEC
648 | PTRACE_O_TRACECLONE
;
649 if (linux_supports_tracevforkdone (pid
))
650 options
|= PTRACE_O_TRACEVFORKDONE
;
652 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
653 read-only process state. */
655 ptrace (PTRACE_SETOPTIONS
, pid
, 0, options
);
659 linux_child_post_attach (int pid
)
661 linux_enable_event_reporting (pid_to_ptid (pid
));
662 check_for_thread_db ();
666 linux_child_post_startup_inferior (ptid_t ptid
)
668 linux_enable_event_reporting (ptid
);
669 check_for_thread_db ();
673 linux_child_follow_fork (struct target_ops
*ops
, int follow_child
)
676 struct target_waitstatus last_status
;
678 int parent_pid
, child_pid
;
680 if (target_can_async_p ())
681 target_async (NULL
, 0);
683 get_last_target_status (&last_ptid
, &last_status
);
684 has_vforked
= (last_status
.kind
== TARGET_WAITKIND_VFORKED
);
685 parent_pid
= ptid_get_lwp (last_ptid
);
687 parent_pid
= ptid_get_pid (last_ptid
);
688 child_pid
= PIDGET (last_status
.value
.related_pid
);
692 /* We're already attached to the parent, by default. */
694 /* Before detaching from the child, remove all breakpoints from
695 it. (This won't actually modify the breakpoint list, but will
696 physically remove the breakpoints from the child.) */
697 /* If we vforked this will remove the breakpoints from the parent
698 also, but they'll be reinserted below. */
699 detach_breakpoints (child_pid
);
701 /* Detach new forked process? */
704 if (info_verbose
|| debug_linux_nat
)
706 target_terminal_ours ();
707 fprintf_filtered (gdb_stdlog
,
708 "Detaching after fork from child process %d.\n",
712 ptrace (PTRACE_DETACH
, child_pid
, 0, 0);
716 struct fork_info
*fp
;
717 /* Retain child fork in ptrace (stopped) state. */
718 fp
= find_fork_pid (child_pid
);
720 fp
= add_fork (child_pid
);
721 fork_save_infrun_state (fp
, 0);
726 gdb_assert (linux_supports_tracefork_flag
>= 0);
727 if (linux_supports_tracevforkdone (0))
731 ptrace (PTRACE_CONT
, parent_pid
, 0, 0);
732 my_waitpid (parent_pid
, &status
, __WALL
);
733 if ((status
>> 16) != PTRACE_EVENT_VFORK_DONE
)
734 warning (_("Unexpected waitpid result %06x when waiting for "
735 "vfork-done"), status
);
739 /* We can't insert breakpoints until the child has
740 finished with the shared memory region. We need to
741 wait until that happens. Ideal would be to just
743 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
744 - waitpid (parent_pid, &status, __WALL);
745 However, most architectures can't handle a syscall
746 being traced on the way out if it wasn't traced on
749 We might also think to loop, continuing the child
750 until it exits or gets a SIGTRAP. One problem is
751 that the child might call ptrace with PTRACE_TRACEME.
753 There's no simple and reliable way to figure out when
754 the vforked child will be done with its copy of the
755 shared memory. We could step it out of the syscall,
756 two instructions, let it go, and then single-step the
757 parent once. When we have hardware single-step, this
758 would work; with software single-step it could still
759 be made to work but we'd have to be able to insert
760 single-step breakpoints in the child, and we'd have
761 to insert -just- the single-step breakpoint in the
762 parent. Very awkward.
764 In the end, the best we can do is to make sure it
765 runs for a little while. Hopefully it will be out of
766 range of any breakpoints we reinsert. Usually this
767 is only the single-step breakpoint at vfork's return
773 /* Since we vforked, breakpoints were removed in the parent
774 too. Put them back. */
775 reattach_breakpoints (parent_pid
);
780 char child_pid_spelling
[40];
782 /* Needed to keep the breakpoint lists in sync. */
784 detach_breakpoints (child_pid
);
786 /* Before detaching from the parent, remove all breakpoints from it. */
787 remove_breakpoints ();
789 if (info_verbose
|| debug_linux_nat
)
791 target_terminal_ours ();
792 fprintf_filtered (gdb_stdlog
,
793 "Attaching after fork to child process %d.\n",
797 /* If we're vforking, we may want to hold on to the parent until
798 the child exits or execs. At exec time we can remove the old
799 breakpoints from the parent and detach it; at exit time we
800 could do the same (or even, sneakily, resume debugging it - the
801 child's exec has failed, or something similar).
803 This doesn't clean up "properly", because we can't call
804 target_detach, but that's OK; if the current target is "child",
805 then it doesn't need any further cleanups, and lin_lwp will
806 generally not encounter vfork (vfork is defined to fork
809 The holding part is very easy if we have VFORKDONE events;
810 but keeping track of both processes is beyond GDB at the
811 moment. So we don't expose the parent to the rest of GDB.
812 Instead we quietly hold onto it until such time as we can
816 linux_parent_pid
= parent_pid
;
817 else if (!detach_fork
)
819 struct fork_info
*fp
;
820 /* Retain parent fork in ptrace (stopped) state. */
821 fp
= find_fork_pid (parent_pid
);
823 fp
= add_fork (parent_pid
);
824 fork_save_infrun_state (fp
, 0);
827 target_detach (NULL
, 0);
829 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
831 /* Reinstall ourselves, since we might have been removed in
832 target_detach (which does other necessary cleanup). */
835 linux_nat_switch_fork (inferior_ptid
);
836 check_for_thread_db ();
838 /* Reset breakpoints in the child as appropriate. */
839 follow_inferior_reset_breakpoints ();
842 if (target_can_async_p ())
843 target_async (inferior_event_handler
, 0);
850 linux_child_insert_fork_catchpoint (int pid
)
852 if (! linux_supports_tracefork (pid
))
853 error (_("Your system does not support fork catchpoints."));
857 linux_child_insert_vfork_catchpoint (int pid
)
859 if (!linux_supports_tracefork (pid
))
860 error (_("Your system does not support vfork catchpoints."));
864 linux_child_insert_exec_catchpoint (int pid
)
866 if (!linux_supports_tracefork (pid
))
867 error (_("Your system does not support exec catchpoints."));
870 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
871 are processes sharing the same VM space. A multi-threaded process
872 is basically a group of such processes. However, such a grouping
873 is almost entirely a user-space issue; the kernel doesn't enforce
874 such a grouping at all (this might change in the future). In
875 general, we'll rely on the threads library (i.e. the GNU/Linux
876 Threads library) to provide such a grouping.
878 It is perfectly well possible to write a multi-threaded application
879 without the assistance of a threads library, by using the clone
880 system call directly. This module should be able to give some
881 rudimentary support for debugging such applications if developers
882 specify the CLONE_PTRACE flag in the clone system call, and are
883 using the Linux kernel 2.4 or above.
885 Note that there are some peculiarities in GNU/Linux that affect
888 - In general one should specify the __WCLONE flag to waitpid in
889 order to make it report events for any of the cloned processes
890 (and leave it out for the initial process). However, if a cloned
891 process has exited the exit status is only reported if the
892 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
893 we cannot use it since GDB must work on older systems too.
895 - When a traced, cloned process exits and is waited for by the
896 debugger, the kernel reassigns it to the original parent and
897 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
898 library doesn't notice this, which leads to the "zombie problem":
899 When debugged a multi-threaded process that spawns a lot of
900 threads will run out of processes, even if the threads exit,
901 because the "zombies" stay around. */
903 /* List of known LWPs. */
904 struct lwp_info
*lwp_list
;
906 /* Number of LWPs in the list. */
910 /* Original signal mask. */
911 static sigset_t normal_mask
;
913 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
914 _initialize_linux_nat. */
915 static sigset_t suspend_mask
;
917 /* SIGCHLD action for synchronous mode. */
918 struct sigaction sync_sigchld_action
;
920 /* SIGCHLD action for asynchronous mode. */
921 static struct sigaction async_sigchld_action
;
923 /* SIGCHLD default action, to pass to new inferiors. */
924 static struct sigaction sigchld_default_action
;
927 /* Prototypes for local functions. */
928 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
929 static int linux_nat_thread_alive (ptid_t ptid
);
930 static char *linux_child_pid_to_exec_file (int pid
);
931 static int cancel_breakpoint (struct lwp_info
*lp
);
934 /* Convert wait status STATUS to a string. Used for printing debug
938 status_to_str (int status
)
942 if (WIFSTOPPED (status
))
943 snprintf (buf
, sizeof (buf
), "%s (stopped)",
944 strsignal (WSTOPSIG (status
)));
945 else if (WIFSIGNALED (status
))
946 snprintf (buf
, sizeof (buf
), "%s (terminated)",
947 strsignal (WSTOPSIG (status
)));
949 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
954 /* Initialize the list of LWPs. Note that this module, contrary to
955 what GDB's generic threads layer does for its thread list,
956 re-initializes the LWP lists whenever we mourn or detach (which
957 doesn't involve mourning) the inferior. */
962 struct lwp_info
*lp
, *lpnext
;
964 for (lp
= lwp_list
; lp
; lp
= lpnext
)
974 /* Add the LWP specified by PID to the list. Return a pointer to the
975 structure describing the new LWP. The LWP should already be stopped
976 (with an exception for the very first LWP). */
978 static struct lwp_info
*
979 add_lwp (ptid_t ptid
)
983 gdb_assert (is_lwp (ptid
));
985 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
987 memset (lp
, 0, sizeof (struct lwp_info
));
989 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
997 if (num_lwps
> 1 && linux_nat_new_thread
!= NULL
)
998 linux_nat_new_thread (ptid
);
1003 /* Remove the LWP specified by PID from the list. */
1006 delete_lwp (ptid_t ptid
)
1008 struct lwp_info
*lp
, *lpprev
;
1012 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
1013 if (ptid_equal (lp
->ptid
, ptid
))
1022 lpprev
->next
= lp
->next
;
1024 lwp_list
= lp
->next
;
1029 /* Return a pointer to the structure describing the LWP corresponding
1030 to PID. If no corresponding LWP could be found, return NULL. */
1032 static struct lwp_info
*
1033 find_lwp_pid (ptid_t ptid
)
1035 struct lwp_info
*lp
;
1039 lwp
= GET_LWP (ptid
);
1041 lwp
= GET_PID (ptid
);
1043 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
1044 if (lwp
== GET_LWP (lp
->ptid
))
1050 /* Call CALLBACK with its second argument set to DATA for every LWP in
1051 the list. If CALLBACK returns 1 for a particular LWP, return a
1052 pointer to the structure describing that LWP immediately.
1053 Otherwise return NULL. */
1056 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
1058 struct lwp_info
*lp
, *lpnext
;
1060 for (lp
= lwp_list
; lp
; lp
= lpnext
)
1063 if ((*callback
) (lp
, data
))
1070 /* Update our internal state when changing from one fork (checkpoint,
1071 et cetera) to another indicated by NEW_PTID. We can only switch
1072 single-threaded applications, so we only create one new LWP, and
1073 the previous list is discarded. */
1076 linux_nat_switch_fork (ptid_t new_ptid
)
1078 struct lwp_info
*lp
;
1081 lp
= add_lwp (new_ptid
);
1084 init_thread_list ();
1085 add_thread_silent (new_ptid
);
1088 /* Handle the exit of a single thread LP. */
1091 exit_lwp (struct lwp_info
*lp
)
1093 struct thread_info
*th
= find_thread_pid (lp
->ptid
);
1097 if (print_thread_events
)
1098 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp
->ptid
));
1100 delete_thread (lp
->ptid
);
1103 delete_lwp (lp
->ptid
);
1106 /* Detect `T (stopped)' in `/proc/PID/status'.
1107 Other states including `T (tracing stop)' are reported as false. */
1110 pid_is_stopped (pid_t pid
)
1116 snprintf (buf
, sizeof (buf
), "/proc/%d/status", (int) pid
);
1117 status_file
= fopen (buf
, "r");
1118 if (status_file
!= NULL
)
1122 while (fgets (buf
, sizeof (buf
), status_file
))
1124 if (strncmp (buf
, "State:", 6) == 0)
1130 if (have_state
&& strstr (buf
, "T (stopped)") != NULL
)
1132 fclose (status_file
);
1137 /* Wait for the LWP specified by LP, which we have just attached to.
1138 Returns a wait status for that LWP, to cache. */
1141 linux_nat_post_attach_wait (ptid_t ptid
, int first
, int *cloned
,
1144 pid_t new_pid
, pid
= GET_LWP (ptid
);
1147 if (pid_is_stopped (pid
))
1149 if (debug_linux_nat
)
1150 fprintf_unfiltered (gdb_stdlog
,
1151 "LNPAW: Attaching to a stopped process\n");
1153 /* The process is definitely stopped. It is in a job control
1154 stop, unless the kernel predates the TASK_STOPPED /
1155 TASK_TRACED distinction, in which case it might be in a
1156 ptrace stop. Make sure it is in a ptrace stop; from there we
1157 can kill it, signal it, et cetera.
1159 First make sure there is a pending SIGSTOP. Since we are
1160 already attached, the process can not transition from stopped
1161 to running without a PTRACE_CONT; so we know this signal will
1162 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1163 probably already in the queue (unless this kernel is old
1164 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1165 is not an RT signal, it can only be queued once. */
1166 kill_lwp (pid
, SIGSTOP
);
1168 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1169 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1170 ptrace (PTRACE_CONT
, pid
, 0, 0);
1173 /* Make sure the initial process is stopped. The user-level threads
1174 layer might want to poke around in the inferior, and that won't
1175 work if things haven't stabilized yet. */
1176 new_pid
= my_waitpid (pid
, &status
, 0);
1177 if (new_pid
== -1 && errno
== ECHILD
)
1180 warning (_("%s is a cloned process"), target_pid_to_str (ptid
));
1182 /* Try again with __WCLONE to check cloned processes. */
1183 new_pid
= my_waitpid (pid
, &status
, __WCLONE
);
1187 gdb_assert (pid
== new_pid
&& WIFSTOPPED (status
));
1189 if (WSTOPSIG (status
) != SIGSTOP
)
1192 if (debug_linux_nat
)
1193 fprintf_unfiltered (gdb_stdlog
,
1194 "LNPAW: Received %s after attaching\n",
1195 status_to_str (status
));
1201 /* Attach to the LWP specified by PID. Return 0 if successful or -1
1202 if the new LWP could not be attached. */
1205 lin_lwp_attach_lwp (ptid_t ptid
)
1207 struct lwp_info
*lp
;
1208 enum sigchld_state async_events_original_state
;
1210 gdb_assert (is_lwp (ptid
));
1212 async_events_original_state
= linux_nat_async_events (sigchld_sync
);
1214 lp
= find_lwp_pid (ptid
);
1216 /* We assume that we're already attached to any LWP that has an id
1217 equal to the overall process id, and to any LWP that is already
1218 in our list of LWPs. If we're not seeing exit events from threads
1219 and we've had PID wraparound since we last tried to stop all threads,
1220 this assumption might be wrong; fortunately, this is very unlikely
1222 if (GET_LWP (ptid
) != GET_PID (ptid
) && lp
== NULL
)
1224 int status
, cloned
= 0, signalled
= 0;
1226 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
1228 /* If we fail to attach to the thread, issue a warning,
1229 but continue. One way this can happen is if thread
1230 creation is interrupted; as of Linux kernel 2.6.19, a
1231 bug may place threads in the thread list and then fail
1233 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
1234 safe_strerror (errno
));
1238 if (debug_linux_nat
)
1239 fprintf_unfiltered (gdb_stdlog
,
1240 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1241 target_pid_to_str (ptid
));
1243 status
= linux_nat_post_attach_wait (ptid
, 0, &cloned
, &signalled
);
1244 lp
= add_lwp (ptid
);
1246 lp
->cloned
= cloned
;
1247 lp
->signalled
= signalled
;
1248 if (WSTOPSIG (status
) != SIGSTOP
)
1251 lp
->status
= status
;
1254 target_post_attach (GET_LWP (lp
->ptid
));
1256 if (debug_linux_nat
)
1258 fprintf_unfiltered (gdb_stdlog
,
1259 "LLAL: waitpid %s received %s\n",
1260 target_pid_to_str (ptid
),
1261 status_to_str (status
));
1266 /* We assume that the LWP representing the original process is
1267 already stopped. Mark it as stopped in the data structure
1268 that the GNU/linux ptrace layer uses to keep track of
1269 threads. Note that this won't have already been done since
1270 the main thread will have, we assume, been stopped by an
1271 attach from a different layer. */
1273 lp
= add_lwp (ptid
);
1277 linux_nat_async_events (async_events_original_state
);
1282 linux_nat_create_inferior (char *exec_file
, char *allargs
, char **env
,
1285 int saved_async
= 0;
1286 #ifdef HAVE_PERSONALITY
1287 int personality_orig
= 0, personality_set
= 0;
1288 #endif /* HAVE_PERSONALITY */
1290 /* The fork_child mechanism is synchronous and calls target_wait, so
1291 we have to mask the async mode. */
1293 if (target_can_async_p ())
1294 /* Mask async mode. Creating a child requires a loop calling
1295 wait_for_inferior currently. */
1296 saved_async
= linux_nat_async_mask (0);
1299 /* Restore the original signal mask. */
1300 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1301 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1302 suspend_mask
= normal_mask
;
1303 sigdelset (&suspend_mask
, SIGCHLD
);
1306 /* Set SIGCHLD to the default action, until after execing the child,
1307 since the inferior inherits the superior's signal mask. It will
1308 be blocked again in linux_nat_wait, which is only reached after
1309 the inferior execing. */
1310 linux_nat_async_events (sigchld_default
);
1312 #ifdef HAVE_PERSONALITY
1313 if (disable_randomization
)
1316 personality_orig
= personality (0xffffffff);
1317 if (errno
== 0 && !(personality_orig
& ADDR_NO_RANDOMIZE
))
1319 personality_set
= 1;
1320 personality (personality_orig
| ADDR_NO_RANDOMIZE
);
1322 if (errno
!= 0 || (personality_set
1323 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE
)))
1324 warning (_("Error disabling address space randomization: %s"),
1325 safe_strerror (errno
));
1327 #endif /* HAVE_PERSONALITY */
1329 linux_ops
->to_create_inferior (exec_file
, allargs
, env
, from_tty
);
1331 #ifdef HAVE_PERSONALITY
1332 if (personality_set
)
1335 personality (personality_orig
);
1337 warning (_("Error restoring address space randomization: %s"),
1338 safe_strerror (errno
));
1340 #endif /* HAVE_PERSONALITY */
1343 linux_nat_async_mask (saved_async
);
1347 linux_nat_attach (char *args
, int from_tty
)
1349 struct lwp_info
*lp
;
1352 /* FIXME: We should probably accept a list of process id's, and
1353 attach all of them. */
1354 linux_ops
->to_attach (args
, from_tty
);
1356 if (!target_can_async_p ())
1358 /* Restore the original signal mask. */
1359 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1360 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1361 suspend_mask
= normal_mask
;
1362 sigdelset (&suspend_mask
, SIGCHLD
);
1365 /* Add the initial process as the first LWP to the list. */
1366 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
));
1367 lp
= add_lwp (inferior_ptid
);
1369 status
= linux_nat_post_attach_wait (lp
->ptid
, 1, &lp
->cloned
,
1373 /* If this process is not using thread_db, then we still don't
1374 detect any other threads, but add at least this one. */
1375 add_thread_silent (lp
->ptid
);
1377 /* Save the wait status to report later. */
1379 if (debug_linux_nat
)
1380 fprintf_unfiltered (gdb_stdlog
,
1381 "LNA: waitpid %ld, saving status %s\n",
1382 (long) GET_PID (lp
->ptid
), status_to_str (status
));
1384 if (!target_can_async_p ())
1385 lp
->status
= status
;
1388 /* We already waited for this LWP, so put the wait result on the
1389 pipe. The event loop will wake up and gets us to handling
1391 linux_nat_event_pipe_push (GET_PID (lp
->ptid
), status
,
1392 lp
->cloned
? __WCLONE
: 0);
1393 /* Register in the event loop. */
1394 target_async (inferior_event_handler
, 0);
1398 /* Get pending status of LP. */
1400 get_pending_status (struct lwp_info
*lp
, int *status
)
1402 struct target_waitstatus last
;
1405 get_last_target_status (&last_ptid
, &last
);
1407 /* If this lwp is the ptid that GDB is processing an event from, the
1408 signal will be in stop_signal. Otherwise, in all-stop + sync
1409 mode, we may cache pending events in lp->status while trying to
1410 stop all threads (see stop_wait_callback). In async mode, the
1411 events are always cached in waitpid_queue. */
1417 enum target_signal signo
= TARGET_SIGNAL_0
;
1419 if (is_executing (lp
->ptid
))
1421 /* If the core thought this lwp was executing --- e.g., the
1422 executing property hasn't been updated yet, but the
1423 thread has been stopped with a stop_callback /
1424 stop_wait_callback sequence (see linux_nat_detach for
1425 example) --- we can only have pending events in the local
1427 if (queued_waitpid (GET_LWP (lp
->ptid
), status
, __WALL
) != -1)
1429 if (WIFSTOPPED (status
))
1430 signo
= target_signal_from_host (WSTOPSIG (status
));
1432 /* If not stopped, then the lwp is gone, no use in
1433 resending a signal. */
1438 /* If the core knows the thread is not executing, then we
1439 have the last signal recorded in
1440 thread_info->stop_signal, unless this is inferior_ptid,
1441 in which case, it's in the global stop_signal, due to
1442 context switching. */
1444 if (ptid_equal (lp
->ptid
, inferior_ptid
))
1445 signo
= stop_signal
;
1448 struct thread_info
*tp
= find_thread_pid (lp
->ptid
);
1450 signo
= tp
->stop_signal
;
1454 if (signo
!= TARGET_SIGNAL_0
1455 && !signal_pass_state (signo
))
1457 if (debug_linux_nat
)
1458 fprintf_unfiltered (gdb_stdlog
, "\
1459 GPT: lwp %s had signal %s, but it is in no pass state\n",
1460 target_pid_to_str (lp
->ptid
),
1461 target_signal_to_string (signo
));
1465 if (signo
!= TARGET_SIGNAL_0
)
1466 *status
= W_STOPCODE (target_signal_to_host (signo
));
1468 if (debug_linux_nat
)
1469 fprintf_unfiltered (gdb_stdlog
,
1470 "GPT: lwp %s as pending signal %s\n",
1471 target_pid_to_str (lp
->ptid
),
1472 target_signal_to_string (signo
));
1477 if (GET_LWP (lp
->ptid
) == GET_LWP (last_ptid
))
1479 if (stop_signal
!= TARGET_SIGNAL_0
1480 && signal_pass_state (stop_signal
))
1481 *status
= W_STOPCODE (target_signal_to_host (stop_signal
));
1483 else if (target_can_async_p ())
1484 queued_waitpid (GET_LWP (lp
->ptid
), status
, __WALL
);
1486 *status
= lp
->status
;
1493 detach_callback (struct lwp_info
*lp
, void *data
)
1495 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1497 if (debug_linux_nat
&& lp
->status
)
1498 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
1499 strsignal (WSTOPSIG (lp
->status
)),
1500 target_pid_to_str (lp
->ptid
));
1502 /* If there is a pending SIGSTOP, get rid of it. */
1505 if (debug_linux_nat
)
1506 fprintf_unfiltered (gdb_stdlog
,
1507 "DC: Sending SIGCONT to %s\n",
1508 target_pid_to_str (lp
->ptid
));
1510 kill_lwp (GET_LWP (lp
->ptid
), SIGCONT
);
1514 /* We don't actually detach from the LWP that has an id equal to the
1515 overall process id just yet. */
1516 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
1520 /* Pass on any pending signal for this LWP. */
1521 get_pending_status (lp
, &status
);
1524 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
1525 WSTOPSIG (status
)) < 0)
1526 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1527 safe_strerror (errno
));
1529 if (debug_linux_nat
)
1530 fprintf_unfiltered (gdb_stdlog
,
1531 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1532 target_pid_to_str (lp
->ptid
),
1533 strsignal (WSTOPSIG (lp
->status
)));
1535 delete_lwp (lp
->ptid
);
1542 linux_nat_detach (char *args
, int from_tty
)
1546 enum target_signal sig
;
1548 if (target_can_async_p ())
1549 linux_nat_async (NULL
, 0);
1551 /* Stop all threads before detaching. ptrace requires that the
1552 thread is stopped to sucessfully detach. */
1553 iterate_over_lwps (stop_callback
, NULL
);
1554 /* ... and wait until all of them have reported back that
1555 they're no longer running. */
1556 iterate_over_lwps (stop_wait_callback
, NULL
);
1558 iterate_over_lwps (detach_callback
, NULL
);
1560 /* Only the initial process should be left right now. */
1561 gdb_assert (num_lwps
== 1);
1563 /* Pass on any pending signal for the last LWP. */
1564 if ((args
== NULL
|| *args
== '\0')
1565 && get_pending_status (lwp_list
, &status
) != -1
1566 && WIFSTOPPED (status
))
1568 /* Put the signal number in ARGS so that inf_ptrace_detach will
1569 pass it along with PTRACE_DETACH. */
1571 sprintf (args
, "%d", (int) WSTOPSIG (status
));
1572 fprintf_unfiltered (gdb_stdlog
,
1573 "LND: Sending signal %s to %s\n",
1575 target_pid_to_str (lwp_list
->ptid
));
1578 /* Destroy LWP info; it's no longer valid. */
1581 pid
= GET_PID (inferior_ptid
);
1582 inferior_ptid
= pid_to_ptid (pid
);
1583 linux_ops
->to_detach (args
, from_tty
);
1585 if (target_can_async_p ())
1586 drain_queued_events (pid
);
1592 resume_callback (struct lwp_info
*lp
, void *data
)
1594 if (lp
->stopped
&& lp
->status
== 0)
1596 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
1597 0, TARGET_SIGNAL_0
);
1598 if (debug_linux_nat
)
1599 fprintf_unfiltered (gdb_stdlog
,
1600 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1601 target_pid_to_str (lp
->ptid
));
1604 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1606 else if (lp
->stopped
&& debug_linux_nat
)
1607 fprintf_unfiltered (gdb_stdlog
, "RC: Not resuming sibling %s (has pending)\n",
1608 target_pid_to_str (lp
->ptid
));
1609 else if (debug_linux_nat
)
1610 fprintf_unfiltered (gdb_stdlog
, "RC: Not resuming sibling %s (not stopped)\n",
1611 target_pid_to_str (lp
->ptid
));
1617 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1624 resume_set_callback (struct lwp_info
*lp
, void *data
)
1631 linux_nat_resume (ptid_t ptid
, int step
, enum target_signal signo
)
1633 struct lwp_info
*lp
;
1636 if (debug_linux_nat
)
1637 fprintf_unfiltered (gdb_stdlog
,
1638 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1639 step
? "step" : "resume",
1640 target_pid_to_str (ptid
),
1641 signo
? strsignal (signo
) : "0",
1642 target_pid_to_str (inferior_ptid
));
1644 if (target_can_async_p ())
1645 /* Block events while we're here. */
1646 linux_nat_async_events (sigchld_sync
);
1648 /* A specific PTID means `step only this process id'. */
1649 resume_all
= (PIDGET (ptid
) == -1);
1651 if (non_stop
&& resume_all
)
1652 internal_error (__FILE__
, __LINE__
,
1653 "can't resume all in non-stop mode");
1658 iterate_over_lwps (resume_set_callback
, NULL
);
1660 iterate_over_lwps (resume_clear_callback
, NULL
);
1663 /* If PID is -1, it's the current inferior that should be
1664 handled specially. */
1665 if (PIDGET (ptid
) == -1)
1666 ptid
= inferior_ptid
;
1668 lp
= find_lwp_pid (ptid
);
1669 gdb_assert (lp
!= NULL
);
1671 /* Convert to something the lower layer understands. */
1672 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
1674 /* Remember if we're stepping. */
1677 /* Mark this LWP as resumed. */
1680 /* If we have a pending wait status for this thread, there is no
1681 point in resuming the process. But first make sure that
1682 linux_nat_wait won't preemptively handle the event - we
1683 should never take this short-circuit if we are going to
1684 leave LP running, since we have skipped resuming all the
1685 other threads. This bit of code needs to be synchronized
1686 with linux_nat_wait. */
1688 /* In async mode, we never have pending wait status. */
1689 if (target_can_async_p () && lp
->status
)
1690 internal_error (__FILE__
, __LINE__
, "Pending status in async mode");
1692 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1694 int saved_signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1696 if (signal_stop_state (saved_signo
) == 0
1697 && signal_print_state (saved_signo
) == 0
1698 && signal_pass_state (saved_signo
) == 1)
1700 if (debug_linux_nat
)
1701 fprintf_unfiltered (gdb_stdlog
,
1702 "LLR: Not short circuiting for ignored "
1703 "status 0x%x\n", lp
->status
);
1705 /* FIXME: What should we do if we are supposed to continue
1706 this thread with a signal? */
1707 gdb_assert (signo
== TARGET_SIGNAL_0
);
1708 signo
= saved_signo
;
1715 /* FIXME: What should we do if we are supposed to continue
1716 this thread with a signal? */
1717 gdb_assert (signo
== TARGET_SIGNAL_0
);
1719 if (debug_linux_nat
)
1720 fprintf_unfiltered (gdb_stdlog
,
1721 "LLR: Short circuiting for status 0x%x\n",
1727 /* Mark LWP as not stopped to prevent it from being continued by
1732 iterate_over_lwps (resume_callback
, NULL
);
1734 linux_ops
->to_resume (ptid
, step
, signo
);
1735 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1737 if (debug_linux_nat
)
1738 fprintf_unfiltered (gdb_stdlog
,
1739 "LLR: %s %s, %s (resume event thread)\n",
1740 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1741 target_pid_to_str (ptid
),
1742 signo
? strsignal (signo
) : "0");
1744 if (target_can_async_p ())
1745 target_async (inferior_event_handler
, 0);
1748 /* Issue kill to specified lwp. */
1750 static int tkill_failed
;
1753 kill_lwp (int lwpid
, int signo
)
1757 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1758 fails, then we are not using nptl threads and we should be using kill. */
1760 #ifdef HAVE_TKILL_SYSCALL
1763 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
1764 if (errno
!= ENOSYS
)
1771 return kill (lwpid
, signo
);
1774 /* Handle a GNU/Linux extended wait response. If we see a clone
1775 event, we need to add the new LWP to our list (and not report the
1776 trap to higher layers). This function returns non-zero if the
1777 event should be ignored and we should wait again. If STOPPING is
1778 true, the new LWP remains stopped, otherwise it is continued. */
1781 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
1784 int pid
= GET_LWP (lp
->ptid
);
1785 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1786 struct lwp_info
*new_lp
= NULL
;
1787 int event
= status
>> 16;
1789 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1790 || event
== PTRACE_EVENT_CLONE
)
1792 unsigned long new_pid
;
1795 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1797 /* If we haven't already seen the new PID stop, wait for it now. */
1798 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1800 /* The new child has a pending SIGSTOP. We can't affect it until it
1801 hits the SIGSTOP, but we're already attached. */
1802 ret
= my_waitpid (new_pid
, &status
,
1803 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
1805 perror_with_name (_("waiting for new child"));
1806 else if (ret
!= new_pid
)
1807 internal_error (__FILE__
, __LINE__
,
1808 _("wait returned unexpected PID %d"), ret
);
1809 else if (!WIFSTOPPED (status
))
1810 internal_error (__FILE__
, __LINE__
,
1811 _("wait returned unexpected status 0x%x"), status
);
1814 ourstatus
->value
.related_pid
= ptid_build (new_pid
, new_pid
, 0);
1816 if (event
== PTRACE_EVENT_FORK
)
1817 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1818 else if (event
== PTRACE_EVENT_VFORK
)
1819 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1822 struct cleanup
*old_chain
;
1824 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1825 new_lp
= add_lwp (BUILD_LWP (new_pid
, GET_PID (inferior_ptid
)));
1827 new_lp
->stopped
= 1;
1829 if (WSTOPSIG (status
) != SIGSTOP
)
1831 /* This can happen if someone starts sending signals to
1832 the new thread before it gets a chance to run, which
1833 have a lower number than SIGSTOP (e.g. SIGUSR1).
1834 This is an unlikely case, and harder to handle for
1835 fork / vfork than for clone, so we do not try - but
1836 we handle it for clone events here. We'll send
1837 the other signal on to the thread below. */
1839 new_lp
->signalled
= 1;
1846 /* Add the new thread to GDB's lists as soon as possible
1849 1) the frontend doesn't have to wait for a stop to
1852 2) we tag it with the correct running state. */
1854 /* If the thread_db layer is active, let it know about
1855 this new thread, and add it to GDB's list. */
1856 if (!thread_db_attach_lwp (new_lp
->ptid
))
1858 /* We're not using thread_db. Add it to GDB's
1860 target_post_attach (GET_LWP (new_lp
->ptid
));
1861 add_thread (new_lp
->ptid
);
1866 set_running (new_lp
->ptid
, 1);
1867 set_executing (new_lp
->ptid
, 1);
1873 new_lp
->stopped
= 0;
1874 new_lp
->resumed
= 1;
1875 ptrace (PTRACE_CONT
, new_pid
, 0,
1876 status
? WSTOPSIG (status
) : 0);
1879 if (debug_linux_nat
)
1880 fprintf_unfiltered (gdb_stdlog
,
1881 "LHEW: Got clone event from LWP %ld, resuming\n",
1882 GET_LWP (lp
->ptid
));
1883 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1891 if (event
== PTRACE_EVENT_EXEC
)
1893 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1894 ourstatus
->value
.execd_pathname
1895 = xstrdup (linux_child_pid_to_exec_file (pid
));
1897 if (linux_parent_pid
)
1899 detach_breakpoints (linux_parent_pid
);
1900 ptrace (PTRACE_DETACH
, linux_parent_pid
, 0, 0);
1902 linux_parent_pid
= 0;
1905 /* At this point, all inserted breakpoints are gone. Doing this
1906 as soon as we detect an exec prevents the badness of deleting
1907 a breakpoint writing the current "shadow contents" to lift
1908 the bp. That shadow is NOT valid after an exec.
1910 Note that we have to do this after the detach_breakpoints
1911 call above, otherwise breakpoints wouldn't be lifted from the
1912 parent on a vfork, because detach_breakpoints would think
1913 that breakpoints are not inserted. */
1914 mark_breakpoints_out ();
1918 internal_error (__FILE__
, __LINE__
,
1919 _("unknown ptrace event %d"), event
);
1922 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1926 wait_lwp (struct lwp_info
*lp
)
1930 int thread_dead
= 0;
1932 gdb_assert (!lp
->stopped
);
1933 gdb_assert (lp
->status
== 0);
1935 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, 0);
1936 if (pid
== -1 && errno
== ECHILD
)
1938 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
1939 if (pid
== -1 && errno
== ECHILD
)
1941 /* The thread has previously exited. We need to delete it
1942 now because, for some vendor 2.4 kernels with NPTL
1943 support backported, there won't be an exit event unless
1944 it is the main thread. 2.6 kernels will report an exit
1945 event for each thread that exits, as expected. */
1947 if (debug_linux_nat
)
1948 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
1949 target_pid_to_str (lp
->ptid
));
1955 gdb_assert (pid
== GET_LWP (lp
->ptid
));
1957 if (debug_linux_nat
)
1959 fprintf_unfiltered (gdb_stdlog
,
1960 "WL: waitpid %s received %s\n",
1961 target_pid_to_str (lp
->ptid
),
1962 status_to_str (status
));
1966 /* Check if the thread has exited. */
1967 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1970 if (debug_linux_nat
)
1971 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
1972 target_pid_to_str (lp
->ptid
));
1981 gdb_assert (WIFSTOPPED (status
));
1983 /* Handle GNU/Linux's extended waitstatus for trace events. */
1984 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1986 if (debug_linux_nat
)
1987 fprintf_unfiltered (gdb_stdlog
,
1988 "WL: Handling extended status 0x%06x\n",
1990 if (linux_handle_extended_wait (lp
, status
, 1))
1991 return wait_lwp (lp
);
1997 /* Save the most recent siginfo for LP. This is currently only called
1998 for SIGTRAP; some ports use the si_addr field for
1999 target_stopped_data_address. In the future, it may also be used to
2000 restore the siginfo of requeued signals. */
2003 save_siginfo (struct lwp_info
*lp
)
2006 ptrace (PTRACE_GETSIGINFO
, GET_LWP (lp
->ptid
),
2007 (PTRACE_TYPE_ARG3
) 0, &lp
->siginfo
);
2010 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
2013 /* Send a SIGSTOP to LP. */
2016 stop_callback (struct lwp_info
*lp
, void *data
)
2018 if (!lp
->stopped
&& !lp
->signalled
)
2022 if (debug_linux_nat
)
2024 fprintf_unfiltered (gdb_stdlog
,
2025 "SC: kill %s **<SIGSTOP>**\n",
2026 target_pid_to_str (lp
->ptid
));
2029 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
2030 if (debug_linux_nat
)
2032 fprintf_unfiltered (gdb_stdlog
,
2033 "SC: lwp kill %d %s\n",
2035 errno
? safe_strerror (errno
) : "ERRNO-OK");
2039 gdb_assert (lp
->status
== 0);
2045 /* Return non-zero if LWP PID has a pending SIGINT. */
2048 linux_nat_has_pending_sigint (int pid
)
2050 sigset_t pending
, blocked
, ignored
;
2053 linux_proc_pending_signals (pid
, &pending
, &blocked
, &ignored
);
2055 if (sigismember (&pending
, SIGINT
)
2056 && !sigismember (&ignored
, SIGINT
))
2062 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2065 set_ignore_sigint (struct lwp_info
*lp
, void *data
)
2067 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2068 flag to consume the next one. */
2069 if (lp
->stopped
&& lp
->status
!= 0 && WIFSTOPPED (lp
->status
)
2070 && WSTOPSIG (lp
->status
) == SIGINT
)
2073 lp
->ignore_sigint
= 1;
2078 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2079 This function is called after we know the LWP has stopped; if the LWP
2080 stopped before the expected SIGINT was delivered, then it will never have
2081 arrived. Also, if the signal was delivered to a shared queue and consumed
2082 by a different thread, it will never be delivered to this LWP. */
2085 maybe_clear_ignore_sigint (struct lwp_info
*lp
)
2087 if (!lp
->ignore_sigint
)
2090 if (!linux_nat_has_pending_sigint (GET_LWP (lp
->ptid
)))
2092 if (debug_linux_nat
)
2093 fprintf_unfiltered (gdb_stdlog
,
2094 "MCIS: Clearing bogus flag for %s\n",
2095 target_pid_to_str (lp
->ptid
));
2096 lp
->ignore_sigint
= 0;
2100 /* Wait until LP is stopped. */
2103 stop_wait_callback (struct lwp_info
*lp
, void *data
)
2109 status
= wait_lwp (lp
);
2113 if (lp
->ignore_sigint
&& WIFSTOPPED (status
)
2114 && WSTOPSIG (status
) == SIGINT
)
2116 lp
->ignore_sigint
= 0;
2119 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2120 if (debug_linux_nat
)
2121 fprintf_unfiltered (gdb_stdlog
,
2122 "PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)\n",
2123 target_pid_to_str (lp
->ptid
),
2124 errno
? safe_strerror (errno
) : "OK");
2126 return stop_wait_callback (lp
, NULL
);
2129 maybe_clear_ignore_sigint (lp
);
2131 if (WSTOPSIG (status
) != SIGSTOP
)
2133 if (WSTOPSIG (status
) == SIGTRAP
)
2135 /* If a LWP other than the LWP that we're reporting an
2136 event for has hit a GDB breakpoint (as opposed to
2137 some random trap signal), then just arrange for it to
2138 hit it again later. We don't keep the SIGTRAP status
2139 and don't forward the SIGTRAP signal to the LWP. We
2140 will handle the current event, eventually we will
2141 resume all LWPs, and this one will get its breakpoint
2144 If we do not do this, then we run the risk that the
2145 user will delete or disable the breakpoint, but the
2146 thread will have already tripped on it. */
2148 /* Save the trap's siginfo in case we need it later. */
2151 /* Now resume this LWP and get the SIGSTOP event. */
2153 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2154 if (debug_linux_nat
)
2156 fprintf_unfiltered (gdb_stdlog
,
2157 "PTRACE_CONT %s, 0, 0 (%s)\n",
2158 target_pid_to_str (lp
->ptid
),
2159 errno
? safe_strerror (errno
) : "OK");
2161 fprintf_unfiltered (gdb_stdlog
,
2162 "SWC: Candidate SIGTRAP event in %s\n",
2163 target_pid_to_str (lp
->ptid
));
2165 /* Hold this event/waitstatus while we check to see if
2166 there are any more (we still want to get that SIGSTOP). */
2167 stop_wait_callback (lp
, NULL
);
2169 if (target_can_async_p ())
2171 /* Don't leave a pending wait status in async mode.
2172 Retrigger the breakpoint. */
2173 if (!cancel_breakpoint (lp
))
2175 /* There was no gdb breakpoint set at pc. Put
2176 the event back in the queue. */
2177 if (debug_linux_nat
)
2178 fprintf_unfiltered (gdb_stdlog
,
2179 "SWC: kill %s, %s\n",
2180 target_pid_to_str (lp
->ptid
),
2181 status_to_str ((int) status
));
2182 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
2187 /* Hold the SIGTRAP for handling by
2189 /* If there's another event, throw it back into the
2193 if (debug_linux_nat
)
2194 fprintf_unfiltered (gdb_stdlog
,
2195 "SWC: kill %s, %s\n",
2196 target_pid_to_str (lp
->ptid
),
2197 status_to_str ((int) status
));
2198 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
2200 /* Save the sigtrap event. */
2201 lp
->status
= status
;
2207 /* The thread was stopped with a signal other than
2208 SIGSTOP, and didn't accidentally trip a breakpoint. */
2210 if (debug_linux_nat
)
2212 fprintf_unfiltered (gdb_stdlog
,
2213 "SWC: Pending event %s in %s\n",
2214 status_to_str ((int) status
),
2215 target_pid_to_str (lp
->ptid
));
2217 /* Now resume this LWP and get the SIGSTOP event. */
2219 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2220 if (debug_linux_nat
)
2221 fprintf_unfiltered (gdb_stdlog
,
2222 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
2223 target_pid_to_str (lp
->ptid
),
2224 errno
? safe_strerror (errno
) : "OK");
2226 /* Hold this event/waitstatus while we check to see if
2227 there are any more (we still want to get that SIGSTOP). */
2228 stop_wait_callback (lp
, NULL
);
2230 /* If the lp->status field is still empty, use it to
2231 hold this event. If not, then this event must be
2232 returned to the event queue of the LWP. */
2233 if (lp
->status
|| target_can_async_p ())
2235 if (debug_linux_nat
)
2237 fprintf_unfiltered (gdb_stdlog
,
2238 "SWC: kill %s, %s\n",
2239 target_pid_to_str (lp
->ptid
),
2240 status_to_str ((int) status
));
2242 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
2245 lp
->status
= status
;
2251 /* We caught the SIGSTOP that we intended to catch, so
2252 there's no SIGSTOP pending. */
2261 /* Return non-zero if LP has a wait status pending. */
2264 status_callback (struct lwp_info
*lp
, void *data
)
2266 /* Only report a pending wait status if we pretend that this has
2267 indeed been resumed. */
2268 return (lp
->status
!= 0 && lp
->resumed
);
2271 /* Return non-zero if LP isn't stopped. */
2274 running_callback (struct lwp_info
*lp
, void *data
)
2276 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
2279 /* Count the LWP's that have had events. */
2282 count_events_callback (struct lwp_info
*lp
, void *data
)
2286 gdb_assert (count
!= NULL
);
2288 /* Count only resumed LWPs that have a SIGTRAP event pending. */
2289 if (lp
->status
!= 0 && lp
->resumed
2290 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
2296 /* Select the LWP (if any) that is currently being single-stepped. */
2299 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
2301 if (lp
->step
&& lp
->status
!= 0)
2307 /* Select the Nth LWP that has had a SIGTRAP event. */
2310 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
2312 int *selector
= data
;
2314 gdb_assert (selector
!= NULL
);
2316 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2317 if (lp
->status
!= 0 && lp
->resumed
2318 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
2319 if ((*selector
)-- == 0)
2326 cancel_breakpoint (struct lwp_info
*lp
)
2328 /* Arrange for a breakpoint to be hit again later. We don't keep
2329 the SIGTRAP status and don't forward the SIGTRAP signal to the
2330 LWP. We will handle the current event, eventually we will resume
2331 this LWP, and this breakpoint will trap again.
2333 If we do not do this, then we run the risk that the user will
2334 delete or disable the breakpoint, but the LWP will have already
2337 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
2338 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2341 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
2342 if (breakpoint_inserted_here_p (pc
))
2344 if (debug_linux_nat
)
2345 fprintf_unfiltered (gdb_stdlog
,
2346 "CB: Push back breakpoint for %s\n",
2347 target_pid_to_str (lp
->ptid
));
2349 /* Back up the PC if necessary. */
2350 if (gdbarch_decr_pc_after_break (gdbarch
))
2351 regcache_write_pc (regcache
, pc
);
2359 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
2361 struct lwp_info
*event_lp
= data
;
2363 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2367 /* If a LWP other than the LWP that we're reporting an event for has
2368 hit a GDB breakpoint (as opposed to some random trap signal),
2369 then just arrange for it to hit it again later. We don't keep
2370 the SIGTRAP status and don't forward the SIGTRAP signal to the
2371 LWP. We will handle the current event, eventually we will resume
2372 all LWPs, and this one will get its breakpoint trap again.
2374 If we do not do this, then we run the risk that the user will
2375 delete or disable the breakpoint, but the LWP will have already
2379 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
2380 && cancel_breakpoint (lp
))
2381 /* Throw away the SIGTRAP. */
2387 /* Select one LWP out of those that have events pending. */
2390 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
2393 int random_selector
;
2394 struct lwp_info
*event_lp
;
2396 /* Record the wait status for the original LWP. */
2397 (*orig_lp
)->status
= *status
;
2399 /* Give preference to any LWP that is being single-stepped. */
2400 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
2401 if (event_lp
!= NULL
)
2403 if (debug_linux_nat
)
2404 fprintf_unfiltered (gdb_stdlog
,
2405 "SEL: Select single-step %s\n",
2406 target_pid_to_str (event_lp
->ptid
));
2410 /* No single-stepping LWP. Select one at random, out of those
2411 which have had SIGTRAP events. */
2413 /* First see how many SIGTRAP events we have. */
2414 iterate_over_lwps (count_events_callback
, &num_events
);
2416 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2417 random_selector
= (int)
2418 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2420 if (debug_linux_nat
&& num_events
> 1)
2421 fprintf_unfiltered (gdb_stdlog
,
2422 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2423 num_events
, random_selector
);
2425 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
2429 if (event_lp
!= NULL
)
2431 /* Switch the event LWP. */
2432 *orig_lp
= event_lp
;
2433 *status
= event_lp
->status
;
2436 /* Flush the wait status for the event LWP. */
2437 (*orig_lp
)->status
= 0;
2440 /* Return non-zero if LP has been resumed. */
2443 resumed_callback (struct lwp_info
*lp
, void *data
)
2448 /* Stop an active thread, verify it still exists, then resume it. */
2451 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
2453 struct lwp_info
*ptr
;
2455 if (!lp
->stopped
&& !lp
->signalled
)
2457 stop_callback (lp
, NULL
);
2458 stop_wait_callback (lp
, NULL
);
2459 /* Resume if the lwp still exists. */
2460 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
2463 resume_callback (lp
, NULL
);
2464 resume_set_callback (lp
, NULL
);
2470 /* Check if we should go on and pass this event to common code.
2471 Return the affected lwp if we are, or NULL otherwise. */
2472 static struct lwp_info
*
2473 linux_nat_filter_event (int lwpid
, int status
, int options
)
2475 struct lwp_info
*lp
;
2477 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
2479 /* Check for stop events reported by a process we didn't already
2480 know about - anything not already in our LWP list.
2482 If we're expecting to receive stopped processes after
2483 fork, vfork, and clone events, then we'll just add the
2484 new one to our list and go back to waiting for the event
2485 to be reported - the stopped process might be returned
2486 from waitpid before or after the event is. */
2487 if (WIFSTOPPED (status
) && !lp
)
2489 linux_record_stopped_pid (lwpid
, status
);
2493 /* Make sure we don't report an event for the exit of an LWP not in
2494 our list, i.e. not part of the current process. This can happen
2495 if we detach from a program we original forked and then it
2497 if (!WIFSTOPPED (status
) && !lp
)
2500 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
2501 CLONE_PTRACE processes which do not use the thread library -
2502 otherwise we wouldn't find the new LWP this way. That doesn't
2503 currently work, and the following code is currently unreachable
2504 due to the two blocks above. If it's fixed some day, this code
2505 should be broken out into a function so that we can also pick up
2506 LWPs from the new interface. */
2509 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
2510 if (options
& __WCLONE
)
2513 gdb_assert (WIFSTOPPED (status
)
2514 && WSTOPSIG (status
) == SIGSTOP
);
2517 if (!in_thread_list (inferior_ptid
))
2519 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2520 GET_PID (inferior_ptid
));
2521 add_thread (inferior_ptid
);
2524 add_thread (lp
->ptid
);
2527 /* Save the trap's siginfo in case we need it later. */
2528 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2531 /* Handle GNU/Linux's extended waitstatus for trace events. */
2532 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
2534 if (debug_linux_nat
)
2535 fprintf_unfiltered (gdb_stdlog
,
2536 "LLW: Handling extended status 0x%06x\n",
2538 if (linux_handle_extended_wait (lp
, status
, 0))
2542 /* Check if the thread has exited. */
2543 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
2545 /* If this is the main thread, we must stop all threads and
2546 verify if they are still alive. This is because in the nptl
2547 thread model, there is no signal issued for exiting LWPs
2548 other than the main thread. We only get the main thread exit
2549 signal once all child threads have already exited. If we
2550 stop all the threads and use the stop_wait_callback to check
2551 if they have exited we can determine whether this signal
2552 should be ignored or whether it means the end of the debugged
2553 application, regardless of which threading model is being
2555 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
2558 iterate_over_lwps (stop_and_resume_callback
, NULL
);
2561 if (debug_linux_nat
)
2562 fprintf_unfiltered (gdb_stdlog
,
2563 "LLW: %s exited.\n",
2564 target_pid_to_str (lp
->ptid
));
2568 /* If there is at least one more LWP, then the exit signal was
2569 not the end of the debugged application and should be
2575 /* Check if the current LWP has previously exited. In the nptl
2576 thread model, LWPs other than the main thread do not issue
2577 signals when they exit so we must check whenever the thread has
2578 stopped. A similar check is made in stop_wait_callback(). */
2579 if (num_lwps
> 1 && !linux_nat_thread_alive (lp
->ptid
))
2581 if (debug_linux_nat
)
2582 fprintf_unfiltered (gdb_stdlog
,
2583 "LLW: %s exited.\n",
2584 target_pid_to_str (lp
->ptid
));
2588 /* Make sure there is at least one thread running. */
2589 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
2591 /* Discard the event. */
2595 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2596 an attempt to stop an LWP. */
2598 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
2600 if (debug_linux_nat
)
2601 fprintf_unfiltered (gdb_stdlog
,
2602 "LLW: Delayed SIGSTOP caught for %s.\n",
2603 target_pid_to_str (lp
->ptid
));
2605 /* This is a delayed SIGSTOP. */
2608 registers_changed ();
2610 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2611 lp
->step
, TARGET_SIGNAL_0
);
2612 if (debug_linux_nat
)
2613 fprintf_unfiltered (gdb_stdlog
,
2614 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2616 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2617 target_pid_to_str (lp
->ptid
));
2620 gdb_assert (lp
->resumed
);
2622 /* Discard the event. */
2626 /* Make sure we don't report a SIGINT that we have already displayed
2627 for another thread. */
2628 if (lp
->ignore_sigint
2629 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGINT
)
2631 if (debug_linux_nat
)
2632 fprintf_unfiltered (gdb_stdlog
,
2633 "LLW: Delayed SIGINT caught for %s.\n",
2634 target_pid_to_str (lp
->ptid
));
2636 /* This is a delayed SIGINT. */
2637 lp
->ignore_sigint
= 0;
2639 registers_changed ();
2640 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2641 lp
->step
, TARGET_SIGNAL_0
);
2642 if (debug_linux_nat
)
2643 fprintf_unfiltered (gdb_stdlog
,
2644 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
2646 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2647 target_pid_to_str (lp
->ptid
));
2650 gdb_assert (lp
->resumed
);
2652 /* Discard the event. */
2656 /* An interesting event. */
2661 /* Get the events stored in the pipe into the local queue, so they are
2662 accessible to queued_waitpid. We need to do this, since it is not
2663 always the case that the event at the head of the pipe is the event
2667 pipe_to_local_event_queue (void)
2669 if (debug_linux_nat_async
)
2670 fprintf_unfiltered (gdb_stdlog
,
2671 "PTLEQ: linux_nat_num_queued_events(%d)\n",
2672 linux_nat_num_queued_events
);
2673 while (linux_nat_num_queued_events
)
2675 int lwpid
, status
, options
;
2676 lwpid
= linux_nat_event_pipe_pop (&status
, &options
);
2677 gdb_assert (lwpid
> 0);
2678 push_waitpid (lwpid
, status
, options
);
2682 /* Get the unprocessed events stored in the local queue back into the
2683 pipe, so the event loop realizes there's something else to
2687 local_event_queue_to_pipe (void)
2689 struct waitpid_result
*w
= waitpid_queue
;
2692 struct waitpid_result
*next
= w
->next
;
2693 linux_nat_event_pipe_push (w
->pid
,
2699 waitpid_queue
= NULL
;
2701 if (debug_linux_nat_async
)
2702 fprintf_unfiltered (gdb_stdlog
,
2703 "LEQTP: linux_nat_num_queued_events(%d)\n",
2704 linux_nat_num_queued_events
);
2708 linux_nat_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
2710 struct lwp_info
*lp
= NULL
;
2713 pid_t pid
= PIDGET (ptid
);
2715 if (debug_linux_nat_async
)
2716 fprintf_unfiltered (gdb_stdlog
, "LLW: enter\n");
2718 /* The first time we get here after starting a new inferior, we may
2719 not have added it to the LWP list yet - this is the earliest
2720 moment at which we know its PID. */
2723 gdb_assert (!is_lwp (inferior_ptid
));
2725 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2726 GET_PID (inferior_ptid
));
2727 lp
= add_lwp (inferior_ptid
);
2729 /* Add the main thread to GDB's thread list. */
2730 add_thread_silent (lp
->ptid
);
2731 set_running (lp
->ptid
, 1);
2732 set_executing (lp
->ptid
, 1);
2735 /* Block events while we're here. */
2736 linux_nat_async_events (sigchld_sync
);
2740 /* Make sure there is at least one LWP that has been resumed. */
2741 gdb_assert (iterate_over_lwps (resumed_callback
, NULL
));
2743 /* First check if there is a LWP with a wait status pending. */
2746 /* Any LWP that's been resumed will do. */
2747 lp
= iterate_over_lwps (status_callback
, NULL
);
2750 if (target_can_async_p ())
2751 internal_error (__FILE__
, __LINE__
,
2752 "Found an LWP with a pending status in async mode.");
2754 status
= lp
->status
;
2757 if (debug_linux_nat
&& status
)
2758 fprintf_unfiltered (gdb_stdlog
,
2759 "LLW: Using pending wait status %s for %s.\n",
2760 status_to_str (status
),
2761 target_pid_to_str (lp
->ptid
));
2764 /* But if we don't find one, we'll have to wait, and check both
2765 cloned and uncloned processes. We start with the cloned
2767 options
= __WCLONE
| WNOHANG
;
2769 else if (is_lwp (ptid
))
2771 if (debug_linux_nat
)
2772 fprintf_unfiltered (gdb_stdlog
,
2773 "LLW: Waiting for specific LWP %s.\n",
2774 target_pid_to_str (ptid
));
2776 /* We have a specific LWP to check. */
2777 lp
= find_lwp_pid (ptid
);
2779 status
= lp
->status
;
2782 if (debug_linux_nat
&& status
)
2783 fprintf_unfiltered (gdb_stdlog
,
2784 "LLW: Using pending wait status %s for %s.\n",
2785 status_to_str (status
),
2786 target_pid_to_str (lp
->ptid
));
2788 /* If we have to wait, take into account whether PID is a cloned
2789 process or not. And we have to convert it to something that
2790 the layer beneath us can understand. */
2791 options
= lp
->cloned
? __WCLONE
: 0;
2792 pid
= GET_LWP (ptid
);
2795 if (status
&& lp
->signalled
)
2797 /* A pending SIGSTOP may interfere with the normal stream of
2798 events. In a typical case where interference is a problem,
2799 we have a SIGSTOP signal pending for LWP A while
2800 single-stepping it, encounter an event in LWP B, and take the
2801 pending SIGSTOP while trying to stop LWP A. After processing
2802 the event in LWP B, LWP A is continued, and we'll never see
2803 the SIGTRAP associated with the last time we were
2804 single-stepping LWP A. */
2806 /* Resume the thread. It should halt immediately returning the
2808 registers_changed ();
2809 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2810 lp
->step
, TARGET_SIGNAL_0
);
2811 if (debug_linux_nat
)
2812 fprintf_unfiltered (gdb_stdlog
,
2813 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
2814 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2815 target_pid_to_str (lp
->ptid
));
2817 gdb_assert (lp
->resumed
);
2819 /* This should catch the pending SIGSTOP. */
2820 stop_wait_callback (lp
, NULL
);
2823 if (!target_can_async_p ())
2825 /* Causes SIGINT to be passed on to the attached process. */
2834 if (target_can_async_p ())
2835 /* In async mode, don't ever block. Only look at the locally
2837 lwpid
= queued_waitpid (pid
, &status
, options
);
2839 lwpid
= my_waitpid (pid
, &status
, options
);
2843 gdb_assert (pid
== -1 || lwpid
== pid
);
2845 if (debug_linux_nat
)
2847 fprintf_unfiltered (gdb_stdlog
,
2848 "LLW: waitpid %ld received %s\n",
2849 (long) lwpid
, status_to_str (status
));
2852 lp
= linux_nat_filter_event (lwpid
, status
, options
);
2855 /* A discarded event. */
2865 /* Alternate between checking cloned and uncloned processes. */
2866 options
^= __WCLONE
;
2868 /* And every time we have checked both:
2869 In async mode, return to event loop;
2870 In sync mode, suspend waiting for a SIGCHLD signal. */
2871 if (options
& __WCLONE
)
2873 if (target_can_async_p ())
2875 /* No interesting event. */
2876 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2878 /* Get ready for the next event. */
2879 target_async (inferior_event_handler
, 0);
2881 if (debug_linux_nat_async
)
2882 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
2884 return minus_one_ptid
;
2887 sigsuspend (&suspend_mask
);
2891 /* We shouldn't end up here unless we want to try again. */
2892 gdb_assert (status
== 0);
2895 if (!target_can_async_p ())
2897 clear_sigio_trap ();
2898 clear_sigint_trap ();
2903 /* Don't report signals that GDB isn't interested in, such as
2904 signals that are neither printed nor stopped upon. Stopping all
2905 threads can be a bit time-consuming so if we want decent
2906 performance with heavily multi-threaded programs, especially when
2907 they're using a high frequency timer, we'd better avoid it if we
2910 if (WIFSTOPPED (status
))
2912 int signo
= target_signal_from_host (WSTOPSIG (status
));
2914 /* If we get a signal while single-stepping, we may need special
2915 care, e.g. to skip the signal handler. Defer to common code. */
2917 && signal_stop_state (signo
) == 0
2918 && signal_print_state (signo
) == 0
2919 && signal_pass_state (signo
) == 1)
2921 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2922 here? It is not clear we should. GDB may not expect
2923 other threads to run. On the other hand, not resuming
2924 newly attached threads may cause an unwanted delay in
2925 getting them running. */
2926 registers_changed ();
2927 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2929 if (debug_linux_nat
)
2930 fprintf_unfiltered (gdb_stdlog
,
2931 "LLW: %s %s, %s (preempt 'handle')\n",
2933 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2934 target_pid_to_str (lp
->ptid
),
2935 signo
? strsignal (signo
) : "0");
2941 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
2943 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2944 forwarded to the entire process group, that is, all LWPs
2945 will receive it - unless they're using CLONE_THREAD to
2946 share signals. Since we only want to report it once, we
2947 mark it as ignored for all LWPs except this one. */
2948 iterate_over_lwps (set_ignore_sigint
, NULL
);
2949 lp
->ignore_sigint
= 0;
2952 maybe_clear_ignore_sigint (lp
);
2955 /* This LWP is stopped now. */
2958 if (debug_linux_nat
)
2959 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
2960 status_to_str (status
), target_pid_to_str (lp
->ptid
));
2964 /* Now stop all other LWP's ... */
2965 iterate_over_lwps (stop_callback
, NULL
);
2967 /* ... and wait until all of them have reported back that
2968 they're no longer running. */
2969 iterate_over_lwps (stop_wait_callback
, NULL
);
2971 /* If we're not waiting for a specific LWP, choose an event LWP
2972 from among those that have had events. Giving equal priority
2973 to all LWPs that have had events helps prevent
2976 select_event_lwp (&lp
, &status
);
2979 /* Now that we've selected our final event LWP, cancel any
2980 breakpoints in other LWPs that have hit a GDB breakpoint. See
2981 the comment in cancel_breakpoints_callback to find out why. */
2982 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
2984 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2986 if (debug_linux_nat
)
2987 fprintf_unfiltered (gdb_stdlog
,
2988 "LLW: trap ptid is %s.\n",
2989 target_pid_to_str (lp
->ptid
));
2992 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
2994 *ourstatus
= lp
->waitstatus
;
2995 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
2998 store_waitstatus (ourstatus
, status
);
3000 /* Get ready for the next event. */
3001 if (target_can_async_p ())
3002 target_async (inferior_event_handler
, 0);
3004 if (debug_linux_nat_async
)
3005 fprintf_unfiltered (gdb_stdlog
, "LLW: exit\n");
3011 kill_callback (struct lwp_info
*lp
, void *data
)
3014 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
3015 if (debug_linux_nat
)
3016 fprintf_unfiltered (gdb_stdlog
,
3017 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
3018 target_pid_to_str (lp
->ptid
),
3019 errno
? safe_strerror (errno
) : "OK");
3025 kill_wait_callback (struct lwp_info
*lp
, void *data
)
3029 /* We must make sure that there are no pending events (delayed
3030 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3031 program doesn't interfere with any following debugging session. */
3033 /* For cloned processes we must check both with __WCLONE and
3034 without, since the exit status of a cloned process isn't reported
3040 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
3041 if (pid
!= (pid_t
) -1)
3043 if (debug_linux_nat
)
3044 fprintf_unfiltered (gdb_stdlog
,
3045 "KWC: wait %s received unknown.\n",
3046 target_pid_to_str (lp
->ptid
));
3047 /* The Linux kernel sometimes fails to kill a thread
3048 completely after PTRACE_KILL; that goes from the stop
3049 point in do_fork out to the one in
3050 get_signal_to_deliever and waits again. So kill it
3052 kill_callback (lp
, NULL
);
3055 while (pid
== GET_LWP (lp
->ptid
));
3057 gdb_assert (pid
== -1 && errno
== ECHILD
);
3062 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
3063 if (pid
!= (pid_t
) -1)
3065 if (debug_linux_nat
)
3066 fprintf_unfiltered (gdb_stdlog
,
3067 "KWC: wait %s received unk.\n",
3068 target_pid_to_str (lp
->ptid
));
3069 /* See the call to kill_callback above. */
3070 kill_callback (lp
, NULL
);
3073 while (pid
== GET_LWP (lp
->ptid
));
3075 gdb_assert (pid
== -1 && errno
== ECHILD
);
3080 linux_nat_kill (void)
3082 struct target_waitstatus last
;
3086 if (target_can_async_p ())
3087 target_async (NULL
, 0);
3089 /* If we're stopped while forking and we haven't followed yet,
3090 kill the other task. We need to do this first because the
3091 parent will be sleeping if this is a vfork. */
3093 get_last_target_status (&last_ptid
, &last
);
3095 if (last
.kind
== TARGET_WAITKIND_FORKED
3096 || last
.kind
== TARGET_WAITKIND_VFORKED
)
3098 ptrace (PT_KILL
, PIDGET (last
.value
.related_pid
), 0, 0);
3102 if (forks_exist_p ())
3104 linux_fork_killall ();
3105 drain_queued_events (-1);
3109 /* Stop all threads before killing them, since ptrace requires
3110 that the thread is stopped to sucessfully PTRACE_KILL. */
3111 iterate_over_lwps (stop_callback
, NULL
);
3112 /* ... and wait until all of them have reported back that
3113 they're no longer running. */
3114 iterate_over_lwps (stop_wait_callback
, NULL
);
3116 /* Kill all LWP's ... */
3117 iterate_over_lwps (kill_callback
, NULL
);
3119 /* ... and wait until we've flushed all events. */
3120 iterate_over_lwps (kill_wait_callback
, NULL
);
3123 target_mourn_inferior ();
3127 linux_nat_mourn_inferior (void)
3129 /* Destroy LWP info; it's no longer valid. */
3132 if (! forks_exist_p ())
3134 /* Normal case, no other forks available. */
3135 if (target_can_async_p ())
3136 linux_nat_async (NULL
, 0);
3137 linux_ops
->to_mourn_inferior ();
3140 /* Multi-fork case. The current inferior_ptid has exited, but
3141 there are other viable forks to debug. Delete the exiting
3142 one and context-switch to the first available. */
3143 linux_fork_mourn_inferior ();
3147 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3148 const char *annex
, gdb_byte
*readbuf
,
3149 const gdb_byte
*writebuf
,
3150 ULONGEST offset
, LONGEST len
)
3152 struct cleanup
*old_chain
= save_inferior_ptid ();
3155 if (is_lwp (inferior_ptid
))
3156 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
3158 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3161 do_cleanups (old_chain
);
3166 linux_nat_thread_alive (ptid_t ptid
)
3170 gdb_assert (is_lwp (ptid
));
3172 /* Send signal 0 instead of anything ptrace, because ptracing a
3173 running thread errors out claiming that the thread doesn't
3175 err
= kill_lwp (GET_LWP (ptid
), 0);
3177 if (debug_linux_nat
)
3178 fprintf_unfiltered (gdb_stdlog
,
3179 "LLTA: KILL(SIG0) %s (%s)\n",
3180 target_pid_to_str (ptid
),
3181 err
? safe_strerror (err
) : "OK");
3190 linux_nat_pid_to_str (ptid_t ptid
)
3192 static char buf
[64];
3195 && ((lwp_list
&& lwp_list
->next
)
3196 || GET_PID (ptid
) != GET_LWP (ptid
)))
3198 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
3202 return normal_pid_to_str (ptid
);
3206 sigchld_handler (int signo
)
3208 if (linux_nat_async_enabled
3209 && linux_nat_async_events_state
!= sigchld_sync
3210 && signo
== SIGCHLD
)
3211 /* It is *always* a bug to hit this. */
3212 internal_error (__FILE__
, __LINE__
,
3213 "sigchld_handler called when async events are enabled");
3215 /* Do nothing. The only reason for this handler is that it allows
3216 us to use sigsuspend in linux_nat_wait above to wait for the
3217 arrival of a SIGCHLD. */
3220 /* Accepts an integer PID; Returns a string representing a file that
3221 can be opened to get the symbols for the child process. */
3224 linux_child_pid_to_exec_file (int pid
)
3226 char *name1
, *name2
;
3228 name1
= xmalloc (MAXPATHLEN
);
3229 name2
= xmalloc (MAXPATHLEN
);
3230 make_cleanup (xfree
, name1
);
3231 make_cleanup (xfree
, name2
);
3232 memset (name2
, 0, MAXPATHLEN
);
3234 sprintf (name1
, "/proc/%d/exe", pid
);
3235 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
3241 /* Service function for corefiles and info proc. */
3244 read_mapping (FILE *mapfile
,
3249 char *device
, long long *inode
, char *filename
)
3251 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
3252 addr
, endaddr
, permissions
, offset
, device
, inode
);
3255 if (ret
> 0 && ret
!= EOF
)
3257 /* Eat everything up to EOL for the filename. This will prevent
3258 weird filenames (such as one with embedded whitespace) from
3259 confusing this code. It also makes this code more robust in
3260 respect to annotations the kernel may add after the filename.
3262 Note the filename is used for informational purposes
3264 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
3267 return (ret
!= 0 && ret
!= EOF
);
3270 /* Fills the "to_find_memory_regions" target vector. Lists the memory
3271 regions in the inferior for a corefile. */
3274 linux_nat_find_memory_regions (int (*func
) (CORE_ADDR
,
3276 int, int, int, void *), void *obfd
)
3278 long long pid
= PIDGET (inferior_ptid
);
3279 char mapsfilename
[MAXPATHLEN
];
3281 long long addr
, endaddr
, size
, offset
, inode
;
3282 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
3283 int read
, write
, exec
;
3286 /* Compose the filename for the /proc memory map, and open it. */
3287 sprintf (mapsfilename
, "/proc/%lld/maps", pid
);
3288 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
3289 error (_("Could not open %s."), mapsfilename
);
3292 fprintf_filtered (gdb_stdout
,
3293 "Reading memory regions from %s\n", mapsfilename
);
3295 /* Now iterate until end-of-file. */
3296 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
3297 &offset
, &device
[0], &inode
, &filename
[0]))
3299 size
= endaddr
- addr
;
3301 /* Get the segment's permissions. */
3302 read
= (strchr (permissions
, 'r') != 0);
3303 write
= (strchr (permissions
, 'w') != 0);
3304 exec
= (strchr (permissions
, 'x') != 0);
3308 fprintf_filtered (gdb_stdout
,
3309 "Save segment, %lld bytes at 0x%s (%c%c%c)",
3310 size
, paddr_nz (addr
),
3312 write
? 'w' : ' ', exec
? 'x' : ' ');
3314 fprintf_filtered (gdb_stdout
, " for %s", filename
);
3315 fprintf_filtered (gdb_stdout
, "\n");
3318 /* Invoke the callback function to create the corefile
3320 func (addr
, size
, read
, write
, exec
, obfd
);
3326 /* Records the thread's register state for the corefile note
3330 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
3331 char *note_data
, int *note_size
)
3333 gdb_gregset_t gregs
;
3334 gdb_fpregset_t fpregs
;
3335 unsigned long lwp
= ptid_get_lwp (ptid
);
3336 struct regcache
*regcache
= get_thread_regcache (ptid
);
3337 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3338 const struct regset
*regset
;
3340 struct cleanup
*old_chain
;
3341 struct core_regset_section
*sect_list
;
3344 old_chain
= save_inferior_ptid ();
3345 inferior_ptid
= ptid
;
3346 target_fetch_registers (regcache
, -1);
3347 do_cleanups (old_chain
);
3349 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
3350 sect_list
= gdbarch_core_regset_sections (gdbarch
);
3353 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
3354 sizeof (gregs
))) != NULL
3355 && regset
->collect_regset
!= NULL
)
3356 regset
->collect_regset (regset
, regcache
, -1,
3357 &gregs
, sizeof (gregs
));
3359 fill_gregset (regcache
, &gregs
, -1);
3361 note_data
= (char *) elfcore_write_prstatus (obfd
,
3365 stop_signal
, &gregs
);
3367 /* The loop below uses the new struct core_regset_section, which stores
3368 the supported section names and sizes for the core file. Note that
3369 note PRSTATUS needs to be treated specially. But the other notes are
3370 structurally the same, so they can benefit from the new struct. */
3371 if (core_regset_p
&& sect_list
!= NULL
)
3372 while (sect_list
->sect_name
!= NULL
)
3374 /* .reg was already handled above. */
3375 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
3380 regset
= gdbarch_regset_from_core_section (gdbarch
,
3381 sect_list
->sect_name
,
3383 gdb_assert (regset
&& regset
->collect_regset
);
3384 gdb_regset
= xmalloc (sect_list
->size
);
3385 regset
->collect_regset (regset
, regcache
, -1,
3386 gdb_regset
, sect_list
->size
);
3387 note_data
= (char *) elfcore_write_register_note (obfd
,
3390 sect_list
->sect_name
,
3397 /* For architectures that does not have the struct core_regset_section
3398 implemented, we use the old method. When all the architectures have
3399 the new support, the code below should be deleted. */
3403 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
3404 sizeof (fpregs
))) != NULL
3405 && regset
->collect_regset
!= NULL
)
3406 regset
->collect_regset (regset
, regcache
, -1,
3407 &fpregs
, sizeof (fpregs
));
3409 fill_fpregset (regcache
, &fpregs
, -1);
3411 note_data
= (char *) elfcore_write_prfpreg (obfd
,
3414 &fpregs
, sizeof (fpregs
));
3420 struct linux_nat_corefile_thread_data
3428 /* Called by gdbthread.c once per thread. Records the thread's
3429 register state for the corefile note section. */
3432 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
3434 struct linux_nat_corefile_thread_data
*args
= data
;
3436 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
3445 /* Records the register state for the corefile note section. */
3448 linux_nat_do_registers (bfd
*obfd
, ptid_t ptid
,
3449 char *note_data
, int *note_size
)
3451 return linux_nat_do_thread_registers (obfd
,
3452 ptid_build (ptid_get_pid (inferior_ptid
),
3453 ptid_get_pid (inferior_ptid
),
3455 note_data
, note_size
);
3458 /* Fills the "to_make_corefile_note" target vector. Builds the note
3459 section for a corefile, and returns it in a malloc buffer. */
3462 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
3464 struct linux_nat_corefile_thread_data thread_args
;
3465 struct cleanup
*old_chain
;
3466 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
3467 char fname
[16] = { '\0' };
3468 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
3469 char psargs
[80] = { '\0' };
3470 char *note_data
= NULL
;
3471 ptid_t current_ptid
= inferior_ptid
;
3475 if (get_exec_file (0))
3477 strncpy (fname
, strrchr (get_exec_file (0), '/') + 1, sizeof (fname
));
3478 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3479 if (get_inferior_args ())
3482 char *psargs_end
= psargs
+ sizeof (psargs
);
3484 /* linux_elfcore_write_prpsinfo () handles zero unterminated
3486 string_end
= memchr (psargs
, 0, sizeof (psargs
));
3487 if (string_end
!= NULL
)
3489 *string_end
++ = ' ';
3490 strncpy (string_end
, get_inferior_args (),
3491 psargs_end
- string_end
);
3494 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
3496 note_size
, fname
, psargs
);
3499 /* Dump information for threads. */
3500 thread_args
.obfd
= obfd
;
3501 thread_args
.note_data
= note_data
;
3502 thread_args
.note_size
= note_size
;
3503 thread_args
.num_notes
= 0;
3504 iterate_over_lwps (linux_nat_corefile_thread_callback
, &thread_args
);
3505 if (thread_args
.num_notes
== 0)
3507 /* iterate_over_threads didn't come up with any threads; just
3508 use inferior_ptid. */
3509 note_data
= linux_nat_do_registers (obfd
, inferior_ptid
,
3510 note_data
, note_size
);
3514 note_data
= thread_args
.note_data
;
3517 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
3521 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
3522 "CORE", NT_AUXV
, auxv
, auxv_len
);
3526 make_cleanup (xfree
, note_data
);
3530 /* Implement the "info proc" command. */
3533 linux_nat_info_proc_cmd (char *args
, int from_tty
)
3535 long long pid
= PIDGET (inferior_ptid
);
3538 char buffer
[MAXPATHLEN
];
3539 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
3552 /* Break up 'args' into an argv array. */
3553 if ((argv
= buildargv (args
)) == NULL
)
3556 make_cleanup_freeargv (argv
);
3558 while (argv
!= NULL
&& *argv
!= NULL
)
3560 if (isdigit (argv
[0][0]))
3562 pid
= strtoul (argv
[0], NULL
, 10);
3564 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
3568 else if (strcmp (argv
[0], "status") == 0)
3572 else if (strcmp (argv
[0], "stat") == 0)
3576 else if (strcmp (argv
[0], "cmd") == 0)
3580 else if (strncmp (argv
[0], "exe", strlen (argv
[0])) == 0)
3584 else if (strcmp (argv
[0], "cwd") == 0)
3588 else if (strncmp (argv
[0], "all", strlen (argv
[0])) == 0)
3594 /* [...] (future options here) */
3599 error (_("No current process: you must name one."));
3601 sprintf (fname1
, "/proc/%lld", pid
);
3602 if (stat (fname1
, &dummy
) != 0)
3603 error (_("No /proc directory: '%s'"), fname1
);
3605 printf_filtered (_("process %lld\n"), pid
);
3606 if (cmdline_f
|| all
)
3608 sprintf (fname1
, "/proc/%lld/cmdline", pid
);
3609 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3611 fgets (buffer
, sizeof (buffer
), procfile
);
3612 printf_filtered ("cmdline = '%s'\n", buffer
);
3616 warning (_("unable to open /proc file '%s'"), fname1
);
3620 sprintf (fname1
, "/proc/%lld/cwd", pid
);
3621 memset (fname2
, 0, sizeof (fname2
));
3622 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
3623 printf_filtered ("cwd = '%s'\n", fname2
);
3625 warning (_("unable to read link '%s'"), fname1
);
3629 sprintf (fname1
, "/proc/%lld/exe", pid
);
3630 memset (fname2
, 0, sizeof (fname2
));
3631 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
3632 printf_filtered ("exe = '%s'\n", fname2
);
3634 warning (_("unable to read link '%s'"), fname1
);
3636 if (mappings_f
|| all
)
3638 sprintf (fname1
, "/proc/%lld/maps", pid
);
3639 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3641 long long addr
, endaddr
, size
, offset
, inode
;
3642 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
3644 printf_filtered (_("Mapped address spaces:\n\n"));
3645 if (gdbarch_addr_bit (current_gdbarch
) == 32)
3647 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3650 " Size", " Offset", "objfile");
3654 printf_filtered (" %18s %18s %10s %10s %7s\n",
3657 " Size", " Offset", "objfile");
3660 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
3661 &offset
, &device
[0], &inode
, &filename
[0]))
3663 size
= endaddr
- addr
;
3665 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
3666 calls here (and possibly above) should be abstracted
3667 out into their own functions? Andrew suggests using
3668 a generic local_address_string instead to print out
3669 the addresses; that makes sense to me, too. */
3671 if (gdbarch_addr_bit (current_gdbarch
) == 32)
3673 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3674 (unsigned long) addr
, /* FIXME: pr_addr */
3675 (unsigned long) endaddr
,
3677 (unsigned int) offset
,
3678 filename
[0] ? filename
: "");
3682 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3683 (unsigned long) addr
, /* FIXME: pr_addr */
3684 (unsigned long) endaddr
,
3686 (unsigned int) offset
,
3687 filename
[0] ? filename
: "");
3694 warning (_("unable to open /proc file '%s'"), fname1
);
3696 if (status_f
|| all
)
3698 sprintf (fname1
, "/proc/%lld/status", pid
);
3699 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3701 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
3702 puts_filtered (buffer
);
3706 warning (_("unable to open /proc file '%s'"), fname1
);
3710 sprintf (fname1
, "/proc/%lld/stat", pid
);
3711 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3717 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3718 printf_filtered (_("Process: %d\n"), itmp
);
3719 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
3720 printf_filtered (_("Exec file: %s\n"), buffer
);
3721 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
3722 printf_filtered (_("State: %c\n"), ctmp
);
3723 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3724 printf_filtered (_("Parent process: %d\n"), itmp
);
3725 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3726 printf_filtered (_("Process group: %d\n"), itmp
);
3727 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3728 printf_filtered (_("Session id: %d\n"), itmp
);
3729 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3730 printf_filtered (_("TTY: %d\n"), itmp
);
3731 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3732 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
3733 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3734 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
3735 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3736 printf_filtered (_("Minor faults (no memory page): %lu\n"),
3737 (unsigned long) ltmp
);
3738 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3739 printf_filtered (_("Minor faults, children: %lu\n"),
3740 (unsigned long) ltmp
);
3741 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3742 printf_filtered (_("Major faults (memory page faults): %lu\n"),
3743 (unsigned long) ltmp
);
3744 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3745 printf_filtered (_("Major faults, children: %lu\n"),
3746 (unsigned long) ltmp
);
3747 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3748 printf_filtered (_("utime: %ld\n"), ltmp
);
3749 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3750 printf_filtered (_("stime: %ld\n"), ltmp
);
3751 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3752 printf_filtered (_("utime, children: %ld\n"), ltmp
);
3753 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3754 printf_filtered (_("stime, children: %ld\n"), ltmp
);
3755 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3756 printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
3758 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3759 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
3760 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3761 printf_filtered (_("jiffies until next timeout: %lu\n"),
3762 (unsigned long) ltmp
);
3763 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3764 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
3765 (unsigned long) ltmp
);
3766 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3767 printf_filtered (_("start time (jiffies since system boot): %ld\n"),
3769 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3770 printf_filtered (_("Virtual memory size: %lu\n"),
3771 (unsigned long) ltmp
);
3772 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3773 printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp
);
3774 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3775 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
3776 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3777 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
3778 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3779 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
3780 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3781 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
3782 #if 0 /* Don't know how architecture-dependent the rest is...
3783 Anyway the signal bitmap info is available from "status". */
3784 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3785 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
3786 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3787 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
3788 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3789 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
3790 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3791 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
3792 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3793 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
3794 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3795 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
3796 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3797 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
3802 warning (_("unable to open /proc file '%s'"), fname1
);
3806 /* Implement the to_xfer_partial interface for memory reads using the /proc
3807 filesystem. Because we can use a single read() call for /proc, this
3808 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3809 but it doesn't support writes. */
3812 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3813 const char *annex
, gdb_byte
*readbuf
,
3814 const gdb_byte
*writebuf
,
3815 ULONGEST offset
, LONGEST len
)
3821 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
3824 /* Don't bother for one word. */
3825 if (len
< 3 * sizeof (long))
3828 /* We could keep this file open and cache it - possibly one per
3829 thread. That requires some juggling, but is even faster. */
3830 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
3831 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
3835 /* If pread64 is available, use it. It's faster if the kernel
3836 supports it (only one syscall), and it's 64-bit safe even on
3837 32-bit platforms (for instance, SPARC debugging a SPARC64
3840 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
3842 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
3852 /* Parse LINE as a signal set and add its set bits to SIGS. */
3855 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
3857 int len
= strlen (line
) - 1;
3861 if (line
[len
] != '\n')
3862 error (_("Could not parse signal set: %s"), line
);
3870 if (*p
>= '0' && *p
<= '9')
3872 else if (*p
>= 'a' && *p
<= 'f')
3873 digit
= *p
- 'a' + 10;
3875 error (_("Could not parse signal set: %s"), line
);
3880 sigaddset (sigs
, signum
+ 1);
3882 sigaddset (sigs
, signum
+ 2);
3884 sigaddset (sigs
, signum
+ 3);
3886 sigaddset (sigs
, signum
+ 4);
3892 /* Find process PID's pending signals from /proc/pid/status and set
3896 linux_proc_pending_signals (int pid
, sigset_t
*pending
, sigset_t
*blocked
, sigset_t
*ignored
)
3899 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
3902 sigemptyset (pending
);
3903 sigemptyset (blocked
);
3904 sigemptyset (ignored
);
3905 sprintf (fname
, "/proc/%d/status", pid
);
3906 procfile
= fopen (fname
, "r");
3907 if (procfile
== NULL
)
3908 error (_("Could not open %s"), fname
);
3910 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
3912 /* Normal queued signals are on the SigPnd line in the status
3913 file. However, 2.6 kernels also have a "shared" pending
3914 queue for delivering signals to a thread group, so check for
3917 Unfortunately some Red Hat kernels include the shared pending
3918 queue but not the ShdPnd status field. */
3920 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
3921 add_line_to_sigset (buffer
+ 8, pending
);
3922 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
3923 add_line_to_sigset (buffer
+ 8, pending
);
3924 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
3925 add_line_to_sigset (buffer
+ 8, blocked
);
3926 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
3927 add_line_to_sigset (buffer
+ 8, ignored
);
3934 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3935 const char *annex
, gdb_byte
*readbuf
,
3936 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3940 if (object
== TARGET_OBJECT_AUXV
)
3941 return procfs_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
3944 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3949 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3953 /* Create a prototype generic GNU/Linux target. The client can override
3954 it with local methods. */
3957 linux_target_install_ops (struct target_ops
*t
)
3959 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
3960 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
3961 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
3962 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
3963 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
3964 t
->to_post_attach
= linux_child_post_attach
;
3965 t
->to_follow_fork
= linux_child_follow_fork
;
3966 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
3967 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
3969 super_xfer_partial
= t
->to_xfer_partial
;
3970 t
->to_xfer_partial
= linux_xfer_partial
;
3976 struct target_ops
*t
;
3978 t
= inf_ptrace_target ();
3979 linux_target_install_ops (t
);
3985 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
3987 struct target_ops
*t
;
3989 t
= inf_ptrace_trad_target (register_u_offset
);
3990 linux_target_install_ops (t
);
3995 /* Controls if async mode is permitted. */
3996 static int linux_async_permitted
= 0;
3998 /* The set command writes to this variable. If the inferior is
3999 executing, linux_nat_async_permitted is *not* updated. */
4000 static int linux_async_permitted_1
= 0;
4003 set_maintenance_linux_async_permitted (char *args
, int from_tty
,
4004 struct cmd_list_element
*c
)
4006 if (target_has_execution
)
4008 linux_async_permitted_1
= linux_async_permitted
;
4009 error (_("Cannot change this setting while the inferior is running."));
4012 linux_async_permitted
= linux_async_permitted_1
;
4013 linux_nat_set_async_mode (linux_async_permitted
);
4017 show_maintenance_linux_async_permitted (struct ui_file
*file
, int from_tty
,
4018 struct cmd_list_element
*c
, const char *value
)
4020 fprintf_filtered (file
, _("\
4021 Controlling the GNU/Linux inferior in asynchronous mode is %s.\n"),
4025 /* target_is_async_p implementation. */
4028 linux_nat_is_async_p (void)
4030 /* NOTE: palves 2008-03-21: We're only async when the user requests
4031 it explicitly with the "maintenance set linux-async" command.
4032 Someday, linux will always be async. */
4033 if (!linux_async_permitted
)
4039 /* target_can_async_p implementation. */
4042 linux_nat_can_async_p (void)
4044 /* NOTE: palves 2008-03-21: We're only async when the user requests
4045 it explicitly with the "maintenance set linux-async" command.
4046 Someday, linux will always be async. */
4047 if (!linux_async_permitted
)
4050 /* See target.h/target_async_mask. */
4051 return linux_nat_async_mask_value
;
4054 /* target_async_mask implementation. */
4057 linux_nat_async_mask (int mask
)
4060 current_state
= linux_nat_async_mask_value
;
4062 if (current_state
!= mask
)
4066 linux_nat_async (NULL
, 0);
4067 linux_nat_async_mask_value
= mask
;
4071 linux_nat_async_mask_value
= mask
;
4072 linux_nat_async (inferior_event_handler
, 0);
4076 return current_state
;
4079 /* Pop an event from the event pipe. */
4082 linux_nat_event_pipe_pop (int* ptr_status
, int* ptr_options
)
4084 struct waitpid_result event
= {0};
4089 ret
= read (linux_nat_event_pipe
[0], &event
, sizeof (event
));
4091 while (ret
== -1 && errno
== EINTR
);
4093 gdb_assert (ret
== sizeof (event
));
4095 *ptr_status
= event
.status
;
4096 *ptr_options
= event
.options
;
4098 linux_nat_num_queued_events
--;
4103 /* Push an event into the event pipe. */
4106 linux_nat_event_pipe_push (int pid
, int status
, int options
)
4109 struct waitpid_result event
= {0};
4111 event
.status
= status
;
4112 event
.options
= options
;
4116 ret
= write (linux_nat_event_pipe
[1], &event
, sizeof (event
));
4117 gdb_assert ((ret
== -1 && errno
== EINTR
) || ret
== sizeof (event
));
4118 } while (ret
== -1 && errno
== EINTR
);
4120 linux_nat_num_queued_events
++;
4124 get_pending_events (void)
4126 int status
, options
, pid
;
4128 if (!linux_nat_async_enabled
4129 || linux_nat_async_events_state
!= sigchld_async
)
4130 internal_error (__FILE__
, __LINE__
,
4131 "get_pending_events called with async masked");
4136 options
= __WCLONE
| WNOHANG
;
4140 pid
= waitpid (-1, &status
, options
);
4142 while (pid
== -1 && errno
== EINTR
);
4149 pid
= waitpid (-1, &status
, options
);
4151 while (pid
== -1 && errno
== EINTR
);
4155 /* No more children reporting events. */
4158 if (debug_linux_nat_async
)
4159 fprintf_unfiltered (gdb_stdlog
, "\
4160 get_pending_events: pid(%d), status(%x), options (%x)\n",
4161 pid
, status
, options
);
4163 linux_nat_event_pipe_push (pid
, status
, options
);
4166 if (debug_linux_nat_async
)
4167 fprintf_unfiltered (gdb_stdlog
, "\
4168 get_pending_events: linux_nat_num_queued_events(%d)\n",
4169 linux_nat_num_queued_events
);
4172 /* SIGCHLD handler for async mode. */
4175 async_sigchld_handler (int signo
)
4177 if (debug_linux_nat_async
)
4178 fprintf_unfiltered (gdb_stdlog
, "async_sigchld_handler\n");
4180 get_pending_events ();
4183 /* Set SIGCHLD handling state to STATE. Returns previous state. */
4185 static enum sigchld_state
4186 linux_nat_async_events (enum sigchld_state state
)
4188 enum sigchld_state current_state
= linux_nat_async_events_state
;
4190 if (debug_linux_nat_async
)
4191 fprintf_unfiltered (gdb_stdlog
,
4192 "LNAE: state(%d): linux_nat_async_events_state(%d), "
4193 "linux_nat_num_queued_events(%d)\n",
4194 state
, linux_nat_async_events_state
,
4195 linux_nat_num_queued_events
);
4197 if (current_state
!= state
)
4200 sigemptyset (&mask
);
4201 sigaddset (&mask
, SIGCHLD
);
4203 /* Always block before changing state. */
4204 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4206 /* Set new state. */
4207 linux_nat_async_events_state
= state
;
4213 /* Block target events. */
4214 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4215 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
4216 /* Get events out of queue, and make them available to
4217 queued_waitpid / my_waitpid. */
4218 pipe_to_local_event_queue ();
4223 /* Unblock target events for async mode. */
4225 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4227 /* Put events we already waited on, in the pipe first, so
4229 local_event_queue_to_pipe ();
4230 /* While in masked async, we may have not collected all
4231 the pending events. Get them out now. */
4232 get_pending_events ();
4235 sigaction (SIGCHLD
, &async_sigchld_action
, NULL
);
4236 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
4239 case sigchld_default
:
4241 /* SIGCHLD default mode. */
4242 sigaction (SIGCHLD
, &sigchld_default_action
, NULL
);
4244 /* Get events out of queue, and make them available to
4245 queued_waitpid / my_waitpid. */
4246 pipe_to_local_event_queue ();
4248 /* Unblock SIGCHLD. */
4249 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
4255 return current_state
;
4258 static int async_terminal_is_ours
= 1;
4260 /* target_terminal_inferior implementation. */
4263 linux_nat_terminal_inferior (void)
4265 if (!target_is_async_p ())
4267 /* Async mode is disabled. */
4268 terminal_inferior ();
4272 /* GDB should never give the terminal to the inferior, if the
4273 inferior is running in the background (run&, continue&, etc.).
4274 This check can be removed when the common code is fixed. */
4275 if (!sync_execution
)
4278 terminal_inferior ();
4280 if (!async_terminal_is_ours
)
4283 delete_file_handler (input_fd
);
4284 async_terminal_is_ours
= 0;
4288 /* target_terminal_ours implementation. */
4291 linux_nat_terminal_ours (void)
4293 if (!target_is_async_p ())
4295 /* Async mode is disabled. */
4300 /* GDB should never give the terminal to the inferior if the
4301 inferior is running in the background (run&, continue&, etc.),
4302 but claiming it sure should. */
4305 if (!sync_execution
)
4308 if (async_terminal_is_ours
)
4311 clear_sigint_trap ();
4312 add_file_handler (input_fd
, stdin_event_handler
, 0);
4313 async_terminal_is_ours
= 1;
4316 static void (*async_client_callback
) (enum inferior_event_type event_type
,
4318 static void *async_client_context
;
4321 linux_nat_async_file_handler (int error
, gdb_client_data client_data
)
4323 async_client_callback (INF_REG_EVENT
, async_client_context
);
4326 /* target_async implementation. */
4329 linux_nat_async (void (*callback
) (enum inferior_event_type event_type
,
4330 void *context
), void *context
)
4332 if (linux_nat_async_mask_value
== 0 || !linux_nat_async_enabled
)
4333 internal_error (__FILE__
, __LINE__
,
4334 "Calling target_async when async is masked");
4336 if (callback
!= NULL
)
4338 async_client_callback
= callback
;
4339 async_client_context
= context
;
4340 add_file_handler (linux_nat_event_pipe
[0],
4341 linux_nat_async_file_handler
, NULL
);
4343 linux_nat_async_events (sigchld_async
);
4347 async_client_callback
= callback
;
4348 async_client_context
= context
;
4350 linux_nat_async_events (sigchld_sync
);
4351 delete_file_handler (linux_nat_event_pipe
[0]);
4356 /* Enable/Disable async mode. */
4359 linux_nat_set_async_mode (int on
)
4361 if (linux_nat_async_enabled
!= on
)
4365 gdb_assert (waitpid_queue
== NULL
);
4366 if (pipe (linux_nat_event_pipe
) == -1)
4367 internal_error (__FILE__
, __LINE__
,
4368 "creating event pipe failed.");
4369 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
4370 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
4374 drain_queued_events (-1);
4375 linux_nat_num_queued_events
= 0;
4376 close (linux_nat_event_pipe
[0]);
4377 close (linux_nat_event_pipe
[1]);
4378 linux_nat_event_pipe
[0] = linux_nat_event_pipe
[1] = -1;
4382 linux_nat_async_enabled
= on
;
4386 send_sigint_callback (struct lwp_info
*lp
, void *data
)
4388 /* Use is_running instead of !lp->stopped, because the lwp may be
4389 stopped due to an internal event, and we want to interrupt it in
4390 that case too. What we want is to check if the thread is stopped
4391 from the point of view of the user. */
4392 if (is_running (lp
->ptid
))
4393 kill_lwp (GET_LWP (lp
->ptid
), SIGINT
);
4398 linux_nat_stop (ptid_t ptid
)
4402 if (ptid_equal (ptid
, minus_one_ptid
))
4403 iterate_over_lwps (send_sigint_callback
, &ptid
);
4406 struct lwp_info
*lp
= find_lwp_pid (ptid
);
4407 send_sigint_callback (lp
, NULL
);
4411 linux_ops
->to_stop (ptid
);
4415 linux_nat_add_target (struct target_ops
*t
)
4417 /* Save the provided single-threaded target. We save this in a separate
4418 variable because another target we've inherited from (e.g. inf-ptrace)
4419 may have saved a pointer to T; we want to use it for the final
4420 process stratum target. */
4421 linux_ops_saved
= *t
;
4422 linux_ops
= &linux_ops_saved
;
4424 /* Override some methods for multithreading. */
4425 t
->to_create_inferior
= linux_nat_create_inferior
;
4426 t
->to_attach
= linux_nat_attach
;
4427 t
->to_detach
= linux_nat_detach
;
4428 t
->to_resume
= linux_nat_resume
;
4429 t
->to_wait
= linux_nat_wait
;
4430 t
->to_xfer_partial
= linux_nat_xfer_partial
;
4431 t
->to_kill
= linux_nat_kill
;
4432 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
4433 t
->to_thread_alive
= linux_nat_thread_alive
;
4434 t
->to_pid_to_str
= linux_nat_pid_to_str
;
4435 t
->to_has_thread_control
= tc_schedlock
;
4437 t
->to_can_async_p
= linux_nat_can_async_p
;
4438 t
->to_is_async_p
= linux_nat_is_async_p
;
4439 t
->to_async
= linux_nat_async
;
4440 t
->to_async_mask
= linux_nat_async_mask
;
4441 t
->to_terminal_inferior
= linux_nat_terminal_inferior
;
4442 t
->to_terminal_ours
= linux_nat_terminal_ours
;
4444 /* Methods for non-stop support. */
4445 t
->to_stop
= linux_nat_stop
;
4447 /* We don't change the stratum; this target will sit at
4448 process_stratum and thread_db will set at thread_stratum. This
4449 is a little strange, since this is a multi-threaded-capable
4450 target, but we want to be on the stack below thread_db, and we
4451 also want to be used for single-threaded processes. */
4455 /* TODO: Eliminate this and have libthread_db use
4456 find_target_beneath. */
4460 /* Register a method to call whenever a new thread is attached. */
4462 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
4464 /* Save the pointer. We only support a single registered instance
4465 of the GNU/Linux native target, so we do not need to map this to
4467 linux_nat_new_thread
= new_thread
;
4470 /* Return the saved siginfo associated with PTID. */
4472 linux_nat_get_siginfo (ptid_t ptid
)
4474 struct lwp_info
*lp
= find_lwp_pid (ptid
);
4476 gdb_assert (lp
!= NULL
);
4478 return &lp
->siginfo
;
4482 _initialize_linux_nat (void)
4486 add_info ("proc", linux_nat_info_proc_cmd
, _("\
4487 Show /proc process information about any running process.\n\
4488 Specify any process id, or use the program being debugged by default.\n\
4489 Specify any of the following keywords for detailed info:\n\
4490 mappings -- list of mapped memory regions.\n\
4491 stat -- list a bunch of random process info.\n\
4492 status -- list a different bunch of random process info.\n\
4493 all -- list all available /proc info."));
4495 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance
,
4496 &debug_linux_nat
, _("\
4497 Set debugging of GNU/Linux lwp module."), _("\
4498 Show debugging of GNU/Linux lwp module."), _("\
4499 Enables printf debugging output."),
4501 show_debug_linux_nat
,
4502 &setdebuglist
, &showdebuglist
);
4504 add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance
,
4505 &debug_linux_nat_async
, _("\
4506 Set debugging of GNU/Linux async lwp module."), _("\
4507 Show debugging of GNU/Linux async lwp module."), _("\
4508 Enables printf debugging output."),
4510 show_debug_linux_nat_async
,
4511 &setdebuglist
, &showdebuglist
);
4513 add_setshow_boolean_cmd ("linux-async", class_maintenance
,
4514 &linux_async_permitted_1
, _("\
4515 Set whether gdb controls the GNU/Linux inferior in asynchronous mode."), _("\
4516 Show whether gdb controls the GNU/Linux inferior in asynchronous mode."), _("\
4517 Tells gdb whether to control the GNU/Linux inferior in asynchronous mode."),
4518 set_maintenance_linux_async_permitted
,
4519 show_maintenance_linux_async_permitted
,
4520 &maintenance_set_cmdlist
,
4521 &maintenance_show_cmdlist
);
4523 /* Get the default SIGCHLD action. Used while forking an inferior
4524 (see linux_nat_create_inferior/linux_nat_async_events). */
4525 sigaction (SIGCHLD
, NULL
, &sigchld_default_action
);
4527 /* Block SIGCHLD by default. Doing this early prevents it getting
4528 unblocked if an exception is thrown due to an error while the
4529 inferior is starting (sigsetjmp/siglongjmp). */
4530 sigemptyset (&mask
);
4531 sigaddset (&mask
, SIGCHLD
);
4532 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4534 /* Save this mask as the default. */
4535 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
4537 /* The synchronous SIGCHLD handler. */
4538 sync_sigchld_action
.sa_handler
= sigchld_handler
;
4539 sigemptyset (&sync_sigchld_action
.sa_mask
);
4540 sync_sigchld_action
.sa_flags
= SA_RESTART
;
4542 /* Make it the default. */
4543 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
4545 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4546 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
4547 sigdelset (&suspend_mask
, SIGCHLD
);
4549 /* SIGCHLD handler for async mode. */
4550 async_sigchld_action
.sa_handler
= async_sigchld_handler
;
4551 sigemptyset (&async_sigchld_action
.sa_mask
);
4552 async_sigchld_action
.sa_flags
= SA_RESTART
;
4554 /* Install the default mode. */
4555 linux_nat_set_async_mode (linux_async_permitted
);
4557 add_setshow_boolean_cmd ("disable-randomization", class_support
,
4558 &disable_randomization
, _("\
4559 Set disabling of debuggee's virtual address space randomization."), _("\
4560 Show disabling of debuggee's virtual address space randomization."), _("\
4561 When this mode is on (which is the default), randomization of the virtual\n\
4562 address space is disabled. Standalone programs run with the randomization\n\
4563 enabled by default on some platforms."),
4564 &set_disable_randomization
,
4565 &show_disable_randomization
,
4566 &setlist
, &showlist
);
4570 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4571 the GNU/Linux Threads library and therefore doesn't really belong
4574 /* Read variable NAME in the target and return its value if found.
4575 Otherwise return zero. It is assumed that the type of the variable
4579 get_signo (const char *name
)
4581 struct minimal_symbol
*ms
;
4584 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
4588 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
4589 sizeof (signo
)) != 0)
4595 /* Return the set of signals used by the threads library in *SET. */
4598 lin_thread_get_thread_signals (sigset_t
*set
)
4600 struct sigaction action
;
4601 int restart
, cancel
;
4602 sigset_t blocked_mask
;
4604 sigemptyset (&blocked_mask
);
4607 restart
= get_signo ("__pthread_sig_restart");
4608 cancel
= get_signo ("__pthread_sig_cancel");
4610 /* LinuxThreads normally uses the first two RT signals, but in some legacy
4611 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
4612 not provide any way for the debugger to query the signal numbers -
4613 fortunately they don't change! */
4616 restart
= __SIGRTMIN
;
4619 cancel
= __SIGRTMIN
+ 1;
4621 sigaddset (set
, restart
);
4622 sigaddset (set
, cancel
);
4624 /* The GNU/Linux Threads library makes terminating threads send a
4625 special "cancel" signal instead of SIGCHLD. Make sure we catch
4626 those (to prevent them from terminating GDB itself, which is
4627 likely to be their default action) and treat them the same way as
4630 action
.sa_handler
= sigchld_handler
;
4631 sigemptyset (&action
.sa_mask
);
4632 action
.sa_flags
= SA_RESTART
;
4633 sigaction (cancel
, &action
, NULL
);
4635 /* We block the "cancel" signal throughout this code ... */
4636 sigaddset (&blocked_mask
, cancel
);
4637 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
4639 /* ... except during a sigsuspend. */
4640 sigdelset (&suspend_mask
, cancel
);