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 /* Zero if the async mode, although enabled, is masked, which means
280 linux_nat_wait should behave as if async mode was off. */
281 static int linux_nat_async_mask_value
= 1;
283 /* The read/write ends of the pipe registered as waitable file in the
285 static int linux_nat_event_pipe
[2] = { -1, -1 };
287 /* Number of queued events in the pipe. */
288 static volatile int linux_nat_num_queued_events
;
290 /* The possible SIGCHLD handling states. */
294 /* SIGCHLD disabled, with action set to sigchld_handler, for the
295 sigsuspend in linux_nat_wait. */
297 /* SIGCHLD enabled, with action set to async_sigchld_handler. */
299 /* Set SIGCHLD to default action. Used while creating an
304 /* The current SIGCHLD handling state. */
305 static enum sigchld_state linux_nat_async_events_state
;
307 static enum sigchld_state
linux_nat_async_events (enum sigchld_state enable
);
308 static void pipe_to_local_event_queue (void);
309 static void local_event_queue_to_pipe (void);
310 static void linux_nat_event_pipe_push (int pid
, int status
, int options
);
311 static int linux_nat_event_pipe_pop (int* ptr_status
, int* ptr_options
);
312 static void linux_nat_set_async_mode (int on
);
313 static void linux_nat_async (void (*callback
)
314 (enum inferior_event_type event_type
, void *context
),
316 static int linux_nat_async_mask (int mask
);
317 static int kill_lwp (int lwpid
, int signo
);
319 static int send_sigint_callback (struct lwp_info
*lp
, void *data
);
320 static int stop_callback (struct lwp_info
*lp
, void *data
);
322 /* Captures the result of a successful waitpid call, along with the
323 options used in that call. */
324 struct waitpid_result
329 struct waitpid_result
*next
;
332 /* A singly-linked list of the results of the waitpid calls performed
333 in the async SIGCHLD handler. */
334 static struct waitpid_result
*waitpid_queue
= NULL
;
337 queued_waitpid (int pid
, int *status
, int flags
)
339 struct waitpid_result
*msg
= waitpid_queue
, *prev
= NULL
;
341 if (debug_linux_nat_async
)
342 fprintf_unfiltered (gdb_stdlog
,
344 QWPID: linux_nat_async_events_state(%d), linux_nat_num_queued_events(%d)\n",
345 linux_nat_async_events_state
,
346 linux_nat_num_queued_events
);
350 for (; msg
; prev
= msg
, msg
= msg
->next
)
351 if (pid
== -1 || pid
== msg
->pid
)
354 else if (flags
& __WCLONE
)
356 for (; msg
; prev
= msg
, msg
= msg
->next
)
357 if (msg
->options
& __WCLONE
358 && (pid
== -1 || pid
== msg
->pid
))
363 for (; msg
; prev
= msg
, msg
= msg
->next
)
364 if ((msg
->options
& __WCLONE
) == 0
365 && (pid
== -1 || pid
== msg
->pid
))
374 prev
->next
= msg
->next
;
376 waitpid_queue
= msg
->next
;
380 *status
= msg
->status
;
383 if (debug_linux_nat_async
)
384 fprintf_unfiltered (gdb_stdlog
, "QWPID: pid(%d), status(%x)\n",
391 if (debug_linux_nat_async
)
392 fprintf_unfiltered (gdb_stdlog
, "QWPID: miss\n");
400 push_waitpid (int pid
, int status
, int options
)
402 struct waitpid_result
*event
, *new_event
;
404 new_event
= xmalloc (sizeof (*new_event
));
405 new_event
->pid
= pid
;
406 new_event
->status
= status
;
407 new_event
->options
= options
;
408 new_event
->next
= NULL
;
412 for (event
= waitpid_queue
;
413 event
&& event
->next
;
417 event
->next
= new_event
;
420 waitpid_queue
= new_event
;
423 /* Drain all queued events of PID. If PID is -1, the effect is of
424 draining all events. */
426 drain_queued_events (int pid
)
428 while (queued_waitpid (pid
, NULL
, __WALL
) != -1)
433 /* Trivial list manipulation functions to keep track of a list of
434 new stopped processes. */
436 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
438 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
440 new_pid
->status
= status
;
441 new_pid
->next
= *listp
;
446 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *status
)
448 struct simple_pid_list
**p
;
450 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
451 if ((*p
)->pid
== pid
)
453 struct simple_pid_list
*next
= (*p
)->next
;
454 *status
= (*p
)->status
;
463 linux_record_stopped_pid (int pid
, int status
)
465 add_to_pid_list (&stopped_pids
, pid
, status
);
469 /* A helper function for linux_test_for_tracefork, called after fork (). */
472 linux_tracefork_child (void)
476 ptrace (PTRACE_TRACEME
, 0, 0, 0);
477 kill (getpid (), SIGSTOP
);
482 /* Wrapper function for waitpid which handles EINTR, and checks for
483 locally queued events. */
486 my_waitpid (int pid
, int *status
, int flags
)
490 /* There should be no concurrent calls to waitpid. */
491 gdb_assert (linux_nat_async_events_state
== sigchld_sync
);
493 ret
= queued_waitpid (pid
, status
, flags
);
499 ret
= waitpid (pid
, status
, flags
);
501 while (ret
== -1 && errno
== EINTR
);
506 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
508 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
509 we know that the feature is not available. This may change the tracing
510 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
512 However, if it succeeds, we don't know for sure that the feature is
513 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
514 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
515 fork tracing, and let it fork. If the process exits, we assume that we
516 can't use TRACEFORK; if we get the fork notification, and we can extract
517 the new child's PID, then we assume that we can. */
520 linux_test_for_tracefork (int original_pid
)
522 int child_pid
, ret
, status
;
524 enum sigchld_state async_events_original_state
;
526 async_events_original_state
= linux_nat_async_events (sigchld_sync
);
528 linux_supports_tracefork_flag
= 0;
529 linux_supports_tracevforkdone_flag
= 0;
531 ret
= ptrace (PTRACE_SETOPTIONS
, original_pid
, 0, PTRACE_O_TRACEFORK
);
537 perror_with_name (("fork"));
540 linux_tracefork_child ();
542 ret
= my_waitpid (child_pid
, &status
, 0);
544 perror_with_name (("waitpid"));
545 else if (ret
!= child_pid
)
546 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret
);
547 if (! WIFSTOPPED (status
))
548 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status
);
550 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
553 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
556 warning (_("linux_test_for_tracefork: failed to kill child"));
557 linux_nat_async_events (async_events_original_state
);
561 ret
= my_waitpid (child_pid
, &status
, 0);
562 if (ret
!= child_pid
)
563 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
564 else if (!WIFSIGNALED (status
))
565 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
566 "killed child"), status
);
568 linux_nat_async_events (async_events_original_state
);
572 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
573 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0,
574 PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORKDONE
);
575 linux_supports_tracevforkdone_flag
= (ret
== 0);
577 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
579 warning (_("linux_test_for_tracefork: failed to resume child"));
581 ret
= my_waitpid (child_pid
, &status
, 0);
583 if (ret
== child_pid
&& WIFSTOPPED (status
)
584 && status
>> 16 == PTRACE_EVENT_FORK
)
587 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
588 if (ret
== 0 && second_pid
!= 0)
592 linux_supports_tracefork_flag
= 1;
593 my_waitpid (second_pid
, &second_status
, 0);
594 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
596 warning (_("linux_test_for_tracefork: failed to kill second child"));
597 my_waitpid (second_pid
, &status
, 0);
601 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
602 "(%d, status 0x%x)"), ret
, status
);
604 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
606 warning (_("linux_test_for_tracefork: failed to kill child"));
607 my_waitpid (child_pid
, &status
, 0);
609 linux_nat_async_events (async_events_original_state
);
612 /* Return non-zero iff we have tracefork functionality available.
613 This function also sets linux_supports_tracefork_flag. */
616 linux_supports_tracefork (int pid
)
618 if (linux_supports_tracefork_flag
== -1)
619 linux_test_for_tracefork (pid
);
620 return linux_supports_tracefork_flag
;
624 linux_supports_tracevforkdone (int pid
)
626 if (linux_supports_tracefork_flag
== -1)
627 linux_test_for_tracefork (pid
);
628 return linux_supports_tracevforkdone_flag
;
633 linux_enable_event_reporting (ptid_t ptid
)
635 int pid
= ptid_get_lwp (ptid
);
639 pid
= ptid_get_pid (ptid
);
641 if (! linux_supports_tracefork (pid
))
644 options
= PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEEXEC
645 | PTRACE_O_TRACECLONE
;
646 if (linux_supports_tracevforkdone (pid
))
647 options
|= PTRACE_O_TRACEVFORKDONE
;
649 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
650 read-only process state. */
652 ptrace (PTRACE_SETOPTIONS
, pid
, 0, options
);
656 linux_child_post_attach (int pid
)
658 linux_enable_event_reporting (pid_to_ptid (pid
));
659 check_for_thread_db ();
663 linux_child_post_startup_inferior (ptid_t ptid
)
665 linux_enable_event_reporting (ptid
);
666 check_for_thread_db ();
670 linux_child_follow_fork (struct target_ops
*ops
, int follow_child
)
673 struct target_waitstatus last_status
;
675 int parent_pid
, child_pid
;
677 if (target_can_async_p ())
678 target_async (NULL
, 0);
680 get_last_target_status (&last_ptid
, &last_status
);
681 has_vforked
= (last_status
.kind
== TARGET_WAITKIND_VFORKED
);
682 parent_pid
= ptid_get_lwp (last_ptid
);
684 parent_pid
= ptid_get_pid (last_ptid
);
685 child_pid
= PIDGET (last_status
.value
.related_pid
);
689 /* We're already attached to the parent, by default. */
691 /* Before detaching from the child, remove all breakpoints from
692 it. (This won't actually modify the breakpoint list, but will
693 physically remove the breakpoints from the child.) */
694 /* If we vforked this will remove the breakpoints from the parent
695 also, but they'll be reinserted below. */
696 detach_breakpoints (child_pid
);
698 /* Detach new forked process? */
701 if (info_verbose
|| debug_linux_nat
)
703 target_terminal_ours ();
704 fprintf_filtered (gdb_stdlog
,
705 "Detaching after fork from child process %d.\n",
709 ptrace (PTRACE_DETACH
, child_pid
, 0, 0);
713 struct fork_info
*fp
;
714 /* Retain child fork in ptrace (stopped) state. */
715 fp
= find_fork_pid (child_pid
);
717 fp
= add_fork (child_pid
);
718 fork_save_infrun_state (fp
, 0);
723 gdb_assert (linux_supports_tracefork_flag
>= 0);
724 if (linux_supports_tracevforkdone (0))
728 ptrace (PTRACE_CONT
, parent_pid
, 0, 0);
729 my_waitpid (parent_pid
, &status
, __WALL
);
730 if ((status
>> 16) != PTRACE_EVENT_VFORK_DONE
)
731 warning (_("Unexpected waitpid result %06x when waiting for "
732 "vfork-done"), status
);
736 /* We can't insert breakpoints until the child has
737 finished with the shared memory region. We need to
738 wait until that happens. Ideal would be to just
740 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
741 - waitpid (parent_pid, &status, __WALL);
742 However, most architectures can't handle a syscall
743 being traced on the way out if it wasn't traced on
746 We might also think to loop, continuing the child
747 until it exits or gets a SIGTRAP. One problem is
748 that the child might call ptrace with PTRACE_TRACEME.
750 There's no simple and reliable way to figure out when
751 the vforked child will be done with its copy of the
752 shared memory. We could step it out of the syscall,
753 two instructions, let it go, and then single-step the
754 parent once. When we have hardware single-step, this
755 would work; with software single-step it could still
756 be made to work but we'd have to be able to insert
757 single-step breakpoints in the child, and we'd have
758 to insert -just- the single-step breakpoint in the
759 parent. Very awkward.
761 In the end, the best we can do is to make sure it
762 runs for a little while. Hopefully it will be out of
763 range of any breakpoints we reinsert. Usually this
764 is only the single-step breakpoint at vfork's return
770 /* Since we vforked, breakpoints were removed in the parent
771 too. Put them back. */
772 reattach_breakpoints (parent_pid
);
777 char child_pid_spelling
[40];
779 /* Needed to keep the breakpoint lists in sync. */
781 detach_breakpoints (child_pid
);
783 /* Before detaching from the parent, remove all breakpoints from it. */
784 remove_breakpoints ();
786 if (info_verbose
|| debug_linux_nat
)
788 target_terminal_ours ();
789 fprintf_filtered (gdb_stdlog
,
790 "Attaching after fork to child process %d.\n",
794 /* If we're vforking, we may want to hold on to the parent until
795 the child exits or execs. At exec time we can remove the old
796 breakpoints from the parent and detach it; at exit time we
797 could do the same (or even, sneakily, resume debugging it - the
798 child's exec has failed, or something similar).
800 This doesn't clean up "properly", because we can't call
801 target_detach, but that's OK; if the current target is "child",
802 then it doesn't need any further cleanups, and lin_lwp will
803 generally not encounter vfork (vfork is defined to fork
806 The holding part is very easy if we have VFORKDONE events;
807 but keeping track of both processes is beyond GDB at the
808 moment. So we don't expose the parent to the rest of GDB.
809 Instead we quietly hold onto it until such time as we can
813 linux_parent_pid
= parent_pid
;
814 else if (!detach_fork
)
816 struct fork_info
*fp
;
817 /* Retain parent fork in ptrace (stopped) state. */
818 fp
= find_fork_pid (parent_pid
);
820 fp
= add_fork (parent_pid
);
821 fork_save_infrun_state (fp
, 0);
824 target_detach (NULL
, 0);
826 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
828 /* Reinstall ourselves, since we might have been removed in
829 target_detach (which does other necessary cleanup). */
832 linux_nat_switch_fork (inferior_ptid
);
833 check_for_thread_db ();
835 /* Reset breakpoints in the child as appropriate. */
836 follow_inferior_reset_breakpoints ();
839 if (target_can_async_p ())
840 target_async (inferior_event_handler
, 0);
847 linux_child_insert_fork_catchpoint (int pid
)
849 if (! linux_supports_tracefork (pid
))
850 error (_("Your system does not support fork catchpoints."));
854 linux_child_insert_vfork_catchpoint (int pid
)
856 if (!linux_supports_tracefork (pid
))
857 error (_("Your system does not support vfork catchpoints."));
861 linux_child_insert_exec_catchpoint (int pid
)
863 if (!linux_supports_tracefork (pid
))
864 error (_("Your system does not support exec catchpoints."));
867 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
868 are processes sharing the same VM space. A multi-threaded process
869 is basically a group of such processes. However, such a grouping
870 is almost entirely a user-space issue; the kernel doesn't enforce
871 such a grouping at all (this might change in the future). In
872 general, we'll rely on the threads library (i.e. the GNU/Linux
873 Threads library) to provide such a grouping.
875 It is perfectly well possible to write a multi-threaded application
876 without the assistance of a threads library, by using the clone
877 system call directly. This module should be able to give some
878 rudimentary support for debugging such applications if developers
879 specify the CLONE_PTRACE flag in the clone system call, and are
880 using the Linux kernel 2.4 or above.
882 Note that there are some peculiarities in GNU/Linux that affect
885 - In general one should specify the __WCLONE flag to waitpid in
886 order to make it report events for any of the cloned processes
887 (and leave it out for the initial process). However, if a cloned
888 process has exited the exit status is only reported if the
889 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
890 we cannot use it since GDB must work on older systems too.
892 - When a traced, cloned process exits and is waited for by the
893 debugger, the kernel reassigns it to the original parent and
894 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
895 library doesn't notice this, which leads to the "zombie problem":
896 When debugged a multi-threaded process that spawns a lot of
897 threads will run out of processes, even if the threads exit,
898 because the "zombies" stay around. */
900 /* List of known LWPs. */
901 struct lwp_info
*lwp_list
;
903 /* Number of LWPs in the list. */
907 /* Original signal mask. */
908 static sigset_t normal_mask
;
910 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
911 _initialize_linux_nat. */
912 static sigset_t suspend_mask
;
914 /* SIGCHLD action for synchronous mode. */
915 struct sigaction sync_sigchld_action
;
917 /* SIGCHLD action for asynchronous mode. */
918 static struct sigaction async_sigchld_action
;
920 /* SIGCHLD default action, to pass to new inferiors. */
921 static struct sigaction sigchld_default_action
;
924 /* Prototypes for local functions. */
925 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
926 static int linux_nat_thread_alive (ptid_t ptid
);
927 static char *linux_child_pid_to_exec_file (int pid
);
928 static int cancel_breakpoint (struct lwp_info
*lp
);
931 /* Convert wait status STATUS to a string. Used for printing debug
935 status_to_str (int status
)
939 if (WIFSTOPPED (status
))
940 snprintf (buf
, sizeof (buf
), "%s (stopped)",
941 strsignal (WSTOPSIG (status
)));
942 else if (WIFSIGNALED (status
))
943 snprintf (buf
, sizeof (buf
), "%s (terminated)",
944 strsignal (WSTOPSIG (status
)));
946 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
951 /* Initialize the list of LWPs. Note that this module, contrary to
952 what GDB's generic threads layer does for its thread list,
953 re-initializes the LWP lists whenever we mourn or detach (which
954 doesn't involve mourning) the inferior. */
959 struct lwp_info
*lp
, *lpnext
;
961 for (lp
= lwp_list
; lp
; lp
= lpnext
)
971 /* Add the LWP specified by PID to the list. Return a pointer to the
972 structure describing the new LWP. The LWP should already be stopped
973 (with an exception for the very first LWP). */
975 static struct lwp_info
*
976 add_lwp (ptid_t ptid
)
980 gdb_assert (is_lwp (ptid
));
982 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
984 memset (lp
, 0, sizeof (struct lwp_info
));
986 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
994 if (num_lwps
> 1 && linux_nat_new_thread
!= NULL
)
995 linux_nat_new_thread (ptid
);
1000 /* Remove the LWP specified by PID from the list. */
1003 delete_lwp (ptid_t ptid
)
1005 struct lwp_info
*lp
, *lpprev
;
1009 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
1010 if (ptid_equal (lp
->ptid
, ptid
))
1019 lpprev
->next
= lp
->next
;
1021 lwp_list
= lp
->next
;
1026 /* Return a pointer to the structure describing the LWP corresponding
1027 to PID. If no corresponding LWP could be found, return NULL. */
1029 static struct lwp_info
*
1030 find_lwp_pid (ptid_t ptid
)
1032 struct lwp_info
*lp
;
1036 lwp
= GET_LWP (ptid
);
1038 lwp
= GET_PID (ptid
);
1040 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
1041 if (lwp
== GET_LWP (lp
->ptid
))
1047 /* Call CALLBACK with its second argument set to DATA for every LWP in
1048 the list. If CALLBACK returns 1 for a particular LWP, return a
1049 pointer to the structure describing that LWP immediately.
1050 Otherwise return NULL. */
1053 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
1055 struct lwp_info
*lp
, *lpnext
;
1057 for (lp
= lwp_list
; lp
; lp
= lpnext
)
1060 if ((*callback
) (lp
, data
))
1067 /* Update our internal state when changing from one fork (checkpoint,
1068 et cetera) to another indicated by NEW_PTID. We can only switch
1069 single-threaded applications, so we only create one new LWP, and
1070 the previous list is discarded. */
1073 linux_nat_switch_fork (ptid_t new_ptid
)
1075 struct lwp_info
*lp
;
1078 lp
= add_lwp (new_ptid
);
1081 init_thread_list ();
1082 add_thread_silent (new_ptid
);
1085 /* Handle the exit of a single thread LP. */
1088 exit_lwp (struct lwp_info
*lp
)
1090 struct thread_info
*th
= find_thread_pid (lp
->ptid
);
1094 if (print_thread_events
)
1095 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp
->ptid
));
1097 delete_thread (lp
->ptid
);
1100 delete_lwp (lp
->ptid
);
1103 /* Detect `T (stopped)' in `/proc/PID/status'.
1104 Other states including `T (tracing stop)' are reported as false. */
1107 pid_is_stopped (pid_t pid
)
1113 snprintf (buf
, sizeof (buf
), "/proc/%d/status", (int) pid
);
1114 status_file
= fopen (buf
, "r");
1115 if (status_file
!= NULL
)
1119 while (fgets (buf
, sizeof (buf
), status_file
))
1121 if (strncmp (buf
, "State:", 6) == 0)
1127 if (have_state
&& strstr (buf
, "T (stopped)") != NULL
)
1129 fclose (status_file
);
1134 /* Wait for the LWP specified by LP, which we have just attached to.
1135 Returns a wait status for that LWP, to cache. */
1138 linux_nat_post_attach_wait (ptid_t ptid
, int first
, int *cloned
,
1141 pid_t new_pid
, pid
= GET_LWP (ptid
);
1144 if (pid_is_stopped (pid
))
1146 if (debug_linux_nat
)
1147 fprintf_unfiltered (gdb_stdlog
,
1148 "LNPAW: Attaching to a stopped process\n");
1150 /* The process is definitely stopped. It is in a job control
1151 stop, unless the kernel predates the TASK_STOPPED /
1152 TASK_TRACED distinction, in which case it might be in a
1153 ptrace stop. Make sure it is in a ptrace stop; from there we
1154 can kill it, signal it, et cetera.
1156 First make sure there is a pending SIGSTOP. Since we are
1157 already attached, the process can not transition from stopped
1158 to running without a PTRACE_CONT; so we know this signal will
1159 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1160 probably already in the queue (unless this kernel is old
1161 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1162 is not an RT signal, it can only be queued once. */
1163 kill_lwp (pid
, SIGSTOP
);
1165 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1166 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1167 ptrace (PTRACE_CONT
, pid
, 0, 0);
1170 /* Make sure the initial process is stopped. The user-level threads
1171 layer might want to poke around in the inferior, and that won't
1172 work if things haven't stabilized yet. */
1173 new_pid
= my_waitpid (pid
, &status
, 0);
1174 if (new_pid
== -1 && errno
== ECHILD
)
1177 warning (_("%s is a cloned process"), target_pid_to_str (ptid
));
1179 /* Try again with __WCLONE to check cloned processes. */
1180 new_pid
= my_waitpid (pid
, &status
, __WCLONE
);
1184 gdb_assert (pid
== new_pid
&& WIFSTOPPED (status
));
1186 if (WSTOPSIG (status
) != SIGSTOP
)
1189 if (debug_linux_nat
)
1190 fprintf_unfiltered (gdb_stdlog
,
1191 "LNPAW: Received %s after attaching\n",
1192 status_to_str (status
));
1198 /* Attach to the LWP specified by PID. Return 0 if successful or -1
1199 if the new LWP could not be attached. */
1202 lin_lwp_attach_lwp (ptid_t ptid
)
1204 struct lwp_info
*lp
;
1205 enum sigchld_state async_events_original_state
;
1207 gdb_assert (is_lwp (ptid
));
1209 async_events_original_state
= linux_nat_async_events (sigchld_sync
);
1211 lp
= find_lwp_pid (ptid
);
1213 /* We assume that we're already attached to any LWP that has an id
1214 equal to the overall process id, and to any LWP that is already
1215 in our list of LWPs. If we're not seeing exit events from threads
1216 and we've had PID wraparound since we last tried to stop all threads,
1217 this assumption might be wrong; fortunately, this is very unlikely
1219 if (GET_LWP (ptid
) != GET_PID (ptid
) && lp
== NULL
)
1221 int status
, cloned
= 0, signalled
= 0;
1223 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
1225 /* If we fail to attach to the thread, issue a warning,
1226 but continue. One way this can happen is if thread
1227 creation is interrupted; as of Linux kernel 2.6.19, a
1228 bug may place threads in the thread list and then fail
1230 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
1231 safe_strerror (errno
));
1235 if (debug_linux_nat
)
1236 fprintf_unfiltered (gdb_stdlog
,
1237 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1238 target_pid_to_str (ptid
));
1240 status
= linux_nat_post_attach_wait (ptid
, 0, &cloned
, &signalled
);
1241 lp
= add_lwp (ptid
);
1243 lp
->cloned
= cloned
;
1244 lp
->signalled
= signalled
;
1245 if (WSTOPSIG (status
) != SIGSTOP
)
1248 lp
->status
= status
;
1251 target_post_attach (GET_LWP (lp
->ptid
));
1253 if (debug_linux_nat
)
1255 fprintf_unfiltered (gdb_stdlog
,
1256 "LLAL: waitpid %s received %s\n",
1257 target_pid_to_str (ptid
),
1258 status_to_str (status
));
1263 /* We assume that the LWP representing the original process is
1264 already stopped. Mark it as stopped in the data structure
1265 that the GNU/linux ptrace layer uses to keep track of
1266 threads. Note that this won't have already been done since
1267 the main thread will have, we assume, been stopped by an
1268 attach from a different layer. */
1270 lp
= add_lwp (ptid
);
1274 linux_nat_async_events (async_events_original_state
);
1279 linux_nat_create_inferior (char *exec_file
, char *allargs
, char **env
,
1282 int saved_async
= 0;
1283 #ifdef HAVE_PERSONALITY
1284 int personality_orig
= 0, personality_set
= 0;
1285 #endif /* HAVE_PERSONALITY */
1287 /* The fork_child mechanism is synchronous and calls target_wait, so
1288 we have to mask the async mode. */
1290 if (target_can_async_p ())
1291 /* Mask async mode. Creating a child requires a loop calling
1292 wait_for_inferior currently. */
1293 saved_async
= linux_nat_async_mask (0);
1296 /* Restore the original signal mask. */
1297 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1298 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1299 suspend_mask
= normal_mask
;
1300 sigdelset (&suspend_mask
, SIGCHLD
);
1303 /* Set SIGCHLD to the default action, until after execing the child,
1304 since the inferior inherits the superior's signal mask. It will
1305 be blocked again in linux_nat_wait, which is only reached after
1306 the inferior execing. */
1307 linux_nat_async_events (sigchld_default
);
1309 #ifdef HAVE_PERSONALITY
1310 if (disable_randomization
)
1313 personality_orig
= personality (0xffffffff);
1314 if (errno
== 0 && !(personality_orig
& ADDR_NO_RANDOMIZE
))
1316 personality_set
= 1;
1317 personality (personality_orig
| ADDR_NO_RANDOMIZE
);
1319 if (errno
!= 0 || (personality_set
1320 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE
)))
1321 warning (_("Error disabling address space randomization: %s"),
1322 safe_strerror (errno
));
1324 #endif /* HAVE_PERSONALITY */
1326 linux_ops
->to_create_inferior (exec_file
, allargs
, env
, from_tty
);
1328 #ifdef HAVE_PERSONALITY
1329 if (personality_set
)
1332 personality (personality_orig
);
1334 warning (_("Error restoring address space randomization: %s"),
1335 safe_strerror (errno
));
1337 #endif /* HAVE_PERSONALITY */
1340 linux_nat_async_mask (saved_async
);
1344 linux_nat_attach (char *args
, int from_tty
)
1346 struct lwp_info
*lp
;
1349 /* FIXME: We should probably accept a list of process id's, and
1350 attach all of them. */
1351 linux_ops
->to_attach (args
, from_tty
);
1353 if (!target_can_async_p ())
1355 /* Restore the original signal mask. */
1356 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1357 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1358 suspend_mask
= normal_mask
;
1359 sigdelset (&suspend_mask
, SIGCHLD
);
1362 /* Add the initial process as the first LWP to the list. */
1363 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
));
1364 lp
= add_lwp (inferior_ptid
);
1366 status
= linux_nat_post_attach_wait (lp
->ptid
, 1, &lp
->cloned
,
1370 /* If this process is not using thread_db, then we still don't
1371 detect any other threads, but add at least this one. */
1372 add_thread_silent (lp
->ptid
);
1374 /* Save the wait status to report later. */
1376 if (debug_linux_nat
)
1377 fprintf_unfiltered (gdb_stdlog
,
1378 "LNA: waitpid %ld, saving status %s\n",
1379 (long) GET_PID (lp
->ptid
), status_to_str (status
));
1381 if (!target_can_async_p ())
1382 lp
->status
= status
;
1385 /* We already waited for this LWP, so put the wait result on the
1386 pipe. The event loop will wake up and gets us to handling
1388 linux_nat_event_pipe_push (GET_PID (lp
->ptid
), status
,
1389 lp
->cloned
? __WCLONE
: 0);
1390 /* Register in the event loop. */
1391 target_async (inferior_event_handler
, 0);
1395 /* Get pending status of LP. */
1397 get_pending_status (struct lwp_info
*lp
, int *status
)
1399 struct target_waitstatus last
;
1402 get_last_target_status (&last_ptid
, &last
);
1404 /* If this lwp is the ptid that GDB is processing an event from, the
1405 signal will be in stop_signal. Otherwise, in all-stop + sync
1406 mode, we may cache pending events in lp->status while trying to
1407 stop all threads (see stop_wait_callback). In async mode, the
1408 events are always cached in waitpid_queue. */
1414 enum target_signal signo
= TARGET_SIGNAL_0
;
1416 if (is_executing (lp
->ptid
))
1418 /* If the core thought this lwp was executing --- e.g., the
1419 executing property hasn't been updated yet, but the
1420 thread has been stopped with a stop_callback /
1421 stop_wait_callback sequence (see linux_nat_detach for
1422 example) --- we can only have pending events in the local
1424 if (queued_waitpid (GET_LWP (lp
->ptid
), status
, __WALL
) != -1)
1426 if (WIFSTOPPED (status
))
1427 signo
= target_signal_from_host (WSTOPSIG (status
));
1429 /* If not stopped, then the lwp is gone, no use in
1430 resending a signal. */
1435 /* If the core knows the thread is not executing, then we
1436 have the last signal recorded in
1437 thread_info->stop_signal, unless this is inferior_ptid,
1438 in which case, it's in the global stop_signal, due to
1439 context switching. */
1441 if (ptid_equal (lp
->ptid
, inferior_ptid
))
1442 signo
= stop_signal
;
1445 struct thread_info
*tp
= find_thread_pid (lp
->ptid
);
1447 signo
= tp
->stop_signal
;
1451 if (signo
!= TARGET_SIGNAL_0
1452 && !signal_pass_state (signo
))
1454 if (debug_linux_nat
)
1455 fprintf_unfiltered (gdb_stdlog
, "\
1456 GPT: lwp %s had signal %s, but it is in no pass state\n",
1457 target_pid_to_str (lp
->ptid
),
1458 target_signal_to_string (signo
));
1462 if (signo
!= TARGET_SIGNAL_0
)
1463 *status
= W_STOPCODE (target_signal_to_host (signo
));
1465 if (debug_linux_nat
)
1466 fprintf_unfiltered (gdb_stdlog
,
1467 "GPT: lwp %s as pending signal %s\n",
1468 target_pid_to_str (lp
->ptid
),
1469 target_signal_to_string (signo
));
1474 if (GET_LWP (lp
->ptid
) == GET_LWP (last_ptid
))
1476 if (stop_signal
!= TARGET_SIGNAL_0
1477 && signal_pass_state (stop_signal
))
1478 *status
= W_STOPCODE (target_signal_to_host (stop_signal
));
1480 else if (target_can_async_p ())
1481 queued_waitpid (GET_LWP (lp
->ptid
), status
, __WALL
);
1483 *status
= lp
->status
;
1490 detach_callback (struct lwp_info
*lp
, void *data
)
1492 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1494 if (debug_linux_nat
&& lp
->status
)
1495 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
1496 strsignal (WSTOPSIG (lp
->status
)),
1497 target_pid_to_str (lp
->ptid
));
1499 /* If there is a pending SIGSTOP, get rid of it. */
1502 if (debug_linux_nat
)
1503 fprintf_unfiltered (gdb_stdlog
,
1504 "DC: Sending SIGCONT to %s\n",
1505 target_pid_to_str (lp
->ptid
));
1507 kill_lwp (GET_LWP (lp
->ptid
), SIGCONT
);
1511 /* We don't actually detach from the LWP that has an id equal to the
1512 overall process id just yet. */
1513 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
1517 /* Pass on any pending signal for this LWP. */
1518 get_pending_status (lp
, &status
);
1521 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
1522 WSTOPSIG (status
)) < 0)
1523 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1524 safe_strerror (errno
));
1526 if (debug_linux_nat
)
1527 fprintf_unfiltered (gdb_stdlog
,
1528 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1529 target_pid_to_str (lp
->ptid
),
1530 strsignal (WSTOPSIG (lp
->status
)));
1532 delete_lwp (lp
->ptid
);
1539 linux_nat_detach (char *args
, int from_tty
)
1543 enum target_signal sig
;
1545 if (target_can_async_p ())
1546 linux_nat_async (NULL
, 0);
1548 /* Stop all threads before detaching. ptrace requires that the
1549 thread is stopped to sucessfully detach. */
1550 iterate_over_lwps (stop_callback
, NULL
);
1551 /* ... and wait until all of them have reported back that
1552 they're no longer running. */
1553 iterate_over_lwps (stop_wait_callback
, NULL
);
1555 iterate_over_lwps (detach_callback
, NULL
);
1557 /* Only the initial process should be left right now. */
1558 gdb_assert (num_lwps
== 1);
1560 /* Pass on any pending signal for the last LWP. */
1561 if ((args
== NULL
|| *args
== '\0')
1562 && get_pending_status (lwp_list
, &status
) != -1
1563 && WIFSTOPPED (status
))
1565 /* Put the signal number in ARGS so that inf_ptrace_detach will
1566 pass it along with PTRACE_DETACH. */
1568 sprintf (args
, "%d", (int) WSTOPSIG (status
));
1569 fprintf_unfiltered (gdb_stdlog
,
1570 "LND: Sending signal %s to %s\n",
1572 target_pid_to_str (lwp_list
->ptid
));
1575 /* Destroy LWP info; it's no longer valid. */
1578 pid
= GET_PID (inferior_ptid
);
1579 inferior_ptid
= pid_to_ptid (pid
);
1580 linux_ops
->to_detach (args
, from_tty
);
1582 if (target_can_async_p ())
1583 drain_queued_events (pid
);
1589 resume_callback (struct lwp_info
*lp
, void *data
)
1591 if (lp
->stopped
&& lp
->status
== 0)
1593 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
1594 0, TARGET_SIGNAL_0
);
1595 if (debug_linux_nat
)
1596 fprintf_unfiltered (gdb_stdlog
,
1597 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1598 target_pid_to_str (lp
->ptid
));
1601 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1603 else if (lp
->stopped
&& debug_linux_nat
)
1604 fprintf_unfiltered (gdb_stdlog
, "RC: Not resuming sibling %s (has pending)\n",
1605 target_pid_to_str (lp
->ptid
));
1606 else if (debug_linux_nat
)
1607 fprintf_unfiltered (gdb_stdlog
, "RC: Not resuming sibling %s (not stopped)\n",
1608 target_pid_to_str (lp
->ptid
));
1614 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1621 resume_set_callback (struct lwp_info
*lp
, void *data
)
1628 linux_nat_resume (ptid_t ptid
, int step
, enum target_signal signo
)
1630 struct lwp_info
*lp
;
1633 if (debug_linux_nat
)
1634 fprintf_unfiltered (gdb_stdlog
,
1635 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1636 step
? "step" : "resume",
1637 target_pid_to_str (ptid
),
1638 signo
? strsignal (signo
) : "0",
1639 target_pid_to_str (inferior_ptid
));
1641 if (target_can_async_p ())
1642 /* Block events while we're here. */
1643 linux_nat_async_events (sigchld_sync
);
1645 /* A specific PTID means `step only this process id'. */
1646 resume_all
= (PIDGET (ptid
) == -1);
1648 if (non_stop
&& resume_all
)
1649 internal_error (__FILE__
, __LINE__
,
1650 "can't resume all in non-stop mode");
1655 iterate_over_lwps (resume_set_callback
, NULL
);
1657 iterate_over_lwps (resume_clear_callback
, NULL
);
1660 /* If PID is -1, it's the current inferior that should be
1661 handled specially. */
1662 if (PIDGET (ptid
) == -1)
1663 ptid
= inferior_ptid
;
1665 lp
= find_lwp_pid (ptid
);
1666 gdb_assert (lp
!= NULL
);
1668 /* Convert to something the lower layer understands. */
1669 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
1671 /* Remember if we're stepping. */
1674 /* Mark this LWP as resumed. */
1677 /* If we have a pending wait status for this thread, there is no
1678 point in resuming the process. But first make sure that
1679 linux_nat_wait won't preemptively handle the event - we
1680 should never take this short-circuit if we are going to
1681 leave LP running, since we have skipped resuming all the
1682 other threads. This bit of code needs to be synchronized
1683 with linux_nat_wait. */
1685 /* In async mode, we never have pending wait status. */
1686 if (target_can_async_p () && lp
->status
)
1687 internal_error (__FILE__
, __LINE__
, "Pending status in async mode");
1689 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1691 int saved_signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1693 if (signal_stop_state (saved_signo
) == 0
1694 && signal_print_state (saved_signo
) == 0
1695 && signal_pass_state (saved_signo
) == 1)
1697 if (debug_linux_nat
)
1698 fprintf_unfiltered (gdb_stdlog
,
1699 "LLR: Not short circuiting for ignored "
1700 "status 0x%x\n", lp
->status
);
1702 /* FIXME: What should we do if we are supposed to continue
1703 this thread with a signal? */
1704 gdb_assert (signo
== TARGET_SIGNAL_0
);
1705 signo
= saved_signo
;
1712 /* FIXME: What should we do if we are supposed to continue
1713 this thread with a signal? */
1714 gdb_assert (signo
== TARGET_SIGNAL_0
);
1716 if (debug_linux_nat
)
1717 fprintf_unfiltered (gdb_stdlog
,
1718 "LLR: Short circuiting for status 0x%x\n",
1724 /* Mark LWP as not stopped to prevent it from being continued by
1729 iterate_over_lwps (resume_callback
, NULL
);
1731 linux_ops
->to_resume (ptid
, step
, signo
);
1732 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1734 if (debug_linux_nat
)
1735 fprintf_unfiltered (gdb_stdlog
,
1736 "LLR: %s %s, %s (resume event thread)\n",
1737 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1738 target_pid_to_str (ptid
),
1739 signo
? strsignal (signo
) : "0");
1741 if (target_can_async_p ())
1742 target_async (inferior_event_handler
, 0);
1745 /* Issue kill to specified lwp. */
1747 static int tkill_failed
;
1750 kill_lwp (int lwpid
, int signo
)
1754 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1755 fails, then we are not using nptl threads and we should be using kill. */
1757 #ifdef HAVE_TKILL_SYSCALL
1760 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
1761 if (errno
!= ENOSYS
)
1768 return kill (lwpid
, signo
);
1771 /* Handle a GNU/Linux extended wait response. If we see a clone
1772 event, we need to add the new LWP to our list (and not report the
1773 trap to higher layers). This function returns non-zero if the
1774 event should be ignored and we should wait again. If STOPPING is
1775 true, the new LWP remains stopped, otherwise it is continued. */
1778 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
1781 int pid
= GET_LWP (lp
->ptid
);
1782 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1783 struct lwp_info
*new_lp
= NULL
;
1784 int event
= status
>> 16;
1786 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1787 || event
== PTRACE_EVENT_CLONE
)
1789 unsigned long new_pid
;
1792 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1794 /* If we haven't already seen the new PID stop, wait for it now. */
1795 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1797 /* The new child has a pending SIGSTOP. We can't affect it until it
1798 hits the SIGSTOP, but we're already attached. */
1799 ret
= my_waitpid (new_pid
, &status
,
1800 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
1802 perror_with_name (_("waiting for new child"));
1803 else if (ret
!= new_pid
)
1804 internal_error (__FILE__
, __LINE__
,
1805 _("wait returned unexpected PID %d"), ret
);
1806 else if (!WIFSTOPPED (status
))
1807 internal_error (__FILE__
, __LINE__
,
1808 _("wait returned unexpected status 0x%x"), status
);
1811 ourstatus
->value
.related_pid
= ptid_build (new_pid
, new_pid
, 0);
1813 if (event
== PTRACE_EVENT_FORK
)
1814 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1815 else if (event
== PTRACE_EVENT_VFORK
)
1816 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1819 struct cleanup
*old_chain
;
1821 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1822 new_lp
= add_lwp (BUILD_LWP (new_pid
, GET_PID (inferior_ptid
)));
1824 new_lp
->stopped
= 1;
1826 if (WSTOPSIG (status
) != SIGSTOP
)
1828 /* This can happen if someone starts sending signals to
1829 the new thread before it gets a chance to run, which
1830 have a lower number than SIGSTOP (e.g. SIGUSR1).
1831 This is an unlikely case, and harder to handle for
1832 fork / vfork than for clone, so we do not try - but
1833 we handle it for clone events here. We'll send
1834 the other signal on to the thread below. */
1836 new_lp
->signalled
= 1;
1843 /* Add the new thread to GDB's lists as soon as possible
1846 1) the frontend doesn't have to wait for a stop to
1849 2) we tag it with the correct running state. */
1851 /* If the thread_db layer is active, let it know about
1852 this new thread, and add it to GDB's list. */
1853 if (!thread_db_attach_lwp (new_lp
->ptid
))
1855 /* We're not using thread_db. Add it to GDB's
1857 target_post_attach (GET_LWP (new_lp
->ptid
));
1858 add_thread (new_lp
->ptid
);
1863 set_running (new_lp
->ptid
, 1);
1864 set_executing (new_lp
->ptid
, 1);
1870 new_lp
->stopped
= 0;
1871 new_lp
->resumed
= 1;
1872 ptrace (PTRACE_CONT
, new_pid
, 0,
1873 status
? WSTOPSIG (status
) : 0);
1876 if (debug_linux_nat
)
1877 fprintf_unfiltered (gdb_stdlog
,
1878 "LHEW: Got clone event from LWP %ld, resuming\n",
1879 GET_LWP (lp
->ptid
));
1880 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1888 if (event
== PTRACE_EVENT_EXEC
)
1890 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1891 ourstatus
->value
.execd_pathname
1892 = xstrdup (linux_child_pid_to_exec_file (pid
));
1894 if (linux_parent_pid
)
1896 detach_breakpoints (linux_parent_pid
);
1897 ptrace (PTRACE_DETACH
, linux_parent_pid
, 0, 0);
1899 linux_parent_pid
= 0;
1902 /* At this point, all inserted breakpoints are gone. Doing this
1903 as soon as we detect an exec prevents the badness of deleting
1904 a breakpoint writing the current "shadow contents" to lift
1905 the bp. That shadow is NOT valid after an exec.
1907 Note that we have to do this after the detach_breakpoints
1908 call above, otherwise breakpoints wouldn't be lifted from the
1909 parent on a vfork, because detach_breakpoints would think
1910 that breakpoints are not inserted. */
1911 mark_breakpoints_out ();
1915 internal_error (__FILE__
, __LINE__
,
1916 _("unknown ptrace event %d"), event
);
1919 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1923 wait_lwp (struct lwp_info
*lp
)
1927 int thread_dead
= 0;
1929 gdb_assert (!lp
->stopped
);
1930 gdb_assert (lp
->status
== 0);
1932 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, 0);
1933 if (pid
== -1 && errno
== ECHILD
)
1935 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
1936 if (pid
== -1 && errno
== ECHILD
)
1938 /* The thread has previously exited. We need to delete it
1939 now because, for some vendor 2.4 kernels with NPTL
1940 support backported, there won't be an exit event unless
1941 it is the main thread. 2.6 kernels will report an exit
1942 event for each thread that exits, as expected. */
1944 if (debug_linux_nat
)
1945 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
1946 target_pid_to_str (lp
->ptid
));
1952 gdb_assert (pid
== GET_LWP (lp
->ptid
));
1954 if (debug_linux_nat
)
1956 fprintf_unfiltered (gdb_stdlog
,
1957 "WL: waitpid %s received %s\n",
1958 target_pid_to_str (lp
->ptid
),
1959 status_to_str (status
));
1963 /* Check if the thread has exited. */
1964 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1967 if (debug_linux_nat
)
1968 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
1969 target_pid_to_str (lp
->ptid
));
1978 gdb_assert (WIFSTOPPED (status
));
1980 /* Handle GNU/Linux's extended waitstatus for trace events. */
1981 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1983 if (debug_linux_nat
)
1984 fprintf_unfiltered (gdb_stdlog
,
1985 "WL: Handling extended status 0x%06x\n",
1987 if (linux_handle_extended_wait (lp
, status
, 1))
1988 return wait_lwp (lp
);
1994 /* Save the most recent siginfo for LP. This is currently only called
1995 for SIGTRAP; some ports use the si_addr field for
1996 target_stopped_data_address. In the future, it may also be used to
1997 restore the siginfo of requeued signals. */
2000 save_siginfo (struct lwp_info
*lp
)
2003 ptrace (PTRACE_GETSIGINFO
, GET_LWP (lp
->ptid
),
2004 (PTRACE_TYPE_ARG3
) 0, &lp
->siginfo
);
2007 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
2010 /* Send a SIGSTOP to LP. */
2013 stop_callback (struct lwp_info
*lp
, void *data
)
2015 if (!lp
->stopped
&& !lp
->signalled
)
2019 if (debug_linux_nat
)
2021 fprintf_unfiltered (gdb_stdlog
,
2022 "SC: kill %s **<SIGSTOP>**\n",
2023 target_pid_to_str (lp
->ptid
));
2026 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
2027 if (debug_linux_nat
)
2029 fprintf_unfiltered (gdb_stdlog
,
2030 "SC: lwp kill %d %s\n",
2032 errno
? safe_strerror (errno
) : "ERRNO-OK");
2036 gdb_assert (lp
->status
== 0);
2042 /* Return non-zero if LWP PID has a pending SIGINT. */
2045 linux_nat_has_pending_sigint (int pid
)
2047 sigset_t pending
, blocked
, ignored
;
2050 linux_proc_pending_signals (pid
, &pending
, &blocked
, &ignored
);
2052 if (sigismember (&pending
, SIGINT
)
2053 && !sigismember (&ignored
, SIGINT
))
2059 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2062 set_ignore_sigint (struct lwp_info
*lp
, void *data
)
2064 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2065 flag to consume the next one. */
2066 if (lp
->stopped
&& lp
->status
!= 0 && WIFSTOPPED (lp
->status
)
2067 && WSTOPSIG (lp
->status
) == SIGINT
)
2070 lp
->ignore_sigint
= 1;
2075 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2076 This function is called after we know the LWP has stopped; if the LWP
2077 stopped before the expected SIGINT was delivered, then it will never have
2078 arrived. Also, if the signal was delivered to a shared queue and consumed
2079 by a different thread, it will never be delivered to this LWP. */
2082 maybe_clear_ignore_sigint (struct lwp_info
*lp
)
2084 if (!lp
->ignore_sigint
)
2087 if (!linux_nat_has_pending_sigint (GET_LWP (lp
->ptid
)))
2089 if (debug_linux_nat
)
2090 fprintf_unfiltered (gdb_stdlog
,
2091 "MCIS: Clearing bogus flag for %s\n",
2092 target_pid_to_str (lp
->ptid
));
2093 lp
->ignore_sigint
= 0;
2097 /* Wait until LP is stopped. */
2100 stop_wait_callback (struct lwp_info
*lp
, void *data
)
2106 status
= wait_lwp (lp
);
2110 if (lp
->ignore_sigint
&& WIFSTOPPED (status
)
2111 && WSTOPSIG (status
) == SIGINT
)
2113 lp
->ignore_sigint
= 0;
2116 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2117 if (debug_linux_nat
)
2118 fprintf_unfiltered (gdb_stdlog
,
2119 "PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)\n",
2120 target_pid_to_str (lp
->ptid
),
2121 errno
? safe_strerror (errno
) : "OK");
2123 return stop_wait_callback (lp
, NULL
);
2126 maybe_clear_ignore_sigint (lp
);
2128 if (WSTOPSIG (status
) != SIGSTOP
)
2130 if (WSTOPSIG (status
) == SIGTRAP
)
2132 /* If a LWP other than the LWP that we're reporting an
2133 event for has hit a GDB breakpoint (as opposed to
2134 some random trap signal), then just arrange for it to
2135 hit it again later. We don't keep the SIGTRAP status
2136 and don't forward the SIGTRAP signal to the LWP. We
2137 will handle the current event, eventually we will
2138 resume all LWPs, and this one will get its breakpoint
2141 If we do not do this, then we run the risk that the
2142 user will delete or disable the breakpoint, but the
2143 thread will have already tripped on it. */
2145 /* Save the trap's siginfo in case we need it later. */
2148 /* Now resume this LWP and get the SIGSTOP event. */
2150 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2151 if (debug_linux_nat
)
2153 fprintf_unfiltered (gdb_stdlog
,
2154 "PTRACE_CONT %s, 0, 0 (%s)\n",
2155 target_pid_to_str (lp
->ptid
),
2156 errno
? safe_strerror (errno
) : "OK");
2158 fprintf_unfiltered (gdb_stdlog
,
2159 "SWC: Candidate SIGTRAP event in %s\n",
2160 target_pid_to_str (lp
->ptid
));
2162 /* Hold this event/waitstatus while we check to see if
2163 there are any more (we still want to get that SIGSTOP). */
2164 stop_wait_callback (lp
, NULL
);
2166 if (target_can_async_p ())
2168 /* Don't leave a pending wait status in async mode.
2169 Retrigger the breakpoint. */
2170 if (!cancel_breakpoint (lp
))
2172 /* There was no gdb breakpoint set at pc. Put
2173 the event back in the queue. */
2174 if (debug_linux_nat
)
2175 fprintf_unfiltered (gdb_stdlog
,
2176 "SWC: kill %s, %s\n",
2177 target_pid_to_str (lp
->ptid
),
2178 status_to_str ((int) status
));
2179 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
2184 /* Hold the SIGTRAP for handling by
2186 /* If there's another event, throw it back into the
2190 if (debug_linux_nat
)
2191 fprintf_unfiltered (gdb_stdlog
,
2192 "SWC: kill %s, %s\n",
2193 target_pid_to_str (lp
->ptid
),
2194 status_to_str ((int) status
));
2195 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
2197 /* Save the sigtrap event. */
2198 lp
->status
= status
;
2204 /* The thread was stopped with a signal other than
2205 SIGSTOP, and didn't accidentally trip a breakpoint. */
2207 if (debug_linux_nat
)
2209 fprintf_unfiltered (gdb_stdlog
,
2210 "SWC: Pending event %s in %s\n",
2211 status_to_str ((int) status
),
2212 target_pid_to_str (lp
->ptid
));
2214 /* Now resume this LWP and get the SIGSTOP event. */
2216 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2217 if (debug_linux_nat
)
2218 fprintf_unfiltered (gdb_stdlog
,
2219 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
2220 target_pid_to_str (lp
->ptid
),
2221 errno
? safe_strerror (errno
) : "OK");
2223 /* Hold this event/waitstatus while we check to see if
2224 there are any more (we still want to get that SIGSTOP). */
2225 stop_wait_callback (lp
, NULL
);
2227 /* If the lp->status field is still empty, use it to
2228 hold this event. If not, then this event must be
2229 returned to the event queue of the LWP. */
2230 if (lp
->status
|| target_can_async_p ())
2232 if (debug_linux_nat
)
2234 fprintf_unfiltered (gdb_stdlog
,
2235 "SWC: kill %s, %s\n",
2236 target_pid_to_str (lp
->ptid
),
2237 status_to_str ((int) status
));
2239 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
2242 lp
->status
= status
;
2248 /* We caught the SIGSTOP that we intended to catch, so
2249 there's no SIGSTOP pending. */
2258 /* Return non-zero if LP has a wait status pending. */
2261 status_callback (struct lwp_info
*lp
, void *data
)
2263 /* Only report a pending wait status if we pretend that this has
2264 indeed been resumed. */
2265 return (lp
->status
!= 0 && lp
->resumed
);
2268 /* Return non-zero if LP isn't stopped. */
2271 running_callback (struct lwp_info
*lp
, void *data
)
2273 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
2276 /* Count the LWP's that have had events. */
2279 count_events_callback (struct lwp_info
*lp
, void *data
)
2283 gdb_assert (count
!= NULL
);
2285 /* Count only resumed LWPs that have a SIGTRAP event pending. */
2286 if (lp
->status
!= 0 && lp
->resumed
2287 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
2293 /* Select the LWP (if any) that is currently being single-stepped. */
2296 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
2298 if (lp
->step
&& lp
->status
!= 0)
2304 /* Select the Nth LWP that has had a SIGTRAP event. */
2307 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
2309 int *selector
= data
;
2311 gdb_assert (selector
!= NULL
);
2313 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2314 if (lp
->status
!= 0 && lp
->resumed
2315 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
2316 if ((*selector
)-- == 0)
2323 cancel_breakpoint (struct lwp_info
*lp
)
2325 /* Arrange for a breakpoint to be hit again later. We don't keep
2326 the SIGTRAP status and don't forward the SIGTRAP signal to the
2327 LWP. We will handle the current event, eventually we will resume
2328 this LWP, and this breakpoint will trap again.
2330 If we do not do this, then we run the risk that the user will
2331 delete or disable the breakpoint, but the LWP will have already
2334 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
2335 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2338 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
2339 if (breakpoint_inserted_here_p (pc
))
2341 if (debug_linux_nat
)
2342 fprintf_unfiltered (gdb_stdlog
,
2343 "CB: Push back breakpoint for %s\n",
2344 target_pid_to_str (lp
->ptid
));
2346 /* Back up the PC if necessary. */
2347 if (gdbarch_decr_pc_after_break (gdbarch
))
2348 regcache_write_pc (regcache
, pc
);
2356 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
2358 struct lwp_info
*event_lp
= data
;
2360 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2364 /* If a LWP other than the LWP that we're reporting an event for has
2365 hit a GDB breakpoint (as opposed to some random trap signal),
2366 then just arrange for it to hit it again later. We don't keep
2367 the SIGTRAP status and don't forward the SIGTRAP signal to the
2368 LWP. We will handle the current event, eventually we will resume
2369 all LWPs, and this one will get its breakpoint trap again.
2371 If we do not do this, then we run the risk that the user will
2372 delete or disable the breakpoint, but the LWP will have already
2376 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
2377 && cancel_breakpoint (lp
))
2378 /* Throw away the SIGTRAP. */
2384 /* Select one LWP out of those that have events pending. */
2387 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
2390 int random_selector
;
2391 struct lwp_info
*event_lp
;
2393 /* Record the wait status for the original LWP. */
2394 (*orig_lp
)->status
= *status
;
2396 /* Give preference to any LWP that is being single-stepped. */
2397 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
2398 if (event_lp
!= NULL
)
2400 if (debug_linux_nat
)
2401 fprintf_unfiltered (gdb_stdlog
,
2402 "SEL: Select single-step %s\n",
2403 target_pid_to_str (event_lp
->ptid
));
2407 /* No single-stepping LWP. Select one at random, out of those
2408 which have had SIGTRAP events. */
2410 /* First see how many SIGTRAP events we have. */
2411 iterate_over_lwps (count_events_callback
, &num_events
);
2413 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2414 random_selector
= (int)
2415 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2417 if (debug_linux_nat
&& num_events
> 1)
2418 fprintf_unfiltered (gdb_stdlog
,
2419 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2420 num_events
, random_selector
);
2422 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
2426 if (event_lp
!= NULL
)
2428 /* Switch the event LWP. */
2429 *orig_lp
= event_lp
;
2430 *status
= event_lp
->status
;
2433 /* Flush the wait status for the event LWP. */
2434 (*orig_lp
)->status
= 0;
2437 /* Return non-zero if LP has been resumed. */
2440 resumed_callback (struct lwp_info
*lp
, void *data
)
2445 /* Stop an active thread, verify it still exists, then resume it. */
2448 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
2450 struct lwp_info
*ptr
;
2452 if (!lp
->stopped
&& !lp
->signalled
)
2454 stop_callback (lp
, NULL
);
2455 stop_wait_callback (lp
, NULL
);
2456 /* Resume if the lwp still exists. */
2457 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
2460 resume_callback (lp
, NULL
);
2461 resume_set_callback (lp
, NULL
);
2467 /* Check if we should go on and pass this event to common code.
2468 Return the affected lwp if we are, or NULL otherwise. */
2469 static struct lwp_info
*
2470 linux_nat_filter_event (int lwpid
, int status
, int options
)
2472 struct lwp_info
*lp
;
2474 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
2476 /* Check for stop events reported by a process we didn't already
2477 know about - anything not already in our LWP list.
2479 If we're expecting to receive stopped processes after
2480 fork, vfork, and clone events, then we'll just add the
2481 new one to our list and go back to waiting for the event
2482 to be reported - the stopped process might be returned
2483 from waitpid before or after the event is. */
2484 if (WIFSTOPPED (status
) && !lp
)
2486 linux_record_stopped_pid (lwpid
, status
);
2490 /* Make sure we don't report an event for the exit of an LWP not in
2491 our list, i.e. not part of the current process. This can happen
2492 if we detach from a program we original forked and then it
2494 if (!WIFSTOPPED (status
) && !lp
)
2497 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
2498 CLONE_PTRACE processes which do not use the thread library -
2499 otherwise we wouldn't find the new LWP this way. That doesn't
2500 currently work, and the following code is currently unreachable
2501 due to the two blocks above. If it's fixed some day, this code
2502 should be broken out into a function so that we can also pick up
2503 LWPs from the new interface. */
2506 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
2507 if (options
& __WCLONE
)
2510 gdb_assert (WIFSTOPPED (status
)
2511 && WSTOPSIG (status
) == SIGSTOP
);
2514 if (!in_thread_list (inferior_ptid
))
2516 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2517 GET_PID (inferior_ptid
));
2518 add_thread (inferior_ptid
);
2521 add_thread (lp
->ptid
);
2524 /* Save the trap's siginfo in case we need it later. */
2525 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2528 /* Handle GNU/Linux's extended waitstatus for trace events. */
2529 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
2531 if (debug_linux_nat
)
2532 fprintf_unfiltered (gdb_stdlog
,
2533 "LLW: Handling extended status 0x%06x\n",
2535 if (linux_handle_extended_wait (lp
, status
, 0))
2539 /* Check if the thread has exited. */
2540 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
2542 /* If this is the main thread, we must stop all threads and
2543 verify if they are still alive. This is because in the nptl
2544 thread model, there is no signal issued for exiting LWPs
2545 other than the main thread. We only get the main thread exit
2546 signal once all child threads have already exited. If we
2547 stop all the threads and use the stop_wait_callback to check
2548 if they have exited we can determine whether this signal
2549 should be ignored or whether it means the end of the debugged
2550 application, regardless of which threading model is being
2552 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
2555 iterate_over_lwps (stop_and_resume_callback
, NULL
);
2558 if (debug_linux_nat
)
2559 fprintf_unfiltered (gdb_stdlog
,
2560 "LLW: %s exited.\n",
2561 target_pid_to_str (lp
->ptid
));
2565 /* If there is at least one more LWP, then the exit signal was
2566 not the end of the debugged application and should be
2572 /* Check if the current LWP has previously exited. In the nptl
2573 thread model, LWPs other than the main thread do not issue
2574 signals when they exit so we must check whenever the thread has
2575 stopped. A similar check is made in stop_wait_callback(). */
2576 if (num_lwps
> 1 && !linux_nat_thread_alive (lp
->ptid
))
2578 if (debug_linux_nat
)
2579 fprintf_unfiltered (gdb_stdlog
,
2580 "LLW: %s exited.\n",
2581 target_pid_to_str (lp
->ptid
));
2585 /* Make sure there is at least one thread running. */
2586 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
2588 /* Discard the event. */
2592 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2593 an attempt to stop an LWP. */
2595 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
2597 if (debug_linux_nat
)
2598 fprintf_unfiltered (gdb_stdlog
,
2599 "LLW: Delayed SIGSTOP caught for %s.\n",
2600 target_pid_to_str (lp
->ptid
));
2602 /* This is a delayed SIGSTOP. */
2605 registers_changed ();
2607 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2608 lp
->step
, TARGET_SIGNAL_0
);
2609 if (debug_linux_nat
)
2610 fprintf_unfiltered (gdb_stdlog
,
2611 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2613 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2614 target_pid_to_str (lp
->ptid
));
2617 gdb_assert (lp
->resumed
);
2619 /* Discard the event. */
2623 /* Make sure we don't report a SIGINT that we have already displayed
2624 for another thread. */
2625 if (lp
->ignore_sigint
2626 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGINT
)
2628 if (debug_linux_nat
)
2629 fprintf_unfiltered (gdb_stdlog
,
2630 "LLW: Delayed SIGINT caught for %s.\n",
2631 target_pid_to_str (lp
->ptid
));
2633 /* This is a delayed SIGINT. */
2634 lp
->ignore_sigint
= 0;
2636 registers_changed ();
2637 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2638 lp
->step
, TARGET_SIGNAL_0
);
2639 if (debug_linux_nat
)
2640 fprintf_unfiltered (gdb_stdlog
,
2641 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
2643 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2644 target_pid_to_str (lp
->ptid
));
2647 gdb_assert (lp
->resumed
);
2649 /* Discard the event. */
2653 /* An interesting event. */
2658 /* Get the events stored in the pipe into the local queue, so they are
2659 accessible to queued_waitpid. We need to do this, since it is not
2660 always the case that the event at the head of the pipe is the event
2664 pipe_to_local_event_queue (void)
2666 if (debug_linux_nat_async
)
2667 fprintf_unfiltered (gdb_stdlog
,
2668 "PTLEQ: linux_nat_num_queued_events(%d)\n",
2669 linux_nat_num_queued_events
);
2670 while (linux_nat_num_queued_events
)
2672 int lwpid
, status
, options
;
2673 lwpid
= linux_nat_event_pipe_pop (&status
, &options
);
2674 gdb_assert (lwpid
> 0);
2675 push_waitpid (lwpid
, status
, options
);
2679 /* Get the unprocessed events stored in the local queue back into the
2680 pipe, so the event loop realizes there's something else to
2684 local_event_queue_to_pipe (void)
2686 struct waitpid_result
*w
= waitpid_queue
;
2689 struct waitpid_result
*next
= w
->next
;
2690 linux_nat_event_pipe_push (w
->pid
,
2696 waitpid_queue
= NULL
;
2698 if (debug_linux_nat_async
)
2699 fprintf_unfiltered (gdb_stdlog
,
2700 "LEQTP: linux_nat_num_queued_events(%d)\n",
2701 linux_nat_num_queued_events
);
2705 linux_nat_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
2707 struct lwp_info
*lp
= NULL
;
2710 pid_t pid
= PIDGET (ptid
);
2712 if (debug_linux_nat_async
)
2713 fprintf_unfiltered (gdb_stdlog
, "LLW: enter\n");
2715 /* The first time we get here after starting a new inferior, we may
2716 not have added it to the LWP list yet - this is the earliest
2717 moment at which we know its PID. */
2720 gdb_assert (!is_lwp (inferior_ptid
));
2722 /* Upgrade the main thread's ptid. */
2723 thread_change_ptid (inferior_ptid
,
2724 BUILD_LWP (GET_PID (inferior_ptid
),
2725 GET_PID (inferior_ptid
)));
2727 lp
= add_lwp (inferior_ptid
);
2731 /* Block events while we're here. */
2732 linux_nat_async_events (sigchld_sync
);
2736 /* Make sure there is at least one LWP that has been resumed. */
2737 gdb_assert (iterate_over_lwps (resumed_callback
, NULL
));
2739 /* First check if there is a LWP with a wait status pending. */
2742 /* Any LWP that's been resumed will do. */
2743 lp
= iterate_over_lwps (status_callback
, NULL
);
2746 if (target_can_async_p ())
2747 internal_error (__FILE__
, __LINE__
,
2748 "Found an LWP with a pending status in async mode.");
2750 status
= lp
->status
;
2753 if (debug_linux_nat
&& status
)
2754 fprintf_unfiltered (gdb_stdlog
,
2755 "LLW: Using pending wait status %s for %s.\n",
2756 status_to_str (status
),
2757 target_pid_to_str (lp
->ptid
));
2760 /* But if we don't find one, we'll have to wait, and check both
2761 cloned and uncloned processes. We start with the cloned
2763 options
= __WCLONE
| WNOHANG
;
2765 else if (is_lwp (ptid
))
2767 if (debug_linux_nat
)
2768 fprintf_unfiltered (gdb_stdlog
,
2769 "LLW: Waiting for specific LWP %s.\n",
2770 target_pid_to_str (ptid
));
2772 /* We have a specific LWP to check. */
2773 lp
= find_lwp_pid (ptid
);
2775 status
= lp
->status
;
2778 if (debug_linux_nat
&& status
)
2779 fprintf_unfiltered (gdb_stdlog
,
2780 "LLW: Using pending wait status %s for %s.\n",
2781 status_to_str (status
),
2782 target_pid_to_str (lp
->ptid
));
2784 /* If we have to wait, take into account whether PID is a cloned
2785 process or not. And we have to convert it to something that
2786 the layer beneath us can understand. */
2787 options
= lp
->cloned
? __WCLONE
: 0;
2788 pid
= GET_LWP (ptid
);
2791 if (status
&& lp
->signalled
)
2793 /* A pending SIGSTOP may interfere with the normal stream of
2794 events. In a typical case where interference is a problem,
2795 we have a SIGSTOP signal pending for LWP A while
2796 single-stepping it, encounter an event in LWP B, and take the
2797 pending SIGSTOP while trying to stop LWP A. After processing
2798 the event in LWP B, LWP A is continued, and we'll never see
2799 the SIGTRAP associated with the last time we were
2800 single-stepping LWP A. */
2802 /* Resume the thread. It should halt immediately returning the
2804 registers_changed ();
2805 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2806 lp
->step
, TARGET_SIGNAL_0
);
2807 if (debug_linux_nat
)
2808 fprintf_unfiltered (gdb_stdlog
,
2809 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
2810 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2811 target_pid_to_str (lp
->ptid
));
2813 gdb_assert (lp
->resumed
);
2815 /* This should catch the pending SIGSTOP. */
2816 stop_wait_callback (lp
, NULL
);
2819 if (!target_can_async_p ())
2821 /* Causes SIGINT to be passed on to the attached process. */
2830 if (target_can_async_p ())
2831 /* In async mode, don't ever block. Only look at the locally
2833 lwpid
= queued_waitpid (pid
, &status
, options
);
2835 lwpid
= my_waitpid (pid
, &status
, options
);
2839 gdb_assert (pid
== -1 || lwpid
== pid
);
2841 if (debug_linux_nat
)
2843 fprintf_unfiltered (gdb_stdlog
,
2844 "LLW: waitpid %ld received %s\n",
2845 (long) lwpid
, status_to_str (status
));
2848 lp
= linux_nat_filter_event (lwpid
, status
, options
);
2851 /* A discarded event. */
2861 /* Alternate between checking cloned and uncloned processes. */
2862 options
^= __WCLONE
;
2864 /* And every time we have checked both:
2865 In async mode, return to event loop;
2866 In sync mode, suspend waiting for a SIGCHLD signal. */
2867 if (options
& __WCLONE
)
2869 if (target_can_async_p ())
2871 /* No interesting event. */
2872 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2874 /* Get ready for the next event. */
2875 target_async (inferior_event_handler
, 0);
2877 if (debug_linux_nat_async
)
2878 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
2880 return minus_one_ptid
;
2883 sigsuspend (&suspend_mask
);
2887 /* We shouldn't end up here unless we want to try again. */
2888 gdb_assert (status
== 0);
2891 if (!target_can_async_p ())
2893 clear_sigio_trap ();
2894 clear_sigint_trap ();
2899 /* Don't report signals that GDB isn't interested in, such as
2900 signals that are neither printed nor stopped upon. Stopping all
2901 threads can be a bit time-consuming so if we want decent
2902 performance with heavily multi-threaded programs, especially when
2903 they're using a high frequency timer, we'd better avoid it if we
2906 if (WIFSTOPPED (status
))
2908 int signo
= target_signal_from_host (WSTOPSIG (status
));
2910 /* If we get a signal while single-stepping, we may need special
2911 care, e.g. to skip the signal handler. Defer to common code. */
2913 && signal_stop_state (signo
) == 0
2914 && signal_print_state (signo
) == 0
2915 && signal_pass_state (signo
) == 1)
2917 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2918 here? It is not clear we should. GDB may not expect
2919 other threads to run. On the other hand, not resuming
2920 newly attached threads may cause an unwanted delay in
2921 getting them running. */
2922 registers_changed ();
2923 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2925 if (debug_linux_nat
)
2926 fprintf_unfiltered (gdb_stdlog
,
2927 "LLW: %s %s, %s (preempt 'handle')\n",
2929 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2930 target_pid_to_str (lp
->ptid
),
2931 signo
? strsignal (signo
) : "0");
2937 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
2939 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2940 forwarded to the entire process group, that is, all LWPs
2941 will receive it - unless they're using CLONE_THREAD to
2942 share signals. Since we only want to report it once, we
2943 mark it as ignored for all LWPs except this one. */
2944 iterate_over_lwps (set_ignore_sigint
, NULL
);
2945 lp
->ignore_sigint
= 0;
2948 maybe_clear_ignore_sigint (lp
);
2951 /* This LWP is stopped now. */
2954 if (debug_linux_nat
)
2955 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
2956 status_to_str (status
), target_pid_to_str (lp
->ptid
));
2960 /* Now stop all other LWP's ... */
2961 iterate_over_lwps (stop_callback
, NULL
);
2963 /* ... and wait until all of them have reported back that
2964 they're no longer running. */
2965 iterate_over_lwps (stop_wait_callback
, NULL
);
2967 /* If we're not waiting for a specific LWP, choose an event LWP
2968 from among those that have had events. Giving equal priority
2969 to all LWPs that have had events helps prevent
2972 select_event_lwp (&lp
, &status
);
2975 /* Now that we've selected our final event LWP, cancel any
2976 breakpoints in other LWPs that have hit a GDB breakpoint. See
2977 the comment in cancel_breakpoints_callback to find out why. */
2978 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
2980 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2982 if (debug_linux_nat
)
2983 fprintf_unfiltered (gdb_stdlog
,
2984 "LLW: trap ptid is %s.\n",
2985 target_pid_to_str (lp
->ptid
));
2988 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
2990 *ourstatus
= lp
->waitstatus
;
2991 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
2994 store_waitstatus (ourstatus
, status
);
2996 /* Get ready for the next event. */
2997 if (target_can_async_p ())
2998 target_async (inferior_event_handler
, 0);
3000 if (debug_linux_nat_async
)
3001 fprintf_unfiltered (gdb_stdlog
, "LLW: exit\n");
3007 kill_callback (struct lwp_info
*lp
, void *data
)
3010 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
3011 if (debug_linux_nat
)
3012 fprintf_unfiltered (gdb_stdlog
,
3013 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
3014 target_pid_to_str (lp
->ptid
),
3015 errno
? safe_strerror (errno
) : "OK");
3021 kill_wait_callback (struct lwp_info
*lp
, void *data
)
3025 /* We must make sure that there are no pending events (delayed
3026 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3027 program doesn't interfere with any following debugging session. */
3029 /* For cloned processes we must check both with __WCLONE and
3030 without, since the exit status of a cloned process isn't reported
3036 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
3037 if (pid
!= (pid_t
) -1)
3039 if (debug_linux_nat
)
3040 fprintf_unfiltered (gdb_stdlog
,
3041 "KWC: wait %s received unknown.\n",
3042 target_pid_to_str (lp
->ptid
));
3043 /* The Linux kernel sometimes fails to kill a thread
3044 completely after PTRACE_KILL; that goes from the stop
3045 point in do_fork out to the one in
3046 get_signal_to_deliever and waits again. So kill it
3048 kill_callback (lp
, NULL
);
3051 while (pid
== GET_LWP (lp
->ptid
));
3053 gdb_assert (pid
== -1 && errno
== ECHILD
);
3058 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
3059 if (pid
!= (pid_t
) -1)
3061 if (debug_linux_nat
)
3062 fprintf_unfiltered (gdb_stdlog
,
3063 "KWC: wait %s received unk.\n",
3064 target_pid_to_str (lp
->ptid
));
3065 /* See the call to kill_callback above. */
3066 kill_callback (lp
, NULL
);
3069 while (pid
== GET_LWP (lp
->ptid
));
3071 gdb_assert (pid
== -1 && errno
== ECHILD
);
3076 linux_nat_kill (void)
3078 struct target_waitstatus last
;
3082 if (target_can_async_p ())
3083 target_async (NULL
, 0);
3085 /* If we're stopped while forking and we haven't followed yet,
3086 kill the other task. We need to do this first because the
3087 parent will be sleeping if this is a vfork. */
3089 get_last_target_status (&last_ptid
, &last
);
3091 if (last
.kind
== TARGET_WAITKIND_FORKED
3092 || last
.kind
== TARGET_WAITKIND_VFORKED
)
3094 ptrace (PT_KILL
, PIDGET (last
.value
.related_pid
), 0, 0);
3098 if (forks_exist_p ())
3100 linux_fork_killall ();
3101 drain_queued_events (-1);
3105 /* Stop all threads before killing them, since ptrace requires
3106 that the thread is stopped to sucessfully PTRACE_KILL. */
3107 iterate_over_lwps (stop_callback
, NULL
);
3108 /* ... and wait until all of them have reported back that
3109 they're no longer running. */
3110 iterate_over_lwps (stop_wait_callback
, NULL
);
3112 /* Kill all LWP's ... */
3113 iterate_over_lwps (kill_callback
, NULL
);
3115 /* ... and wait until we've flushed all events. */
3116 iterate_over_lwps (kill_wait_callback
, NULL
);
3119 target_mourn_inferior ();
3123 linux_nat_mourn_inferior (void)
3125 /* Destroy LWP info; it's no longer valid. */
3128 if (! forks_exist_p ())
3130 /* Normal case, no other forks available. */
3131 if (target_can_async_p ())
3132 linux_nat_async (NULL
, 0);
3133 linux_ops
->to_mourn_inferior ();
3136 /* Multi-fork case. The current inferior_ptid has exited, but
3137 there are other viable forks to debug. Delete the exiting
3138 one and context-switch to the first available. */
3139 linux_fork_mourn_inferior ();
3143 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3144 const char *annex
, gdb_byte
*readbuf
,
3145 const gdb_byte
*writebuf
,
3146 ULONGEST offset
, LONGEST len
)
3148 struct cleanup
*old_chain
= save_inferior_ptid ();
3151 if (is_lwp (inferior_ptid
))
3152 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
3154 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3157 do_cleanups (old_chain
);
3162 linux_nat_thread_alive (ptid_t ptid
)
3166 gdb_assert (is_lwp (ptid
));
3168 /* Send signal 0 instead of anything ptrace, because ptracing a
3169 running thread errors out claiming that the thread doesn't
3171 err
= kill_lwp (GET_LWP (ptid
), 0);
3173 if (debug_linux_nat
)
3174 fprintf_unfiltered (gdb_stdlog
,
3175 "LLTA: KILL(SIG0) %s (%s)\n",
3176 target_pid_to_str (ptid
),
3177 err
? safe_strerror (err
) : "OK");
3186 linux_nat_pid_to_str (ptid_t ptid
)
3188 static char buf
[64];
3191 && ((lwp_list
&& lwp_list
->next
)
3192 || GET_PID (ptid
) != GET_LWP (ptid
)))
3194 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
3198 return normal_pid_to_str (ptid
);
3202 sigchld_handler (int signo
)
3204 if (target_async_permitted
3205 && linux_nat_async_events_state
!= sigchld_sync
3206 && signo
== SIGCHLD
)
3207 /* It is *always* a bug to hit this. */
3208 internal_error (__FILE__
, __LINE__
,
3209 "sigchld_handler called when async events are enabled");
3211 /* Do nothing. The only reason for this handler is that it allows
3212 us to use sigsuspend in linux_nat_wait above to wait for the
3213 arrival of a SIGCHLD. */
3216 /* Accepts an integer PID; Returns a string representing a file that
3217 can be opened to get the symbols for the child process. */
3220 linux_child_pid_to_exec_file (int pid
)
3222 char *name1
, *name2
;
3224 name1
= xmalloc (MAXPATHLEN
);
3225 name2
= xmalloc (MAXPATHLEN
);
3226 make_cleanup (xfree
, name1
);
3227 make_cleanup (xfree
, name2
);
3228 memset (name2
, 0, MAXPATHLEN
);
3230 sprintf (name1
, "/proc/%d/exe", pid
);
3231 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
3237 /* Service function for corefiles and info proc. */
3240 read_mapping (FILE *mapfile
,
3245 char *device
, long long *inode
, char *filename
)
3247 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
3248 addr
, endaddr
, permissions
, offset
, device
, inode
);
3251 if (ret
> 0 && ret
!= EOF
)
3253 /* Eat everything up to EOL for the filename. This will prevent
3254 weird filenames (such as one with embedded whitespace) from
3255 confusing this code. It also makes this code more robust in
3256 respect to annotations the kernel may add after the filename.
3258 Note the filename is used for informational purposes
3260 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
3263 return (ret
!= 0 && ret
!= EOF
);
3266 /* Fills the "to_find_memory_regions" target vector. Lists the memory
3267 regions in the inferior for a corefile. */
3270 linux_nat_find_memory_regions (int (*func
) (CORE_ADDR
,
3272 int, int, int, void *), void *obfd
)
3274 long long pid
= PIDGET (inferior_ptid
);
3275 char mapsfilename
[MAXPATHLEN
];
3277 long long addr
, endaddr
, size
, offset
, inode
;
3278 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
3279 int read
, write
, exec
;
3282 /* Compose the filename for the /proc memory map, and open it. */
3283 sprintf (mapsfilename
, "/proc/%lld/maps", pid
);
3284 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
3285 error (_("Could not open %s."), mapsfilename
);
3288 fprintf_filtered (gdb_stdout
,
3289 "Reading memory regions from %s\n", mapsfilename
);
3291 /* Now iterate until end-of-file. */
3292 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
3293 &offset
, &device
[0], &inode
, &filename
[0]))
3295 size
= endaddr
- addr
;
3297 /* Get the segment's permissions. */
3298 read
= (strchr (permissions
, 'r') != 0);
3299 write
= (strchr (permissions
, 'w') != 0);
3300 exec
= (strchr (permissions
, 'x') != 0);
3304 fprintf_filtered (gdb_stdout
,
3305 "Save segment, %lld bytes at 0x%s (%c%c%c)",
3306 size
, paddr_nz (addr
),
3308 write
? 'w' : ' ', exec
? 'x' : ' ');
3310 fprintf_filtered (gdb_stdout
, " for %s", filename
);
3311 fprintf_filtered (gdb_stdout
, "\n");
3314 /* Invoke the callback function to create the corefile
3316 func (addr
, size
, read
, write
, exec
, obfd
);
3322 /* Records the thread's register state for the corefile note
3326 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
3327 char *note_data
, int *note_size
)
3329 gdb_gregset_t gregs
;
3330 gdb_fpregset_t fpregs
;
3331 unsigned long lwp
= ptid_get_lwp (ptid
);
3332 struct regcache
*regcache
= get_thread_regcache (ptid
);
3333 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3334 const struct regset
*regset
;
3336 struct cleanup
*old_chain
;
3337 struct core_regset_section
*sect_list
;
3340 old_chain
= save_inferior_ptid ();
3341 inferior_ptid
= ptid
;
3342 target_fetch_registers (regcache
, -1);
3343 do_cleanups (old_chain
);
3345 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
3346 sect_list
= gdbarch_core_regset_sections (gdbarch
);
3349 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
3350 sizeof (gregs
))) != NULL
3351 && regset
->collect_regset
!= NULL
)
3352 regset
->collect_regset (regset
, regcache
, -1,
3353 &gregs
, sizeof (gregs
));
3355 fill_gregset (regcache
, &gregs
, -1);
3357 note_data
= (char *) elfcore_write_prstatus (obfd
,
3361 stop_signal
, &gregs
);
3363 /* The loop below uses the new struct core_regset_section, which stores
3364 the supported section names and sizes for the core file. Note that
3365 note PRSTATUS needs to be treated specially. But the other notes are
3366 structurally the same, so they can benefit from the new struct. */
3367 if (core_regset_p
&& sect_list
!= NULL
)
3368 while (sect_list
->sect_name
!= NULL
)
3370 /* .reg was already handled above. */
3371 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
3376 regset
= gdbarch_regset_from_core_section (gdbarch
,
3377 sect_list
->sect_name
,
3379 gdb_assert (regset
&& regset
->collect_regset
);
3380 gdb_regset
= xmalloc (sect_list
->size
);
3381 regset
->collect_regset (regset
, regcache
, -1,
3382 gdb_regset
, sect_list
->size
);
3383 note_data
= (char *) elfcore_write_register_note (obfd
,
3386 sect_list
->sect_name
,
3393 /* For architectures that does not have the struct core_regset_section
3394 implemented, we use the old method. When all the architectures have
3395 the new support, the code below should be deleted. */
3399 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
3400 sizeof (fpregs
))) != NULL
3401 && regset
->collect_regset
!= NULL
)
3402 regset
->collect_regset (regset
, regcache
, -1,
3403 &fpregs
, sizeof (fpregs
));
3405 fill_fpregset (regcache
, &fpregs
, -1);
3407 note_data
= (char *) elfcore_write_prfpreg (obfd
,
3410 &fpregs
, sizeof (fpregs
));
3416 struct linux_nat_corefile_thread_data
3424 /* Called by gdbthread.c once per thread. Records the thread's
3425 register state for the corefile note section. */
3428 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
3430 struct linux_nat_corefile_thread_data
*args
= data
;
3432 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
3441 /* Records the register state for the corefile note section. */
3444 linux_nat_do_registers (bfd
*obfd
, ptid_t ptid
,
3445 char *note_data
, int *note_size
)
3447 return linux_nat_do_thread_registers (obfd
,
3448 ptid_build (ptid_get_pid (inferior_ptid
),
3449 ptid_get_pid (inferior_ptid
),
3451 note_data
, note_size
);
3454 /* Fills the "to_make_corefile_note" target vector. Builds the note
3455 section for a corefile, and returns it in a malloc buffer. */
3458 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
3460 struct linux_nat_corefile_thread_data thread_args
;
3461 struct cleanup
*old_chain
;
3462 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
3463 char fname
[16] = { '\0' };
3464 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
3465 char psargs
[80] = { '\0' };
3466 char *note_data
= NULL
;
3467 ptid_t current_ptid
= inferior_ptid
;
3471 if (get_exec_file (0))
3473 strncpy (fname
, strrchr (get_exec_file (0), '/') + 1, sizeof (fname
));
3474 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3475 if (get_inferior_args ())
3478 char *psargs_end
= psargs
+ sizeof (psargs
);
3480 /* linux_elfcore_write_prpsinfo () handles zero unterminated
3482 string_end
= memchr (psargs
, 0, sizeof (psargs
));
3483 if (string_end
!= NULL
)
3485 *string_end
++ = ' ';
3486 strncpy (string_end
, get_inferior_args (),
3487 psargs_end
- string_end
);
3490 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
3492 note_size
, fname
, psargs
);
3495 /* Dump information for threads. */
3496 thread_args
.obfd
= obfd
;
3497 thread_args
.note_data
= note_data
;
3498 thread_args
.note_size
= note_size
;
3499 thread_args
.num_notes
= 0;
3500 iterate_over_lwps (linux_nat_corefile_thread_callback
, &thread_args
);
3501 if (thread_args
.num_notes
== 0)
3503 /* iterate_over_threads didn't come up with any threads; just
3504 use inferior_ptid. */
3505 note_data
= linux_nat_do_registers (obfd
, inferior_ptid
,
3506 note_data
, note_size
);
3510 note_data
= thread_args
.note_data
;
3513 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
3517 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
3518 "CORE", NT_AUXV
, auxv
, auxv_len
);
3522 make_cleanup (xfree
, note_data
);
3526 /* Implement the "info proc" command. */
3529 linux_nat_info_proc_cmd (char *args
, int from_tty
)
3531 long long pid
= PIDGET (inferior_ptid
);
3534 char buffer
[MAXPATHLEN
];
3535 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
3548 /* Break up 'args' into an argv array. */
3549 if ((argv
= buildargv (args
)) == NULL
)
3552 make_cleanup_freeargv (argv
);
3554 while (argv
!= NULL
&& *argv
!= NULL
)
3556 if (isdigit (argv
[0][0]))
3558 pid
= strtoul (argv
[0], NULL
, 10);
3560 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
3564 else if (strcmp (argv
[0], "status") == 0)
3568 else if (strcmp (argv
[0], "stat") == 0)
3572 else if (strcmp (argv
[0], "cmd") == 0)
3576 else if (strncmp (argv
[0], "exe", strlen (argv
[0])) == 0)
3580 else if (strcmp (argv
[0], "cwd") == 0)
3584 else if (strncmp (argv
[0], "all", strlen (argv
[0])) == 0)
3590 /* [...] (future options here) */
3595 error (_("No current process: you must name one."));
3597 sprintf (fname1
, "/proc/%lld", pid
);
3598 if (stat (fname1
, &dummy
) != 0)
3599 error (_("No /proc directory: '%s'"), fname1
);
3601 printf_filtered (_("process %lld\n"), pid
);
3602 if (cmdline_f
|| all
)
3604 sprintf (fname1
, "/proc/%lld/cmdline", pid
);
3605 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3607 fgets (buffer
, sizeof (buffer
), procfile
);
3608 printf_filtered ("cmdline = '%s'\n", buffer
);
3612 warning (_("unable to open /proc file '%s'"), fname1
);
3616 sprintf (fname1
, "/proc/%lld/cwd", pid
);
3617 memset (fname2
, 0, sizeof (fname2
));
3618 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
3619 printf_filtered ("cwd = '%s'\n", fname2
);
3621 warning (_("unable to read link '%s'"), fname1
);
3625 sprintf (fname1
, "/proc/%lld/exe", pid
);
3626 memset (fname2
, 0, sizeof (fname2
));
3627 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
3628 printf_filtered ("exe = '%s'\n", fname2
);
3630 warning (_("unable to read link '%s'"), fname1
);
3632 if (mappings_f
|| all
)
3634 sprintf (fname1
, "/proc/%lld/maps", pid
);
3635 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3637 long long addr
, endaddr
, size
, offset
, inode
;
3638 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
3640 printf_filtered (_("Mapped address spaces:\n\n"));
3641 if (gdbarch_addr_bit (current_gdbarch
) == 32)
3643 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3646 " Size", " Offset", "objfile");
3650 printf_filtered (" %18s %18s %10s %10s %7s\n",
3653 " Size", " Offset", "objfile");
3656 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
3657 &offset
, &device
[0], &inode
, &filename
[0]))
3659 size
= endaddr
- addr
;
3661 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
3662 calls here (and possibly above) should be abstracted
3663 out into their own functions? Andrew suggests using
3664 a generic local_address_string instead to print out
3665 the addresses; that makes sense to me, too. */
3667 if (gdbarch_addr_bit (current_gdbarch
) == 32)
3669 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3670 (unsigned long) addr
, /* FIXME: pr_addr */
3671 (unsigned long) endaddr
,
3673 (unsigned int) offset
,
3674 filename
[0] ? filename
: "");
3678 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3679 (unsigned long) addr
, /* FIXME: pr_addr */
3680 (unsigned long) endaddr
,
3682 (unsigned int) offset
,
3683 filename
[0] ? filename
: "");
3690 warning (_("unable to open /proc file '%s'"), fname1
);
3692 if (status_f
|| all
)
3694 sprintf (fname1
, "/proc/%lld/status", pid
);
3695 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3697 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
3698 puts_filtered (buffer
);
3702 warning (_("unable to open /proc file '%s'"), fname1
);
3706 sprintf (fname1
, "/proc/%lld/stat", pid
);
3707 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3713 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3714 printf_filtered (_("Process: %d\n"), itmp
);
3715 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
3716 printf_filtered (_("Exec file: %s\n"), buffer
);
3717 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
3718 printf_filtered (_("State: %c\n"), ctmp
);
3719 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3720 printf_filtered (_("Parent process: %d\n"), itmp
);
3721 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3722 printf_filtered (_("Process group: %d\n"), itmp
);
3723 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3724 printf_filtered (_("Session id: %d\n"), itmp
);
3725 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3726 printf_filtered (_("TTY: %d\n"), itmp
);
3727 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3728 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
3729 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3730 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
3731 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3732 printf_filtered (_("Minor faults (no memory page): %lu\n"),
3733 (unsigned long) ltmp
);
3734 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3735 printf_filtered (_("Minor faults, children: %lu\n"),
3736 (unsigned long) ltmp
);
3737 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3738 printf_filtered (_("Major faults (memory page faults): %lu\n"),
3739 (unsigned long) ltmp
);
3740 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3741 printf_filtered (_("Major faults, children: %lu\n"),
3742 (unsigned long) ltmp
);
3743 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3744 printf_filtered (_("utime: %ld\n"), ltmp
);
3745 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3746 printf_filtered (_("stime: %ld\n"), ltmp
);
3747 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3748 printf_filtered (_("utime, children: %ld\n"), ltmp
);
3749 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3750 printf_filtered (_("stime, children: %ld\n"), ltmp
);
3751 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3752 printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
3754 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3755 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
3756 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3757 printf_filtered (_("jiffies until next timeout: %lu\n"),
3758 (unsigned long) ltmp
);
3759 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3760 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
3761 (unsigned long) ltmp
);
3762 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3763 printf_filtered (_("start time (jiffies since system boot): %ld\n"),
3765 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3766 printf_filtered (_("Virtual memory size: %lu\n"),
3767 (unsigned long) ltmp
);
3768 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3769 printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp
);
3770 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3771 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
3772 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3773 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
3774 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3775 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
3776 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3777 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
3778 #if 0 /* Don't know how architecture-dependent the rest is...
3779 Anyway the signal bitmap info is available from "status". */
3780 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3781 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
3782 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3783 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
3784 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3785 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
3786 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3787 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
3788 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3789 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
3790 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3791 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
3792 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3793 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
3798 warning (_("unable to open /proc file '%s'"), fname1
);
3802 /* Implement the to_xfer_partial interface for memory reads using the /proc
3803 filesystem. Because we can use a single read() call for /proc, this
3804 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3805 but it doesn't support writes. */
3808 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3809 const char *annex
, gdb_byte
*readbuf
,
3810 const gdb_byte
*writebuf
,
3811 ULONGEST offset
, LONGEST len
)
3817 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
3820 /* Don't bother for one word. */
3821 if (len
< 3 * sizeof (long))
3824 /* We could keep this file open and cache it - possibly one per
3825 thread. That requires some juggling, but is even faster. */
3826 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
3827 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
3831 /* If pread64 is available, use it. It's faster if the kernel
3832 supports it (only one syscall), and it's 64-bit safe even on
3833 32-bit platforms (for instance, SPARC debugging a SPARC64
3836 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
3838 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
3848 /* Parse LINE as a signal set and add its set bits to SIGS. */
3851 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
3853 int len
= strlen (line
) - 1;
3857 if (line
[len
] != '\n')
3858 error (_("Could not parse signal set: %s"), line
);
3866 if (*p
>= '0' && *p
<= '9')
3868 else if (*p
>= 'a' && *p
<= 'f')
3869 digit
= *p
- 'a' + 10;
3871 error (_("Could not parse signal set: %s"), line
);
3876 sigaddset (sigs
, signum
+ 1);
3878 sigaddset (sigs
, signum
+ 2);
3880 sigaddset (sigs
, signum
+ 3);
3882 sigaddset (sigs
, signum
+ 4);
3888 /* Find process PID's pending signals from /proc/pid/status and set
3892 linux_proc_pending_signals (int pid
, sigset_t
*pending
, sigset_t
*blocked
, sigset_t
*ignored
)
3895 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
3898 sigemptyset (pending
);
3899 sigemptyset (blocked
);
3900 sigemptyset (ignored
);
3901 sprintf (fname
, "/proc/%d/status", pid
);
3902 procfile
= fopen (fname
, "r");
3903 if (procfile
== NULL
)
3904 error (_("Could not open %s"), fname
);
3906 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
3908 /* Normal queued signals are on the SigPnd line in the status
3909 file. However, 2.6 kernels also have a "shared" pending
3910 queue for delivering signals to a thread group, so check for
3913 Unfortunately some Red Hat kernels include the shared pending
3914 queue but not the ShdPnd status field. */
3916 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
3917 add_line_to_sigset (buffer
+ 8, pending
);
3918 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
3919 add_line_to_sigset (buffer
+ 8, pending
);
3920 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
3921 add_line_to_sigset (buffer
+ 8, blocked
);
3922 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
3923 add_line_to_sigset (buffer
+ 8, ignored
);
3930 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3931 const char *annex
, gdb_byte
*readbuf
,
3932 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3936 if (object
== TARGET_OBJECT_AUXV
)
3937 return procfs_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
3940 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3945 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3949 /* Create a prototype generic GNU/Linux target. The client can override
3950 it with local methods. */
3953 linux_target_install_ops (struct target_ops
*t
)
3955 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
3956 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
3957 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
3958 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
3959 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
3960 t
->to_post_attach
= linux_child_post_attach
;
3961 t
->to_follow_fork
= linux_child_follow_fork
;
3962 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
3963 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
3965 super_xfer_partial
= t
->to_xfer_partial
;
3966 t
->to_xfer_partial
= linux_xfer_partial
;
3972 struct target_ops
*t
;
3974 t
= inf_ptrace_target ();
3975 linux_target_install_ops (t
);
3981 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
3983 struct target_ops
*t
;
3985 t
= inf_ptrace_trad_target (register_u_offset
);
3986 linux_target_install_ops (t
);
3991 /* target_is_async_p implementation. */
3994 linux_nat_is_async_p (void)
3996 /* NOTE: palves 2008-03-21: We're only async when the user requests
3997 it explicitly with the "maintenance set target-async" command.
3998 Someday, linux will always be async. */
3999 if (!target_async_permitted
)
4005 /* target_can_async_p implementation. */
4008 linux_nat_can_async_p (void)
4010 /* NOTE: palves 2008-03-21: We're only async when the user requests
4011 it explicitly with the "maintenance set target-async" command.
4012 Someday, linux will always be async. */
4013 if (!target_async_permitted
)
4016 /* See target.h/target_async_mask. */
4017 return linux_nat_async_mask_value
;
4021 linux_nat_supports_non_stop (void)
4026 /* target_async_mask implementation. */
4029 linux_nat_async_mask (int mask
)
4032 current_state
= linux_nat_async_mask_value
;
4034 if (current_state
!= mask
)
4038 linux_nat_async (NULL
, 0);
4039 linux_nat_async_mask_value
= mask
;
4043 linux_nat_async_mask_value
= mask
;
4044 linux_nat_async (inferior_event_handler
, 0);
4048 return current_state
;
4051 /* Pop an event from the event pipe. */
4054 linux_nat_event_pipe_pop (int* ptr_status
, int* ptr_options
)
4056 struct waitpid_result event
= {0};
4061 ret
= read (linux_nat_event_pipe
[0], &event
, sizeof (event
));
4063 while (ret
== -1 && errno
== EINTR
);
4065 gdb_assert (ret
== sizeof (event
));
4067 *ptr_status
= event
.status
;
4068 *ptr_options
= event
.options
;
4070 linux_nat_num_queued_events
--;
4075 /* Push an event into the event pipe. */
4078 linux_nat_event_pipe_push (int pid
, int status
, int options
)
4081 struct waitpid_result event
= {0};
4083 event
.status
= status
;
4084 event
.options
= options
;
4088 ret
= write (linux_nat_event_pipe
[1], &event
, sizeof (event
));
4089 gdb_assert ((ret
== -1 && errno
== EINTR
) || ret
== sizeof (event
));
4090 } while (ret
== -1 && errno
== EINTR
);
4092 linux_nat_num_queued_events
++;
4096 get_pending_events (void)
4098 int status
, options
, pid
;
4100 if (!target_async_permitted
4101 || linux_nat_async_events_state
!= sigchld_async
)
4102 internal_error (__FILE__
, __LINE__
,
4103 "get_pending_events called with async masked");
4108 options
= __WCLONE
| WNOHANG
;
4112 pid
= waitpid (-1, &status
, options
);
4114 while (pid
== -1 && errno
== EINTR
);
4121 pid
= waitpid (-1, &status
, options
);
4123 while (pid
== -1 && errno
== EINTR
);
4127 /* No more children reporting events. */
4130 if (debug_linux_nat_async
)
4131 fprintf_unfiltered (gdb_stdlog
, "\
4132 get_pending_events: pid(%d), status(%x), options (%x)\n",
4133 pid
, status
, options
);
4135 linux_nat_event_pipe_push (pid
, status
, options
);
4138 if (debug_linux_nat_async
)
4139 fprintf_unfiltered (gdb_stdlog
, "\
4140 get_pending_events: linux_nat_num_queued_events(%d)\n",
4141 linux_nat_num_queued_events
);
4144 /* SIGCHLD handler for async mode. */
4147 async_sigchld_handler (int signo
)
4149 if (debug_linux_nat_async
)
4150 fprintf_unfiltered (gdb_stdlog
, "async_sigchld_handler\n");
4152 get_pending_events ();
4155 /* Set SIGCHLD handling state to STATE. Returns previous state. */
4157 static enum sigchld_state
4158 linux_nat_async_events (enum sigchld_state state
)
4160 enum sigchld_state current_state
= linux_nat_async_events_state
;
4162 if (debug_linux_nat_async
)
4163 fprintf_unfiltered (gdb_stdlog
,
4164 "LNAE: state(%d): linux_nat_async_events_state(%d), "
4165 "linux_nat_num_queued_events(%d)\n",
4166 state
, linux_nat_async_events_state
,
4167 linux_nat_num_queued_events
);
4169 if (current_state
!= state
)
4172 sigemptyset (&mask
);
4173 sigaddset (&mask
, SIGCHLD
);
4175 /* Always block before changing state. */
4176 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4178 /* Set new state. */
4179 linux_nat_async_events_state
= state
;
4185 /* Block target events. */
4186 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4187 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
4188 /* Get events out of queue, and make them available to
4189 queued_waitpid / my_waitpid. */
4190 pipe_to_local_event_queue ();
4195 /* Unblock target events for async mode. */
4197 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4199 /* Put events we already waited on, in the pipe first, so
4201 local_event_queue_to_pipe ();
4202 /* While in masked async, we may have not collected all
4203 the pending events. Get them out now. */
4204 get_pending_events ();
4207 sigaction (SIGCHLD
, &async_sigchld_action
, NULL
);
4208 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
4211 case sigchld_default
:
4213 /* SIGCHLD default mode. */
4214 sigaction (SIGCHLD
, &sigchld_default_action
, NULL
);
4216 /* Get events out of queue, and make them available to
4217 queued_waitpid / my_waitpid. */
4218 pipe_to_local_event_queue ();
4220 /* Unblock SIGCHLD. */
4221 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
4227 return current_state
;
4230 static int async_terminal_is_ours
= 1;
4232 /* target_terminal_inferior implementation. */
4235 linux_nat_terminal_inferior (void)
4237 if (!target_is_async_p ())
4239 /* Async mode is disabled. */
4240 terminal_inferior ();
4244 /* GDB should never give the terminal to the inferior, if the
4245 inferior is running in the background (run&, continue&, etc.).
4246 This check can be removed when the common code is fixed. */
4247 if (!sync_execution
)
4250 terminal_inferior ();
4252 if (!async_terminal_is_ours
)
4255 delete_file_handler (input_fd
);
4256 async_terminal_is_ours
= 0;
4260 /* target_terminal_ours implementation. */
4263 linux_nat_terminal_ours (void)
4265 if (!target_is_async_p ())
4267 /* Async mode is disabled. */
4272 /* GDB should never give the terminal to the inferior if the
4273 inferior is running in the background (run&, continue&, etc.),
4274 but claiming it sure should. */
4277 if (!sync_execution
)
4280 if (async_terminal_is_ours
)
4283 clear_sigint_trap ();
4284 add_file_handler (input_fd
, stdin_event_handler
, 0);
4285 async_terminal_is_ours
= 1;
4288 static void (*async_client_callback
) (enum inferior_event_type event_type
,
4290 static void *async_client_context
;
4293 linux_nat_async_file_handler (int error
, gdb_client_data client_data
)
4295 async_client_callback (INF_REG_EVENT
, async_client_context
);
4298 /* target_async implementation. */
4301 linux_nat_async (void (*callback
) (enum inferior_event_type event_type
,
4302 void *context
), void *context
)
4304 if (linux_nat_async_mask_value
== 0 || !target_async_permitted
)
4305 internal_error (__FILE__
, __LINE__
,
4306 "Calling target_async when async is masked");
4308 if (callback
!= NULL
)
4310 async_client_callback
= callback
;
4311 async_client_context
= context
;
4312 add_file_handler (linux_nat_event_pipe
[0],
4313 linux_nat_async_file_handler
, NULL
);
4315 linux_nat_async_events (sigchld_async
);
4319 async_client_callback
= callback
;
4320 async_client_context
= context
;
4322 linux_nat_async_events (sigchld_sync
);
4323 delete_file_handler (linux_nat_event_pipe
[0]);
4329 send_sigint_callback (struct lwp_info
*lp
, void *data
)
4331 /* Use is_running instead of !lp->stopped, because the lwp may be
4332 stopped due to an internal event, and we want to interrupt it in
4333 that case too. What we want is to check if the thread is stopped
4334 from the point of view of the user. */
4335 if (is_running (lp
->ptid
))
4336 kill_lwp (GET_LWP (lp
->ptid
), SIGINT
);
4341 linux_nat_stop (ptid_t ptid
)
4345 if (ptid_equal (ptid
, minus_one_ptid
))
4346 iterate_over_lwps (send_sigint_callback
, &ptid
);
4349 struct lwp_info
*lp
= find_lwp_pid (ptid
);
4350 send_sigint_callback (lp
, NULL
);
4354 linux_ops
->to_stop (ptid
);
4358 linux_nat_add_target (struct target_ops
*t
)
4360 /* Save the provided single-threaded target. We save this in a separate
4361 variable because another target we've inherited from (e.g. inf-ptrace)
4362 may have saved a pointer to T; we want to use it for the final
4363 process stratum target. */
4364 linux_ops_saved
= *t
;
4365 linux_ops
= &linux_ops_saved
;
4367 /* Override some methods for multithreading. */
4368 t
->to_create_inferior
= linux_nat_create_inferior
;
4369 t
->to_attach
= linux_nat_attach
;
4370 t
->to_detach
= linux_nat_detach
;
4371 t
->to_resume
= linux_nat_resume
;
4372 t
->to_wait
= linux_nat_wait
;
4373 t
->to_xfer_partial
= linux_nat_xfer_partial
;
4374 t
->to_kill
= linux_nat_kill
;
4375 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
4376 t
->to_thread_alive
= linux_nat_thread_alive
;
4377 t
->to_pid_to_str
= linux_nat_pid_to_str
;
4378 t
->to_has_thread_control
= tc_schedlock
;
4380 t
->to_can_async_p
= linux_nat_can_async_p
;
4381 t
->to_is_async_p
= linux_nat_is_async_p
;
4382 t
->to_supports_non_stop
= linux_nat_supports_non_stop
;
4383 t
->to_async
= linux_nat_async
;
4384 t
->to_async_mask
= linux_nat_async_mask
;
4385 t
->to_terminal_inferior
= linux_nat_terminal_inferior
;
4386 t
->to_terminal_ours
= linux_nat_terminal_ours
;
4388 /* Methods for non-stop support. */
4389 t
->to_stop
= linux_nat_stop
;
4391 /* We don't change the stratum; this target will sit at
4392 process_stratum and thread_db will set at thread_stratum. This
4393 is a little strange, since this is a multi-threaded-capable
4394 target, but we want to be on the stack below thread_db, and we
4395 also want to be used for single-threaded processes. */
4399 /* TODO: Eliminate this and have libthread_db use
4400 find_target_beneath. */
4404 /* Register a method to call whenever a new thread is attached. */
4406 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
4408 /* Save the pointer. We only support a single registered instance
4409 of the GNU/Linux native target, so we do not need to map this to
4411 linux_nat_new_thread
= new_thread
;
4414 /* Return the saved siginfo associated with PTID. */
4416 linux_nat_get_siginfo (ptid_t ptid
)
4418 struct lwp_info
*lp
= find_lwp_pid (ptid
);
4420 gdb_assert (lp
!= NULL
);
4422 return &lp
->siginfo
;
4425 /* Enable/Disable async mode. */
4428 linux_nat_setup_async (void)
4430 if (pipe (linux_nat_event_pipe
) == -1)
4431 internal_error (__FILE__
, __LINE__
,
4432 "creating event pipe failed.");
4433 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
4434 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
4438 _initialize_linux_nat (void)
4442 add_info ("proc", linux_nat_info_proc_cmd
, _("\
4443 Show /proc process information about any running process.\n\
4444 Specify any process id, or use the program being debugged by default.\n\
4445 Specify any of the following keywords for detailed info:\n\
4446 mappings -- list of mapped memory regions.\n\
4447 stat -- list a bunch of random process info.\n\
4448 status -- list a different bunch of random process info.\n\
4449 all -- list all available /proc info."));
4451 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance
,
4452 &debug_linux_nat
, _("\
4453 Set debugging of GNU/Linux lwp module."), _("\
4454 Show debugging of GNU/Linux lwp module."), _("\
4455 Enables printf debugging output."),
4457 show_debug_linux_nat
,
4458 &setdebuglist
, &showdebuglist
);
4460 add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance
,
4461 &debug_linux_nat_async
, _("\
4462 Set debugging of GNU/Linux async lwp module."), _("\
4463 Show debugging of GNU/Linux async lwp module."), _("\
4464 Enables printf debugging output."),
4466 show_debug_linux_nat_async
,
4467 &setdebuglist
, &showdebuglist
);
4469 /* Get the default SIGCHLD action. Used while forking an inferior
4470 (see linux_nat_create_inferior/linux_nat_async_events). */
4471 sigaction (SIGCHLD
, NULL
, &sigchld_default_action
);
4473 /* Block SIGCHLD by default. Doing this early prevents it getting
4474 unblocked if an exception is thrown due to an error while the
4475 inferior is starting (sigsetjmp/siglongjmp). */
4476 sigemptyset (&mask
);
4477 sigaddset (&mask
, SIGCHLD
);
4478 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4480 /* Save this mask as the default. */
4481 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
4483 /* The synchronous SIGCHLD handler. */
4484 sync_sigchld_action
.sa_handler
= sigchld_handler
;
4485 sigemptyset (&sync_sigchld_action
.sa_mask
);
4486 sync_sigchld_action
.sa_flags
= SA_RESTART
;
4488 /* Make it the default. */
4489 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
4491 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4492 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
4493 sigdelset (&suspend_mask
, SIGCHLD
);
4495 /* SIGCHLD handler for async mode. */
4496 async_sigchld_action
.sa_handler
= async_sigchld_handler
;
4497 sigemptyset (&async_sigchld_action
.sa_mask
);
4498 async_sigchld_action
.sa_flags
= SA_RESTART
;
4500 linux_nat_setup_async ();
4502 add_setshow_boolean_cmd ("disable-randomization", class_support
,
4503 &disable_randomization
, _("\
4504 Set disabling of debuggee's virtual address space randomization."), _("\
4505 Show disabling of debuggee's virtual address space randomization."), _("\
4506 When this mode is on (which is the default), randomization of the virtual\n\
4507 address space is disabled. Standalone programs run with the randomization\n\
4508 enabled by default on some platforms."),
4509 &set_disable_randomization
,
4510 &show_disable_randomization
,
4511 &setlist
, &showlist
);
4515 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4516 the GNU/Linux Threads library and therefore doesn't really belong
4519 /* Read variable NAME in the target and return its value if found.
4520 Otherwise return zero. It is assumed that the type of the variable
4524 get_signo (const char *name
)
4526 struct minimal_symbol
*ms
;
4529 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
4533 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
4534 sizeof (signo
)) != 0)
4540 /* Return the set of signals used by the threads library in *SET. */
4543 lin_thread_get_thread_signals (sigset_t
*set
)
4545 struct sigaction action
;
4546 int restart
, cancel
;
4547 sigset_t blocked_mask
;
4549 sigemptyset (&blocked_mask
);
4552 restart
= get_signo ("__pthread_sig_restart");
4553 cancel
= get_signo ("__pthread_sig_cancel");
4555 /* LinuxThreads normally uses the first two RT signals, but in some legacy
4556 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
4557 not provide any way for the debugger to query the signal numbers -
4558 fortunately they don't change! */
4561 restart
= __SIGRTMIN
;
4564 cancel
= __SIGRTMIN
+ 1;
4566 sigaddset (set
, restart
);
4567 sigaddset (set
, cancel
);
4569 /* The GNU/Linux Threads library makes terminating threads send a
4570 special "cancel" signal instead of SIGCHLD. Make sure we catch
4571 those (to prevent them from terminating GDB itself, which is
4572 likely to be their default action) and treat them the same way as
4575 action
.sa_handler
= sigchld_handler
;
4576 sigemptyset (&action
.sa_mask
);
4577 action
.sa_flags
= SA_RESTART
;
4578 sigaction (cancel
, &action
, NULL
);
4580 /* We block the "cancel" signal throughout this code ... */
4581 sigaddset (&blocked_mask
, cancel
);
4582 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
4584 /* ... except during a sigsuspend. */
4585 sigdelset (&suspend_mask
, cancel
);