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 /* This comment documents high-level logic of this file.
55 Waiting for events in sync mode
56 ===============================
58 When waiting for an event in a specific thread, we just use waitpid, passing
59 the specific pid, and not passing WNOHANG.
61 When waiting for an event in all threads, waitpid is not quite good. Prior to
62 version 2.4, Linux can either wait for event in main thread, or in secondary
63 threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
64 miss an event. The solution is to use non-blocking waitpid, together with
65 sigsuspend. First, we use non-blocking waitpid to get an event in the main
66 process, if any. Second, we use non-blocking waitpid with the __WCLONED
67 flag to check for events in cloned processes. If nothing is found, we use
68 sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
69 happened to a child process -- and SIGCHLD will be delivered both for events
70 in main debugged process and in cloned processes. As soon as we know there's
71 an event, we get back to calling nonblocking waitpid with and without __WCLONED.
73 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
74 so that we don't miss a signal. If SIGCHLD arrives in between, when it's
75 blocked, the signal becomes pending and sigsuspend immediately
76 notices it and returns.
78 Waiting for events in async mode
79 ================================
81 In async mode, GDB should always be ready to handle both user input and target
82 events, so neither blocking waitpid nor sigsuspend are viable
83 options. Instead, we should notify the GDB main event loop whenever there's
84 unprocessed event from the target. The only way to notify this event loop is
85 to make it wait on input from a pipe, and write something to the pipe whenever
86 there's event. Obviously, if we fail to notify the event loop if there's
87 target event, it's bad. If we notify the event loop when there's no event
88 from target, linux-nat.c will detect that there's no event, actually, and
89 report event of type TARGET_WAITKIND_IGNORE, but it will waste time and
92 The main design point is that every time GDB is outside linux-nat.c, we have a
93 SIGCHLD handler installed that is called when something happens to the target
94 and notifies the GDB event loop. Also, the event is extracted from the target
95 using waitpid and stored for future use. Whenever GDB core decides to handle
96 the event, and calls into linux-nat.c, we disable SIGCHLD and process things
97 as in sync mode, except that before waitpid call we check if there are any
98 previously read events.
100 It could happen that during event processing, we'll try to get more events
101 than there are events in the local queue, which will result to waitpid call.
102 Those waitpid calls, while blocking, are guarantied to always have
103 something for waitpid to return. E.g., stopping a thread with SIGSTOP, and
104 waiting for the lwp to stop.
106 The event loop is notified about new events using a pipe. SIGCHLD handler does
107 waitpid and writes the results in to a pipe. GDB event loop has the other end
108 of the pipe among the sources. When event loop starts to process the event
109 and calls a function in linux-nat.c, all events from the pipe are transferred
110 into a local queue and SIGCHLD is blocked. Further processing goes as in sync
111 mode. Before we return from linux_nat_wait, we transfer all unprocessed events
112 from local queue back to the pipe, so that when we get back to event loop,
113 event loop will notice there's something more to do.
115 SIGCHLD is blocked when we're inside target_wait, so that should we actually
116 want to wait for some more events, SIGCHLD handler does not steal them from
117 us. Technically, it would be possible to add new events to the local queue but
118 it's about the same amount of work as blocking SIGCHLD.
120 This moving of events from pipe into local queue and back into pipe when we
121 enter/leave linux-nat.c is somewhat ugly. Unfortunately, GDB event loop is
122 home-grown and incapable to wait on any queue.
127 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
128 signal is not entirely significant; we just need for a signal to be delivered,
129 so that we can intercept it. SIGSTOP's advantage is that it can not be
130 blocked. A disadvantage is that it is not a real-time signal, so it can only
131 be queued once; we do not keep track of other sources of SIGSTOP.
133 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
134 use them, because they have special behavior when the signal is generated -
135 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
136 kills the entire thread group.
138 A delivered SIGSTOP would stop the entire thread group, not just the thread we
139 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
140 cancel it (by PTRACE_CONT without passing SIGSTOP).
142 We could use a real-time signal instead. This would solve those problems; we
143 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
144 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
145 generates it, and there are races with trying to find a signal that is not
149 #define O_LARGEFILE 0
152 /* If the system headers did not provide the constants, hard-code the normal
154 #ifndef PTRACE_EVENT_FORK
156 #define PTRACE_SETOPTIONS 0x4200
157 #define PTRACE_GETEVENTMSG 0x4201
159 /* options set using PTRACE_SETOPTIONS */
160 #define PTRACE_O_TRACESYSGOOD 0x00000001
161 #define PTRACE_O_TRACEFORK 0x00000002
162 #define PTRACE_O_TRACEVFORK 0x00000004
163 #define PTRACE_O_TRACECLONE 0x00000008
164 #define PTRACE_O_TRACEEXEC 0x00000010
165 #define PTRACE_O_TRACEVFORKDONE 0x00000020
166 #define PTRACE_O_TRACEEXIT 0x00000040
168 /* Wait extended result codes for the above trace options. */
169 #define PTRACE_EVENT_FORK 1
170 #define PTRACE_EVENT_VFORK 2
171 #define PTRACE_EVENT_CLONE 3
172 #define PTRACE_EVENT_EXEC 4
173 #define PTRACE_EVENT_VFORK_DONE 5
174 #define PTRACE_EVENT_EXIT 6
176 #endif /* PTRACE_EVENT_FORK */
178 /* We can't always assume that this flag is available, but all systems
179 with the ptrace event handlers also have __WALL, so it's safe to use
182 #define __WALL 0x40000000 /* Wait for any child. */
185 #ifndef PTRACE_GETSIGINFO
186 #define PTRACE_GETSIGINFO 0x4202
189 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
190 the use of the multi-threaded target. */
191 static struct target_ops
*linux_ops
;
192 static struct target_ops linux_ops_saved
;
194 /* The method to call, if any, when a new thread is attached. */
195 static void (*linux_nat_new_thread
) (ptid_t
);
197 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
198 Called by our to_xfer_partial. */
199 static LONGEST (*super_xfer_partial
) (struct target_ops
*,
201 const char *, gdb_byte
*,
205 static int debug_linux_nat
;
207 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
208 struct cmd_list_element
*c
, const char *value
)
210 fprintf_filtered (file
, _("Debugging of GNU/Linux lwp module is %s.\n"),
214 static int debug_linux_nat_async
= 0;
216 show_debug_linux_nat_async (struct ui_file
*file
, int from_tty
,
217 struct cmd_list_element
*c
, const char *value
)
219 fprintf_filtered (file
, _("Debugging of GNU/Linux async lwp module is %s.\n"),
223 static int linux_parent_pid
;
225 struct simple_pid_list
229 struct simple_pid_list
*next
;
231 struct simple_pid_list
*stopped_pids
;
233 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
234 can not be used, 1 if it can. */
236 static int linux_supports_tracefork_flag
= -1;
238 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
239 PTRACE_O_TRACEVFORKDONE. */
241 static int linux_supports_tracevforkdone_flag
= -1;
243 /* Async mode support */
245 /* True if async mode is currently on. */
246 static int linux_nat_async_enabled
;
248 /* Zero if the async mode, although enabled, is masked, which means
249 linux_nat_wait should behave as if async mode was off. */
250 static int linux_nat_async_mask_value
= 1;
252 /* The read/write ends of the pipe registered as waitable file in the
254 static int linux_nat_event_pipe
[2] = { -1, -1 };
256 /* Number of queued events in the pipe. */
257 static volatile int linux_nat_num_queued_events
;
259 /* The possible SIGCHLD handling states. */
263 /* SIGCHLD disabled, with action set to sigchld_handler, for the
264 sigsuspend in linux_nat_wait. */
266 /* SIGCHLD enabled, with action set to async_sigchld_handler. */
268 /* Set SIGCHLD to default action. Used while creating an
273 /* The current SIGCHLD handling state. */
274 static enum sigchld_state linux_nat_async_events_state
;
276 static enum sigchld_state
linux_nat_async_events (enum sigchld_state enable
);
277 static void pipe_to_local_event_queue (void);
278 static void local_event_queue_to_pipe (void);
279 static void linux_nat_event_pipe_push (int pid
, int status
, int options
);
280 static int linux_nat_event_pipe_pop (int* ptr_status
, int* ptr_options
);
281 static void linux_nat_set_async_mode (int on
);
282 static void linux_nat_async (void (*callback
)
283 (enum inferior_event_type event_type
, void *context
),
285 static int linux_nat_async_mask (int mask
);
286 static int kill_lwp (int lwpid
, int signo
);
288 /* Captures the result of a successful waitpid call, along with the
289 options used in that call. */
290 struct waitpid_result
295 struct waitpid_result
*next
;
298 /* A singly-linked list of the results of the waitpid calls performed
299 in the async SIGCHLD handler. */
300 static struct waitpid_result
*waitpid_queue
= NULL
;
303 queued_waitpid (int pid
, int *status
, int flags
)
305 struct waitpid_result
*msg
= waitpid_queue
, *prev
= NULL
;
307 if (debug_linux_nat_async
)
308 fprintf_unfiltered (gdb_stdlog
,
310 QWPID: linux_nat_async_events_state(%d), linux_nat_num_queued_events(%d)\n",
311 linux_nat_async_events_state
,
312 linux_nat_num_queued_events
);
316 for (; msg
; prev
= msg
, msg
= msg
->next
)
317 if (pid
== -1 || pid
== msg
->pid
)
320 else if (flags
& __WCLONE
)
322 for (; msg
; prev
= msg
, msg
= msg
->next
)
323 if (msg
->options
& __WCLONE
324 && (pid
== -1 || pid
== msg
->pid
))
329 for (; msg
; prev
= msg
, msg
= msg
->next
)
330 if ((msg
->options
& __WCLONE
) == 0
331 && (pid
== -1 || pid
== msg
->pid
))
340 prev
->next
= msg
->next
;
342 waitpid_queue
= msg
->next
;
346 *status
= msg
->status
;
349 if (debug_linux_nat_async
)
350 fprintf_unfiltered (gdb_stdlog
, "QWPID: pid(%d), status(%x)\n",
357 if (debug_linux_nat_async
)
358 fprintf_unfiltered (gdb_stdlog
, "QWPID: miss\n");
366 push_waitpid (int pid
, int status
, int options
)
368 struct waitpid_result
*event
, *new_event
;
370 new_event
= xmalloc (sizeof (*new_event
));
371 new_event
->pid
= pid
;
372 new_event
->status
= status
;
373 new_event
->options
= options
;
374 new_event
->next
= NULL
;
378 for (event
= waitpid_queue
;
379 event
&& event
->next
;
383 event
->next
= new_event
;
386 waitpid_queue
= new_event
;
389 /* Drain all queued events of PID. If PID is -1, the effect is of
390 draining all events. */
392 drain_queued_events (int pid
)
394 while (queued_waitpid (pid
, NULL
, __WALL
) != -1)
399 /* Trivial list manipulation functions to keep track of a list of
400 new stopped processes. */
402 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
404 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
406 new_pid
->status
= status
;
407 new_pid
->next
= *listp
;
412 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *status
)
414 struct simple_pid_list
**p
;
416 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
417 if ((*p
)->pid
== pid
)
419 struct simple_pid_list
*next
= (*p
)->next
;
420 *status
= (*p
)->status
;
429 linux_record_stopped_pid (int pid
, int status
)
431 add_to_pid_list (&stopped_pids
, pid
, status
);
435 /* A helper function for linux_test_for_tracefork, called after fork (). */
438 linux_tracefork_child (void)
442 ptrace (PTRACE_TRACEME
, 0, 0, 0);
443 kill (getpid (), SIGSTOP
);
448 /* Wrapper function for waitpid which handles EINTR, and checks for
449 locally queued events. */
452 my_waitpid (int pid
, int *status
, int flags
)
456 /* There should be no concurrent calls to waitpid. */
457 gdb_assert (linux_nat_async_events_state
== sigchld_sync
);
459 ret
= queued_waitpid (pid
, status
, flags
);
465 ret
= waitpid (pid
, status
, flags
);
467 while (ret
== -1 && errno
== EINTR
);
472 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
474 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
475 we know that the feature is not available. This may change the tracing
476 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
478 However, if it succeeds, we don't know for sure that the feature is
479 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
480 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
481 fork tracing, and let it fork. If the process exits, we assume that we
482 can't use TRACEFORK; if we get the fork notification, and we can extract
483 the new child's PID, then we assume that we can. */
486 linux_test_for_tracefork (int original_pid
)
488 int child_pid
, ret
, status
;
491 linux_supports_tracefork_flag
= 0;
492 linux_supports_tracevforkdone_flag
= 0;
494 ret
= ptrace (PTRACE_SETOPTIONS
, original_pid
, 0, PTRACE_O_TRACEFORK
);
500 perror_with_name (("fork"));
503 linux_tracefork_child ();
505 ret
= my_waitpid (child_pid
, &status
, 0);
507 perror_with_name (("waitpid"));
508 else if (ret
!= child_pid
)
509 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret
);
510 if (! WIFSTOPPED (status
))
511 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status
);
513 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
516 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
519 warning (_("linux_test_for_tracefork: failed to kill child"));
523 ret
= my_waitpid (child_pid
, &status
, 0);
524 if (ret
!= child_pid
)
525 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
526 else if (!WIFSIGNALED (status
))
527 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
528 "killed child"), status
);
533 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
534 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0,
535 PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORKDONE
);
536 linux_supports_tracevforkdone_flag
= (ret
== 0);
538 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
540 warning (_("linux_test_for_tracefork: failed to resume child"));
542 ret
= my_waitpid (child_pid
, &status
, 0);
544 if (ret
== child_pid
&& WIFSTOPPED (status
)
545 && status
>> 16 == PTRACE_EVENT_FORK
)
548 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
549 if (ret
== 0 && second_pid
!= 0)
553 linux_supports_tracefork_flag
= 1;
554 my_waitpid (second_pid
, &second_status
, 0);
555 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
557 warning (_("linux_test_for_tracefork: failed to kill second child"));
558 my_waitpid (second_pid
, &status
, 0);
562 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
563 "(%d, status 0x%x)"), ret
, status
);
565 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
567 warning (_("linux_test_for_tracefork: failed to kill child"));
568 my_waitpid (child_pid
, &status
, 0);
571 /* Return non-zero iff we have tracefork functionality available.
572 This function also sets linux_supports_tracefork_flag. */
575 linux_supports_tracefork (int pid
)
577 if (linux_supports_tracefork_flag
== -1)
578 linux_test_for_tracefork (pid
);
579 return linux_supports_tracefork_flag
;
583 linux_supports_tracevforkdone (int pid
)
585 if (linux_supports_tracefork_flag
== -1)
586 linux_test_for_tracefork (pid
);
587 return linux_supports_tracevforkdone_flag
;
592 linux_enable_event_reporting (ptid_t ptid
)
594 int pid
= ptid_get_lwp (ptid
);
598 pid
= ptid_get_pid (ptid
);
600 if (! linux_supports_tracefork (pid
))
603 options
= PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEEXEC
604 | PTRACE_O_TRACECLONE
;
605 if (linux_supports_tracevforkdone (pid
))
606 options
|= PTRACE_O_TRACEVFORKDONE
;
608 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
609 read-only process state. */
611 ptrace (PTRACE_SETOPTIONS
, pid
, 0, options
);
615 linux_child_post_attach (int pid
)
617 linux_enable_event_reporting (pid_to_ptid (pid
));
618 check_for_thread_db ();
622 linux_child_post_startup_inferior (ptid_t ptid
)
624 linux_enable_event_reporting (ptid
);
625 check_for_thread_db ();
629 linux_child_follow_fork (struct target_ops
*ops
, int follow_child
)
632 struct target_waitstatus last_status
;
634 int parent_pid
, child_pid
;
636 if (target_can_async_p ())
637 target_async (NULL
, 0);
639 get_last_target_status (&last_ptid
, &last_status
);
640 has_vforked
= (last_status
.kind
== TARGET_WAITKIND_VFORKED
);
641 parent_pid
= ptid_get_lwp (last_ptid
);
643 parent_pid
= ptid_get_pid (last_ptid
);
644 child_pid
= last_status
.value
.related_pid
;
648 /* We're already attached to the parent, by default. */
650 /* Before detaching from the child, remove all breakpoints from
651 it. (This won't actually modify the breakpoint list, but will
652 physically remove the breakpoints from the child.) */
653 /* If we vforked this will remove the breakpoints from the parent
654 also, but they'll be reinserted below. */
655 detach_breakpoints (child_pid
);
657 /* Detach new forked process? */
660 if (info_verbose
|| debug_linux_nat
)
662 target_terminal_ours ();
663 fprintf_filtered (gdb_stdlog
,
664 "Detaching after fork from child process %d.\n",
668 ptrace (PTRACE_DETACH
, child_pid
, 0, 0);
672 struct fork_info
*fp
;
673 /* Retain child fork in ptrace (stopped) state. */
674 fp
= find_fork_pid (child_pid
);
676 fp
= add_fork (child_pid
);
677 fork_save_infrun_state (fp
, 0);
682 gdb_assert (linux_supports_tracefork_flag
>= 0);
683 if (linux_supports_tracevforkdone (0))
687 ptrace (PTRACE_CONT
, parent_pid
, 0, 0);
688 my_waitpid (parent_pid
, &status
, __WALL
);
689 if ((status
>> 16) != PTRACE_EVENT_VFORK_DONE
)
690 warning (_("Unexpected waitpid result %06x when waiting for "
691 "vfork-done"), status
);
695 /* We can't insert breakpoints until the child has
696 finished with the shared memory region. We need to
697 wait until that happens. Ideal would be to just
699 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
700 - waitpid (parent_pid, &status, __WALL);
701 However, most architectures can't handle a syscall
702 being traced on the way out if it wasn't traced on
705 We might also think to loop, continuing the child
706 until it exits or gets a SIGTRAP. One problem is
707 that the child might call ptrace with PTRACE_TRACEME.
709 There's no simple and reliable way to figure out when
710 the vforked child will be done with its copy of the
711 shared memory. We could step it out of the syscall,
712 two instructions, let it go, and then single-step the
713 parent once. When we have hardware single-step, this
714 would work; with software single-step it could still
715 be made to work but we'd have to be able to insert
716 single-step breakpoints in the child, and we'd have
717 to insert -just- the single-step breakpoint in the
718 parent. Very awkward.
720 In the end, the best we can do is to make sure it
721 runs for a little while. Hopefully it will be out of
722 range of any breakpoints we reinsert. Usually this
723 is only the single-step breakpoint at vfork's return
729 /* Since we vforked, breakpoints were removed in the parent
730 too. Put them back. */
731 reattach_breakpoints (parent_pid
);
736 char child_pid_spelling
[40];
738 /* Needed to keep the breakpoint lists in sync. */
740 detach_breakpoints (child_pid
);
742 /* Before detaching from the parent, remove all breakpoints from it. */
743 remove_breakpoints ();
745 if (info_verbose
|| debug_linux_nat
)
747 target_terminal_ours ();
748 fprintf_filtered (gdb_stdlog
,
749 "Attaching after fork to child process %d.\n",
753 /* If we're vforking, we may want to hold on to the parent until
754 the child exits or execs. At exec time we can remove the old
755 breakpoints from the parent and detach it; at exit time we
756 could do the same (or even, sneakily, resume debugging it - the
757 child's exec has failed, or something similar).
759 This doesn't clean up "properly", because we can't call
760 target_detach, but that's OK; if the current target is "child",
761 then it doesn't need any further cleanups, and lin_lwp will
762 generally not encounter vfork (vfork is defined to fork
765 The holding part is very easy if we have VFORKDONE events;
766 but keeping track of both processes is beyond GDB at the
767 moment. So we don't expose the parent to the rest of GDB.
768 Instead we quietly hold onto it until such time as we can
772 linux_parent_pid
= parent_pid
;
773 else if (!detach_fork
)
775 struct fork_info
*fp
;
776 /* Retain parent fork in ptrace (stopped) state. */
777 fp
= find_fork_pid (parent_pid
);
779 fp
= add_fork (parent_pid
);
780 fork_save_infrun_state (fp
, 0);
783 target_detach (NULL
, 0);
785 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
787 /* Reinstall ourselves, since we might have been removed in
788 target_detach (which does other necessary cleanup). */
791 linux_nat_switch_fork (inferior_ptid
);
792 check_for_thread_db ();
794 /* Reset breakpoints in the child as appropriate. */
795 follow_inferior_reset_breakpoints ();
798 if (target_can_async_p ())
799 target_async (inferior_event_handler
, 0);
806 linux_child_insert_fork_catchpoint (int pid
)
808 if (! linux_supports_tracefork (pid
))
809 error (_("Your system does not support fork catchpoints."));
813 linux_child_insert_vfork_catchpoint (int pid
)
815 if (!linux_supports_tracefork (pid
))
816 error (_("Your system does not support vfork catchpoints."));
820 linux_child_insert_exec_catchpoint (int pid
)
822 if (!linux_supports_tracefork (pid
))
823 error (_("Your system does not support exec catchpoints."));
826 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
827 are processes sharing the same VM space. A multi-threaded process
828 is basically a group of such processes. However, such a grouping
829 is almost entirely a user-space issue; the kernel doesn't enforce
830 such a grouping at all (this might change in the future). In
831 general, we'll rely on the threads library (i.e. the GNU/Linux
832 Threads library) to provide such a grouping.
834 It is perfectly well possible to write a multi-threaded application
835 without the assistance of a threads library, by using the clone
836 system call directly. This module should be able to give some
837 rudimentary support for debugging such applications if developers
838 specify the CLONE_PTRACE flag in the clone system call, and are
839 using the Linux kernel 2.4 or above.
841 Note that there are some peculiarities in GNU/Linux that affect
844 - In general one should specify the __WCLONE flag to waitpid in
845 order to make it report events for any of the cloned processes
846 (and leave it out for the initial process). However, if a cloned
847 process has exited the exit status is only reported if the
848 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
849 we cannot use it since GDB must work on older systems too.
851 - When a traced, cloned process exits and is waited for by the
852 debugger, the kernel reassigns it to the original parent and
853 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
854 library doesn't notice this, which leads to the "zombie problem":
855 When debugged a multi-threaded process that spawns a lot of
856 threads will run out of processes, even if the threads exit,
857 because the "zombies" stay around. */
859 /* List of known LWPs. */
860 struct lwp_info
*lwp_list
;
862 /* Number of LWPs in the list. */
866 /* Original signal mask. */
867 static sigset_t normal_mask
;
869 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
870 _initialize_linux_nat. */
871 static sigset_t suspend_mask
;
873 /* SIGCHLD action for synchronous mode. */
874 struct sigaction sync_sigchld_action
;
876 /* SIGCHLD action for asynchronous mode. */
877 static struct sigaction async_sigchld_action
;
879 /* SIGCHLD default action, to pass to new inferiors. */
880 static struct sigaction sigchld_default_action
;
883 /* Prototypes for local functions. */
884 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
885 static int linux_nat_thread_alive (ptid_t ptid
);
886 static char *linux_child_pid_to_exec_file (int pid
);
887 static int cancel_breakpoint (struct lwp_info
*lp
);
890 /* Convert wait status STATUS to a string. Used for printing debug
894 status_to_str (int status
)
898 if (WIFSTOPPED (status
))
899 snprintf (buf
, sizeof (buf
), "%s (stopped)",
900 strsignal (WSTOPSIG (status
)));
901 else if (WIFSIGNALED (status
))
902 snprintf (buf
, sizeof (buf
), "%s (terminated)",
903 strsignal (WSTOPSIG (status
)));
905 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
910 /* Initialize the list of LWPs. Note that this module, contrary to
911 what GDB's generic threads layer does for its thread list,
912 re-initializes the LWP lists whenever we mourn or detach (which
913 doesn't involve mourning) the inferior. */
918 struct lwp_info
*lp
, *lpnext
;
920 for (lp
= lwp_list
; lp
; lp
= lpnext
)
930 /* Add the LWP specified by PID to the list. Return a pointer to the
931 structure describing the new LWP. The LWP should already be stopped
932 (with an exception for the very first LWP). */
934 static struct lwp_info
*
935 add_lwp (ptid_t ptid
)
939 gdb_assert (is_lwp (ptid
));
941 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
943 memset (lp
, 0, sizeof (struct lwp_info
));
945 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
953 if (num_lwps
> 1 && linux_nat_new_thread
!= NULL
)
954 linux_nat_new_thread (ptid
);
959 /* Remove the LWP specified by PID from the list. */
962 delete_lwp (ptid_t ptid
)
964 struct lwp_info
*lp
, *lpprev
;
968 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
969 if (ptid_equal (lp
->ptid
, ptid
))
978 lpprev
->next
= lp
->next
;
985 /* Return a pointer to the structure describing the LWP corresponding
986 to PID. If no corresponding LWP could be found, return NULL. */
988 static struct lwp_info
*
989 find_lwp_pid (ptid_t ptid
)
995 lwp
= GET_LWP (ptid
);
997 lwp
= GET_PID (ptid
);
999 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
1000 if (lwp
== GET_LWP (lp
->ptid
))
1006 /* Call CALLBACK with its second argument set to DATA for every LWP in
1007 the list. If CALLBACK returns 1 for a particular LWP, return a
1008 pointer to the structure describing that LWP immediately.
1009 Otherwise return NULL. */
1012 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
1014 struct lwp_info
*lp
, *lpnext
;
1016 for (lp
= lwp_list
; lp
; lp
= lpnext
)
1019 if ((*callback
) (lp
, data
))
1026 /* Update our internal state when changing from one fork (checkpoint,
1027 et cetera) to another indicated by NEW_PTID. We can only switch
1028 single-threaded applications, so we only create one new LWP, and
1029 the previous list is discarded. */
1032 linux_nat_switch_fork (ptid_t new_ptid
)
1034 struct lwp_info
*lp
;
1036 init_thread_list ();
1038 lp
= add_lwp (new_ptid
);
1039 add_thread_silent (new_ptid
);
1043 /* Record a PTID for later deletion. */
1048 struct saved_ptids
*next
;
1050 static struct saved_ptids
*threads_to_delete
;
1053 record_dead_thread (ptid_t ptid
)
1055 struct saved_ptids
*p
= xmalloc (sizeof (struct saved_ptids
));
1057 p
->next
= threads_to_delete
;
1058 threads_to_delete
= p
;
1061 /* Delete any dead threads which are not the current thread. */
1066 struct saved_ptids
**p
= &threads_to_delete
;
1069 if (! ptid_equal ((*p
)->ptid
, inferior_ptid
))
1071 struct saved_ptids
*tmp
= *p
;
1072 delete_thread (tmp
->ptid
);
1080 /* Handle the exit of a single thread LP. */
1083 exit_lwp (struct lwp_info
*lp
)
1085 struct thread_info
*th
= find_thread_pid (lp
->ptid
);
1089 if (print_thread_events
)
1090 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp
->ptid
));
1092 /* Core GDB cannot deal with us deleting the current thread. */
1093 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1094 delete_thread (lp
->ptid
);
1096 record_dead_thread (lp
->ptid
);
1099 delete_lwp (lp
->ptid
);
1102 /* Detect `T (stopped)' in `/proc/PID/status'.
1103 Other states including `T (tracing stop)' are reported as false. */
1106 pid_is_stopped (pid_t pid
)
1112 snprintf (buf
, sizeof (buf
), "/proc/%d/status", (int) pid
);
1113 status_file
= fopen (buf
, "r");
1114 if (status_file
!= NULL
)
1118 while (fgets (buf
, sizeof (buf
), status_file
))
1120 if (strncmp (buf
, "State:", 6) == 0)
1126 if (have_state
&& strstr (buf
, "T (stopped)") != NULL
)
1128 fclose (status_file
);
1133 /* Wait for the LWP specified by LP, which we have just attached to.
1134 Returns a wait status for that LWP, to cache. */
1137 linux_nat_post_attach_wait (ptid_t ptid
, int first
, int *cloned
,
1140 pid_t new_pid
, pid
= GET_LWP (ptid
);
1143 if (pid_is_stopped (pid
))
1145 if (debug_linux_nat
)
1146 fprintf_unfiltered (gdb_stdlog
,
1147 "LNPAW: Attaching to a stopped process\n");
1149 /* The process is definitely stopped. It is in a job control
1150 stop, unless the kernel predates the TASK_STOPPED /
1151 TASK_TRACED distinction, in which case it might be in a
1152 ptrace stop. Make sure it is in a ptrace stop; from there we
1153 can kill it, signal it, et cetera.
1155 First make sure there is a pending SIGSTOP. Since we are
1156 already attached, the process can not transition from stopped
1157 to running without a PTRACE_CONT; so we know this signal will
1158 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1159 probably already in the queue (unless this kernel is old
1160 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1161 is not an RT signal, it can only be queued once. */
1162 kill_lwp (pid
, SIGSTOP
);
1164 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1165 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1166 ptrace (PTRACE_CONT
, pid
, 0, 0);
1169 /* Make sure the initial process is stopped. The user-level threads
1170 layer might want to poke around in the inferior, and that won't
1171 work if things haven't stabilized yet. */
1172 new_pid
= my_waitpid (pid
, &status
, 0);
1173 if (new_pid
== -1 && errno
== ECHILD
)
1176 warning (_("%s is a cloned process"), target_pid_to_str (ptid
));
1178 /* Try again with __WCLONE to check cloned processes. */
1179 new_pid
= my_waitpid (pid
, &status
, __WCLONE
);
1183 gdb_assert (pid
== new_pid
&& WIFSTOPPED (status
));
1185 if (WSTOPSIG (status
) != SIGSTOP
)
1188 if (debug_linux_nat
)
1189 fprintf_unfiltered (gdb_stdlog
,
1190 "LNPAW: Received %s after attaching\n",
1191 status_to_str (status
));
1197 /* Attach to the LWP specified by PID. Return 0 if successful or -1
1198 if the new LWP could not be attached. */
1201 lin_lwp_attach_lwp (ptid_t ptid
)
1203 struct lwp_info
*lp
;
1204 enum sigchld_state async_events_original_state
;
1206 gdb_assert (is_lwp (ptid
));
1208 async_events_original_state
= linux_nat_async_events (sigchld_sync
);
1210 lp
= find_lwp_pid (ptid
);
1212 /* We assume that we're already attached to any LWP that has an id
1213 equal to the overall process id, and to any LWP that is already
1214 in our list of LWPs. If we're not seeing exit events from threads
1215 and we've had PID wraparound since we last tried to stop all threads,
1216 this assumption might be wrong; fortunately, this is very unlikely
1218 if (GET_LWP (ptid
) != GET_PID (ptid
) && lp
== NULL
)
1220 int status
, cloned
= 0, signalled
= 0;
1222 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
1224 /* If we fail to attach to the thread, issue a warning,
1225 but continue. One way this can happen is if thread
1226 creation is interrupted; as of Linux kernel 2.6.19, a
1227 bug may place threads in the thread list and then fail
1229 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
1230 safe_strerror (errno
));
1234 if (debug_linux_nat
)
1235 fprintf_unfiltered (gdb_stdlog
,
1236 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1237 target_pid_to_str (ptid
));
1239 status
= linux_nat_post_attach_wait (ptid
, 0, &cloned
, &signalled
);
1240 lp
= add_lwp (ptid
);
1242 lp
->cloned
= cloned
;
1243 lp
->signalled
= signalled
;
1244 if (WSTOPSIG (status
) != SIGSTOP
)
1247 lp
->status
= status
;
1250 target_post_attach (GET_LWP (lp
->ptid
));
1252 if (debug_linux_nat
)
1254 fprintf_unfiltered (gdb_stdlog
,
1255 "LLAL: waitpid %s received %s\n",
1256 target_pid_to_str (ptid
),
1257 status_to_str (status
));
1262 /* We assume that the LWP representing the original process is
1263 already stopped. Mark it as stopped in the data structure
1264 that the GNU/linux ptrace layer uses to keep track of
1265 threads. Note that this won't have already been done since
1266 the main thread will have, we assume, been stopped by an
1267 attach from a different layer. */
1269 lp
= add_lwp (ptid
);
1273 linux_nat_async_events (async_events_original_state
);
1278 linux_nat_create_inferior (char *exec_file
, char *allargs
, char **env
,
1281 int saved_async
= 0;
1283 /* The fork_child mechanism is synchronous and calls target_wait, so
1284 we have to mask the async mode. */
1286 if (target_can_async_p ())
1287 /* Mask async mode. Creating a child requires a loop calling
1288 wait_for_inferior currently. */
1289 saved_async
= linux_nat_async_mask (0);
1292 /* Restore the original signal mask. */
1293 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1294 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1295 suspend_mask
= normal_mask
;
1296 sigdelset (&suspend_mask
, SIGCHLD
);
1299 /* Set SIGCHLD to the default action, until after execing the child,
1300 since the inferior inherits the superior's signal mask. It will
1301 be blocked again in linux_nat_wait, which is only reached after
1302 the inferior execing. */
1303 linux_nat_async_events (sigchld_default
);
1305 linux_ops
->to_create_inferior (exec_file
, allargs
, env
, from_tty
);
1308 linux_nat_async_mask (saved_async
);
1312 linux_nat_attach (char *args
, int from_tty
)
1314 struct lwp_info
*lp
;
1317 /* FIXME: We should probably accept a list of process id's, and
1318 attach all of them. */
1319 linux_ops
->to_attach (args
, from_tty
);
1321 if (!target_can_async_p ())
1323 /* Restore the original signal mask. */
1324 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1325 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1326 suspend_mask
= normal_mask
;
1327 sigdelset (&suspend_mask
, SIGCHLD
);
1330 /* Add the initial process as the first LWP to the list. */
1331 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
));
1332 lp
= add_lwp (inferior_ptid
);
1334 status
= linux_nat_post_attach_wait (lp
->ptid
, 1, &lp
->cloned
,
1338 /* If this process is not using thread_db, then we still don't
1339 detect any other threads, but add at least this one. */
1340 add_thread_silent (lp
->ptid
);
1342 /* Save the wait status to report later. */
1344 if (debug_linux_nat
)
1345 fprintf_unfiltered (gdb_stdlog
,
1346 "LNA: waitpid %ld, saving status %s\n",
1347 (long) GET_PID (lp
->ptid
), status_to_str (status
));
1349 if (!target_can_async_p ())
1350 lp
->status
= status
;
1353 /* We already waited for this LWP, so put the wait result on the
1354 pipe. The event loop will wake up and gets us to handling
1356 linux_nat_event_pipe_push (GET_PID (lp
->ptid
), status
,
1357 lp
->cloned
? __WCLONE
: 0);
1358 /* Register in the event loop. */
1359 target_async (inferior_event_handler
, 0);
1363 /* Get pending status of LP. */
1365 get_pending_status (struct lwp_info
*lp
, int *status
)
1367 struct target_waitstatus last
;
1370 get_last_target_status (&last_ptid
, &last
);
1372 /* If this lwp is the ptid that GDB is processing an event from, the
1373 signal will be in stop_signal. Otherwise, in all-stop + sync
1374 mode, we may cache pending events in lp->status while trying to
1375 stop all threads (see stop_wait_callback). In async mode, the
1376 events are always cached in waitpid_queue. */
1379 if (GET_LWP (lp
->ptid
) == GET_LWP (last_ptid
))
1381 if (stop_signal
!= TARGET_SIGNAL_0
1382 && signal_pass_state (stop_signal
))
1383 *status
= W_STOPCODE (target_signal_to_host (stop_signal
));
1385 else if (target_can_async_p ())
1386 queued_waitpid (GET_LWP (lp
->ptid
), status
, __WALL
);
1388 *status
= lp
->status
;
1394 detach_callback (struct lwp_info
*lp
, void *data
)
1396 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1398 if (debug_linux_nat
&& lp
->status
)
1399 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
1400 strsignal (WSTOPSIG (lp
->status
)),
1401 target_pid_to_str (lp
->ptid
));
1403 /* If there is a pending SIGSTOP, get rid of it. */
1406 if (debug_linux_nat
)
1407 fprintf_unfiltered (gdb_stdlog
,
1408 "DC: Sending SIGCONT to %s\n",
1409 target_pid_to_str (lp
->ptid
));
1411 kill_lwp (GET_LWP (lp
->ptid
), SIGCONT
);
1415 /* We don't actually detach from the LWP that has an id equal to the
1416 overall process id just yet. */
1417 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
1421 /* Pass on any pending signal for this LWP. */
1422 get_pending_status (lp
, &status
);
1425 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
1426 WSTOPSIG (status
)) < 0)
1427 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1428 safe_strerror (errno
));
1430 if (debug_linux_nat
)
1431 fprintf_unfiltered (gdb_stdlog
,
1432 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1433 target_pid_to_str (lp
->ptid
),
1434 strsignal (WSTOPSIG (lp
->status
)));
1436 delete_lwp (lp
->ptid
);
1443 linux_nat_detach (char *args
, int from_tty
)
1447 enum target_signal sig
;
1449 if (target_can_async_p ())
1450 linux_nat_async (NULL
, 0);
1452 iterate_over_lwps (detach_callback
, NULL
);
1454 /* Only the initial process should be left right now. */
1455 gdb_assert (num_lwps
== 1);
1457 /* Pass on any pending signal for the last LWP. */
1458 if ((args
== NULL
|| *args
== '\0')
1459 && get_pending_status (lwp_list
, &status
) != -1
1460 && WIFSTOPPED (status
))
1462 /* Put the signal number in ARGS so that inf_ptrace_detach will
1463 pass it along with PTRACE_DETACH. */
1465 sprintf (args
, "%d", (int) WSTOPSIG (status
));
1466 fprintf_unfiltered (gdb_stdlog
,
1467 "LND: Sending signal %s to %s\n",
1469 target_pid_to_str (lwp_list
->ptid
));
1472 /* Destroy LWP info; it's no longer valid. */
1475 pid
= GET_PID (inferior_ptid
);
1476 inferior_ptid
= pid_to_ptid (pid
);
1477 linux_ops
->to_detach (args
, from_tty
);
1479 if (target_can_async_p ())
1480 drain_queued_events (pid
);
1486 resume_callback (struct lwp_info
*lp
, void *data
)
1488 if (lp
->stopped
&& lp
->status
== 0)
1490 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
1491 0, TARGET_SIGNAL_0
);
1492 if (debug_linux_nat
)
1493 fprintf_unfiltered (gdb_stdlog
,
1494 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1495 target_pid_to_str (lp
->ptid
));
1498 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1505 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1512 resume_set_callback (struct lwp_info
*lp
, void *data
)
1519 linux_nat_resume (ptid_t ptid
, int step
, enum target_signal signo
)
1521 struct lwp_info
*lp
;
1524 if (debug_linux_nat
)
1525 fprintf_unfiltered (gdb_stdlog
,
1526 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1527 step
? "step" : "resume",
1528 target_pid_to_str (ptid
),
1529 signo
? strsignal (signo
) : "0",
1530 target_pid_to_str (inferior_ptid
));
1534 if (target_can_async_p ())
1535 /* Block events while we're here. */
1536 linux_nat_async_events (sigchld_sync
);
1538 /* A specific PTID means `step only this process id'. */
1539 resume_all
= (PIDGET (ptid
) == -1);
1542 iterate_over_lwps (resume_set_callback
, NULL
);
1544 iterate_over_lwps (resume_clear_callback
, NULL
);
1546 /* If PID is -1, it's the current inferior that should be
1547 handled specially. */
1548 if (PIDGET (ptid
) == -1)
1549 ptid
= inferior_ptid
;
1551 lp
= find_lwp_pid (ptid
);
1552 gdb_assert (lp
!= NULL
);
1554 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
1556 /* Remember if we're stepping. */
1559 /* Mark this LWP as resumed. */
1562 /* If we have a pending wait status for this thread, there is no
1563 point in resuming the process. But first make sure that
1564 linux_nat_wait won't preemptively handle the event - we
1565 should never take this short-circuit if we are going to
1566 leave LP running, since we have skipped resuming all the
1567 other threads. This bit of code needs to be synchronized
1568 with linux_nat_wait. */
1570 /* In async mode, we never have pending wait status. */
1571 if (target_can_async_p () && lp
->status
)
1572 internal_error (__FILE__
, __LINE__
, "Pending status in async mode");
1574 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1576 int saved_signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1578 if (signal_stop_state (saved_signo
) == 0
1579 && signal_print_state (saved_signo
) == 0
1580 && signal_pass_state (saved_signo
) == 1)
1582 if (debug_linux_nat
)
1583 fprintf_unfiltered (gdb_stdlog
,
1584 "LLR: Not short circuiting for ignored "
1585 "status 0x%x\n", lp
->status
);
1587 /* FIXME: What should we do if we are supposed to continue
1588 this thread with a signal? */
1589 gdb_assert (signo
== TARGET_SIGNAL_0
);
1590 signo
= saved_signo
;
1597 /* FIXME: What should we do if we are supposed to continue
1598 this thread with a signal? */
1599 gdb_assert (signo
== TARGET_SIGNAL_0
);
1601 if (debug_linux_nat
)
1602 fprintf_unfiltered (gdb_stdlog
,
1603 "LLR: Short circuiting for status 0x%x\n",
1609 /* Mark LWP as not stopped to prevent it from being continued by
1614 iterate_over_lwps (resume_callback
, NULL
);
1616 linux_ops
->to_resume (ptid
, step
, signo
);
1617 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1619 if (debug_linux_nat
)
1620 fprintf_unfiltered (gdb_stdlog
,
1621 "LLR: %s %s, %s (resume event thread)\n",
1622 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1623 target_pid_to_str (ptid
),
1624 signo
? strsignal (signo
) : "0");
1626 if (target_can_async_p ())
1628 target_executing
= 1;
1629 target_async (inferior_event_handler
, 0);
1633 /* Issue kill to specified lwp. */
1635 static int tkill_failed
;
1638 kill_lwp (int lwpid
, int signo
)
1642 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1643 fails, then we are not using nptl threads and we should be using kill. */
1645 #ifdef HAVE_TKILL_SYSCALL
1648 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
1649 if (errno
!= ENOSYS
)
1656 return kill (lwpid
, signo
);
1659 /* Handle a GNU/Linux extended wait response. If we see a clone
1660 event, we need to add the new LWP to our list (and not report the
1661 trap to higher layers). This function returns non-zero if the
1662 event should be ignored and we should wait again. If STOPPING is
1663 true, the new LWP remains stopped, otherwise it is continued. */
1666 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
1669 int pid
= GET_LWP (lp
->ptid
);
1670 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1671 struct lwp_info
*new_lp
= NULL
;
1672 int event
= status
>> 16;
1674 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1675 || event
== PTRACE_EVENT_CLONE
)
1677 unsigned long new_pid
;
1680 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1682 /* If we haven't already seen the new PID stop, wait for it now. */
1683 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1685 /* The new child has a pending SIGSTOP. We can't affect it until it
1686 hits the SIGSTOP, but we're already attached. */
1687 ret
= my_waitpid (new_pid
, &status
,
1688 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
1690 perror_with_name (_("waiting for new child"));
1691 else if (ret
!= new_pid
)
1692 internal_error (__FILE__
, __LINE__
,
1693 _("wait returned unexpected PID %d"), ret
);
1694 else if (!WIFSTOPPED (status
))
1695 internal_error (__FILE__
, __LINE__
,
1696 _("wait returned unexpected status 0x%x"), status
);
1699 ourstatus
->value
.related_pid
= new_pid
;
1701 if (event
== PTRACE_EVENT_FORK
)
1702 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1703 else if (event
== PTRACE_EVENT_VFORK
)
1704 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1707 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1708 new_lp
= add_lwp (BUILD_LWP (new_pid
, GET_PID (inferior_ptid
)));
1711 if (WSTOPSIG (status
) != SIGSTOP
)
1713 /* This can happen if someone starts sending signals to
1714 the new thread before it gets a chance to run, which
1715 have a lower number than SIGSTOP (e.g. SIGUSR1).
1716 This is an unlikely case, and harder to handle for
1717 fork / vfork than for clone, so we do not try - but
1718 we handle it for clone events here. We'll send
1719 the other signal on to the thread below. */
1721 new_lp
->signalled
= 1;
1727 new_lp
->stopped
= 1;
1730 new_lp
->resumed
= 1;
1731 ptrace (PTRACE_CONT
, lp
->waitstatus
.value
.related_pid
, 0,
1732 status
? WSTOPSIG (status
) : 0);
1735 if (debug_linux_nat
)
1736 fprintf_unfiltered (gdb_stdlog
,
1737 "LHEW: Got clone event from LWP %ld, resuming\n",
1738 GET_LWP (lp
->ptid
));
1739 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1747 if (event
== PTRACE_EVENT_EXEC
)
1749 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1750 ourstatus
->value
.execd_pathname
1751 = xstrdup (linux_child_pid_to_exec_file (pid
));
1753 if (linux_parent_pid
)
1755 detach_breakpoints (linux_parent_pid
);
1756 ptrace (PTRACE_DETACH
, linux_parent_pid
, 0, 0);
1758 linux_parent_pid
= 0;
1764 internal_error (__FILE__
, __LINE__
,
1765 _("unknown ptrace event %d"), event
);
1768 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1772 wait_lwp (struct lwp_info
*lp
)
1776 int thread_dead
= 0;
1778 gdb_assert (!lp
->stopped
);
1779 gdb_assert (lp
->status
== 0);
1781 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, 0);
1782 if (pid
== -1 && errno
== ECHILD
)
1784 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
1785 if (pid
== -1 && errno
== ECHILD
)
1787 /* The thread has previously exited. We need to delete it
1788 now because, for some vendor 2.4 kernels with NPTL
1789 support backported, there won't be an exit event unless
1790 it is the main thread. 2.6 kernels will report an exit
1791 event for each thread that exits, as expected. */
1793 if (debug_linux_nat
)
1794 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
1795 target_pid_to_str (lp
->ptid
));
1801 gdb_assert (pid
== GET_LWP (lp
->ptid
));
1803 if (debug_linux_nat
)
1805 fprintf_unfiltered (gdb_stdlog
,
1806 "WL: waitpid %s received %s\n",
1807 target_pid_to_str (lp
->ptid
),
1808 status_to_str (status
));
1812 /* Check if the thread has exited. */
1813 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1816 if (debug_linux_nat
)
1817 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
1818 target_pid_to_str (lp
->ptid
));
1827 gdb_assert (WIFSTOPPED (status
));
1829 /* Handle GNU/Linux's extended waitstatus for trace events. */
1830 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1832 if (debug_linux_nat
)
1833 fprintf_unfiltered (gdb_stdlog
,
1834 "WL: Handling extended status 0x%06x\n",
1836 if (linux_handle_extended_wait (lp
, status
, 1))
1837 return wait_lwp (lp
);
1843 /* Save the most recent siginfo for LP. This is currently only called
1844 for SIGTRAP; some ports use the si_addr field for
1845 target_stopped_data_address. In the future, it may also be used to
1846 restore the siginfo of requeued signals. */
1849 save_siginfo (struct lwp_info
*lp
)
1852 ptrace (PTRACE_GETSIGINFO
, GET_LWP (lp
->ptid
),
1853 (PTRACE_TYPE_ARG3
) 0, &lp
->siginfo
);
1856 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1859 /* Send a SIGSTOP to LP. */
1862 stop_callback (struct lwp_info
*lp
, void *data
)
1864 if (!lp
->stopped
&& !lp
->signalled
)
1868 if (debug_linux_nat
)
1870 fprintf_unfiltered (gdb_stdlog
,
1871 "SC: kill %s **<SIGSTOP>**\n",
1872 target_pid_to_str (lp
->ptid
));
1875 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
1876 if (debug_linux_nat
)
1878 fprintf_unfiltered (gdb_stdlog
,
1879 "SC: lwp kill %d %s\n",
1881 errno
? safe_strerror (errno
) : "ERRNO-OK");
1885 gdb_assert (lp
->status
== 0);
1891 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
1892 a pointer to a set of signals to be flushed immediately. */
1895 stop_wait_callback (struct lwp_info
*lp
, void *data
)
1897 sigset_t
*flush_mask
= data
;
1903 status
= wait_lwp (lp
);
1907 /* Ignore any signals in FLUSH_MASK. */
1908 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
1917 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1918 if (debug_linux_nat
)
1919 fprintf_unfiltered (gdb_stdlog
,
1920 "PTRACE_CONT %s, 0, 0 (%s)\n",
1921 target_pid_to_str (lp
->ptid
),
1922 errno
? safe_strerror (errno
) : "OK");
1924 return stop_wait_callback (lp
, flush_mask
);
1927 if (WSTOPSIG (status
) != SIGSTOP
)
1929 if (WSTOPSIG (status
) == SIGTRAP
)
1931 /* If a LWP other than the LWP that we're reporting an
1932 event for has hit a GDB breakpoint (as opposed to
1933 some random trap signal), then just arrange for it to
1934 hit it again later. We don't keep the SIGTRAP status
1935 and don't forward the SIGTRAP signal to the LWP. We
1936 will handle the current event, eventually we will
1937 resume all LWPs, and this one will get its breakpoint
1940 If we do not do this, then we run the risk that the
1941 user will delete or disable the breakpoint, but the
1942 thread will have already tripped on it. */
1944 /* Save the trap's siginfo in case we need it later. */
1947 /* Now resume this LWP and get the SIGSTOP event. */
1949 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1950 if (debug_linux_nat
)
1952 fprintf_unfiltered (gdb_stdlog
,
1953 "PTRACE_CONT %s, 0, 0 (%s)\n",
1954 target_pid_to_str (lp
->ptid
),
1955 errno
? safe_strerror (errno
) : "OK");
1957 fprintf_unfiltered (gdb_stdlog
,
1958 "SWC: Candidate SIGTRAP event in %s\n",
1959 target_pid_to_str (lp
->ptid
));
1961 /* Hold this event/waitstatus while we check to see if
1962 there are any more (we still want to get that SIGSTOP). */
1963 stop_wait_callback (lp
, data
);
1965 if (target_can_async_p ())
1967 /* Don't leave a pending wait status in async mode.
1968 Retrigger the breakpoint. */
1969 if (!cancel_breakpoint (lp
))
1971 /* There was no gdb breakpoint set at pc. Put
1972 the event back in the queue. */
1973 if (debug_linux_nat
)
1974 fprintf_unfiltered (gdb_stdlog
,
1975 "SWC: kill %s, %s\n",
1976 target_pid_to_str (lp
->ptid
),
1977 status_to_str ((int) status
));
1978 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
1983 /* Hold the SIGTRAP for handling by
1985 /* If there's another event, throw it back into the
1989 if (debug_linux_nat
)
1990 fprintf_unfiltered (gdb_stdlog
,
1991 "SWC: kill %s, %s\n",
1992 target_pid_to_str (lp
->ptid
),
1993 status_to_str ((int) status
));
1994 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
1996 /* Save the sigtrap event. */
1997 lp
->status
= status
;
2003 /* The thread was stopped with a signal other than
2004 SIGSTOP, and didn't accidentally trip a breakpoint. */
2006 if (debug_linux_nat
)
2008 fprintf_unfiltered (gdb_stdlog
,
2009 "SWC: Pending event %s in %s\n",
2010 status_to_str ((int) status
),
2011 target_pid_to_str (lp
->ptid
));
2013 /* Now resume this LWP and get the SIGSTOP event. */
2015 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2016 if (debug_linux_nat
)
2017 fprintf_unfiltered (gdb_stdlog
,
2018 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
2019 target_pid_to_str (lp
->ptid
),
2020 errno
? safe_strerror (errno
) : "OK");
2022 /* Hold this event/waitstatus while we check to see if
2023 there are any more (we still want to get that SIGSTOP). */
2024 stop_wait_callback (lp
, data
);
2026 /* If the lp->status field is still empty, use it to
2027 hold this event. If not, then this event must be
2028 returned to the event queue of the LWP. */
2029 if (lp
->status
|| target_can_async_p ())
2031 if (debug_linux_nat
)
2033 fprintf_unfiltered (gdb_stdlog
,
2034 "SWC: kill %s, %s\n",
2035 target_pid_to_str (lp
->ptid
),
2036 status_to_str ((int) status
));
2038 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
2041 lp
->status
= status
;
2047 /* We caught the SIGSTOP that we intended to catch, so
2048 there's no SIGSTOP pending. */
2057 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
2058 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
2061 linux_nat_has_pending (int pid
, sigset_t
*pending
, sigset_t
*flush_mask
)
2063 sigset_t blocked
, ignored
;
2066 linux_proc_pending_signals (pid
, pending
, &blocked
, &ignored
);
2071 for (i
= 1; i
< NSIG
; i
++)
2072 if (sigismember (pending
, i
))
2073 if (!sigismember (flush_mask
, i
)
2074 || sigismember (&blocked
, i
)
2075 || sigismember (&ignored
, i
))
2076 sigdelset (pending
, i
);
2078 if (sigisemptyset (pending
))
2084 /* DATA is interpreted as a mask of signals to flush. If LP has
2085 signals pending, and they are all in the flush mask, then arrange
2086 to flush them. LP should be stopped, as should all other threads
2087 it might share a signal queue with. */
2090 flush_callback (struct lwp_info
*lp
, void *data
)
2092 sigset_t
*flush_mask
= data
;
2093 sigset_t pending
, intersection
, blocked
, ignored
;
2096 /* Normally, when an LWP exits, it is removed from the LWP list. The
2097 last LWP isn't removed till later, however. So if there is only
2098 one LWP on the list, make sure it's alive. */
2099 if (lwp_list
== lp
&& lp
->next
== NULL
)
2100 if (!linux_nat_thread_alive (lp
->ptid
))
2103 /* Just because the LWP is stopped doesn't mean that new signals
2104 can't arrive from outside, so this function must be careful of
2105 race conditions. However, because all threads are stopped, we
2106 can assume that the pending mask will not shrink unless we resume
2107 the LWP, and that it will then get another signal. We can't
2108 control which one, however. */
2112 if (debug_linux_nat
)
2113 printf_unfiltered (_("FC: LP has pending status %06x\n"), lp
->status
);
2114 if (WIFSTOPPED (lp
->status
) && sigismember (flush_mask
, WSTOPSIG (lp
->status
)))
2118 /* While there is a pending signal we would like to flush, continue
2119 the inferior and collect another signal. But if there's already
2120 a saved status that we don't want to flush, we can't resume the
2121 inferior - if it stopped for some other reason we wouldn't have
2122 anywhere to save the new status. In that case, we must leave the
2123 signal unflushed (and possibly generate an extra SIGINT stop).
2124 That's much less bad than losing a signal. */
2125 while (lp
->status
== 0
2126 && linux_nat_has_pending (GET_LWP (lp
->ptid
), &pending
, flush_mask
))
2131 ret
= ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2132 if (debug_linux_nat
)
2133 fprintf_unfiltered (gdb_stderr
,
2134 "FC: Sent PTRACE_CONT, ret %d %d\n", ret
, errno
);
2137 stop_wait_callback (lp
, flush_mask
);
2138 if (debug_linux_nat
)
2139 fprintf_unfiltered (gdb_stderr
,
2140 "FC: Wait finished; saved status is %d\n",
2147 /* Return non-zero if LP has a wait status pending. */
2150 status_callback (struct lwp_info
*lp
, void *data
)
2152 /* Only report a pending wait status if we pretend that this has
2153 indeed been resumed. */
2154 return (lp
->status
!= 0 && lp
->resumed
);
2157 /* Return non-zero if LP isn't stopped. */
2160 running_callback (struct lwp_info
*lp
, void *data
)
2162 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
2165 /* Count the LWP's that have had events. */
2168 count_events_callback (struct lwp_info
*lp
, void *data
)
2172 gdb_assert (count
!= NULL
);
2174 /* Count only LWPs that have a SIGTRAP event pending. */
2176 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
2182 /* Select the LWP (if any) that is currently being single-stepped. */
2185 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
2187 if (lp
->step
&& lp
->status
!= 0)
2193 /* Select the Nth LWP that has had a SIGTRAP event. */
2196 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
2198 int *selector
= data
;
2200 gdb_assert (selector
!= NULL
);
2202 /* Select only LWPs that have a SIGTRAP event pending. */
2204 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
2205 if ((*selector
)-- == 0)
2212 cancel_breakpoint (struct lwp_info
*lp
)
2214 /* Arrange for a breakpoint to be hit again later. We don't keep
2215 the SIGTRAP status and don't forward the SIGTRAP signal to the
2216 LWP. We will handle the current event, eventually we will resume
2217 this LWP, and this breakpoint will trap again.
2219 If we do not do this, then we run the risk that the user will
2220 delete or disable the breakpoint, but the LWP will have already
2223 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
2224 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2227 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
2228 if (breakpoint_inserted_here_p (pc
))
2230 if (debug_linux_nat
)
2231 fprintf_unfiltered (gdb_stdlog
,
2232 "CB: Push back breakpoint for %s\n",
2233 target_pid_to_str (lp
->ptid
));
2235 /* Back up the PC if necessary. */
2236 if (gdbarch_decr_pc_after_break (gdbarch
))
2237 regcache_write_pc (regcache
, pc
);
2245 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
2247 struct lwp_info
*event_lp
= data
;
2249 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2253 /* If a LWP other than the LWP that we're reporting an event for has
2254 hit a GDB breakpoint (as opposed to some random trap signal),
2255 then just arrange for it to hit it again later. We don't keep
2256 the SIGTRAP status and don't forward the SIGTRAP signal to the
2257 LWP. We will handle the current event, eventually we will resume
2258 all LWPs, and this one will get its breakpoint trap again.
2260 If we do not do this, then we run the risk that the user will
2261 delete or disable the breakpoint, but the LWP will have already
2265 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
2266 && cancel_breakpoint (lp
))
2267 /* Throw away the SIGTRAP. */
2273 /* Select one LWP out of those that have events pending. */
2276 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
2279 int random_selector
;
2280 struct lwp_info
*event_lp
;
2282 /* Record the wait status for the original LWP. */
2283 (*orig_lp
)->status
= *status
;
2285 /* Give preference to any LWP that is being single-stepped. */
2286 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
2287 if (event_lp
!= NULL
)
2289 if (debug_linux_nat
)
2290 fprintf_unfiltered (gdb_stdlog
,
2291 "SEL: Select single-step %s\n",
2292 target_pid_to_str (event_lp
->ptid
));
2296 /* No single-stepping LWP. Select one at random, out of those
2297 which have had SIGTRAP events. */
2299 /* First see how many SIGTRAP events we have. */
2300 iterate_over_lwps (count_events_callback
, &num_events
);
2302 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2303 random_selector
= (int)
2304 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2306 if (debug_linux_nat
&& num_events
> 1)
2307 fprintf_unfiltered (gdb_stdlog
,
2308 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2309 num_events
, random_selector
);
2311 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
2315 if (event_lp
!= NULL
)
2317 /* Switch the event LWP. */
2318 *orig_lp
= event_lp
;
2319 *status
= event_lp
->status
;
2322 /* Flush the wait status for the event LWP. */
2323 (*orig_lp
)->status
= 0;
2326 /* Return non-zero if LP has been resumed. */
2329 resumed_callback (struct lwp_info
*lp
, void *data
)
2334 /* Stop an active thread, verify it still exists, then resume it. */
2337 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
2339 struct lwp_info
*ptr
;
2341 if (!lp
->stopped
&& !lp
->signalled
)
2343 stop_callback (lp
, NULL
);
2344 stop_wait_callback (lp
, NULL
);
2345 /* Resume if the lwp still exists. */
2346 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
2349 resume_callback (lp
, NULL
);
2350 resume_set_callback (lp
, NULL
);
2356 /* Check if we should go on and pass this event to common code.
2357 Return the affected lwp if we are, or NULL otherwise. */
2358 static struct lwp_info
*
2359 linux_nat_filter_event (int lwpid
, int status
, int options
)
2361 struct lwp_info
*lp
;
2363 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
2365 /* Check for stop events reported by a process we didn't already
2366 know about - anything not already in our LWP list.
2368 If we're expecting to receive stopped processes after
2369 fork, vfork, and clone events, then we'll just add the
2370 new one to our list and go back to waiting for the event
2371 to be reported - the stopped process might be returned
2372 from waitpid before or after the event is. */
2373 if (WIFSTOPPED (status
) && !lp
)
2375 linux_record_stopped_pid (lwpid
, status
);
2379 /* Make sure we don't report an event for the exit of an LWP not in
2380 our list, i.e. not part of the current process. This can happen
2381 if we detach from a program we original forked and then it
2383 if (!WIFSTOPPED (status
) && !lp
)
2386 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
2387 CLONE_PTRACE processes which do not use the thread library -
2388 otherwise we wouldn't find the new LWP this way. That doesn't
2389 currently work, and the following code is currently unreachable
2390 due to the two blocks above. If it's fixed some day, this code
2391 should be broken out into a function so that we can also pick up
2392 LWPs from the new interface. */
2395 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
2396 if (options
& __WCLONE
)
2399 gdb_assert (WIFSTOPPED (status
)
2400 && WSTOPSIG (status
) == SIGSTOP
);
2403 if (!in_thread_list (inferior_ptid
))
2405 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2406 GET_PID (inferior_ptid
));
2407 add_thread (inferior_ptid
);
2410 add_thread (lp
->ptid
);
2413 /* Save the trap's siginfo in case we need it later. */
2414 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2417 /* Handle GNU/Linux's extended waitstatus for trace events. */
2418 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
2420 if (debug_linux_nat
)
2421 fprintf_unfiltered (gdb_stdlog
,
2422 "LLW: Handling extended status 0x%06x\n",
2424 if (linux_handle_extended_wait (lp
, status
, 0))
2428 /* Check if the thread has exited. */
2429 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
2431 /* If this is the main thread, we must stop all threads and
2432 verify if they are still alive. This is because in the nptl
2433 thread model, there is no signal issued for exiting LWPs
2434 other than the main thread. We only get the main thread exit
2435 signal once all child threads have already exited. If we
2436 stop all the threads and use the stop_wait_callback to check
2437 if they have exited we can determine whether this signal
2438 should be ignored or whether it means the end of the debugged
2439 application, regardless of which threading model is being
2441 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
2444 iterate_over_lwps (stop_and_resume_callback
, NULL
);
2447 if (debug_linux_nat
)
2448 fprintf_unfiltered (gdb_stdlog
,
2449 "LLW: %s exited.\n",
2450 target_pid_to_str (lp
->ptid
));
2454 /* If there is at least one more LWP, then the exit signal was
2455 not the end of the debugged application and should be
2459 /* Make sure there is at least one thread running. */
2460 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
2462 /* Discard the event. */
2467 /* Check if the current LWP has previously exited. In the nptl
2468 thread model, LWPs other than the main thread do not issue
2469 signals when they exit so we must check whenever the thread has
2470 stopped. A similar check is made in stop_wait_callback(). */
2471 if (num_lwps
> 1 && !linux_nat_thread_alive (lp
->ptid
))
2473 if (debug_linux_nat
)
2474 fprintf_unfiltered (gdb_stdlog
,
2475 "LLW: %s exited.\n",
2476 target_pid_to_str (lp
->ptid
));
2480 /* Make sure there is at least one thread running. */
2481 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
2483 /* Discard the event. */
2487 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2488 an attempt to stop an LWP. */
2490 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
2492 if (debug_linux_nat
)
2493 fprintf_unfiltered (gdb_stdlog
,
2494 "LLW: Delayed SIGSTOP caught for %s.\n",
2495 target_pid_to_str (lp
->ptid
));
2497 /* This is a delayed SIGSTOP. */
2500 registers_changed ();
2502 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2503 lp
->step
, TARGET_SIGNAL_0
);
2504 if (debug_linux_nat
)
2505 fprintf_unfiltered (gdb_stdlog
,
2506 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2508 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2509 target_pid_to_str (lp
->ptid
));
2512 gdb_assert (lp
->resumed
);
2514 /* Discard the event. */
2518 /* An interesting event. */
2523 /* Get the events stored in the pipe into the local queue, so they are
2524 accessible to queued_waitpid. We need to do this, since it is not
2525 always the case that the event at the head of the pipe is the event
2529 pipe_to_local_event_queue (void)
2531 if (debug_linux_nat_async
)
2532 fprintf_unfiltered (gdb_stdlog
,
2533 "PTLEQ: linux_nat_num_queued_events(%d)\n",
2534 linux_nat_num_queued_events
);
2535 while (linux_nat_num_queued_events
)
2537 int lwpid
, status
, options
;
2538 lwpid
= linux_nat_event_pipe_pop (&status
, &options
);
2539 gdb_assert (lwpid
> 0);
2540 push_waitpid (lwpid
, status
, options
);
2544 /* Get the unprocessed events stored in the local queue back into the
2545 pipe, so the event loop realizes there's something else to
2549 local_event_queue_to_pipe (void)
2551 struct waitpid_result
*w
= waitpid_queue
;
2554 struct waitpid_result
*next
= w
->next
;
2555 linux_nat_event_pipe_push (w
->pid
,
2561 waitpid_queue
= NULL
;
2563 if (debug_linux_nat_async
)
2564 fprintf_unfiltered (gdb_stdlog
,
2565 "LEQTP: linux_nat_num_queued_events(%d)\n",
2566 linux_nat_num_queued_events
);
2570 linux_nat_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
2572 struct lwp_info
*lp
= NULL
;
2575 pid_t pid
= PIDGET (ptid
);
2576 sigset_t flush_mask
;
2578 if (debug_linux_nat_async
)
2579 fprintf_unfiltered (gdb_stdlog
, "LLW: enter\n");
2581 /* The first time we get here after starting a new inferior, we may
2582 not have added it to the LWP list yet - this is the earliest
2583 moment at which we know its PID. */
2586 gdb_assert (!is_lwp (inferior_ptid
));
2588 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2589 GET_PID (inferior_ptid
));
2590 lp
= add_lwp (inferior_ptid
);
2592 /* Add the main thread to GDB's thread list. */
2593 add_thread_silent (lp
->ptid
);
2596 sigemptyset (&flush_mask
);
2598 /* Block events while we're here. */
2599 linux_nat_async_events (sigchld_sync
);
2603 /* Make sure there is at least one LWP that has been resumed. */
2604 gdb_assert (iterate_over_lwps (resumed_callback
, NULL
));
2606 /* First check if there is a LWP with a wait status pending. */
2609 /* Any LWP that's been resumed will do. */
2610 lp
= iterate_over_lwps (status_callback
, NULL
);
2613 if (target_can_async_p ())
2614 internal_error (__FILE__
, __LINE__
,
2615 "Found an LWP with a pending status in async mode.");
2617 status
= lp
->status
;
2620 if (debug_linux_nat
&& status
)
2621 fprintf_unfiltered (gdb_stdlog
,
2622 "LLW: Using pending wait status %s for %s.\n",
2623 status_to_str (status
),
2624 target_pid_to_str (lp
->ptid
));
2627 /* But if we don't find one, we'll have to wait, and check both
2628 cloned and uncloned processes. We start with the cloned
2630 options
= __WCLONE
| WNOHANG
;
2632 else if (is_lwp (ptid
))
2634 if (debug_linux_nat
)
2635 fprintf_unfiltered (gdb_stdlog
,
2636 "LLW: Waiting for specific LWP %s.\n",
2637 target_pid_to_str (ptid
));
2639 /* We have a specific LWP to check. */
2640 lp
= find_lwp_pid (ptid
);
2642 status
= lp
->status
;
2645 if (debug_linux_nat
&& status
)
2646 fprintf_unfiltered (gdb_stdlog
,
2647 "LLW: Using pending wait status %s for %s.\n",
2648 status_to_str (status
),
2649 target_pid_to_str (lp
->ptid
));
2651 /* If we have to wait, take into account whether PID is a cloned
2652 process or not. And we have to convert it to something that
2653 the layer beneath us can understand. */
2654 options
= lp
->cloned
? __WCLONE
: 0;
2655 pid
= GET_LWP (ptid
);
2658 if (status
&& lp
->signalled
)
2660 /* A pending SIGSTOP may interfere with the normal stream of
2661 events. In a typical case where interference is a problem,
2662 we have a SIGSTOP signal pending for LWP A while
2663 single-stepping it, encounter an event in LWP B, and take the
2664 pending SIGSTOP while trying to stop LWP A. After processing
2665 the event in LWP B, LWP A is continued, and we'll never see
2666 the SIGTRAP associated with the last time we were
2667 single-stepping LWP A. */
2669 /* Resume the thread. It should halt immediately returning the
2671 registers_changed ();
2672 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2673 lp
->step
, TARGET_SIGNAL_0
);
2674 if (debug_linux_nat
)
2675 fprintf_unfiltered (gdb_stdlog
,
2676 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
2677 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2678 target_pid_to_str (lp
->ptid
));
2680 gdb_assert (lp
->resumed
);
2682 /* This should catch the pending SIGSTOP. */
2683 stop_wait_callback (lp
, NULL
);
2686 if (!target_can_async_p ())
2688 /* Causes SIGINT to be passed on to the attached process. */
2697 if (target_can_async_p ())
2698 /* In async mode, don't ever block. Only look at the locally
2700 lwpid
= queued_waitpid (pid
, &status
, options
);
2702 lwpid
= my_waitpid (pid
, &status
, options
);
2706 gdb_assert (pid
== -1 || lwpid
== pid
);
2708 if (debug_linux_nat
)
2710 fprintf_unfiltered (gdb_stdlog
,
2711 "LLW: waitpid %ld received %s\n",
2712 (long) lwpid
, status_to_str (status
));
2715 lp
= linux_nat_filter_event (lwpid
, status
, options
);
2718 /* A discarded event. */
2728 /* Alternate between checking cloned and uncloned processes. */
2729 options
^= __WCLONE
;
2731 /* And every time we have checked both:
2732 In async mode, return to event loop;
2733 In sync mode, suspend waiting for a SIGCHLD signal. */
2734 if (options
& __WCLONE
)
2736 if (target_can_async_p ())
2738 /* No interesting event. */
2739 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2741 /* Get ready for the next event. */
2742 target_async (inferior_event_handler
, 0);
2744 if (debug_linux_nat_async
)
2745 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
2747 return minus_one_ptid
;
2750 sigsuspend (&suspend_mask
);
2754 /* We shouldn't end up here unless we want to try again. */
2755 gdb_assert (status
== 0);
2758 if (!target_can_async_p ())
2760 clear_sigio_trap ();
2761 clear_sigint_trap ();
2766 /* Don't report signals that GDB isn't interested in, such as
2767 signals that are neither printed nor stopped upon. Stopping all
2768 threads can be a bit time-consuming so if we want decent
2769 performance with heavily multi-threaded programs, especially when
2770 they're using a high frequency timer, we'd better avoid it if we
2773 if (WIFSTOPPED (status
))
2775 int signo
= target_signal_from_host (WSTOPSIG (status
));
2777 /* If we get a signal while single-stepping, we may need special
2778 care, e.g. to skip the signal handler. Defer to common code. */
2780 && signal_stop_state (signo
) == 0
2781 && signal_print_state (signo
) == 0
2782 && signal_pass_state (signo
) == 1)
2784 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2785 here? It is not clear we should. GDB may not expect
2786 other threads to run. On the other hand, not resuming
2787 newly attached threads may cause an unwanted delay in
2788 getting them running. */
2789 registers_changed ();
2790 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2792 if (debug_linux_nat
)
2793 fprintf_unfiltered (gdb_stdlog
,
2794 "LLW: %s %s, %s (preempt 'handle')\n",
2796 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2797 target_pid_to_str (lp
->ptid
),
2798 signo
? strsignal (signo
) : "0");
2804 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
2806 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2807 forwarded to the entire process group, that is, all LWP's
2808 will receive it. Since we only want to report it once,
2809 we try to flush it from all LWPs except this one. */
2810 sigaddset (&flush_mask
, SIGINT
);
2814 /* This LWP is stopped now. */
2817 if (debug_linux_nat
)
2818 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
2819 status_to_str (status
), target_pid_to_str (lp
->ptid
));
2821 /* Now stop all other LWP's ... */
2822 iterate_over_lwps (stop_callback
, NULL
);
2824 /* ... and wait until all of them have reported back that they're no
2826 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
2827 iterate_over_lwps (flush_callback
, &flush_mask
);
2829 /* If we're not waiting for a specific LWP, choose an event LWP from
2830 among those that have had events. Giving equal priority to all
2831 LWPs that have had events helps prevent starvation. */
2833 select_event_lwp (&lp
, &status
);
2835 /* Now that we've selected our final event LWP, cancel any
2836 breakpoints in other LWPs that have hit a GDB breakpoint. See
2837 the comment in cancel_breakpoints_callback to find out why. */
2838 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
2840 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2842 if (debug_linux_nat
)
2843 fprintf_unfiltered (gdb_stdlog
,
2844 "LLW: trap ptid is %s.\n",
2845 target_pid_to_str (lp
->ptid
));
2848 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
2850 *ourstatus
= lp
->waitstatus
;
2851 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
2854 store_waitstatus (ourstatus
, status
);
2856 /* Get ready for the next event. */
2857 if (target_can_async_p ())
2858 target_async (inferior_event_handler
, 0);
2860 if (debug_linux_nat_async
)
2861 fprintf_unfiltered (gdb_stdlog
, "LLW: exit\n");
2867 kill_callback (struct lwp_info
*lp
, void *data
)
2870 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
2871 if (debug_linux_nat
)
2872 fprintf_unfiltered (gdb_stdlog
,
2873 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
2874 target_pid_to_str (lp
->ptid
),
2875 errno
? safe_strerror (errno
) : "OK");
2881 kill_wait_callback (struct lwp_info
*lp
, void *data
)
2885 /* We must make sure that there are no pending events (delayed
2886 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
2887 program doesn't interfere with any following debugging session. */
2889 /* For cloned processes we must check both with __WCLONE and
2890 without, since the exit status of a cloned process isn't reported
2896 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
2897 if (pid
!= (pid_t
) -1)
2899 if (debug_linux_nat
)
2900 fprintf_unfiltered (gdb_stdlog
,
2901 "KWC: wait %s received unknown.\n",
2902 target_pid_to_str (lp
->ptid
));
2903 /* The Linux kernel sometimes fails to kill a thread
2904 completely after PTRACE_KILL; that goes from the stop
2905 point in do_fork out to the one in
2906 get_signal_to_deliever and waits again. So kill it
2908 kill_callback (lp
, NULL
);
2911 while (pid
== GET_LWP (lp
->ptid
));
2913 gdb_assert (pid
== -1 && errno
== ECHILD
);
2918 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
2919 if (pid
!= (pid_t
) -1)
2921 if (debug_linux_nat
)
2922 fprintf_unfiltered (gdb_stdlog
,
2923 "KWC: wait %s received unk.\n",
2924 target_pid_to_str (lp
->ptid
));
2925 /* See the call to kill_callback above. */
2926 kill_callback (lp
, NULL
);
2929 while (pid
== GET_LWP (lp
->ptid
));
2931 gdb_assert (pid
== -1 && errno
== ECHILD
);
2936 linux_nat_kill (void)
2938 struct target_waitstatus last
;
2942 if (target_can_async_p ())
2943 target_async (NULL
, 0);
2945 /* If we're stopped while forking and we haven't followed yet,
2946 kill the other task. We need to do this first because the
2947 parent will be sleeping if this is a vfork. */
2949 get_last_target_status (&last_ptid
, &last
);
2951 if (last
.kind
== TARGET_WAITKIND_FORKED
2952 || last
.kind
== TARGET_WAITKIND_VFORKED
)
2954 ptrace (PT_KILL
, last
.value
.related_pid
, 0, 0);
2958 if (forks_exist_p ())
2960 linux_fork_killall ();
2961 drain_queued_events (-1);
2965 /* Kill all LWP's ... */
2966 iterate_over_lwps (kill_callback
, NULL
);
2968 /* ... and wait until we've flushed all events. */
2969 iterate_over_lwps (kill_wait_callback
, NULL
);
2972 target_mourn_inferior ();
2976 linux_nat_mourn_inferior (void)
2978 /* Destroy LWP info; it's no longer valid. */
2981 if (! forks_exist_p ())
2983 /* Normal case, no other forks available. */
2984 if (target_can_async_p ())
2985 linux_nat_async (NULL
, 0);
2986 linux_ops
->to_mourn_inferior ();
2989 /* Multi-fork case. The current inferior_ptid has exited, but
2990 there are other viable forks to debug. Delete the exiting
2991 one and context-switch to the first available. */
2992 linux_fork_mourn_inferior ();
2996 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2997 const char *annex
, gdb_byte
*readbuf
,
2998 const gdb_byte
*writebuf
,
2999 ULONGEST offset
, LONGEST len
)
3001 struct cleanup
*old_chain
= save_inferior_ptid ();
3004 if (is_lwp (inferior_ptid
))
3005 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
3007 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3010 do_cleanups (old_chain
);
3015 linux_nat_thread_alive (ptid_t ptid
)
3017 gdb_assert (is_lwp (ptid
));
3020 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
3021 if (debug_linux_nat
)
3022 fprintf_unfiltered (gdb_stdlog
,
3023 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
3024 target_pid_to_str (ptid
),
3025 errno
? safe_strerror (errno
) : "OK");
3027 /* Not every Linux kernel implements PTRACE_PEEKUSER. But we can
3028 handle that case gracefully since ptrace will first do a lookup
3029 for the process based upon the passed-in pid. If that fails we
3030 will get either -ESRCH or -EPERM, otherwise the child exists and
3032 if (errno
== ESRCH
|| errno
== EPERM
)
3039 linux_nat_pid_to_str (ptid_t ptid
)
3041 static char buf
[64];
3044 && ((lwp_list
&& lwp_list
->next
)
3045 || GET_PID (ptid
) != GET_LWP (ptid
)))
3047 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
3051 return normal_pid_to_str (ptid
);
3055 sigchld_handler (int signo
)
3057 if (linux_nat_async_enabled
3058 && linux_nat_async_events_state
!= sigchld_sync
3059 && signo
== SIGCHLD
)
3060 /* It is *always* a bug to hit this. */
3061 internal_error (__FILE__
, __LINE__
,
3062 "sigchld_handler called when async events are enabled");
3064 /* Do nothing. The only reason for this handler is that it allows
3065 us to use sigsuspend in linux_nat_wait above to wait for the
3066 arrival of a SIGCHLD. */
3069 /* Accepts an integer PID; Returns a string representing a file that
3070 can be opened to get the symbols for the child process. */
3073 linux_child_pid_to_exec_file (int pid
)
3075 char *name1
, *name2
;
3077 name1
= xmalloc (MAXPATHLEN
);
3078 name2
= xmalloc (MAXPATHLEN
);
3079 make_cleanup (xfree
, name1
);
3080 make_cleanup (xfree
, name2
);
3081 memset (name2
, 0, MAXPATHLEN
);
3083 sprintf (name1
, "/proc/%d/exe", pid
);
3084 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
3090 /* Service function for corefiles and info proc. */
3093 read_mapping (FILE *mapfile
,
3098 char *device
, long long *inode
, char *filename
)
3100 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
3101 addr
, endaddr
, permissions
, offset
, device
, inode
);
3104 if (ret
> 0 && ret
!= EOF
)
3106 /* Eat everything up to EOL for the filename. This will prevent
3107 weird filenames (such as one with embedded whitespace) from
3108 confusing this code. It also makes this code more robust in
3109 respect to annotations the kernel may add after the filename.
3111 Note the filename is used for informational purposes
3113 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
3116 return (ret
!= 0 && ret
!= EOF
);
3119 /* Fills the "to_find_memory_regions" target vector. Lists the memory
3120 regions in the inferior for a corefile. */
3123 linux_nat_find_memory_regions (int (*func
) (CORE_ADDR
,
3125 int, int, int, void *), void *obfd
)
3127 long long pid
= PIDGET (inferior_ptid
);
3128 char mapsfilename
[MAXPATHLEN
];
3130 long long addr
, endaddr
, size
, offset
, inode
;
3131 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
3132 int read
, write
, exec
;
3135 /* Compose the filename for the /proc memory map, and open it. */
3136 sprintf (mapsfilename
, "/proc/%lld/maps", pid
);
3137 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
3138 error (_("Could not open %s."), mapsfilename
);
3141 fprintf_filtered (gdb_stdout
,
3142 "Reading memory regions from %s\n", mapsfilename
);
3144 /* Now iterate until end-of-file. */
3145 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
3146 &offset
, &device
[0], &inode
, &filename
[0]))
3148 size
= endaddr
- addr
;
3150 /* Get the segment's permissions. */
3151 read
= (strchr (permissions
, 'r') != 0);
3152 write
= (strchr (permissions
, 'w') != 0);
3153 exec
= (strchr (permissions
, 'x') != 0);
3157 fprintf_filtered (gdb_stdout
,
3158 "Save segment, %lld bytes at 0x%s (%c%c%c)",
3159 size
, paddr_nz (addr
),
3161 write
? 'w' : ' ', exec
? 'x' : ' ');
3163 fprintf_filtered (gdb_stdout
, " for %s", filename
);
3164 fprintf_filtered (gdb_stdout
, "\n");
3167 /* Invoke the callback function to create the corefile
3169 func (addr
, size
, read
, write
, exec
, obfd
);
3175 /* Records the thread's register state for the corefile note
3179 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
3180 char *note_data
, int *note_size
)
3182 gdb_gregset_t gregs
;
3183 gdb_fpregset_t fpregs
;
3184 unsigned long lwp
= ptid_get_lwp (ptid
);
3185 struct regcache
*regcache
= get_thread_regcache (ptid
);
3186 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3187 const struct regset
*regset
;
3189 struct cleanup
*old_chain
;
3190 struct core_regset_section
*sect_list
;
3193 old_chain
= save_inferior_ptid ();
3194 inferior_ptid
= ptid
;
3195 target_fetch_registers (regcache
, -1);
3196 do_cleanups (old_chain
);
3198 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
3199 sect_list
= gdbarch_core_regset_sections (gdbarch
);
3202 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
3203 sizeof (gregs
))) != NULL
3204 && regset
->collect_regset
!= NULL
)
3205 regset
->collect_regset (regset
, regcache
, -1,
3206 &gregs
, sizeof (gregs
));
3208 fill_gregset (regcache
, &gregs
, -1);
3210 note_data
= (char *) elfcore_write_prstatus (obfd
,
3214 stop_signal
, &gregs
);
3216 /* The loop below uses the new struct core_regset_section, which stores
3217 the supported section names and sizes for the core file. Note that
3218 note PRSTATUS needs to be treated specially. But the other notes are
3219 structurally the same, so they can benefit from the new struct. */
3220 if (core_regset_p
&& sect_list
!= NULL
)
3221 while (sect_list
->sect_name
!= NULL
)
3223 /* .reg was already handled above. */
3224 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
3229 regset
= gdbarch_regset_from_core_section (gdbarch
,
3230 sect_list
->sect_name
,
3232 gdb_assert (regset
&& regset
->collect_regset
);
3233 gdb_regset
= xmalloc (sect_list
->size
);
3234 regset
->collect_regset (regset
, regcache
, -1,
3235 gdb_regset
, sect_list
->size
);
3236 note_data
= (char *) elfcore_write_register_note (obfd
,
3239 sect_list
->sect_name
,
3246 /* For architectures that does not have the struct core_regset_section
3247 implemented, we use the old method. When all the architectures have
3248 the new support, the code below should be deleted. */
3252 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
3253 sizeof (fpregs
))) != NULL
3254 && regset
->collect_regset
!= NULL
)
3255 regset
->collect_regset (regset
, regcache
, -1,
3256 &fpregs
, sizeof (fpregs
));
3258 fill_fpregset (regcache
, &fpregs
, -1);
3260 note_data
= (char *) elfcore_write_prfpreg (obfd
,
3263 &fpregs
, sizeof (fpregs
));
3269 struct linux_nat_corefile_thread_data
3277 /* Called by gdbthread.c once per thread. Records the thread's
3278 register state for the corefile note section. */
3281 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
3283 struct linux_nat_corefile_thread_data
*args
= data
;
3285 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
3294 /* Records the register state for the corefile note section. */
3297 linux_nat_do_registers (bfd
*obfd
, ptid_t ptid
,
3298 char *note_data
, int *note_size
)
3300 return linux_nat_do_thread_registers (obfd
,
3301 ptid_build (ptid_get_pid (inferior_ptid
),
3302 ptid_get_pid (inferior_ptid
),
3304 note_data
, note_size
);
3307 /* Fills the "to_make_corefile_note" target vector. Builds the note
3308 section for a corefile, and returns it in a malloc buffer. */
3311 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
3313 struct linux_nat_corefile_thread_data thread_args
;
3314 struct cleanup
*old_chain
;
3315 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
3316 char fname
[16] = { '\0' };
3317 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
3318 char psargs
[80] = { '\0' };
3319 char *note_data
= NULL
;
3320 ptid_t current_ptid
= inferior_ptid
;
3324 if (get_exec_file (0))
3326 strncpy (fname
, strrchr (get_exec_file (0), '/') + 1, sizeof (fname
));
3327 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
3328 if (get_inferior_args ())
3331 char *psargs_end
= psargs
+ sizeof (psargs
);
3333 /* linux_elfcore_write_prpsinfo () handles zero unterminated
3335 string_end
= memchr (psargs
, 0, sizeof (psargs
));
3336 if (string_end
!= NULL
)
3338 *string_end
++ = ' ';
3339 strncpy (string_end
, get_inferior_args (),
3340 psargs_end
- string_end
);
3343 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
3345 note_size
, fname
, psargs
);
3348 /* Dump information for threads. */
3349 thread_args
.obfd
= obfd
;
3350 thread_args
.note_data
= note_data
;
3351 thread_args
.note_size
= note_size
;
3352 thread_args
.num_notes
= 0;
3353 iterate_over_lwps (linux_nat_corefile_thread_callback
, &thread_args
);
3354 if (thread_args
.num_notes
== 0)
3356 /* iterate_over_threads didn't come up with any threads; just
3357 use inferior_ptid. */
3358 note_data
= linux_nat_do_registers (obfd
, inferior_ptid
,
3359 note_data
, note_size
);
3363 note_data
= thread_args
.note_data
;
3366 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
3370 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
3371 "CORE", NT_AUXV
, auxv
, auxv_len
);
3375 make_cleanup (xfree
, note_data
);
3379 /* Implement the "info proc" command. */
3382 linux_nat_info_proc_cmd (char *args
, int from_tty
)
3384 long long pid
= PIDGET (inferior_ptid
);
3387 char buffer
[MAXPATHLEN
];
3388 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
3401 /* Break up 'args' into an argv array. */
3402 if ((argv
= buildargv (args
)) == NULL
)
3405 make_cleanup_freeargv (argv
);
3407 while (argv
!= NULL
&& *argv
!= NULL
)
3409 if (isdigit (argv
[0][0]))
3411 pid
= strtoul (argv
[0], NULL
, 10);
3413 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
3417 else if (strcmp (argv
[0], "status") == 0)
3421 else if (strcmp (argv
[0], "stat") == 0)
3425 else if (strcmp (argv
[0], "cmd") == 0)
3429 else if (strncmp (argv
[0], "exe", strlen (argv
[0])) == 0)
3433 else if (strcmp (argv
[0], "cwd") == 0)
3437 else if (strncmp (argv
[0], "all", strlen (argv
[0])) == 0)
3443 /* [...] (future options here) */
3448 error (_("No current process: you must name one."));
3450 sprintf (fname1
, "/proc/%lld", pid
);
3451 if (stat (fname1
, &dummy
) != 0)
3452 error (_("No /proc directory: '%s'"), fname1
);
3454 printf_filtered (_("process %lld\n"), pid
);
3455 if (cmdline_f
|| all
)
3457 sprintf (fname1
, "/proc/%lld/cmdline", pid
);
3458 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3460 fgets (buffer
, sizeof (buffer
), procfile
);
3461 printf_filtered ("cmdline = '%s'\n", buffer
);
3465 warning (_("unable to open /proc file '%s'"), fname1
);
3469 sprintf (fname1
, "/proc/%lld/cwd", pid
);
3470 memset (fname2
, 0, sizeof (fname2
));
3471 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
3472 printf_filtered ("cwd = '%s'\n", fname2
);
3474 warning (_("unable to read link '%s'"), fname1
);
3478 sprintf (fname1
, "/proc/%lld/exe", pid
);
3479 memset (fname2
, 0, sizeof (fname2
));
3480 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
3481 printf_filtered ("exe = '%s'\n", fname2
);
3483 warning (_("unable to read link '%s'"), fname1
);
3485 if (mappings_f
|| all
)
3487 sprintf (fname1
, "/proc/%lld/maps", pid
);
3488 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3490 long long addr
, endaddr
, size
, offset
, inode
;
3491 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
3493 printf_filtered (_("Mapped address spaces:\n\n"));
3494 if (gdbarch_addr_bit (current_gdbarch
) == 32)
3496 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3499 " Size", " Offset", "objfile");
3503 printf_filtered (" %18s %18s %10s %10s %7s\n",
3506 " Size", " Offset", "objfile");
3509 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
3510 &offset
, &device
[0], &inode
, &filename
[0]))
3512 size
= endaddr
- addr
;
3514 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
3515 calls here (and possibly above) should be abstracted
3516 out into their own functions? Andrew suggests using
3517 a generic local_address_string instead to print out
3518 the addresses; that makes sense to me, too. */
3520 if (gdbarch_addr_bit (current_gdbarch
) == 32)
3522 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3523 (unsigned long) addr
, /* FIXME: pr_addr */
3524 (unsigned long) endaddr
,
3526 (unsigned int) offset
,
3527 filename
[0] ? filename
: "");
3531 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3532 (unsigned long) addr
, /* FIXME: pr_addr */
3533 (unsigned long) endaddr
,
3535 (unsigned int) offset
,
3536 filename
[0] ? filename
: "");
3543 warning (_("unable to open /proc file '%s'"), fname1
);
3545 if (status_f
|| all
)
3547 sprintf (fname1
, "/proc/%lld/status", pid
);
3548 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3550 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
3551 puts_filtered (buffer
);
3555 warning (_("unable to open /proc file '%s'"), fname1
);
3559 sprintf (fname1
, "/proc/%lld/stat", pid
);
3560 if ((procfile
= fopen (fname1
, "r")) != NULL
)
3566 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3567 printf_filtered (_("Process: %d\n"), itmp
);
3568 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
3569 printf_filtered (_("Exec file: %s\n"), buffer
);
3570 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
3571 printf_filtered (_("State: %c\n"), ctmp
);
3572 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3573 printf_filtered (_("Parent process: %d\n"), itmp
);
3574 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3575 printf_filtered (_("Process group: %d\n"), itmp
);
3576 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3577 printf_filtered (_("Session id: %d\n"), itmp
);
3578 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3579 printf_filtered (_("TTY: %d\n"), itmp
);
3580 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3581 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
3582 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3583 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
3584 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3585 printf_filtered (_("Minor faults (no memory page): %lu\n"),
3586 (unsigned long) ltmp
);
3587 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3588 printf_filtered (_("Minor faults, children: %lu\n"),
3589 (unsigned long) ltmp
);
3590 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3591 printf_filtered (_("Major faults (memory page faults): %lu\n"),
3592 (unsigned long) ltmp
);
3593 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3594 printf_filtered (_("Major faults, children: %lu\n"),
3595 (unsigned long) ltmp
);
3596 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3597 printf_filtered (_("utime: %ld\n"), ltmp
);
3598 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3599 printf_filtered (_("stime: %ld\n"), ltmp
);
3600 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3601 printf_filtered (_("utime, children: %ld\n"), ltmp
);
3602 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3603 printf_filtered (_("stime, children: %ld\n"), ltmp
);
3604 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3605 printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
3607 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3608 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
3609 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3610 printf_filtered (_("jiffies until next timeout: %lu\n"),
3611 (unsigned long) ltmp
);
3612 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3613 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
3614 (unsigned long) ltmp
);
3615 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3616 printf_filtered (_("start time (jiffies since system boot): %ld\n"),
3618 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3619 printf_filtered (_("Virtual memory size: %lu\n"),
3620 (unsigned long) ltmp
);
3621 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3622 printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp
);
3623 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3624 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
3625 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3626 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
3627 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3628 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
3629 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3630 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
3631 #if 0 /* Don't know how architecture-dependent the rest is...
3632 Anyway the signal bitmap info is available from "status". */
3633 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3634 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
3635 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3636 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
3637 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3638 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
3639 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3640 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
3641 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3642 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
3643 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3644 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
3645 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3646 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
3651 warning (_("unable to open /proc file '%s'"), fname1
);
3655 /* Implement the to_xfer_partial interface for memory reads using the /proc
3656 filesystem. Because we can use a single read() call for /proc, this
3657 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3658 but it doesn't support writes. */
3661 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3662 const char *annex
, gdb_byte
*readbuf
,
3663 const gdb_byte
*writebuf
,
3664 ULONGEST offset
, LONGEST len
)
3670 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
3673 /* Don't bother for one word. */
3674 if (len
< 3 * sizeof (long))
3677 /* We could keep this file open and cache it - possibly one per
3678 thread. That requires some juggling, but is even faster. */
3679 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
3680 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
3684 /* If pread64 is available, use it. It's faster if the kernel
3685 supports it (only one syscall), and it's 64-bit safe even on
3686 32-bit platforms (for instance, SPARC debugging a SPARC64
3689 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
3691 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
3701 /* Parse LINE as a signal set and add its set bits to SIGS. */
3704 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
3706 int len
= strlen (line
) - 1;
3710 if (line
[len
] != '\n')
3711 error (_("Could not parse signal set: %s"), line
);
3719 if (*p
>= '0' && *p
<= '9')
3721 else if (*p
>= 'a' && *p
<= 'f')
3722 digit
= *p
- 'a' + 10;
3724 error (_("Could not parse signal set: %s"), line
);
3729 sigaddset (sigs
, signum
+ 1);
3731 sigaddset (sigs
, signum
+ 2);
3733 sigaddset (sigs
, signum
+ 3);
3735 sigaddset (sigs
, signum
+ 4);
3741 /* Find process PID's pending signals from /proc/pid/status and set
3745 linux_proc_pending_signals (int pid
, sigset_t
*pending
, sigset_t
*blocked
, sigset_t
*ignored
)
3748 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
3751 sigemptyset (pending
);
3752 sigemptyset (blocked
);
3753 sigemptyset (ignored
);
3754 sprintf (fname
, "/proc/%d/status", pid
);
3755 procfile
= fopen (fname
, "r");
3756 if (procfile
== NULL
)
3757 error (_("Could not open %s"), fname
);
3759 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
3761 /* Normal queued signals are on the SigPnd line in the status
3762 file. However, 2.6 kernels also have a "shared" pending
3763 queue for delivering signals to a thread group, so check for
3766 Unfortunately some Red Hat kernels include the shared pending
3767 queue but not the ShdPnd status field. */
3769 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
3770 add_line_to_sigset (buffer
+ 8, pending
);
3771 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
3772 add_line_to_sigset (buffer
+ 8, pending
);
3773 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
3774 add_line_to_sigset (buffer
+ 8, blocked
);
3775 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
3776 add_line_to_sigset (buffer
+ 8, ignored
);
3783 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3784 const char *annex
, gdb_byte
*readbuf
,
3785 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3789 if (object
== TARGET_OBJECT_AUXV
)
3790 return procfs_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
3793 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3798 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3802 /* Create a prototype generic GNU/Linux target. The client can override
3803 it with local methods. */
3806 linux_target_install_ops (struct target_ops
*t
)
3808 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
3809 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
3810 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
3811 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
3812 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
3813 t
->to_post_attach
= linux_child_post_attach
;
3814 t
->to_follow_fork
= linux_child_follow_fork
;
3815 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
3816 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
3818 super_xfer_partial
= t
->to_xfer_partial
;
3819 t
->to_xfer_partial
= linux_xfer_partial
;
3825 struct target_ops
*t
;
3827 t
= inf_ptrace_target ();
3828 linux_target_install_ops (t
);
3834 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
3836 struct target_ops
*t
;
3838 t
= inf_ptrace_trad_target (register_u_offset
);
3839 linux_target_install_ops (t
);
3844 /* Controls if async mode is permitted. */
3845 static int linux_async_permitted
= 0;
3847 /* The set command writes to this variable. If the inferior is
3848 executing, linux_nat_async_permitted is *not* updated. */
3849 static int linux_async_permitted_1
= 0;
3852 set_maintenance_linux_async_permitted (char *args
, int from_tty
,
3853 struct cmd_list_element
*c
)
3855 if (target_has_execution
)
3857 linux_async_permitted_1
= linux_async_permitted
;
3858 error (_("Cannot change this setting while the inferior is running."));
3861 linux_async_permitted
= linux_async_permitted_1
;
3862 linux_nat_set_async_mode (linux_async_permitted
);
3866 show_maintenance_linux_async_permitted (struct ui_file
*file
, int from_tty
,
3867 struct cmd_list_element
*c
, const char *value
)
3869 fprintf_filtered (file
, _("\
3870 Controlling the GNU/Linux inferior in asynchronous mode is %s.\n"),
3874 /* target_is_async_p implementation. */
3877 linux_nat_is_async_p (void)
3879 /* NOTE: palves 2008-03-21: We're only async when the user requests
3880 it explicitly with the "maintenance set linux-async" command.
3881 Someday, linux will always be async. */
3882 if (!linux_async_permitted
)
3888 /* target_can_async_p implementation. */
3891 linux_nat_can_async_p (void)
3893 /* NOTE: palves 2008-03-21: We're only async when the user requests
3894 it explicitly with the "maintenance set linux-async" command.
3895 Someday, linux will always be async. */
3896 if (!linux_async_permitted
)
3899 /* See target.h/target_async_mask. */
3900 return linux_nat_async_mask_value
;
3903 /* target_async_mask implementation. */
3906 linux_nat_async_mask (int mask
)
3909 current_state
= linux_nat_async_mask_value
;
3911 if (current_state
!= mask
)
3915 linux_nat_async (NULL
, 0);
3916 linux_nat_async_mask_value
= mask
;
3920 linux_nat_async_mask_value
= mask
;
3921 linux_nat_async (inferior_event_handler
, 0);
3925 return current_state
;
3928 /* Pop an event from the event pipe. */
3931 linux_nat_event_pipe_pop (int* ptr_status
, int* ptr_options
)
3933 struct waitpid_result event
= {0};
3938 ret
= read (linux_nat_event_pipe
[0], &event
, sizeof (event
));
3940 while (ret
== -1 && errno
== EINTR
);
3942 gdb_assert (ret
== sizeof (event
));
3944 *ptr_status
= event
.status
;
3945 *ptr_options
= event
.options
;
3947 linux_nat_num_queued_events
--;
3952 /* Push an event into the event pipe. */
3955 linux_nat_event_pipe_push (int pid
, int status
, int options
)
3958 struct waitpid_result event
= {0};
3960 event
.status
= status
;
3961 event
.options
= options
;
3965 ret
= write (linux_nat_event_pipe
[1], &event
, sizeof (event
));
3966 gdb_assert ((ret
== -1 && errno
== EINTR
) || ret
== sizeof (event
));
3967 } while (ret
== -1 && errno
== EINTR
);
3969 linux_nat_num_queued_events
++;
3973 get_pending_events (void)
3975 int status
, options
, pid
;
3977 if (!linux_nat_async_enabled
3978 || linux_nat_async_events_state
!= sigchld_async
)
3979 internal_error (__FILE__
, __LINE__
,
3980 "get_pending_events called with async masked");
3985 options
= __WCLONE
| WNOHANG
;
3989 pid
= waitpid (-1, &status
, options
);
3991 while (pid
== -1 && errno
== EINTR
);
3998 pid
= waitpid (-1, &status
, options
);
4000 while (pid
== -1 && errno
== EINTR
);
4004 /* No more children reporting events. */
4007 if (debug_linux_nat_async
)
4008 fprintf_unfiltered (gdb_stdlog
, "\
4009 get_pending_events: pid(%d), status(%x), options (%x)\n",
4010 pid
, status
, options
);
4012 linux_nat_event_pipe_push (pid
, status
, options
);
4015 if (debug_linux_nat_async
)
4016 fprintf_unfiltered (gdb_stdlog
, "\
4017 get_pending_events: linux_nat_num_queued_events(%d)\n",
4018 linux_nat_num_queued_events
);
4021 /* SIGCHLD handler for async mode. */
4024 async_sigchld_handler (int signo
)
4026 if (debug_linux_nat_async
)
4027 fprintf_unfiltered (gdb_stdlog
, "async_sigchld_handler\n");
4029 get_pending_events ();
4032 /* Set SIGCHLD handling state to STATE. Returns previous state. */
4034 static enum sigchld_state
4035 linux_nat_async_events (enum sigchld_state state
)
4037 enum sigchld_state current_state
= linux_nat_async_events_state
;
4039 if (debug_linux_nat_async
)
4040 fprintf_unfiltered (gdb_stdlog
,
4041 "LNAE: state(%d): linux_nat_async_events_state(%d), "
4042 "linux_nat_num_queued_events(%d)\n",
4043 state
, linux_nat_async_events_state
,
4044 linux_nat_num_queued_events
);
4046 if (current_state
!= state
)
4049 sigemptyset (&mask
);
4050 sigaddset (&mask
, SIGCHLD
);
4052 /* Always block before changing state. */
4053 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4055 /* Set new state. */
4056 linux_nat_async_events_state
= state
;
4062 /* Block target events. */
4063 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4064 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
4065 /* Get events out of queue, and make them available to
4066 queued_waitpid / my_waitpid. */
4067 pipe_to_local_event_queue ();
4072 /* Unblock target events for async mode. */
4074 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4076 /* Put events we already waited on, in the pipe first, so
4078 local_event_queue_to_pipe ();
4079 /* While in masked async, we may have not collected all
4080 the pending events. Get them out now. */
4081 get_pending_events ();
4084 sigaction (SIGCHLD
, &async_sigchld_action
, NULL
);
4085 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
4088 case sigchld_default
:
4090 /* SIGCHLD default mode. */
4091 sigaction (SIGCHLD
, &sigchld_default_action
, NULL
);
4093 /* Get events out of queue, and make them available to
4094 queued_waitpid / my_waitpid. */
4095 pipe_to_local_event_queue ();
4097 /* Unblock SIGCHLD. */
4098 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
4104 return current_state
;
4107 static int async_terminal_is_ours
= 1;
4109 /* target_terminal_inferior implementation. */
4112 linux_nat_terminal_inferior (void)
4114 if (!target_is_async_p ())
4116 /* Async mode is disabled. */
4117 terminal_inferior ();
4121 /* GDB should never give the terminal to the inferior, if the
4122 inferior is running in the background (run&, continue&, etc.).
4123 This check can be removed when the common code is fixed. */
4124 if (!sync_execution
)
4127 terminal_inferior ();
4129 if (!async_terminal_is_ours
)
4132 delete_file_handler (input_fd
);
4133 async_terminal_is_ours
= 0;
4137 /* target_terminal_ours implementation. */
4140 linux_nat_terminal_ours (void)
4142 if (!target_is_async_p ())
4144 /* Async mode is disabled. */
4149 /* GDB should never give the terminal to the inferior if the
4150 inferior is running in the background (run&, continue&, etc.),
4151 but claiming it sure should. */
4154 if (!sync_execution
)
4157 if (async_terminal_is_ours
)
4160 clear_sigint_trap ();
4161 add_file_handler (input_fd
, stdin_event_handler
, 0);
4162 async_terminal_is_ours
= 1;
4165 static void (*async_client_callback
) (enum inferior_event_type event_type
,
4167 static void *async_client_context
;
4170 linux_nat_async_file_handler (int error
, gdb_client_data client_data
)
4172 async_client_callback (INF_REG_EVENT
, async_client_context
);
4175 /* target_async implementation. */
4178 linux_nat_async (void (*callback
) (enum inferior_event_type event_type
,
4179 void *context
), void *context
)
4181 if (linux_nat_async_mask_value
== 0 || !linux_nat_async_enabled
)
4182 internal_error (__FILE__
, __LINE__
,
4183 "Calling target_async when async is masked");
4185 if (callback
!= NULL
)
4187 async_client_callback
= callback
;
4188 async_client_context
= context
;
4189 add_file_handler (linux_nat_event_pipe
[0],
4190 linux_nat_async_file_handler
, NULL
);
4192 linux_nat_async_events (sigchld_async
);
4196 async_client_callback
= callback
;
4197 async_client_context
= context
;
4199 linux_nat_async_events (sigchld_sync
);
4200 delete_file_handler (linux_nat_event_pipe
[0]);
4205 /* Enable/Disable async mode. */
4208 linux_nat_set_async_mode (int on
)
4210 if (linux_nat_async_enabled
!= on
)
4214 gdb_assert (waitpid_queue
== NULL
);
4215 if (pipe (linux_nat_event_pipe
) == -1)
4216 internal_error (__FILE__
, __LINE__
,
4217 "creating event pipe failed.");
4218 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
4219 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
4223 drain_queued_events (-1);
4224 linux_nat_num_queued_events
= 0;
4225 close (linux_nat_event_pipe
[0]);
4226 close (linux_nat_event_pipe
[1]);
4227 linux_nat_event_pipe
[0] = linux_nat_event_pipe
[1] = -1;
4231 linux_nat_async_enabled
= on
;
4235 linux_nat_add_target (struct target_ops
*t
)
4237 /* Save the provided single-threaded target. We save this in a separate
4238 variable because another target we've inherited from (e.g. inf-ptrace)
4239 may have saved a pointer to T; we want to use it for the final
4240 process stratum target. */
4241 linux_ops_saved
= *t
;
4242 linux_ops
= &linux_ops_saved
;
4244 /* Override some methods for multithreading. */
4245 t
->to_create_inferior
= linux_nat_create_inferior
;
4246 t
->to_attach
= linux_nat_attach
;
4247 t
->to_detach
= linux_nat_detach
;
4248 t
->to_resume
= linux_nat_resume
;
4249 t
->to_wait
= linux_nat_wait
;
4250 t
->to_xfer_partial
= linux_nat_xfer_partial
;
4251 t
->to_kill
= linux_nat_kill
;
4252 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
4253 t
->to_thread_alive
= linux_nat_thread_alive
;
4254 t
->to_pid_to_str
= linux_nat_pid_to_str
;
4255 t
->to_has_thread_control
= tc_schedlock
;
4257 t
->to_can_async_p
= linux_nat_can_async_p
;
4258 t
->to_is_async_p
= linux_nat_is_async_p
;
4259 t
->to_async
= linux_nat_async
;
4260 t
->to_async_mask
= linux_nat_async_mask
;
4261 t
->to_terminal_inferior
= linux_nat_terminal_inferior
;
4262 t
->to_terminal_ours
= linux_nat_terminal_ours
;
4264 /* We don't change the stratum; this target will sit at
4265 process_stratum and thread_db will set at thread_stratum. This
4266 is a little strange, since this is a multi-threaded-capable
4267 target, but we want to be on the stack below thread_db, and we
4268 also want to be used for single-threaded processes. */
4272 /* TODO: Eliminate this and have libthread_db use
4273 find_target_beneath. */
4277 /* Register a method to call whenever a new thread is attached. */
4279 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
4281 /* Save the pointer. We only support a single registered instance
4282 of the GNU/Linux native target, so we do not need to map this to
4284 linux_nat_new_thread
= new_thread
;
4287 /* Return the saved siginfo associated with PTID. */
4289 linux_nat_get_siginfo (ptid_t ptid
)
4291 struct lwp_info
*lp
= find_lwp_pid (ptid
);
4293 gdb_assert (lp
!= NULL
);
4295 return &lp
->siginfo
;
4299 _initialize_linux_nat (void)
4303 add_info ("proc", linux_nat_info_proc_cmd
, _("\
4304 Show /proc process information about any running process.\n\
4305 Specify any process id, or use the program being debugged by default.\n\
4306 Specify any of the following keywords for detailed info:\n\
4307 mappings -- list of mapped memory regions.\n\
4308 stat -- list a bunch of random process info.\n\
4309 status -- list a different bunch of random process info.\n\
4310 all -- list all available /proc info."));
4312 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance
,
4313 &debug_linux_nat
, _("\
4314 Set debugging of GNU/Linux lwp module."), _("\
4315 Show debugging of GNU/Linux lwp module."), _("\
4316 Enables printf debugging output."),
4318 show_debug_linux_nat
,
4319 &setdebuglist
, &showdebuglist
);
4321 add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance
,
4322 &debug_linux_nat_async
, _("\
4323 Set debugging of GNU/Linux async lwp module."), _("\
4324 Show debugging of GNU/Linux async lwp module."), _("\
4325 Enables printf debugging output."),
4327 show_debug_linux_nat_async
,
4328 &setdebuglist
, &showdebuglist
);
4330 add_setshow_boolean_cmd ("linux-async", class_maintenance
,
4331 &linux_async_permitted_1
, _("\
4332 Set whether gdb controls the GNU/Linux inferior in asynchronous mode."), _("\
4333 Show whether gdb controls the GNU/Linux inferior in asynchronous mode."), _("\
4334 Tells gdb whether to control the GNU/Linux inferior in asynchronous mode."),
4335 set_maintenance_linux_async_permitted
,
4336 show_maintenance_linux_async_permitted
,
4337 &maintenance_set_cmdlist
,
4338 &maintenance_show_cmdlist
);
4340 /* Get the default SIGCHLD action. Used while forking an inferior
4341 (see linux_nat_create_inferior/linux_nat_async_events). */
4342 sigaction (SIGCHLD
, NULL
, &sigchld_default_action
);
4344 /* Block SIGCHLD by default. Doing this early prevents it getting
4345 unblocked if an exception is thrown due to an error while the
4346 inferior is starting (sigsetjmp/siglongjmp). */
4347 sigemptyset (&mask
);
4348 sigaddset (&mask
, SIGCHLD
);
4349 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4351 /* Save this mask as the default. */
4352 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
4354 /* The synchronous SIGCHLD handler. */
4355 sync_sigchld_action
.sa_handler
= sigchld_handler
;
4356 sigemptyset (&sync_sigchld_action
.sa_mask
);
4357 sync_sigchld_action
.sa_flags
= SA_RESTART
;
4359 /* Make it the default. */
4360 sigaction (SIGCHLD
, &sync_sigchld_action
, NULL
);
4362 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4363 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
4364 sigdelset (&suspend_mask
, SIGCHLD
);
4366 /* SIGCHLD handler for async mode. */
4367 async_sigchld_action
.sa_handler
= async_sigchld_handler
;
4368 sigemptyset (&async_sigchld_action
.sa_mask
);
4369 async_sigchld_action
.sa_flags
= SA_RESTART
;
4371 /* Install the default mode. */
4372 linux_nat_set_async_mode (linux_async_permitted
);
4376 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4377 the GNU/Linux Threads library and therefore doesn't really belong
4380 /* Read variable NAME in the target and return its value if found.
4381 Otherwise return zero. It is assumed that the type of the variable
4385 get_signo (const char *name
)
4387 struct minimal_symbol
*ms
;
4390 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
4394 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
4395 sizeof (signo
)) != 0)
4401 /* Return the set of signals used by the threads library in *SET. */
4404 lin_thread_get_thread_signals (sigset_t
*set
)
4406 struct sigaction action
;
4407 int restart
, cancel
;
4408 sigset_t blocked_mask
;
4410 sigemptyset (&blocked_mask
);
4413 restart
= get_signo ("__pthread_sig_restart");
4414 cancel
= get_signo ("__pthread_sig_cancel");
4416 /* LinuxThreads normally uses the first two RT signals, but in some legacy
4417 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
4418 not provide any way for the debugger to query the signal numbers -
4419 fortunately they don't change! */
4422 restart
= __SIGRTMIN
;
4425 cancel
= __SIGRTMIN
+ 1;
4427 sigaddset (set
, restart
);
4428 sigaddset (set
, cancel
);
4430 /* The GNU/Linux Threads library makes terminating threads send a
4431 special "cancel" signal instead of SIGCHLD. Make sure we catch
4432 those (to prevent them from terminating GDB itself, which is
4433 likely to be their default action) and treat them the same way as
4436 action
.sa_handler
= sigchld_handler
;
4437 sigemptyset (&action
.sa_mask
);
4438 action
.sa_flags
= SA_RESTART
;
4439 sigaction (cancel
, &action
, NULL
);
4441 /* We block the "cancel" signal throughout this code ... */
4442 sigaddset (&blocked_mask
, cancel
);
4443 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
4445 /* ... except during a sigsuspend. */
4446 sigdelset (&suspend_mask
, cancel
);