1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
26 #include "gdb_assert.h"
27 #ifdef HAVE_TKILL_SYSCALL
29 #include <sys/syscall.h>
31 #include <sys/ptrace.h>
32 #include "linux-nat.h"
33 #include "linux-fork.h"
34 #include "gdbthread.h"
38 #include "inf-ptrace.h"
40 #include <sys/param.h> /* for MAXPATHLEN */
41 #include <sys/procfs.h> /* for elf_gregset etc. */
42 #include "elf-bfd.h" /* for elfcore_write_* */
43 #include "gregset.h" /* for gregset */
44 #include "gdbcore.h" /* for get_exec_file */
45 #include <ctype.h> /* for isdigit */
46 #include "gdbthread.h" /* for struct thread_info etc. */
47 #include "gdb_stat.h" /* for struct stat */
48 #include <fcntl.h> /* for O_RDONLY */
50 #include "event-loop.h"
51 #include "event-top.h"
53 #ifdef HAVE_PERSONALITY
54 # include <sys/personality.h>
55 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
56 # define ADDR_NO_RANDOMIZE 0x0040000
58 #endif /* HAVE_PERSONALITY */
60 /* This comment documents high-level logic of this file.
62 Waiting for events in sync mode
63 ===============================
65 When waiting for an event in a specific thread, we just use waitpid, passing
66 the specific pid, and not passing WNOHANG.
68 When waiting for an event in all threads, waitpid is not quite good. Prior to
69 version 2.4, Linux can either wait for event in main thread, or in secondary
70 threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
71 miss an event. The solution is to use non-blocking waitpid, together with
72 sigsuspend. First, we use non-blocking waitpid to get an event in the main
73 process, if any. Second, we use non-blocking waitpid with the __WCLONED
74 flag to check for events in cloned processes. If nothing is found, we use
75 sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
76 happened to a child process -- and SIGCHLD will be delivered both for events
77 in main debugged process and in cloned processes. As soon as we know there's
78 an event, we get back to calling nonblocking waitpid with and without __WCLONED.
80 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
81 so that we don't miss a signal. If SIGCHLD arrives in between, when it's
82 blocked, the signal becomes pending and sigsuspend immediately
83 notices it and returns.
85 Waiting for events in async mode
86 ================================
88 In async mode, GDB should always be ready to handle both user input and target
89 events, so neither blocking waitpid nor sigsuspend are viable
90 options. Instead, we should notify the GDB main event loop whenever there's
91 unprocessed event from the target. The only way to notify this event loop is
92 to make it wait on input from a pipe, and write something to the pipe whenever
93 there's event. Obviously, if we fail to notify the event loop if there's
94 target event, it's bad. If we notify the event loop when there's no event
95 from target, linux-nat.c will detect that there's no event, actually, and
96 report event of type TARGET_WAITKIND_IGNORE, but it will waste time and
99 The main design point is that every time GDB is outside linux-nat.c, we have a
100 SIGCHLD handler installed that is called when something happens to the target
101 and notifies the GDB event loop. Also, the event is extracted from the target
102 using waitpid and stored for future use. Whenever GDB core decides to handle
103 the event, and calls into linux-nat.c, we disable SIGCHLD and process things
104 as in sync mode, except that before waitpid call we check if there are any
105 previously read events.
107 It could happen that during event processing, we'll try to get more events
108 than there are events in the local queue, which will result to waitpid call.
109 Those waitpid calls, while blocking, are guarantied to always have
110 something for waitpid to return. E.g., stopping a thread with SIGSTOP, and
111 waiting for the lwp to stop.
113 The event loop is notified about new events using a pipe. SIGCHLD handler does
114 waitpid and writes the results in to a pipe. GDB event loop has the other end
115 of the pipe among the sources. When event loop starts to process the event
116 and calls a function in linux-nat.c, all events from the pipe are transferred
117 into a local queue and SIGCHLD is blocked. Further processing goes as in sync
118 mode. Before we return from linux_nat_wait, we transfer all unprocessed events
119 from local queue back to the pipe, so that when we get back to event loop,
120 event loop will notice there's something more to do.
122 SIGCHLD is blocked when we're inside target_wait, so that should we actually
123 want to wait for some more events, SIGCHLD handler does not steal them from
124 us. Technically, it would be possible to add new events to the local queue but
125 it's about the same amount of work as blocking SIGCHLD.
127 This moving of events from pipe into local queue and back into pipe when we
128 enter/leave linux-nat.c is somewhat ugly. Unfortunately, GDB event loop is
129 home-grown and incapable to wait on any queue.
134 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
135 signal is not entirely significant; we just need for a signal to be delivered,
136 so that we can intercept it. SIGSTOP's advantage is that it can not be
137 blocked. A disadvantage is that it is not a real-time signal, so it can only
138 be queued once; we do not keep track of other sources of SIGSTOP.
140 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
141 use them, because they have special behavior when the signal is generated -
142 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
143 kills the entire thread group.
145 A delivered SIGSTOP would stop the entire thread group, not just the thread we
146 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
147 cancel it (by PTRACE_CONT without passing SIGSTOP).
149 We could use a real-time signal instead. This would solve those problems; we
150 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
151 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
152 generates it, and there are races with trying to find a signal that is not
156 #define O_LARGEFILE 0
159 /* If the system headers did not provide the constants, hard-code the normal
161 #ifndef PTRACE_EVENT_FORK
163 #define PTRACE_SETOPTIONS 0x4200
164 #define PTRACE_GETEVENTMSG 0x4201
166 /* options set using PTRACE_SETOPTIONS */
167 #define PTRACE_O_TRACESYSGOOD 0x00000001
168 #define PTRACE_O_TRACEFORK 0x00000002
169 #define PTRACE_O_TRACEVFORK 0x00000004
170 #define PTRACE_O_TRACECLONE 0x00000008
171 #define PTRACE_O_TRACEEXEC 0x00000010
172 #define PTRACE_O_TRACEVFORKDONE 0x00000020
173 #define PTRACE_O_TRACEEXIT 0x00000040
175 /* Wait extended result codes for the above trace options. */
176 #define PTRACE_EVENT_FORK 1
177 #define PTRACE_EVENT_VFORK 2
178 #define PTRACE_EVENT_CLONE 3
179 #define PTRACE_EVENT_EXEC 4
180 #define PTRACE_EVENT_VFORK_DONE 5
181 #define PTRACE_EVENT_EXIT 6
183 #endif /* PTRACE_EVENT_FORK */
185 /* We can't always assume that this flag is available, but all systems
186 with the ptrace event handlers also have __WALL, so it's safe to use
189 #define __WALL 0x40000000 /* Wait for any child. */
192 #ifndef PTRACE_GETSIGINFO
193 #define PTRACE_GETSIGINFO 0x4202
196 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
197 the use of the multi-threaded target. */
198 static struct target_ops *linux_ops;
199 static struct target_ops linux_ops_saved;
201 /* The method to call, if any, when a new thread is attached. */
202 static void (*linux_nat_new_thread) (ptid_t);
204 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
205 Called by our to_xfer_partial. */
206 static LONGEST (*super_xfer_partial) (struct target_ops *,
208 const char *, gdb_byte *,
212 static int debug_linux_nat;
214 show_debug_linux_nat (struct ui_file *file, int from_tty,
215 struct cmd_list_element *c, const char *value)
217 fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
221 static int debug_linux_nat_async = 0;
223 show_debug_linux_nat_async (struct ui_file *file, int from_tty,
224 struct cmd_list_element *c, const char *value)
226 fprintf_filtered (file, _("Debugging of GNU/Linux async lwp module is %s.\n"),
230 static int disable_randomization = 1;
233 show_disable_randomization (struct ui_file *file, int from_tty,
234 struct cmd_list_element *c, const char *value)
236 #ifdef HAVE_PERSONALITY
237 fprintf_filtered (file, _("\
238 Disabling randomization of debuggee's virtual address space is %s.\n"),
240 #else /* !HAVE_PERSONALITY */
242 Disabling randomization of debuggee's virtual address space is unsupported on\n\
243 this platform.\n"), file);
244 #endif /* !HAVE_PERSONALITY */
248 set_disable_randomization (char *args, int from_tty, struct cmd_list_element *c)
250 #ifndef HAVE_PERSONALITY
252 Disabling randomization of debuggee's virtual address space is unsupported on\n\
254 #endif /* !HAVE_PERSONALITY */
257 static int linux_parent_pid;
259 struct simple_pid_list
263 struct simple_pid_list *next;
265 struct simple_pid_list *stopped_pids;
267 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
268 can not be used, 1 if it can. */
270 static int linux_supports_tracefork_flag = -1;
272 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
273 PTRACE_O_TRACEVFORKDONE. */
275 static int linux_supports_tracevforkdone_flag = -1;
277 /* Async mode support */
279 /* True if async mode is currently on. */
280 static int linux_nat_async_enabled;
282 /* Zero if the async mode, although enabled, is masked, which means
283 linux_nat_wait should behave as if async mode was off. */
284 static int linux_nat_async_mask_value = 1;
286 /* The read/write ends of the pipe registered as waitable file in the
288 static int linux_nat_event_pipe[2] = { -1, -1 };
290 /* Number of queued events in the pipe. */
291 static volatile int linux_nat_num_queued_events;
293 /* The possible SIGCHLD handling states. */
297 /* SIGCHLD disabled, with action set to sigchld_handler, for the
298 sigsuspend in linux_nat_wait. */
300 /* SIGCHLD enabled, with action set to async_sigchld_handler. */
302 /* Set SIGCHLD to default action. Used while creating an
307 /* The current SIGCHLD handling state. */
308 static enum sigchld_state linux_nat_async_events_state;
310 static enum sigchld_state linux_nat_async_events (enum sigchld_state enable);
311 static void pipe_to_local_event_queue (void);
312 static void local_event_queue_to_pipe (void);
313 static void linux_nat_event_pipe_push (int pid, int status, int options);
314 static int linux_nat_event_pipe_pop (int* ptr_status, int* ptr_options);
315 static void linux_nat_set_async_mode (int on);
316 static void linux_nat_async (void (*callback)
317 (enum inferior_event_type event_type, void *context),
319 static int linux_nat_async_mask (int mask);
320 static int kill_lwp (int lwpid, int signo);
322 /* Captures the result of a successful waitpid call, along with the
323 options used in that call. */
324 struct waitpid_result
329 struct waitpid_result *next;
332 /* A singly-linked list of the results of the waitpid calls performed
333 in the async SIGCHLD handler. */
334 static struct waitpid_result *waitpid_queue = NULL;
337 queued_waitpid (int pid, int *status, int flags)
339 struct waitpid_result *msg = waitpid_queue, *prev = NULL;
341 if (debug_linux_nat_async)
342 fprintf_unfiltered (gdb_stdlog,
344 QWPID: linux_nat_async_events_state(%d), linux_nat_num_queued_events(%d)\n",
345 linux_nat_async_events_state,
346 linux_nat_num_queued_events);
350 for (; msg; prev = msg, msg = msg->next)
351 if (pid == -1 || pid == msg->pid)
354 else if (flags & __WCLONE)
356 for (; msg; prev = msg, msg = msg->next)
357 if (msg->options & __WCLONE
358 && (pid == -1 || pid == msg->pid))
363 for (; msg; prev = msg, msg = msg->next)
364 if ((msg->options & __WCLONE) == 0
365 && (pid == -1 || pid == msg->pid))
374 prev->next = msg->next;
376 waitpid_queue = msg->next;
380 *status = msg->status;
383 if (debug_linux_nat_async)
384 fprintf_unfiltered (gdb_stdlog, "QWPID: pid(%d), status(%x)\n",
391 if (debug_linux_nat_async)
392 fprintf_unfiltered (gdb_stdlog, "QWPID: miss\n");
400 push_waitpid (int pid, int status, int options)
402 struct waitpid_result *event, *new_event;
404 new_event = xmalloc (sizeof (*new_event));
405 new_event->pid = pid;
406 new_event->status = status;
407 new_event->options = options;
408 new_event->next = NULL;
412 for (event = waitpid_queue;
413 event && event->next;
417 event->next = new_event;
420 waitpid_queue = new_event;
423 /* Drain all queued events of PID. If PID is -1, the effect is of
424 draining all events. */
426 drain_queued_events (int pid)
428 while (queued_waitpid (pid, NULL, __WALL) != -1)
433 /* Trivial list manipulation functions to keep track of a list of
434 new stopped processes. */
436 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
438 struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
440 new_pid->status = status;
441 new_pid->next = *listp;
446 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *status)
448 struct simple_pid_list **p;
450 for (p = listp; *p != NULL; p = &(*p)->next)
451 if ((*p)->pid == pid)
453 struct simple_pid_list *next = (*p)->next;
454 *status = (*p)->status;
463 linux_record_stopped_pid (int pid, int status)
465 add_to_pid_list (&stopped_pids, pid, status);
469 /* A helper function for linux_test_for_tracefork, called after fork (). */
472 linux_tracefork_child (void)
476 ptrace (PTRACE_TRACEME, 0, 0, 0);
477 kill (getpid (), SIGSTOP);
482 /* Wrapper function for waitpid which handles EINTR, and checks for
483 locally queued events. */
486 my_waitpid (int pid, int *status, int flags)
490 /* There should be no concurrent calls to waitpid. */
491 gdb_assert (linux_nat_async_events_state == sigchld_sync);
493 ret = queued_waitpid (pid, status, flags);
499 ret = waitpid (pid, status, flags);
501 while (ret == -1 && errno == EINTR);
506 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
508 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
509 we know that the feature is not available. This may change the tracing
510 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
512 However, if it succeeds, we don't know for sure that the feature is
513 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
514 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
515 fork tracing, and let it fork. If the process exits, we assume that we
516 can't use TRACEFORK; if we get the fork notification, and we can extract
517 the new child's PID, then we assume that we can. */
520 linux_test_for_tracefork (int original_pid)
522 int child_pid, ret, status;
525 linux_supports_tracefork_flag = 0;
526 linux_supports_tracevforkdone_flag = 0;
528 ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACEFORK);
534 perror_with_name (("fork"));
537 linux_tracefork_child ();
539 ret = my_waitpid (child_pid, &status, 0);
541 perror_with_name (("waitpid"));
542 else if (ret != child_pid)
543 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
544 if (! WIFSTOPPED (status))
545 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status);
547 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
550 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
553 warning (_("linux_test_for_tracefork: failed to kill child"));
557 ret = my_waitpid (child_pid, &status, 0);
558 if (ret != child_pid)
559 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
560 else if (!WIFSIGNALED (status))
561 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
562 "killed child"), status);
567 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
568 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
569 PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
570 linux_supports_tracevforkdone_flag = (ret == 0);
572 ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
574 warning (_("linux_test_for_tracefork: failed to resume child"));
576 ret = my_waitpid (child_pid, &status, 0);
578 if (ret == child_pid && WIFSTOPPED (status)
579 && status >> 16 == PTRACE_EVENT_FORK)
582 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
583 if (ret == 0 && second_pid != 0)
587 linux_supports_tracefork_flag = 1;
588 my_waitpid (second_pid, &second_status, 0);
589 ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
591 warning (_("linux_test_for_tracefork: failed to kill second child"));
592 my_waitpid (second_pid, &status, 0);
596 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
597 "(%d, status 0x%x)"), ret, status);
599 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
601 warning (_("linux_test_for_tracefork: failed to kill child"));
602 my_waitpid (child_pid, &status, 0);
605 /* Return non-zero iff we have tracefork functionality available.
606 This function also sets linux_supports_tracefork_flag. */
609 linux_supports_tracefork (int pid)
611 if (linux_supports_tracefork_flag == -1)
612 linux_test_for_tracefork (pid);
613 return linux_supports_tracefork_flag;
617 linux_supports_tracevforkdone (int pid)
619 if (linux_supports_tracefork_flag == -1)
620 linux_test_for_tracefork (pid);
621 return linux_supports_tracevforkdone_flag;
626 linux_enable_event_reporting (ptid_t ptid)
628 int pid = ptid_get_lwp (ptid);
632 pid = ptid_get_pid (ptid);
634 if (! linux_supports_tracefork (pid))
637 options = PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK | PTRACE_O_TRACEEXEC
638 | PTRACE_O_TRACECLONE;
639 if (linux_supports_tracevforkdone (pid))
640 options |= PTRACE_O_TRACEVFORKDONE;
642 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
643 read-only process state. */
645 ptrace (PTRACE_SETOPTIONS, pid, 0, options);
649 linux_child_post_attach (int pid)
651 linux_enable_event_reporting (pid_to_ptid (pid));
652 check_for_thread_db ();
656 linux_child_post_startup_inferior (ptid_t ptid)
658 linux_enable_event_reporting (ptid);
659 check_for_thread_db ();
663 linux_child_follow_fork (struct target_ops *ops, int follow_child)
666 struct target_waitstatus last_status;
668 int parent_pid, child_pid;
670 if (target_can_async_p ())
671 target_async (NULL, 0);
673 get_last_target_status (&last_ptid, &last_status);
674 has_vforked = (last_status.kind == TARGET_WAITKIND_VFORKED);
675 parent_pid = ptid_get_lwp (last_ptid);
677 parent_pid = ptid_get_pid (last_ptid);
678 child_pid = PIDGET (last_status.value.related_pid);
682 /* We're already attached to the parent, by default. */
684 /* Before detaching from the child, remove all breakpoints from
685 it. (This won't actually modify the breakpoint list, but will
686 physically remove the breakpoints from the child.) */
687 /* If we vforked this will remove the breakpoints from the parent
688 also, but they'll be reinserted below. */
689 detach_breakpoints (child_pid);
691 /* Detach new forked process? */
694 if (info_verbose || debug_linux_nat)
696 target_terminal_ours ();
697 fprintf_filtered (gdb_stdlog,
698 "Detaching after fork from child process %d.\n",
702 ptrace (PTRACE_DETACH, child_pid, 0, 0);
706 struct fork_info *fp;
707 /* Retain child fork in ptrace (stopped) state. */
708 fp = find_fork_pid (child_pid);
710 fp = add_fork (child_pid);
711 fork_save_infrun_state (fp, 0);
716 gdb_assert (linux_supports_tracefork_flag >= 0);
717 if (linux_supports_tracevforkdone (0))
721 ptrace (PTRACE_CONT, parent_pid, 0, 0);
722 my_waitpid (parent_pid, &status, __WALL);
723 if ((status >> 16) != PTRACE_EVENT_VFORK_DONE)
724 warning (_("Unexpected waitpid result %06x when waiting for "
725 "vfork-done"), status);
729 /* We can't insert breakpoints until the child has
730 finished with the shared memory region. We need to
731 wait until that happens. Ideal would be to just
733 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
734 - waitpid (parent_pid, &status, __WALL);
735 However, most architectures can't handle a syscall
736 being traced on the way out if it wasn't traced on
739 We might also think to loop, continuing the child
740 until it exits or gets a SIGTRAP. One problem is
741 that the child might call ptrace with PTRACE_TRACEME.
743 There's no simple and reliable way to figure out when
744 the vforked child will be done with its copy of the
745 shared memory. We could step it out of the syscall,
746 two instructions, let it go, and then single-step the
747 parent once. When we have hardware single-step, this
748 would work; with software single-step it could still
749 be made to work but we'd have to be able to insert
750 single-step breakpoints in the child, and we'd have
751 to insert -just- the single-step breakpoint in the
752 parent. Very awkward.
754 In the end, the best we can do is to make sure it
755 runs for a little while. Hopefully it will be out of
756 range of any breakpoints we reinsert. Usually this
757 is only the single-step breakpoint at vfork's return
763 /* Since we vforked, breakpoints were removed in the parent
764 too. Put them back. */
765 reattach_breakpoints (parent_pid);
770 char child_pid_spelling[40];
772 /* Needed to keep the breakpoint lists in sync. */
774 detach_breakpoints (child_pid);
776 /* Before detaching from the parent, remove all breakpoints from it. */
777 remove_breakpoints ();
779 if (info_verbose || debug_linux_nat)
781 target_terminal_ours ();
782 fprintf_filtered (gdb_stdlog,
783 "Attaching after fork to child process %d.\n",
787 /* If we're vforking, we may want to hold on to the parent until
788 the child exits or execs. At exec time we can remove the old
789 breakpoints from the parent and detach it; at exit time we
790 could do the same (or even, sneakily, resume debugging it - the
791 child's exec has failed, or something similar).
793 This doesn't clean up "properly", because we can't call
794 target_detach, but that's OK; if the current target is "child",
795 then it doesn't need any further cleanups, and lin_lwp will
796 generally not encounter vfork (vfork is defined to fork
799 The holding part is very easy if we have VFORKDONE events;
800 but keeping track of both processes is beyond GDB at the
801 moment. So we don't expose the parent to the rest of GDB.
802 Instead we quietly hold onto it until such time as we can
806 linux_parent_pid = parent_pid;
807 else if (!detach_fork)
809 struct fork_info *fp;
810 /* Retain parent fork in ptrace (stopped) state. */
811 fp = find_fork_pid (parent_pid);
813 fp = add_fork (parent_pid);
814 fork_save_infrun_state (fp, 0);
817 target_detach (NULL, 0);
819 inferior_ptid = ptid_build (child_pid, child_pid, 0);
821 /* Reinstall ourselves, since we might have been removed in
822 target_detach (which does other necessary cleanup). */
825 linux_nat_switch_fork (inferior_ptid);
826 check_for_thread_db ();
828 /* Reset breakpoints in the child as appropriate. */
829 follow_inferior_reset_breakpoints ();
832 if (target_can_async_p ())
833 target_async (inferior_event_handler, 0);
840 linux_child_insert_fork_catchpoint (int pid)
842 if (! linux_supports_tracefork (pid))
843 error (_("Your system does not support fork catchpoints."));
847 linux_child_insert_vfork_catchpoint (int pid)
849 if (!linux_supports_tracefork (pid))
850 error (_("Your system does not support vfork catchpoints."));
854 linux_child_insert_exec_catchpoint (int pid)
856 if (!linux_supports_tracefork (pid))
857 error (_("Your system does not support exec catchpoints."));
860 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
861 are processes sharing the same VM space. A multi-threaded process
862 is basically a group of such processes. However, such a grouping
863 is almost entirely a user-space issue; the kernel doesn't enforce
864 such a grouping at all (this might change in the future). In
865 general, we'll rely on the threads library (i.e. the GNU/Linux
866 Threads library) to provide such a grouping.
868 It is perfectly well possible to write a multi-threaded application
869 without the assistance of a threads library, by using the clone
870 system call directly. This module should be able to give some
871 rudimentary support for debugging such applications if developers
872 specify the CLONE_PTRACE flag in the clone system call, and are
873 using the Linux kernel 2.4 or above.
875 Note that there are some peculiarities in GNU/Linux that affect
878 - In general one should specify the __WCLONE flag to waitpid in
879 order to make it report events for any of the cloned processes
880 (and leave it out for the initial process). However, if a cloned
881 process has exited the exit status is only reported if the
882 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
883 we cannot use it since GDB must work on older systems too.
885 - When a traced, cloned process exits and is waited for by the
886 debugger, the kernel reassigns it to the original parent and
887 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
888 library doesn't notice this, which leads to the "zombie problem":
889 When debugged a multi-threaded process that spawns a lot of
890 threads will run out of processes, even if the threads exit,
891 because the "zombies" stay around. */
893 /* List of known LWPs. */
894 struct lwp_info *lwp_list;
896 /* Number of LWPs in the list. */
900 /* Original signal mask. */
901 static sigset_t normal_mask;
903 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
904 _initialize_linux_nat. */
905 static sigset_t suspend_mask;
907 /* SIGCHLD action for synchronous mode. */
908 struct sigaction sync_sigchld_action;
910 /* SIGCHLD action for asynchronous mode. */
911 static struct sigaction async_sigchld_action;
913 /* SIGCHLD default action, to pass to new inferiors. */
914 static struct sigaction sigchld_default_action;
917 /* Prototypes for local functions. */
918 static int stop_wait_callback (struct lwp_info *lp, void *data);
919 static int linux_nat_thread_alive (ptid_t ptid);
920 static char *linux_child_pid_to_exec_file (int pid);
921 static int cancel_breakpoint (struct lwp_info *lp);
924 /* Convert wait status STATUS to a string. Used for printing debug
928 status_to_str (int status)
932 if (WIFSTOPPED (status))
933 snprintf (buf, sizeof (buf), "%s (stopped)",
934 strsignal (WSTOPSIG (status)));
935 else if (WIFSIGNALED (status))
936 snprintf (buf, sizeof (buf), "%s (terminated)",
937 strsignal (WSTOPSIG (status)));
939 snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
944 /* Initialize the list of LWPs. Note that this module, contrary to
945 what GDB's generic threads layer does for its thread list,
946 re-initializes the LWP lists whenever we mourn or detach (which
947 doesn't involve mourning) the inferior. */
952 struct lwp_info *lp, *lpnext;
954 for (lp = lwp_list; lp; lp = lpnext)
964 /* Add the LWP specified by PID to the list. Return a pointer to the
965 structure describing the new LWP. The LWP should already be stopped
966 (with an exception for the very first LWP). */
968 static struct lwp_info *
969 add_lwp (ptid_t ptid)
973 gdb_assert (is_lwp (ptid));
975 lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
977 memset (lp, 0, sizeof (struct lwp_info));
979 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
987 if (num_lwps > 1 && linux_nat_new_thread != NULL)
988 linux_nat_new_thread (ptid);
993 /* Remove the LWP specified by PID from the list. */
996 delete_lwp (ptid_t ptid)
998 struct lwp_info *lp, *lpprev;
1002 for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
1003 if (ptid_equal (lp->ptid, ptid))
1012 lpprev->next = lp->next;
1014 lwp_list = lp->next;
1019 /* Return a pointer to the structure describing the LWP corresponding
1020 to PID. If no corresponding LWP could be found, return NULL. */
1022 static struct lwp_info *
1023 find_lwp_pid (ptid_t ptid)
1025 struct lwp_info *lp;
1029 lwp = GET_LWP (ptid);
1031 lwp = GET_PID (ptid);
1033 for (lp = lwp_list; lp; lp = lp->next)
1034 if (lwp == GET_LWP (lp->ptid))
1040 /* Call CALLBACK with its second argument set to DATA for every LWP in
1041 the list. If CALLBACK returns 1 for a particular LWP, return a
1042 pointer to the structure describing that LWP immediately.
1043 Otherwise return NULL. */
1046 iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data)
1048 struct lwp_info *lp, *lpnext;
1050 for (lp = lwp_list; lp; lp = lpnext)
1053 if ((*callback) (lp, data))
1060 /* Update our internal state when changing from one fork (checkpoint,
1061 et cetera) to another indicated by NEW_PTID. We can only switch
1062 single-threaded applications, so we only create one new LWP, and
1063 the previous list is discarded. */
1066 linux_nat_switch_fork (ptid_t new_ptid)
1068 struct lwp_info *lp;
1070 init_thread_list ();
1072 lp = add_lwp (new_ptid);
1073 add_thread_silent (new_ptid);
1077 /* Record a PTID for later deletion. */
1082 struct saved_ptids *next;
1084 static struct saved_ptids *threads_to_delete;
1087 record_dead_thread (ptid_t ptid)
1089 struct saved_ptids *p = xmalloc (sizeof (struct saved_ptids));
1091 p->next = threads_to_delete;
1092 threads_to_delete = p;
1095 /* Delete any dead threads which are not the current thread. */
1100 struct saved_ptids **p = &threads_to_delete;
1103 if (! ptid_equal ((*p)->ptid, inferior_ptid))
1105 struct saved_ptids *tmp = *p;
1106 delete_thread (tmp->ptid);
1114 /* Handle the exit of a single thread LP. */
1117 exit_lwp (struct lwp_info *lp)
1119 struct thread_info *th = find_thread_pid (lp->ptid);
1123 if (print_thread_events)
1124 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
1126 /* Core GDB cannot deal with us deleting the current thread. */
1127 if (!ptid_equal (lp->ptid, inferior_ptid))
1128 delete_thread (lp->ptid);
1130 record_dead_thread (lp->ptid);
1133 delete_lwp (lp->ptid);
1136 /* Detect `T (stopped)' in `/proc/PID/status'.
1137 Other states including `T (tracing stop)' are reported as false. */
1140 pid_is_stopped (pid_t pid)
1146 snprintf (buf, sizeof (buf), "/proc/%d/status", (int) pid);
1147 status_file = fopen (buf, "r");
1148 if (status_file != NULL)
1152 while (fgets (buf, sizeof (buf), status_file))
1154 if (strncmp (buf, "State:", 6) == 0)
1160 if (have_state && strstr (buf, "T (stopped)") != NULL)
1162 fclose (status_file);
1167 /* Wait for the LWP specified by LP, which we have just attached to.
1168 Returns a wait status for that LWP, to cache. */
1171 linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
1174 pid_t new_pid, pid = GET_LWP (ptid);
1177 if (pid_is_stopped (pid))
1179 if (debug_linux_nat)
1180 fprintf_unfiltered (gdb_stdlog,
1181 "LNPAW: Attaching to a stopped process\n");
1183 /* The process is definitely stopped. It is in a job control
1184 stop, unless the kernel predates the TASK_STOPPED /
1185 TASK_TRACED distinction, in which case it might be in a
1186 ptrace stop. Make sure it is in a ptrace stop; from there we
1187 can kill it, signal it, et cetera.
1189 First make sure there is a pending SIGSTOP. Since we are
1190 already attached, the process can not transition from stopped
1191 to running without a PTRACE_CONT; so we know this signal will
1192 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1193 probably already in the queue (unless this kernel is old
1194 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1195 is not an RT signal, it can only be queued once. */
1196 kill_lwp (pid, SIGSTOP);
1198 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1199 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1200 ptrace (PTRACE_CONT, pid, 0, 0);
1203 /* Make sure the initial process is stopped. The user-level threads
1204 layer might want to poke around in the inferior, and that won't
1205 work if things haven't stabilized yet. */
1206 new_pid = my_waitpid (pid, &status, 0);
1207 if (new_pid == -1 && errno == ECHILD)
1210 warning (_("%s is a cloned process"), target_pid_to_str (ptid));
1212 /* Try again with __WCLONE to check cloned processes. */
1213 new_pid = my_waitpid (pid, &status, __WCLONE);
1217 gdb_assert (pid == new_pid && WIFSTOPPED (status));
1219 if (WSTOPSIG (status) != SIGSTOP)
1222 if (debug_linux_nat)
1223 fprintf_unfiltered (gdb_stdlog,
1224 "LNPAW: Received %s after attaching\n",
1225 status_to_str (status));
1231 /* Attach to the LWP specified by PID. Return 0 if successful or -1
1232 if the new LWP could not be attached. */
1235 lin_lwp_attach_lwp (ptid_t ptid)
1237 struct lwp_info *lp;
1238 enum sigchld_state async_events_original_state;
1240 gdb_assert (is_lwp (ptid));
1242 async_events_original_state = linux_nat_async_events (sigchld_sync);
1244 lp = find_lwp_pid (ptid);
1246 /* We assume that we're already attached to any LWP that has an id
1247 equal to the overall process id, and to any LWP that is already
1248 in our list of LWPs. If we're not seeing exit events from threads
1249 and we've had PID wraparound since we last tried to stop all threads,
1250 this assumption might be wrong; fortunately, this is very unlikely
1252 if (GET_LWP (ptid) != GET_PID (ptid) && lp == NULL)
1254 int status, cloned = 0, signalled = 0;
1256 if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
1258 /* If we fail to attach to the thread, issue a warning,
1259 but continue. One way this can happen is if thread
1260 creation is interrupted; as of Linux kernel 2.6.19, a
1261 bug may place threads in the thread list and then fail
1263 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
1264 safe_strerror (errno));
1268 if (debug_linux_nat)
1269 fprintf_unfiltered (gdb_stdlog,
1270 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1271 target_pid_to_str (ptid));
1273 status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
1274 lp = add_lwp (ptid);
1276 lp->cloned = cloned;
1277 lp->signalled = signalled;
1278 if (WSTOPSIG (status) != SIGSTOP)
1281 lp->status = status;
1284 target_post_attach (GET_LWP (lp->ptid));
1286 if (debug_linux_nat)
1288 fprintf_unfiltered (gdb_stdlog,
1289 "LLAL: waitpid %s received %s\n",
1290 target_pid_to_str (ptid),
1291 status_to_str (status));
1296 /* We assume that the LWP representing the original process is
1297 already stopped. Mark it as stopped in the data structure
1298 that the GNU/linux ptrace layer uses to keep track of
1299 threads. Note that this won't have already been done since
1300 the main thread will have, we assume, been stopped by an
1301 attach from a different layer. */
1303 lp = add_lwp (ptid);
1307 linux_nat_async_events (async_events_original_state);
1312 linux_nat_create_inferior (char *exec_file, char *allargs, char **env,
1315 int saved_async = 0;
1316 #ifdef HAVE_PERSONALITY
1317 int personality_orig = 0, personality_set = 0;
1318 #endif /* HAVE_PERSONALITY */
1320 /* The fork_child mechanism is synchronous and calls target_wait, so
1321 we have to mask the async mode. */
1323 if (target_can_async_p ())
1324 /* Mask async mode. Creating a child requires a loop calling
1325 wait_for_inferior currently. */
1326 saved_async = linux_nat_async_mask (0);
1329 /* Restore the original signal mask. */
1330 sigprocmask (SIG_SETMASK, &normal_mask, NULL);
1331 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1332 suspend_mask = normal_mask;
1333 sigdelset (&suspend_mask, SIGCHLD);
1336 /* Set SIGCHLD to the default action, until after execing the child,
1337 since the inferior inherits the superior's signal mask. It will
1338 be blocked again in linux_nat_wait, which is only reached after
1339 the inferior execing. */
1340 linux_nat_async_events (sigchld_default);
1342 #ifdef HAVE_PERSONALITY
1343 if (disable_randomization)
1346 personality_orig = personality (0xffffffff);
1347 if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
1349 personality_set = 1;
1350 personality (personality_orig | ADDR_NO_RANDOMIZE);
1352 if (errno != 0 || (personality_set
1353 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
1354 warning (_("Error disabling address space randomization: %s"),
1355 safe_strerror (errno));
1357 #endif /* HAVE_PERSONALITY */
1359 linux_ops->to_create_inferior (exec_file, allargs, env, from_tty);
1361 #ifdef HAVE_PERSONALITY
1362 if (personality_set)
1365 personality (personality_orig);
1367 warning (_("Error restoring address space randomization: %s"),
1368 safe_strerror (errno));
1370 #endif /* HAVE_PERSONALITY */
1373 linux_nat_async_mask (saved_async);
1377 linux_nat_attach (char *args, int from_tty)
1379 struct lwp_info *lp;
1382 /* FIXME: We should probably accept a list of process id's, and
1383 attach all of them. */
1384 linux_ops->to_attach (args, from_tty);
1386 if (!target_can_async_p ())
1388 /* Restore the original signal mask. */
1389 sigprocmask (SIG_SETMASK, &normal_mask, NULL);
1390 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1391 suspend_mask = normal_mask;
1392 sigdelset (&suspend_mask, SIGCHLD);
1395 /* Add the initial process as the first LWP to the list. */
1396 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid));
1397 lp = add_lwp (inferior_ptid);
1399 status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
1403 /* If this process is not using thread_db, then we still don't
1404 detect any other threads, but add at least this one. */
1405 add_thread_silent (lp->ptid);
1407 /* Save the wait status to report later. */
1409 if (debug_linux_nat)
1410 fprintf_unfiltered (gdb_stdlog,
1411 "LNA: waitpid %ld, saving status %s\n",
1412 (long) GET_PID (lp->ptid), status_to_str (status));
1414 if (!target_can_async_p ())
1415 lp->status = status;
1418 /* We already waited for this LWP, so put the wait result on the
1419 pipe. The event loop will wake up and gets us to handling
1421 linux_nat_event_pipe_push (GET_PID (lp->ptid), status,
1422 lp->cloned ? __WCLONE : 0);
1423 /* Register in the event loop. */
1424 target_async (inferior_event_handler, 0);
1428 /* Get pending status of LP. */
1430 get_pending_status (struct lwp_info *lp, int *status)
1432 struct target_waitstatus last;
1435 get_last_target_status (&last_ptid, &last);
1437 /* If this lwp is the ptid that GDB is processing an event from, the
1438 signal will be in stop_signal. Otherwise, in all-stop + sync
1439 mode, we may cache pending events in lp->status while trying to
1440 stop all threads (see stop_wait_callback). In async mode, the
1441 events are always cached in waitpid_queue. */
1444 if (GET_LWP (lp->ptid) == GET_LWP (last_ptid))
1446 if (stop_signal != TARGET_SIGNAL_0
1447 && signal_pass_state (stop_signal))
1448 *status = W_STOPCODE (target_signal_to_host (stop_signal));
1450 else if (target_can_async_p ())
1451 queued_waitpid (GET_LWP (lp->ptid), status, __WALL);
1453 *status = lp->status;
1459 detach_callback (struct lwp_info *lp, void *data)
1461 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1463 if (debug_linux_nat && lp->status)
1464 fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
1465 strsignal (WSTOPSIG (lp->status)),
1466 target_pid_to_str (lp->ptid));
1468 /* If there is a pending SIGSTOP, get rid of it. */
1471 if (debug_linux_nat)
1472 fprintf_unfiltered (gdb_stdlog,
1473 "DC: Sending SIGCONT to %s\n",
1474 target_pid_to_str (lp->ptid));
1476 kill_lwp (GET_LWP (lp->ptid), SIGCONT);
1480 /* We don't actually detach from the LWP that has an id equal to the
1481 overall process id just yet. */
1482 if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
1486 /* Pass on any pending signal for this LWP. */
1487 get_pending_status (lp, &status);
1490 if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
1491 WSTOPSIG (status)) < 0)
1492 error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1493 safe_strerror (errno));
1495 if (debug_linux_nat)
1496 fprintf_unfiltered (gdb_stdlog,
1497 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1498 target_pid_to_str (lp->ptid),
1499 strsignal (WSTOPSIG (lp->status)));
1501 delete_lwp (lp->ptid);
1508 linux_nat_detach (char *args, int from_tty)
1512 enum target_signal sig;
1514 if (target_can_async_p ())
1515 linux_nat_async (NULL, 0);
1517 iterate_over_lwps (detach_callback, NULL);
1519 /* Only the initial process should be left right now. */
1520 gdb_assert (num_lwps == 1);
1522 /* Pass on any pending signal for the last LWP. */
1523 if ((args == NULL || *args == '\0')
1524 && get_pending_status (lwp_list, &status) != -1
1525 && WIFSTOPPED (status))
1527 /* Put the signal number in ARGS so that inf_ptrace_detach will
1528 pass it along with PTRACE_DETACH. */
1530 sprintf (args, "%d", (int) WSTOPSIG (status));
1531 fprintf_unfiltered (gdb_stdlog,
1532 "LND: Sending signal %s to %s\n",
1534 target_pid_to_str (lwp_list->ptid));
1537 /* Destroy LWP info; it's no longer valid. */
1540 pid = GET_PID (inferior_ptid);
1541 inferior_ptid = pid_to_ptid (pid);
1542 linux_ops->to_detach (args, from_tty);
1544 if (target_can_async_p ())
1545 drain_queued_events (pid);
1551 resume_callback (struct lwp_info *lp, void *data)
1553 if (lp->stopped && lp->status == 0)
1555 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
1556 0, TARGET_SIGNAL_0);
1557 if (debug_linux_nat)
1558 fprintf_unfiltered (gdb_stdlog,
1559 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1560 target_pid_to_str (lp->ptid));
1563 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1570 resume_clear_callback (struct lwp_info *lp, void *data)
1577 resume_set_callback (struct lwp_info *lp, void *data)
1584 linux_nat_resume (ptid_t ptid, int step, enum target_signal signo)
1586 struct lwp_info *lp;
1589 if (debug_linux_nat)
1590 fprintf_unfiltered (gdb_stdlog,
1591 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1592 step ? "step" : "resume",
1593 target_pid_to_str (ptid),
1594 signo ? strsignal (signo) : "0",
1595 target_pid_to_str (inferior_ptid));
1599 if (target_can_async_p ())
1600 /* Block events while we're here. */
1601 linux_nat_async_events (sigchld_sync);
1603 /* A specific PTID means `step only this process id'. */
1604 resume_all = (PIDGET (ptid) == -1);
1607 iterate_over_lwps (resume_set_callback, NULL);
1609 iterate_over_lwps (resume_clear_callback, NULL);
1611 /* If PID is -1, it's the current inferior that should be
1612 handled specially. */
1613 if (PIDGET (ptid) == -1)
1614 ptid = inferior_ptid;
1616 lp = find_lwp_pid (ptid);
1617 gdb_assert (lp != NULL);
1619 ptid = pid_to_ptid (GET_LWP (lp->ptid));
1621 /* Remember if we're stepping. */
1624 /* Mark this LWP as resumed. */
1627 /* If we have a pending wait status for this thread, there is no
1628 point in resuming the process. But first make sure that
1629 linux_nat_wait won't preemptively handle the event - we
1630 should never take this short-circuit if we are going to
1631 leave LP running, since we have skipped resuming all the
1632 other threads. This bit of code needs to be synchronized
1633 with linux_nat_wait. */
1635 /* In async mode, we never have pending wait status. */
1636 if (target_can_async_p () && lp->status)
1637 internal_error (__FILE__, __LINE__, "Pending status in async mode");
1639 if (lp->status && WIFSTOPPED (lp->status))
1641 int saved_signo = target_signal_from_host (WSTOPSIG (lp->status));
1643 if (signal_stop_state (saved_signo) == 0
1644 && signal_print_state (saved_signo) == 0
1645 && signal_pass_state (saved_signo) == 1)
1647 if (debug_linux_nat)
1648 fprintf_unfiltered (gdb_stdlog,
1649 "LLR: Not short circuiting for ignored "
1650 "status 0x%x\n", lp->status);
1652 /* FIXME: What should we do if we are supposed to continue
1653 this thread with a signal? */
1654 gdb_assert (signo == TARGET_SIGNAL_0);
1655 signo = saved_signo;
1662 /* FIXME: What should we do if we are supposed to continue
1663 this thread with a signal? */
1664 gdb_assert (signo == TARGET_SIGNAL_0);
1666 if (debug_linux_nat)
1667 fprintf_unfiltered (gdb_stdlog,
1668 "LLR: Short circuiting for status 0x%x\n",
1674 /* Mark LWP as not stopped to prevent it from being continued by
1679 iterate_over_lwps (resume_callback, NULL);
1681 linux_ops->to_resume (ptid, step, signo);
1682 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1684 if (debug_linux_nat)
1685 fprintf_unfiltered (gdb_stdlog,
1686 "LLR: %s %s, %s (resume event thread)\n",
1687 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1688 target_pid_to_str (ptid),
1689 signo ? strsignal (signo) : "0");
1691 if (target_can_async_p ())
1692 target_async (inferior_event_handler, 0);
1695 /* Issue kill to specified lwp. */
1697 static int tkill_failed;
1700 kill_lwp (int lwpid, int signo)
1704 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1705 fails, then we are not using nptl threads and we should be using kill. */
1707 #ifdef HAVE_TKILL_SYSCALL
1710 int ret = syscall (__NR_tkill, lwpid, signo);
1711 if (errno != ENOSYS)
1718 return kill (lwpid, signo);
1721 /* Handle a GNU/Linux extended wait response. If we see a clone
1722 event, we need to add the new LWP to our list (and not report the
1723 trap to higher layers). This function returns non-zero if the
1724 event should be ignored and we should wait again. If STOPPING is
1725 true, the new LWP remains stopped, otherwise it is continued. */
1728 linux_handle_extended_wait (struct lwp_info *lp, int status,
1731 int pid = GET_LWP (lp->ptid);
1732 struct target_waitstatus *ourstatus = &lp->waitstatus;
1733 struct lwp_info *new_lp = NULL;
1734 int event = status >> 16;
1736 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1737 || event == PTRACE_EVENT_CLONE)
1739 unsigned long new_pid;
1742 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
1744 /* If we haven't already seen the new PID stop, wait for it now. */
1745 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1747 /* The new child has a pending SIGSTOP. We can't affect it until it
1748 hits the SIGSTOP, but we're already attached. */
1749 ret = my_waitpid (new_pid, &status,
1750 (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
1752 perror_with_name (_("waiting for new child"));
1753 else if (ret != new_pid)
1754 internal_error (__FILE__, __LINE__,
1755 _("wait returned unexpected PID %d"), ret);
1756 else if (!WIFSTOPPED (status))
1757 internal_error (__FILE__, __LINE__,
1758 _("wait returned unexpected status 0x%x"), status);
1761 ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
1763 if (event == PTRACE_EVENT_FORK)
1764 ourstatus->kind = TARGET_WAITKIND_FORKED;
1765 else if (event == PTRACE_EVENT_VFORK)
1766 ourstatus->kind = TARGET_WAITKIND_VFORKED;
1769 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1770 new_lp = add_lwp (BUILD_LWP (new_pid, GET_PID (inferior_ptid)));
1773 if (WSTOPSIG (status) != SIGSTOP)
1775 /* This can happen if someone starts sending signals to
1776 the new thread before it gets a chance to run, which
1777 have a lower number than SIGSTOP (e.g. SIGUSR1).
1778 This is an unlikely case, and harder to handle for
1779 fork / vfork than for clone, so we do not try - but
1780 we handle it for clone events here. We'll send
1781 the other signal on to the thread below. */
1783 new_lp->signalled = 1;
1789 new_lp->stopped = 1;
1792 new_lp->resumed = 1;
1793 ptrace (PTRACE_CONT,
1794 PIDGET (lp->waitstatus.value.related_pid), 0,
1795 status ? WSTOPSIG (status) : 0);
1798 if (debug_linux_nat)
1799 fprintf_unfiltered (gdb_stdlog,
1800 "LHEW: Got clone event from LWP %ld, resuming\n",
1801 GET_LWP (lp->ptid));
1802 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1810 if (event == PTRACE_EVENT_EXEC)
1812 ourstatus->kind = TARGET_WAITKIND_EXECD;
1813 ourstatus->value.execd_pathname
1814 = xstrdup (linux_child_pid_to_exec_file (pid));
1816 if (linux_parent_pid)
1818 detach_breakpoints (linux_parent_pid);
1819 ptrace (PTRACE_DETACH, linux_parent_pid, 0, 0);
1821 linux_parent_pid = 0;
1824 /* At this point, all inserted breakpoints are gone. Doing this
1825 as soon as we detect an exec prevents the badness of deleting
1826 a breakpoint writing the current "shadow contents" to lift
1827 the bp. That shadow is NOT valid after an exec.
1829 Note that we have to do this after the detach_breakpoints
1830 call above, otherwise breakpoints wouldn't be lifted from the
1831 parent on a vfork, because detach_breakpoints would think
1832 that breakpoints are not inserted. */
1833 mark_breakpoints_out ();
1837 internal_error (__FILE__, __LINE__,
1838 _("unknown ptrace event %d"), event);
1841 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1845 wait_lwp (struct lwp_info *lp)
1849 int thread_dead = 0;
1851 gdb_assert (!lp->stopped);
1852 gdb_assert (lp->status == 0);
1854 pid = my_waitpid (GET_LWP (lp->ptid), &status, 0);
1855 if (pid == -1 && errno == ECHILD)
1857 pid = my_waitpid (GET_LWP (lp->ptid), &status, __WCLONE);
1858 if (pid == -1 && errno == ECHILD)
1860 /* The thread has previously exited. We need to delete it
1861 now because, for some vendor 2.4 kernels with NPTL
1862 support backported, there won't be an exit event unless
1863 it is the main thread. 2.6 kernels will report an exit
1864 event for each thread that exits, as expected. */
1866 if (debug_linux_nat)
1867 fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
1868 target_pid_to_str (lp->ptid));
1874 gdb_assert (pid == GET_LWP (lp->ptid));
1876 if (debug_linux_nat)
1878 fprintf_unfiltered (gdb_stdlog,
1879 "WL: waitpid %s received %s\n",
1880 target_pid_to_str (lp->ptid),
1881 status_to_str (status));
1885 /* Check if the thread has exited. */
1886 if (WIFEXITED (status) || WIFSIGNALED (status))
1889 if (debug_linux_nat)
1890 fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
1891 target_pid_to_str (lp->ptid));
1900 gdb_assert (WIFSTOPPED (status));
1902 /* Handle GNU/Linux's extended waitstatus for trace events. */
1903 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
1905 if (debug_linux_nat)
1906 fprintf_unfiltered (gdb_stdlog,
1907 "WL: Handling extended status 0x%06x\n",
1909 if (linux_handle_extended_wait (lp, status, 1))
1910 return wait_lwp (lp);
1916 /* Save the most recent siginfo for LP. This is currently only called
1917 for SIGTRAP; some ports use the si_addr field for
1918 target_stopped_data_address. In the future, it may also be used to
1919 restore the siginfo of requeued signals. */
1922 save_siginfo (struct lwp_info *lp)
1925 ptrace (PTRACE_GETSIGINFO, GET_LWP (lp->ptid),
1926 (PTRACE_TYPE_ARG3) 0, &lp->siginfo);
1929 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1932 /* Send a SIGSTOP to LP. */
1935 stop_callback (struct lwp_info *lp, void *data)
1937 if (!lp->stopped && !lp->signalled)
1941 if (debug_linux_nat)
1943 fprintf_unfiltered (gdb_stdlog,
1944 "SC: kill %s **<SIGSTOP>**\n",
1945 target_pid_to_str (lp->ptid));
1948 ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP);
1949 if (debug_linux_nat)
1951 fprintf_unfiltered (gdb_stdlog,
1952 "SC: lwp kill %d %s\n",
1954 errno ? safe_strerror (errno) : "ERRNO-OK");
1958 gdb_assert (lp->status == 0);
1964 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
1965 a pointer to a set of signals to be flushed immediately. */
1968 stop_wait_callback (struct lwp_info *lp, void *data)
1970 sigset_t *flush_mask = data;
1976 status = wait_lwp (lp);
1980 /* Ignore any signals in FLUSH_MASK. */
1981 if (flush_mask && sigismember (flush_mask, WSTOPSIG (status)))
1990 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1991 if (debug_linux_nat)
1992 fprintf_unfiltered (gdb_stdlog,
1993 "PTRACE_CONT %s, 0, 0 (%s)\n",
1994 target_pid_to_str (lp->ptid),
1995 errno ? safe_strerror (errno) : "OK");
1997 return stop_wait_callback (lp, flush_mask);
2000 if (WSTOPSIG (status) != SIGSTOP)
2002 if (WSTOPSIG (status) == SIGTRAP)
2004 /* If a LWP other than the LWP that we're reporting an
2005 event for has hit a GDB breakpoint (as opposed to
2006 some random trap signal), then just arrange for it to
2007 hit it again later. We don't keep the SIGTRAP status
2008 and don't forward the SIGTRAP signal to the LWP. We
2009 will handle the current event, eventually we will
2010 resume all LWPs, and this one will get its breakpoint
2013 If we do not do this, then we run the risk that the
2014 user will delete or disable the breakpoint, but the
2015 thread will have already tripped on it. */
2017 /* Save the trap's siginfo in case we need it later. */
2020 /* Now resume this LWP and get the SIGSTOP event. */
2022 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2023 if (debug_linux_nat)
2025 fprintf_unfiltered (gdb_stdlog,
2026 "PTRACE_CONT %s, 0, 0 (%s)\n",
2027 target_pid_to_str (lp->ptid),
2028 errno ? safe_strerror (errno) : "OK");
2030 fprintf_unfiltered (gdb_stdlog,
2031 "SWC: Candidate SIGTRAP event in %s\n",
2032 target_pid_to_str (lp->ptid));
2034 /* Hold this event/waitstatus while we check to see if
2035 there are any more (we still want to get that SIGSTOP). */
2036 stop_wait_callback (lp, data);
2038 if (target_can_async_p ())
2040 /* Don't leave a pending wait status in async mode.
2041 Retrigger the breakpoint. */
2042 if (!cancel_breakpoint (lp))
2044 /* There was no gdb breakpoint set at pc. Put
2045 the event back in the queue. */
2046 if (debug_linux_nat)
2047 fprintf_unfiltered (gdb_stdlog,
2048 "SWC: kill %s, %s\n",
2049 target_pid_to_str (lp->ptid),
2050 status_to_str ((int) status));
2051 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
2056 /* Hold the SIGTRAP for handling by
2058 /* If there's another event, throw it back into the
2062 if (debug_linux_nat)
2063 fprintf_unfiltered (gdb_stdlog,
2064 "SWC: kill %s, %s\n",
2065 target_pid_to_str (lp->ptid),
2066 status_to_str ((int) status));
2067 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
2069 /* Save the sigtrap event. */
2070 lp->status = status;
2076 /* The thread was stopped with a signal other than
2077 SIGSTOP, and didn't accidentally trip a breakpoint. */
2079 if (debug_linux_nat)
2081 fprintf_unfiltered (gdb_stdlog,
2082 "SWC: Pending event %s in %s\n",
2083 status_to_str ((int) status),
2084 target_pid_to_str (lp->ptid));
2086 /* Now resume this LWP and get the SIGSTOP event. */
2088 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2089 if (debug_linux_nat)
2090 fprintf_unfiltered (gdb_stdlog,
2091 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
2092 target_pid_to_str (lp->ptid),
2093 errno ? safe_strerror (errno) : "OK");
2095 /* Hold this event/waitstatus while we check to see if
2096 there are any more (we still want to get that SIGSTOP). */
2097 stop_wait_callback (lp, data);
2099 /* If the lp->status field is still empty, use it to
2100 hold this event. If not, then this event must be
2101 returned to the event queue of the LWP. */
2102 if (lp->status || target_can_async_p ())
2104 if (debug_linux_nat)
2106 fprintf_unfiltered (gdb_stdlog,
2107 "SWC: kill %s, %s\n",
2108 target_pid_to_str (lp->ptid),
2109 status_to_str ((int) status));
2111 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
2114 lp->status = status;
2120 /* We caught the SIGSTOP that we intended to catch, so
2121 there's no SIGSTOP pending. */
2130 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
2131 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
2134 linux_nat_has_pending (int pid, sigset_t *pending, sigset_t *flush_mask)
2136 sigset_t blocked, ignored;
2139 linux_proc_pending_signals (pid, pending, &blocked, &ignored);
2144 for (i = 1; i < NSIG; i++)
2145 if (sigismember (pending, i))
2146 if (!sigismember (flush_mask, i)
2147 || sigismember (&blocked, i)
2148 || sigismember (&ignored, i))
2149 sigdelset (pending, i);
2151 if (sigisemptyset (pending))
2157 /* DATA is interpreted as a mask of signals to flush. If LP has
2158 signals pending, and they are all in the flush mask, then arrange
2159 to flush them. LP should be stopped, as should all other threads
2160 it might share a signal queue with. */
2163 flush_callback (struct lwp_info *lp, void *data)
2165 sigset_t *flush_mask = data;
2166 sigset_t pending, intersection, blocked, ignored;
2169 /* Normally, when an LWP exits, it is removed from the LWP list. The
2170 last LWP isn't removed till later, however. So if there is only
2171 one LWP on the list, make sure it's alive. */
2172 if (lwp_list == lp && lp->next == NULL)
2173 if (!linux_nat_thread_alive (lp->ptid))
2176 /* Just because the LWP is stopped doesn't mean that new signals
2177 can't arrive from outside, so this function must be careful of
2178 race conditions. However, because all threads are stopped, we
2179 can assume that the pending mask will not shrink unless we resume
2180 the LWP, and that it will then get another signal. We can't
2181 control which one, however. */
2185 if (debug_linux_nat)
2186 printf_unfiltered (_("FC: LP has pending status %06x\n"), lp->status);
2187 if (WIFSTOPPED (lp->status) && sigismember (flush_mask, WSTOPSIG (lp->status)))
2191 /* While there is a pending signal we would like to flush, continue
2192 the inferior and collect another signal. But if there's already
2193 a saved status that we don't want to flush, we can't resume the
2194 inferior - if it stopped for some other reason we wouldn't have
2195 anywhere to save the new status. In that case, we must leave the
2196 signal unflushed (and possibly generate an extra SIGINT stop).
2197 That's much less bad than losing a signal. */
2198 while (lp->status == 0
2199 && linux_nat_has_pending (GET_LWP (lp->ptid), &pending, flush_mask))
2204 ret = ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2205 if (debug_linux_nat)
2206 fprintf_unfiltered (gdb_stderr,
2207 "FC: Sent PTRACE_CONT, ret %d %d\n", ret, errno);
2210 stop_wait_callback (lp, flush_mask);
2211 if (debug_linux_nat)
2212 fprintf_unfiltered (gdb_stderr,
2213 "FC: Wait finished; saved status is %d\n",
2220 /* Return non-zero if LP has a wait status pending. */
2223 status_callback (struct lwp_info *lp, void *data)
2225 /* Only report a pending wait status if we pretend that this has
2226 indeed been resumed. */
2227 return (lp->status != 0 && lp->resumed);
2230 /* Return non-zero if LP isn't stopped. */
2233 running_callback (struct lwp_info *lp, void *data)
2235 return (lp->stopped == 0 || (lp->status != 0 && lp->resumed));
2238 /* Count the LWP's that have had events. */
2241 count_events_callback (struct lwp_info *lp, void *data)
2245 gdb_assert (count != NULL);
2247 /* Count only LWPs that have a SIGTRAP event pending. */
2249 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
2255 /* Select the LWP (if any) that is currently being single-stepped. */
2258 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
2260 if (lp->step && lp->status != 0)
2266 /* Select the Nth LWP that has had a SIGTRAP event. */
2269 select_event_lwp_callback (struct lwp_info *lp, void *data)
2271 int *selector = data;
2273 gdb_assert (selector != NULL);
2275 /* Select only LWPs that have a SIGTRAP event pending. */
2277 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
2278 if ((*selector)-- == 0)
2285 cancel_breakpoint (struct lwp_info *lp)
2287 /* Arrange for a breakpoint to be hit again later. We don't keep
2288 the SIGTRAP status and don't forward the SIGTRAP signal to the
2289 LWP. We will handle the current event, eventually we will resume
2290 this LWP, and this breakpoint will trap again.
2292 If we do not do this, then we run the risk that the user will
2293 delete or disable the breakpoint, but the LWP will have already
2296 struct regcache *regcache = get_thread_regcache (lp->ptid);
2297 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2300 pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
2301 if (breakpoint_inserted_here_p (pc))
2303 if (debug_linux_nat)
2304 fprintf_unfiltered (gdb_stdlog,
2305 "CB: Push back breakpoint for %s\n",
2306 target_pid_to_str (lp->ptid));
2308 /* Back up the PC if necessary. */
2309 if (gdbarch_decr_pc_after_break (gdbarch))
2310 regcache_write_pc (regcache, pc);
2318 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
2320 struct lwp_info *event_lp = data;
2322 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2326 /* If a LWP other than the LWP that we're reporting an event for has
2327 hit a GDB breakpoint (as opposed to some random trap signal),
2328 then just arrange for it to hit it again later. We don't keep
2329 the SIGTRAP status and don't forward the SIGTRAP signal to the
2330 LWP. We will handle the current event, eventually we will resume
2331 all LWPs, and this one will get its breakpoint trap again.
2333 If we do not do this, then we run the risk that the user will
2334 delete or disable the breakpoint, but the LWP will have already
2338 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
2339 && cancel_breakpoint (lp))
2340 /* Throw away the SIGTRAP. */
2346 /* Select one LWP out of those that have events pending. */
2349 select_event_lwp (struct lwp_info **orig_lp, int *status)
2352 int random_selector;
2353 struct lwp_info *event_lp;
2355 /* Record the wait status for the original LWP. */
2356 (*orig_lp)->status = *status;
2358 /* Give preference to any LWP that is being single-stepped. */
2359 event_lp = iterate_over_lwps (select_singlestep_lwp_callback, NULL);
2360 if (event_lp != NULL)
2362 if (debug_linux_nat)
2363 fprintf_unfiltered (gdb_stdlog,
2364 "SEL: Select single-step %s\n",
2365 target_pid_to_str (event_lp->ptid));
2369 /* No single-stepping LWP. Select one at random, out of those
2370 which have had SIGTRAP events. */
2372 /* First see how many SIGTRAP events we have. */
2373 iterate_over_lwps (count_events_callback, &num_events);
2375 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2376 random_selector = (int)
2377 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2379 if (debug_linux_nat && num_events > 1)
2380 fprintf_unfiltered (gdb_stdlog,
2381 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2382 num_events, random_selector);
2384 event_lp = iterate_over_lwps (select_event_lwp_callback,
2388 if (event_lp != NULL)
2390 /* Switch the event LWP. */
2391 *orig_lp = event_lp;
2392 *status = event_lp->status;
2395 /* Flush the wait status for the event LWP. */
2396 (*orig_lp)->status = 0;
2399 /* Return non-zero if LP has been resumed. */
2402 resumed_callback (struct lwp_info *lp, void *data)
2407 /* Stop an active thread, verify it still exists, then resume it. */
2410 stop_and_resume_callback (struct lwp_info *lp, void *data)
2412 struct lwp_info *ptr;
2414 if (!lp->stopped && !lp->signalled)
2416 stop_callback (lp, NULL);
2417 stop_wait_callback (lp, NULL);
2418 /* Resume if the lwp still exists. */
2419 for (ptr = lwp_list; ptr; ptr = ptr->next)
2422 resume_callback (lp, NULL);
2423 resume_set_callback (lp, NULL);
2429 /* Check if we should go on and pass this event to common code.
2430 Return the affected lwp if we are, or NULL otherwise. */
2431 static struct lwp_info *
2432 linux_nat_filter_event (int lwpid, int status, int options)
2434 struct lwp_info *lp;
2436 lp = find_lwp_pid (pid_to_ptid (lwpid));
2438 /* Check for stop events reported by a process we didn't already
2439 know about - anything not already in our LWP list.
2441 If we're expecting to receive stopped processes after
2442 fork, vfork, and clone events, then we'll just add the
2443 new one to our list and go back to waiting for the event
2444 to be reported - the stopped process might be returned
2445 from waitpid before or after the event is. */
2446 if (WIFSTOPPED (status) && !lp)
2448 linux_record_stopped_pid (lwpid, status);
2452 /* Make sure we don't report an event for the exit of an LWP not in
2453 our list, i.e. not part of the current process. This can happen
2454 if we detach from a program we original forked and then it
2456 if (!WIFSTOPPED (status) && !lp)
2459 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
2460 CLONE_PTRACE processes which do not use the thread library -
2461 otherwise we wouldn't find the new LWP this way. That doesn't
2462 currently work, and the following code is currently unreachable
2463 due to the two blocks above. If it's fixed some day, this code
2464 should be broken out into a function so that we can also pick up
2465 LWPs from the new interface. */
2468 lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
2469 if (options & __WCLONE)
2472 gdb_assert (WIFSTOPPED (status)
2473 && WSTOPSIG (status) == SIGSTOP);
2476 if (!in_thread_list (inferior_ptid))
2478 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
2479 GET_PID (inferior_ptid));
2480 add_thread (inferior_ptid);
2483 add_thread (lp->ptid);
2486 /* Save the trap's siginfo in case we need it later. */
2487 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
2490 /* Handle GNU/Linux's extended waitstatus for trace events. */
2491 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2493 if (debug_linux_nat)
2494 fprintf_unfiltered (gdb_stdlog,
2495 "LLW: Handling extended status 0x%06x\n",
2497 if (linux_handle_extended_wait (lp, status, 0))
2501 /* Check if the thread has exited. */
2502 if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1)
2504 /* If this is the main thread, we must stop all threads and
2505 verify if they are still alive. This is because in the nptl
2506 thread model, there is no signal issued for exiting LWPs
2507 other than the main thread. We only get the main thread exit
2508 signal once all child threads have already exited. If we
2509 stop all the threads and use the stop_wait_callback to check
2510 if they have exited we can determine whether this signal
2511 should be ignored or whether it means the end of the debugged
2512 application, regardless of which threading model is being
2514 if (GET_PID (lp->ptid) == GET_LWP (lp->ptid))
2517 iterate_over_lwps (stop_and_resume_callback, NULL);
2520 if (debug_linux_nat)
2521 fprintf_unfiltered (gdb_stdlog,
2522 "LLW: %s exited.\n",
2523 target_pid_to_str (lp->ptid));
2527 /* If there is at least one more LWP, then the exit signal was
2528 not the end of the debugged application and should be
2532 /* Make sure there is at least one thread running. */
2533 gdb_assert (iterate_over_lwps (running_callback, NULL));
2535 /* Discard the event. */
2540 /* Check if the current LWP has previously exited. In the nptl
2541 thread model, LWPs other than the main thread do not issue
2542 signals when they exit so we must check whenever the thread has
2543 stopped. A similar check is made in stop_wait_callback(). */
2544 if (num_lwps > 1 && !linux_nat_thread_alive (lp->ptid))
2546 if (debug_linux_nat)
2547 fprintf_unfiltered (gdb_stdlog,
2548 "LLW: %s exited.\n",
2549 target_pid_to_str (lp->ptid));
2553 /* Make sure there is at least one thread running. */
2554 gdb_assert (iterate_over_lwps (running_callback, NULL));
2556 /* Discard the event. */
2560 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2561 an attempt to stop an LWP. */
2563 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
2565 if (debug_linux_nat)
2566 fprintf_unfiltered (gdb_stdlog,
2567 "LLW: Delayed SIGSTOP caught for %s.\n",
2568 target_pid_to_str (lp->ptid));
2570 /* This is a delayed SIGSTOP. */
2573 registers_changed ();
2575 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
2576 lp->step, TARGET_SIGNAL_0);
2577 if (debug_linux_nat)
2578 fprintf_unfiltered (gdb_stdlog,
2579 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2581 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2582 target_pid_to_str (lp->ptid));
2585 gdb_assert (lp->resumed);
2587 /* Discard the event. */
2591 /* An interesting event. */
2596 /* Get the events stored in the pipe into the local queue, so they are
2597 accessible to queued_waitpid. We need to do this, since it is not
2598 always the case that the event at the head of the pipe is the event
2602 pipe_to_local_event_queue (void)
2604 if (debug_linux_nat_async)
2605 fprintf_unfiltered (gdb_stdlog,
2606 "PTLEQ: linux_nat_num_queued_events(%d)\n",
2607 linux_nat_num_queued_events);
2608 while (linux_nat_num_queued_events)
2610 int lwpid, status, options;
2611 lwpid = linux_nat_event_pipe_pop (&status, &options);
2612 gdb_assert (lwpid > 0);
2613 push_waitpid (lwpid, status, options);
2617 /* Get the unprocessed events stored in the local queue back into the
2618 pipe, so the event loop realizes there's something else to
2622 local_event_queue_to_pipe (void)
2624 struct waitpid_result *w = waitpid_queue;
2627 struct waitpid_result *next = w->next;
2628 linux_nat_event_pipe_push (w->pid,
2634 waitpid_queue = NULL;
2636 if (debug_linux_nat_async)
2637 fprintf_unfiltered (gdb_stdlog,
2638 "LEQTP: linux_nat_num_queued_events(%d)\n",
2639 linux_nat_num_queued_events);
2643 linux_nat_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
2645 struct lwp_info *lp = NULL;
2648 pid_t pid = PIDGET (ptid);
2649 sigset_t flush_mask;
2651 if (debug_linux_nat_async)
2652 fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
2654 /* The first time we get here after starting a new inferior, we may
2655 not have added it to the LWP list yet - this is the earliest
2656 moment at which we know its PID. */
2659 gdb_assert (!is_lwp (inferior_ptid));
2661 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
2662 GET_PID (inferior_ptid));
2663 lp = add_lwp (inferior_ptid);
2665 /* Add the main thread to GDB's thread list. */
2666 add_thread_silent (lp->ptid);
2669 sigemptyset (&flush_mask);
2671 /* Block events while we're here. */
2672 linux_nat_async_events (sigchld_sync);
2676 /* Make sure there is at least one LWP that has been resumed. */
2677 gdb_assert (iterate_over_lwps (resumed_callback, NULL));
2679 /* First check if there is a LWP with a wait status pending. */
2682 /* Any LWP that's been resumed will do. */
2683 lp = iterate_over_lwps (status_callback, NULL);
2686 if (target_can_async_p ())
2687 internal_error (__FILE__, __LINE__,
2688 "Found an LWP with a pending status in async mode.");
2690 status = lp->status;
2693 if (debug_linux_nat && status)
2694 fprintf_unfiltered (gdb_stdlog,
2695 "LLW: Using pending wait status %s for %s.\n",
2696 status_to_str (status),
2697 target_pid_to_str (lp->ptid));
2700 /* But if we don't find one, we'll have to wait, and check both
2701 cloned and uncloned processes. We start with the cloned
2703 options = __WCLONE | WNOHANG;
2705 else if (is_lwp (ptid))
2707 if (debug_linux_nat)
2708 fprintf_unfiltered (gdb_stdlog,
2709 "LLW: Waiting for specific LWP %s.\n",
2710 target_pid_to_str (ptid));
2712 /* We have a specific LWP to check. */
2713 lp = find_lwp_pid (ptid);
2715 status = lp->status;
2718 if (debug_linux_nat && status)
2719 fprintf_unfiltered (gdb_stdlog,
2720 "LLW: Using pending wait status %s for %s.\n",
2721 status_to_str (status),
2722 target_pid_to_str (lp->ptid));
2724 /* If we have to wait, take into account whether PID is a cloned
2725 process or not. And we have to convert it to something that
2726 the layer beneath us can understand. */
2727 options = lp->cloned ? __WCLONE : 0;
2728 pid = GET_LWP (ptid);
2731 if (status && lp->signalled)
2733 /* A pending SIGSTOP may interfere with the normal stream of
2734 events. In a typical case where interference is a problem,
2735 we have a SIGSTOP signal pending for LWP A while
2736 single-stepping it, encounter an event in LWP B, and take the
2737 pending SIGSTOP while trying to stop LWP A. After processing
2738 the event in LWP B, LWP A is continued, and we'll never see
2739 the SIGTRAP associated with the last time we were
2740 single-stepping LWP A. */
2742 /* Resume the thread. It should halt immediately returning the
2744 registers_changed ();
2745 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
2746 lp->step, TARGET_SIGNAL_0);
2747 if (debug_linux_nat)
2748 fprintf_unfiltered (gdb_stdlog,
2749 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
2750 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2751 target_pid_to_str (lp->ptid));
2753 gdb_assert (lp->resumed);
2755 /* This should catch the pending SIGSTOP. */
2756 stop_wait_callback (lp, NULL);
2759 if (!target_can_async_p ())
2761 /* Causes SIGINT to be passed on to the attached process. */
2770 if (target_can_async_p ())
2771 /* In async mode, don't ever block. Only look at the locally
2773 lwpid = queued_waitpid (pid, &status, options);
2775 lwpid = my_waitpid (pid, &status, options);
2779 gdb_assert (pid == -1 || lwpid == pid);
2781 if (debug_linux_nat)
2783 fprintf_unfiltered (gdb_stdlog,
2784 "LLW: waitpid %ld received %s\n",
2785 (long) lwpid, status_to_str (status));
2788 lp = linux_nat_filter_event (lwpid, status, options);
2791 /* A discarded event. */
2801 /* Alternate between checking cloned and uncloned processes. */
2802 options ^= __WCLONE;
2804 /* And every time we have checked both:
2805 In async mode, return to event loop;
2806 In sync mode, suspend waiting for a SIGCHLD signal. */
2807 if (options & __WCLONE)
2809 if (target_can_async_p ())
2811 /* No interesting event. */
2812 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2814 /* Get ready for the next event. */
2815 target_async (inferior_event_handler, 0);
2817 if (debug_linux_nat_async)
2818 fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
2820 return minus_one_ptid;
2823 sigsuspend (&suspend_mask);
2827 /* We shouldn't end up here unless we want to try again. */
2828 gdb_assert (status == 0);
2831 if (!target_can_async_p ())
2833 clear_sigio_trap ();
2834 clear_sigint_trap ();
2839 /* Don't report signals that GDB isn't interested in, such as
2840 signals that are neither printed nor stopped upon. Stopping all
2841 threads can be a bit time-consuming so if we want decent
2842 performance with heavily multi-threaded programs, especially when
2843 they're using a high frequency timer, we'd better avoid it if we
2846 if (WIFSTOPPED (status))
2848 int signo = target_signal_from_host (WSTOPSIG (status));
2850 /* If we get a signal while single-stepping, we may need special
2851 care, e.g. to skip the signal handler. Defer to common code. */
2853 && signal_stop_state (signo) == 0
2854 && signal_print_state (signo) == 0
2855 && signal_pass_state (signo) == 1)
2857 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2858 here? It is not clear we should. GDB may not expect
2859 other threads to run. On the other hand, not resuming
2860 newly attached threads may cause an unwanted delay in
2861 getting them running. */
2862 registers_changed ();
2863 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
2865 if (debug_linux_nat)
2866 fprintf_unfiltered (gdb_stdlog,
2867 "LLW: %s %s, %s (preempt 'handle')\n",
2869 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2870 target_pid_to_str (lp->ptid),
2871 signo ? strsignal (signo) : "0");
2877 if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
2879 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2880 forwarded to the entire process group, that is, all LWP's
2881 will receive it. Since we only want to report it once,
2882 we try to flush it from all LWPs except this one. */
2883 sigaddset (&flush_mask, SIGINT);
2887 /* This LWP is stopped now. */
2890 if (debug_linux_nat)
2891 fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
2892 status_to_str (status), target_pid_to_str (lp->ptid));
2894 /* Now stop all other LWP's ... */
2895 iterate_over_lwps (stop_callback, NULL);
2897 /* ... and wait until all of them have reported back that they're no
2899 iterate_over_lwps (stop_wait_callback, &flush_mask);
2900 iterate_over_lwps (flush_callback, &flush_mask);
2902 /* If we're not waiting for a specific LWP, choose an event LWP from
2903 among those that have had events. Giving equal priority to all
2904 LWPs that have had events helps prevent starvation. */
2906 select_event_lwp (&lp, &status);
2908 /* Now that we've selected our final event LWP, cancel any
2909 breakpoints in other LWPs that have hit a GDB breakpoint. See
2910 the comment in cancel_breakpoints_callback to find out why. */
2911 iterate_over_lwps (cancel_breakpoints_callback, lp);
2913 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
2915 if (debug_linux_nat)
2916 fprintf_unfiltered (gdb_stdlog,
2917 "LLW: trap ptid is %s.\n",
2918 target_pid_to_str (lp->ptid));
2921 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2923 *ourstatus = lp->waitstatus;
2924 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
2927 store_waitstatus (ourstatus, status);
2929 /* Get ready for the next event. */
2930 if (target_can_async_p ())
2931 target_async (inferior_event_handler, 0);
2933 if (debug_linux_nat_async)
2934 fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
2940 kill_callback (struct lwp_info *lp, void *data)
2943 ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
2944 if (debug_linux_nat)
2945 fprintf_unfiltered (gdb_stdlog,
2946 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
2947 target_pid_to_str (lp->ptid),
2948 errno ? safe_strerror (errno) : "OK");
2954 kill_wait_callback (struct lwp_info *lp, void *data)
2958 /* We must make sure that there are no pending events (delayed
2959 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
2960 program doesn't interfere with any following debugging session. */
2962 /* For cloned processes we must check both with __WCLONE and
2963 without, since the exit status of a cloned process isn't reported
2969 pid = my_waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
2970 if (pid != (pid_t) -1)
2972 if (debug_linux_nat)
2973 fprintf_unfiltered (gdb_stdlog,
2974 "KWC: wait %s received unknown.\n",
2975 target_pid_to_str (lp->ptid));
2976 /* The Linux kernel sometimes fails to kill a thread
2977 completely after PTRACE_KILL; that goes from the stop
2978 point in do_fork out to the one in
2979 get_signal_to_deliever and waits again. So kill it
2981 kill_callback (lp, NULL);
2984 while (pid == GET_LWP (lp->ptid));
2986 gdb_assert (pid == -1 && errno == ECHILD);
2991 pid = my_waitpid (GET_LWP (lp->ptid), NULL, 0);
2992 if (pid != (pid_t) -1)
2994 if (debug_linux_nat)
2995 fprintf_unfiltered (gdb_stdlog,
2996 "KWC: wait %s received unk.\n",
2997 target_pid_to_str (lp->ptid));
2998 /* See the call to kill_callback above. */
2999 kill_callback (lp, NULL);
3002 while (pid == GET_LWP (lp->ptid));
3004 gdb_assert (pid == -1 && errno == ECHILD);
3009 linux_nat_kill (void)
3011 struct target_waitstatus last;
3015 if (target_can_async_p ())
3016 target_async (NULL, 0);
3018 /* If we're stopped while forking and we haven't followed yet,
3019 kill the other task. We need to do this first because the
3020 parent will be sleeping if this is a vfork. */
3022 get_last_target_status (&last_ptid, &last);
3024 if (last.kind == TARGET_WAITKIND_FORKED
3025 || last.kind == TARGET_WAITKIND_VFORKED)
3027 ptrace (PT_KILL, PIDGET (last.value.related_pid), 0, 0);
3031 if (forks_exist_p ())
3033 linux_fork_killall ();
3034 drain_queued_events (-1);
3038 /* Kill all LWP's ... */
3039 iterate_over_lwps (kill_callback, NULL);
3041 /* ... and wait until we've flushed all events. */
3042 iterate_over_lwps (kill_wait_callback, NULL);
3045 target_mourn_inferior ();
3049 linux_nat_mourn_inferior (void)
3051 /* Destroy LWP info; it's no longer valid. */
3054 if (! forks_exist_p ())
3056 /* Normal case, no other forks available. */
3057 if (target_can_async_p ())
3058 linux_nat_async (NULL, 0);
3059 linux_ops->to_mourn_inferior ();
3062 /* Multi-fork case. The current inferior_ptid has exited, but
3063 there are other viable forks to debug. Delete the exiting
3064 one and context-switch to the first available. */
3065 linux_fork_mourn_inferior ();
3069 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
3070 const char *annex, gdb_byte *readbuf,
3071 const gdb_byte *writebuf,
3072 ULONGEST offset, LONGEST len)
3074 struct cleanup *old_chain = save_inferior_ptid ();
3077 if (is_lwp (inferior_ptid))
3078 inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
3080 xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
3083 do_cleanups (old_chain);
3088 linux_nat_thread_alive (ptid_t ptid)
3090 gdb_assert (is_lwp (ptid));
3093 ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0);
3094 if (debug_linux_nat)
3095 fprintf_unfiltered (gdb_stdlog,
3096 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
3097 target_pid_to_str (ptid),
3098 errno ? safe_strerror (errno) : "OK");
3100 /* Not every Linux kernel implements PTRACE_PEEKUSER. But we can
3101 handle that case gracefully since ptrace will first do a lookup
3102 for the process based upon the passed-in pid. If that fails we
3103 will get either -ESRCH or -EPERM, otherwise the child exists and
3105 if (errno == ESRCH || errno == EPERM)
3112 linux_nat_pid_to_str (ptid_t ptid)
3114 static char buf[64];
3117 && ((lwp_list && lwp_list->next)
3118 || GET_PID (ptid) != GET_LWP (ptid)))
3120 snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
3124 return normal_pid_to_str (ptid);
3128 sigchld_handler (int signo)
3130 if (linux_nat_async_enabled
3131 && linux_nat_async_events_state != sigchld_sync
3132 && signo == SIGCHLD)
3133 /* It is *always* a bug to hit this. */
3134 internal_error (__FILE__, __LINE__,
3135 "sigchld_handler called when async events are enabled");
3137 /* Do nothing. The only reason for this handler is that it allows
3138 us to use sigsuspend in linux_nat_wait above to wait for the
3139 arrival of a SIGCHLD. */
3142 /* Accepts an integer PID; Returns a string representing a file that
3143 can be opened to get the symbols for the child process. */
3146 linux_child_pid_to_exec_file (int pid)
3148 char *name1, *name2;
3150 name1 = xmalloc (MAXPATHLEN);
3151 name2 = xmalloc (MAXPATHLEN);
3152 make_cleanup (xfree, name1);
3153 make_cleanup (xfree, name2);
3154 memset (name2, 0, MAXPATHLEN);
3156 sprintf (name1, "/proc/%d/exe", pid);
3157 if (readlink (name1, name2, MAXPATHLEN) > 0)
3163 /* Service function for corefiles and info proc. */
3166 read_mapping (FILE *mapfile,
3171 char *device, long long *inode, char *filename)
3173 int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
3174 addr, endaddr, permissions, offset, device, inode);
3177 if (ret > 0 && ret != EOF)
3179 /* Eat everything up to EOL for the filename. This will prevent
3180 weird filenames (such as one with embedded whitespace) from
3181 confusing this code. It also makes this code more robust in
3182 respect to annotations the kernel may add after the filename.
3184 Note the filename is used for informational purposes
3186 ret += fscanf (mapfile, "%[^\n]\n", filename);
3189 return (ret != 0 && ret != EOF);
3192 /* Fills the "to_find_memory_regions" target vector. Lists the memory
3193 regions in the inferior for a corefile. */
3196 linux_nat_find_memory_regions (int (*func) (CORE_ADDR,
3198 int, int, int, void *), void *obfd)
3200 long long pid = PIDGET (inferior_ptid);
3201 char mapsfilename[MAXPATHLEN];
3203 long long addr, endaddr, size, offset, inode;
3204 char permissions[8], device[8], filename[MAXPATHLEN];
3205 int read, write, exec;
3208 /* Compose the filename for the /proc memory map, and open it. */
3209 sprintf (mapsfilename, "/proc/%lld/maps", pid);
3210 if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
3211 error (_("Could not open %s."), mapsfilename);
3214 fprintf_filtered (gdb_stdout,
3215 "Reading memory regions from %s\n", mapsfilename);
3217 /* Now iterate until end-of-file. */
3218 while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
3219 &offset, &device[0], &inode, &filename[0]))
3221 size = endaddr - addr;
3223 /* Get the segment's permissions. */
3224 read = (strchr (permissions, 'r') != 0);
3225 write = (strchr (permissions, 'w') != 0);
3226 exec = (strchr (permissions, 'x') != 0);
3230 fprintf_filtered (gdb_stdout,
3231 "Save segment, %lld bytes at 0x%s (%c%c%c)",
3232 size, paddr_nz (addr),
3234 write ? 'w' : ' ', exec ? 'x' : ' ');
3236 fprintf_filtered (gdb_stdout, " for %s", filename);
3237 fprintf_filtered (gdb_stdout, "\n");
3240 /* Invoke the callback function to create the corefile
3242 func (addr, size, read, write, exec, obfd);
3248 /* Records the thread's register state for the corefile note
3252 linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
3253 char *note_data, int *note_size)
3255 gdb_gregset_t gregs;
3256 gdb_fpregset_t fpregs;
3257 unsigned long lwp = ptid_get_lwp (ptid);
3258 struct regcache *regcache = get_thread_regcache (ptid);
3259 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3260 const struct regset *regset;
3262 struct cleanup *old_chain;
3263 struct core_regset_section *sect_list;
3266 old_chain = save_inferior_ptid ();
3267 inferior_ptid = ptid;
3268 target_fetch_registers (regcache, -1);
3269 do_cleanups (old_chain);
3271 core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
3272 sect_list = gdbarch_core_regset_sections (gdbarch);
3275 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
3276 sizeof (gregs))) != NULL
3277 && regset->collect_regset != NULL)
3278 regset->collect_regset (regset, regcache, -1,
3279 &gregs, sizeof (gregs));
3281 fill_gregset (regcache, &gregs, -1);
3283 note_data = (char *) elfcore_write_prstatus (obfd,
3287 stop_signal, &gregs);
3289 /* The loop below uses the new struct core_regset_section, which stores
3290 the supported section names and sizes for the core file. Note that
3291 note PRSTATUS needs to be treated specially. But the other notes are
3292 structurally the same, so they can benefit from the new struct. */
3293 if (core_regset_p && sect_list != NULL)
3294 while (sect_list->sect_name != NULL)
3296 /* .reg was already handled above. */
3297 if (strcmp (sect_list->sect_name, ".reg") == 0)
3302 regset = gdbarch_regset_from_core_section (gdbarch,
3303 sect_list->sect_name,
3305 gdb_assert (regset && regset->collect_regset);
3306 gdb_regset = xmalloc (sect_list->size);
3307 regset->collect_regset (regset, regcache, -1,
3308 gdb_regset, sect_list->size);
3309 note_data = (char *) elfcore_write_register_note (obfd,
3312 sect_list->sect_name,
3319 /* For architectures that does not have the struct core_regset_section
3320 implemented, we use the old method. When all the architectures have
3321 the new support, the code below should be deleted. */
3325 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
3326 sizeof (fpregs))) != NULL
3327 && regset->collect_regset != NULL)
3328 regset->collect_regset (regset, regcache, -1,
3329 &fpregs, sizeof (fpregs));
3331 fill_fpregset (regcache, &fpregs, -1);
3333 note_data = (char *) elfcore_write_prfpreg (obfd,
3336 &fpregs, sizeof (fpregs));
3342 struct linux_nat_corefile_thread_data
3350 /* Called by gdbthread.c once per thread. Records the thread's
3351 register state for the corefile note section. */
3354 linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
3356 struct linux_nat_corefile_thread_data *args = data;
3358 args->note_data = linux_nat_do_thread_registers (args->obfd,
3367 /* Records the register state for the corefile note section. */
3370 linux_nat_do_registers (bfd *obfd, ptid_t ptid,
3371 char *note_data, int *note_size)
3373 return linux_nat_do_thread_registers (obfd,
3374 ptid_build (ptid_get_pid (inferior_ptid),
3375 ptid_get_pid (inferior_ptid),
3377 note_data, note_size);
3380 /* Fills the "to_make_corefile_note" target vector. Builds the note
3381 section for a corefile, and returns it in a malloc buffer. */
3384 linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
3386 struct linux_nat_corefile_thread_data thread_args;
3387 struct cleanup *old_chain;
3388 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
3389 char fname[16] = { '\0' };
3390 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
3391 char psargs[80] = { '\0' };
3392 char *note_data = NULL;
3393 ptid_t current_ptid = inferior_ptid;
3397 if (get_exec_file (0))
3399 strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
3400 strncpy (psargs, get_exec_file (0), sizeof (psargs));
3401 if (get_inferior_args ())
3404 char *psargs_end = psargs + sizeof (psargs);
3406 /* linux_elfcore_write_prpsinfo () handles zero unterminated
3408 string_end = memchr (psargs, 0, sizeof (psargs));
3409 if (string_end != NULL)
3411 *string_end++ = ' ';
3412 strncpy (string_end, get_inferior_args (),
3413 psargs_end - string_end);
3416 note_data = (char *) elfcore_write_prpsinfo (obfd,
3418 note_size, fname, psargs);
3421 /* Dump information for threads. */
3422 thread_args.obfd = obfd;
3423 thread_args.note_data = note_data;
3424 thread_args.note_size = note_size;
3425 thread_args.num_notes = 0;
3426 iterate_over_lwps (linux_nat_corefile_thread_callback, &thread_args);
3427 if (thread_args.num_notes == 0)
3429 /* iterate_over_threads didn't come up with any threads; just
3430 use inferior_ptid. */
3431 note_data = linux_nat_do_registers (obfd, inferior_ptid,
3432 note_data, note_size);
3436 note_data = thread_args.note_data;
3439 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
3443 note_data = elfcore_write_note (obfd, note_data, note_size,
3444 "CORE", NT_AUXV, auxv, auxv_len);
3448 make_cleanup (xfree, note_data);
3452 /* Implement the "info proc" command. */
3455 linux_nat_info_proc_cmd (char *args, int from_tty)
3457 long long pid = PIDGET (inferior_ptid);
3460 char buffer[MAXPATHLEN];
3461 char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
3474 /* Break up 'args' into an argv array. */
3475 if ((argv = buildargv (args)) == NULL)
3478 make_cleanup_freeargv (argv);
3480 while (argv != NULL && *argv != NULL)
3482 if (isdigit (argv[0][0]))
3484 pid = strtoul (argv[0], NULL, 10);
3486 else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
3490 else if (strcmp (argv[0], "status") == 0)
3494 else if (strcmp (argv[0], "stat") == 0)
3498 else if (strcmp (argv[0], "cmd") == 0)
3502 else if (strncmp (argv[0], "exe", strlen (argv[0])) == 0)
3506 else if (strcmp (argv[0], "cwd") == 0)
3510 else if (strncmp (argv[0], "all", strlen (argv[0])) == 0)
3516 /* [...] (future options here) */
3521 error (_("No current process: you must name one."));
3523 sprintf (fname1, "/proc/%lld", pid);
3524 if (stat (fname1, &dummy) != 0)
3525 error (_("No /proc directory: '%s'"), fname1);
3527 printf_filtered (_("process %lld\n"), pid);
3528 if (cmdline_f || all)
3530 sprintf (fname1, "/proc/%lld/cmdline", pid);
3531 if ((procfile = fopen (fname1, "r")) != NULL)
3533 fgets (buffer, sizeof (buffer), procfile);
3534 printf_filtered ("cmdline = '%s'\n", buffer);
3538 warning (_("unable to open /proc file '%s'"), fname1);
3542 sprintf (fname1, "/proc/%lld/cwd", pid);
3543 memset (fname2, 0, sizeof (fname2));
3544 if (readlink (fname1, fname2, sizeof (fname2)) > 0)
3545 printf_filtered ("cwd = '%s'\n", fname2);
3547 warning (_("unable to read link '%s'"), fname1);
3551 sprintf (fname1, "/proc/%lld/exe", pid);
3552 memset (fname2, 0, sizeof (fname2));
3553 if (readlink (fname1, fname2, sizeof (fname2)) > 0)
3554 printf_filtered ("exe = '%s'\n", fname2);
3556 warning (_("unable to read link '%s'"), fname1);
3558 if (mappings_f || all)
3560 sprintf (fname1, "/proc/%lld/maps", pid);
3561 if ((procfile = fopen (fname1, "r")) != NULL)
3563 long long addr, endaddr, size, offset, inode;
3564 char permissions[8], device[8], filename[MAXPATHLEN];
3566 printf_filtered (_("Mapped address spaces:\n\n"));
3567 if (gdbarch_addr_bit (current_gdbarch) == 32)
3569 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
3572 " Size", " Offset", "objfile");
3576 printf_filtered (" %18s %18s %10s %10s %7s\n",
3579 " Size", " Offset", "objfile");
3582 while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
3583 &offset, &device[0], &inode, &filename[0]))
3585 size = endaddr - addr;
3587 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
3588 calls here (and possibly above) should be abstracted
3589 out into their own functions? Andrew suggests using
3590 a generic local_address_string instead to print out
3591 the addresses; that makes sense to me, too. */
3593 if (gdbarch_addr_bit (current_gdbarch) == 32)
3595 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
3596 (unsigned long) addr, /* FIXME: pr_addr */
3597 (unsigned long) endaddr,
3599 (unsigned int) offset,
3600 filename[0] ? filename : "");
3604 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
3605 (unsigned long) addr, /* FIXME: pr_addr */
3606 (unsigned long) endaddr,
3608 (unsigned int) offset,
3609 filename[0] ? filename : "");
3616 warning (_("unable to open /proc file '%s'"), fname1);
3618 if (status_f || all)
3620 sprintf (fname1, "/proc/%lld/status", pid);
3621 if ((procfile = fopen (fname1, "r")) != NULL)
3623 while (fgets (buffer, sizeof (buffer), procfile) != NULL)
3624 puts_filtered (buffer);
3628 warning (_("unable to open /proc file '%s'"), fname1);
3632 sprintf (fname1, "/proc/%lld/stat", pid);
3633 if ((procfile = fopen (fname1, "r")) != NULL)
3639 if (fscanf (procfile, "%d ", &itmp) > 0)
3640 printf_filtered (_("Process: %d\n"), itmp);
3641 if (fscanf (procfile, "(%[^)]) ", &buffer[0]) > 0)
3642 printf_filtered (_("Exec file: %s\n"), buffer);
3643 if (fscanf (procfile, "%c ", &ctmp) > 0)
3644 printf_filtered (_("State: %c\n"), ctmp);
3645 if (fscanf (procfile, "%d ", &itmp) > 0)
3646 printf_filtered (_("Parent process: %d\n"), itmp);
3647 if (fscanf (procfile, "%d ", &itmp) > 0)
3648 printf_filtered (_("Process group: %d\n"), itmp);
3649 if (fscanf (procfile, "%d ", &itmp) > 0)
3650 printf_filtered (_("Session id: %d\n"), itmp);
3651 if (fscanf (procfile, "%d ", &itmp) > 0)
3652 printf_filtered (_("TTY: %d\n"), itmp);
3653 if (fscanf (procfile, "%d ", &itmp) > 0)
3654 printf_filtered (_("TTY owner process group: %d\n"), itmp);
3655 if (fscanf (procfile, "%lu ", <mp) > 0)
3656 printf_filtered (_("Flags: 0x%lx\n"), ltmp);
3657 if (fscanf (procfile, "%lu ", <mp) > 0)
3658 printf_filtered (_("Minor faults (no memory page): %lu\n"),
3659 (unsigned long) ltmp);
3660 if (fscanf (procfile, "%lu ", <mp) > 0)
3661 printf_filtered (_("Minor faults, children: %lu\n"),
3662 (unsigned long) ltmp);
3663 if (fscanf (procfile, "%lu ", <mp) > 0)
3664 printf_filtered (_("Major faults (memory page faults): %lu\n"),
3665 (unsigned long) ltmp);
3666 if (fscanf (procfile, "%lu ", <mp) > 0)
3667 printf_filtered (_("Major faults, children: %lu\n"),
3668 (unsigned long) ltmp);
3669 if (fscanf (procfile, "%ld ", <mp) > 0)
3670 printf_filtered (_("utime: %ld\n"), ltmp);
3671 if (fscanf (procfile, "%ld ", <mp) > 0)
3672 printf_filtered (_("stime: %ld\n"), ltmp);
3673 if (fscanf (procfile, "%ld ", <mp) > 0)
3674 printf_filtered (_("utime, children: %ld\n"), ltmp);
3675 if (fscanf (procfile, "%ld ", <mp) > 0)
3676 printf_filtered (_("stime, children: %ld\n"), ltmp);
3677 if (fscanf (procfile, "%ld ", <mp) > 0)
3678 printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
3680 if (fscanf (procfile, "%ld ", <mp) > 0)
3681 printf_filtered (_("'nice' value: %ld\n"), ltmp);
3682 if (fscanf (procfile, "%lu ", <mp) > 0)
3683 printf_filtered (_("jiffies until next timeout: %lu\n"),
3684 (unsigned long) ltmp);
3685 if (fscanf (procfile, "%lu ", <mp) > 0)
3686 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
3687 (unsigned long) ltmp);
3688 if (fscanf (procfile, "%ld ", <mp) > 0)
3689 printf_filtered (_("start time (jiffies since system boot): %ld\n"),
3691 if (fscanf (procfile, "%lu ", <mp) > 0)
3692 printf_filtered (_("Virtual memory size: %lu\n"),
3693 (unsigned long) ltmp);
3694 if (fscanf (procfile, "%lu ", <mp) > 0)
3695 printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp);
3696 if (fscanf (procfile, "%lu ", <mp) > 0)
3697 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp);
3698 if (fscanf (procfile, "%lu ", <mp) > 0)
3699 printf_filtered (_("Start of text: 0x%lx\n"), ltmp);
3700 if (fscanf (procfile, "%lu ", <mp) > 0)
3701 printf_filtered (_("End of text: 0x%lx\n"), ltmp);
3702 if (fscanf (procfile, "%lu ", <mp) > 0)
3703 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp);
3704 #if 0 /* Don't know how architecture-dependent the rest is...
3705 Anyway the signal bitmap info is available from "status". */
3706 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
3707 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp);
3708 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
3709 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp);
3710 if (fscanf (procfile, "%ld ", <mp) > 0)
3711 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp);
3712 if (fscanf (procfile, "%ld ", <mp) > 0)
3713 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp);
3714 if (fscanf (procfile, "%ld ", <mp) > 0)
3715 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp);
3716 if (fscanf (procfile, "%ld ", <mp) > 0)
3717 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp);
3718 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
3719 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp);
3724 warning (_("unable to open /proc file '%s'"), fname1);
3728 /* Implement the to_xfer_partial interface for memory reads using the /proc
3729 filesystem. Because we can use a single read() call for /proc, this
3730 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3731 but it doesn't support writes. */
3734 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
3735 const char *annex, gdb_byte *readbuf,
3736 const gdb_byte *writebuf,
3737 ULONGEST offset, LONGEST len)
3743 if (object != TARGET_OBJECT_MEMORY || !readbuf)
3746 /* Don't bother for one word. */
3747 if (len < 3 * sizeof (long))
3750 /* We could keep this file open and cache it - possibly one per
3751 thread. That requires some juggling, but is even faster. */
3752 sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
3753 fd = open (filename, O_RDONLY | O_LARGEFILE);
3757 /* If pread64 is available, use it. It's faster if the kernel
3758 supports it (only one syscall), and it's 64-bit safe even on
3759 32-bit platforms (for instance, SPARC debugging a SPARC64
3762 if (pread64 (fd, readbuf, len, offset) != len)
3764 if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
3774 /* Parse LINE as a signal set and add its set bits to SIGS. */
3777 add_line_to_sigset (const char *line, sigset_t *sigs)
3779 int len = strlen (line) - 1;
3783 if (line[len] != '\n')
3784 error (_("Could not parse signal set: %s"), line);
3792 if (*p >= '0' && *p <= '9')
3794 else if (*p >= 'a' && *p <= 'f')
3795 digit = *p - 'a' + 10;
3797 error (_("Could not parse signal set: %s"), line);
3802 sigaddset (sigs, signum + 1);
3804 sigaddset (sigs, signum + 2);
3806 sigaddset (sigs, signum + 3);
3808 sigaddset (sigs, signum + 4);
3814 /* Find process PID's pending signals from /proc/pid/status and set
3818 linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored)
3821 char buffer[MAXPATHLEN], fname[MAXPATHLEN];
3824 sigemptyset (pending);
3825 sigemptyset (blocked);
3826 sigemptyset (ignored);
3827 sprintf (fname, "/proc/%d/status", pid);
3828 procfile = fopen (fname, "r");
3829 if (procfile == NULL)
3830 error (_("Could not open %s"), fname);
3832 while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
3834 /* Normal queued signals are on the SigPnd line in the status
3835 file. However, 2.6 kernels also have a "shared" pending
3836 queue for delivering signals to a thread group, so check for
3839 Unfortunately some Red Hat kernels include the shared pending
3840 queue but not the ShdPnd status field. */
3842 if (strncmp (buffer, "SigPnd:\t", 8) == 0)
3843 add_line_to_sigset (buffer + 8, pending);
3844 else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
3845 add_line_to_sigset (buffer + 8, pending);
3846 else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
3847 add_line_to_sigset (buffer + 8, blocked);
3848 else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
3849 add_line_to_sigset (buffer + 8, ignored);
3856 linux_xfer_partial (struct target_ops *ops, enum target_object object,
3857 const char *annex, gdb_byte *readbuf,
3858 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3862 if (object == TARGET_OBJECT_AUXV)
3863 return procfs_xfer_auxv (ops, object, annex, readbuf, writebuf,
3866 xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
3871 return super_xfer_partial (ops, object, annex, readbuf, writebuf,
3875 /* Create a prototype generic GNU/Linux target. The client can override
3876 it with local methods. */
3879 linux_target_install_ops (struct target_ops *t)
3881 t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
3882 t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
3883 t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
3884 t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
3885 t->to_post_startup_inferior = linux_child_post_startup_inferior;
3886 t->to_post_attach = linux_child_post_attach;
3887 t->to_follow_fork = linux_child_follow_fork;
3888 t->to_find_memory_regions = linux_nat_find_memory_regions;
3889 t->to_make_corefile_notes = linux_nat_make_corefile_notes;
3891 super_xfer_partial = t->to_xfer_partial;
3892 t->to_xfer_partial = linux_xfer_partial;
3898 struct target_ops *t;
3900 t = inf_ptrace_target ();
3901 linux_target_install_ops (t);
3907 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
3909 struct target_ops *t;
3911 t = inf_ptrace_trad_target (register_u_offset);
3912 linux_target_install_ops (t);
3917 /* Controls if async mode is permitted. */
3918 static int linux_async_permitted = 0;
3920 /* The set command writes to this variable. If the inferior is
3921 executing, linux_nat_async_permitted is *not* updated. */
3922 static int linux_async_permitted_1 = 0;
3925 set_maintenance_linux_async_permitted (char *args, int from_tty,
3926 struct cmd_list_element *c)
3928 if (target_has_execution)
3930 linux_async_permitted_1 = linux_async_permitted;
3931 error (_("Cannot change this setting while the inferior is running."));
3934 linux_async_permitted = linux_async_permitted_1;
3935 linux_nat_set_async_mode (linux_async_permitted);
3939 show_maintenance_linux_async_permitted (struct ui_file *file, int from_tty,
3940 struct cmd_list_element *c, const char *value)
3942 fprintf_filtered (file, _("\
3943 Controlling the GNU/Linux inferior in asynchronous mode is %s.\n"),
3947 /* target_is_async_p implementation. */
3950 linux_nat_is_async_p (void)
3952 /* NOTE: palves 2008-03-21: We're only async when the user requests
3953 it explicitly with the "maintenance set linux-async" command.
3954 Someday, linux will always be async. */
3955 if (!linux_async_permitted)
3961 /* target_can_async_p implementation. */
3964 linux_nat_can_async_p (void)
3966 /* NOTE: palves 2008-03-21: We're only async when the user requests
3967 it explicitly with the "maintenance set linux-async" command.
3968 Someday, linux will always be async. */
3969 if (!linux_async_permitted)
3972 /* See target.h/target_async_mask. */
3973 return linux_nat_async_mask_value;
3976 /* target_async_mask implementation. */
3979 linux_nat_async_mask (int mask)
3982 current_state = linux_nat_async_mask_value;
3984 if (current_state != mask)
3988 linux_nat_async (NULL, 0);
3989 linux_nat_async_mask_value = mask;
3993 linux_nat_async_mask_value = mask;
3994 linux_nat_async (inferior_event_handler, 0);
3998 return current_state;
4001 /* Pop an event from the event pipe. */
4004 linux_nat_event_pipe_pop (int* ptr_status, int* ptr_options)
4006 struct waitpid_result event = {0};
4011 ret = read (linux_nat_event_pipe[0], &event, sizeof (event));
4013 while (ret == -1 && errno == EINTR);
4015 gdb_assert (ret == sizeof (event));
4017 *ptr_status = event.status;
4018 *ptr_options = event.options;
4020 linux_nat_num_queued_events--;
4025 /* Push an event into the event pipe. */
4028 linux_nat_event_pipe_push (int pid, int status, int options)
4031 struct waitpid_result event = {0};
4033 event.status = status;
4034 event.options = options;
4038 ret = write (linux_nat_event_pipe[1], &event, sizeof (event));
4039 gdb_assert ((ret == -1 && errno == EINTR) || ret == sizeof (event));
4040 } while (ret == -1 && errno == EINTR);
4042 linux_nat_num_queued_events++;
4046 get_pending_events (void)
4048 int status, options, pid;
4050 if (!linux_nat_async_enabled
4051 || linux_nat_async_events_state != sigchld_async)
4052 internal_error (__FILE__, __LINE__,
4053 "get_pending_events called with async masked");
4058 options = __WCLONE | WNOHANG;
4062 pid = waitpid (-1, &status, options);
4064 while (pid == -1 && errno == EINTR);
4071 pid = waitpid (-1, &status, options);
4073 while (pid == -1 && errno == EINTR);
4077 /* No more children reporting events. */
4080 if (debug_linux_nat_async)
4081 fprintf_unfiltered (gdb_stdlog, "\
4082 get_pending_events: pid(%d), status(%x), options (%x)\n",
4083 pid, status, options);
4085 linux_nat_event_pipe_push (pid, status, options);
4088 if (debug_linux_nat_async)
4089 fprintf_unfiltered (gdb_stdlog, "\
4090 get_pending_events: linux_nat_num_queued_events(%d)\n",
4091 linux_nat_num_queued_events);
4094 /* SIGCHLD handler for async mode. */
4097 async_sigchld_handler (int signo)
4099 if (debug_linux_nat_async)
4100 fprintf_unfiltered (gdb_stdlog, "async_sigchld_handler\n");
4102 get_pending_events ();
4105 /* Set SIGCHLD handling state to STATE. Returns previous state. */
4107 static enum sigchld_state
4108 linux_nat_async_events (enum sigchld_state state)
4110 enum sigchld_state current_state = linux_nat_async_events_state;
4112 if (debug_linux_nat_async)
4113 fprintf_unfiltered (gdb_stdlog,
4114 "LNAE: state(%d): linux_nat_async_events_state(%d), "
4115 "linux_nat_num_queued_events(%d)\n",
4116 state, linux_nat_async_events_state,
4117 linux_nat_num_queued_events);
4119 if (current_state != state)
4122 sigemptyset (&mask);
4123 sigaddset (&mask, SIGCHLD);
4125 /* Always block before changing state. */
4126 sigprocmask (SIG_BLOCK, &mask, NULL);
4128 /* Set new state. */
4129 linux_nat_async_events_state = state;
4135 /* Block target events. */
4136 sigprocmask (SIG_BLOCK, &mask, NULL);
4137 sigaction (SIGCHLD, &sync_sigchld_action, NULL);
4138 /* Get events out of queue, and make them available to
4139 queued_waitpid / my_waitpid. */
4140 pipe_to_local_event_queue ();
4145 /* Unblock target events for async mode. */
4147 sigprocmask (SIG_BLOCK, &mask, NULL);
4149 /* Put events we already waited on, in the pipe first, so
4151 local_event_queue_to_pipe ();
4152 /* While in masked async, we may have not collected all
4153 the pending events. Get them out now. */
4154 get_pending_events ();
4157 sigaction (SIGCHLD, &async_sigchld_action, NULL);
4158 sigprocmask (SIG_UNBLOCK, &mask, NULL);
4161 case sigchld_default:
4163 /* SIGCHLD default mode. */
4164 sigaction (SIGCHLD, &sigchld_default_action, NULL);
4166 /* Get events out of queue, and make them available to
4167 queued_waitpid / my_waitpid. */
4168 pipe_to_local_event_queue ();
4170 /* Unblock SIGCHLD. */
4171 sigprocmask (SIG_UNBLOCK, &mask, NULL);
4177 return current_state;
4180 static int async_terminal_is_ours = 1;
4182 /* target_terminal_inferior implementation. */
4185 linux_nat_terminal_inferior (void)
4187 if (!target_is_async_p ())
4189 /* Async mode is disabled. */
4190 terminal_inferior ();
4194 /* GDB should never give the terminal to the inferior, if the
4195 inferior is running in the background (run&, continue&, etc.).
4196 This check can be removed when the common code is fixed. */
4197 if (!sync_execution)
4200 terminal_inferior ();
4202 if (!async_terminal_is_ours)
4205 delete_file_handler (input_fd);
4206 async_terminal_is_ours = 0;
4210 /* target_terminal_ours implementation. */
4213 linux_nat_terminal_ours (void)
4215 if (!target_is_async_p ())
4217 /* Async mode is disabled. */
4222 /* GDB should never give the terminal to the inferior if the
4223 inferior is running in the background (run&, continue&, etc.),
4224 but claiming it sure should. */
4227 if (!sync_execution)
4230 if (async_terminal_is_ours)
4233 clear_sigint_trap ();
4234 add_file_handler (input_fd, stdin_event_handler, 0);
4235 async_terminal_is_ours = 1;
4238 static void (*async_client_callback) (enum inferior_event_type event_type,
4240 static void *async_client_context;
4243 linux_nat_async_file_handler (int error, gdb_client_data client_data)
4245 async_client_callback (INF_REG_EVENT, async_client_context);
4248 /* target_async implementation. */
4251 linux_nat_async (void (*callback) (enum inferior_event_type event_type,
4252 void *context), void *context)
4254 if (linux_nat_async_mask_value == 0 || !linux_nat_async_enabled)
4255 internal_error (__FILE__, __LINE__,
4256 "Calling target_async when async is masked");
4258 if (callback != NULL)
4260 async_client_callback = callback;
4261 async_client_context = context;
4262 add_file_handler (linux_nat_event_pipe[0],
4263 linux_nat_async_file_handler, NULL);
4265 linux_nat_async_events (sigchld_async);
4269 async_client_callback = callback;
4270 async_client_context = context;
4272 linux_nat_async_events (sigchld_sync);
4273 delete_file_handler (linux_nat_event_pipe[0]);
4278 /* Enable/Disable async mode. */
4281 linux_nat_set_async_mode (int on)
4283 if (linux_nat_async_enabled != on)
4287 gdb_assert (waitpid_queue == NULL);
4288 if (pipe (linux_nat_event_pipe) == -1)
4289 internal_error (__FILE__, __LINE__,
4290 "creating event pipe failed.");
4291 fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
4292 fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
4296 drain_queued_events (-1);
4297 linux_nat_num_queued_events = 0;
4298 close (linux_nat_event_pipe[0]);
4299 close (linux_nat_event_pipe[1]);
4300 linux_nat_event_pipe[0] = linux_nat_event_pipe[1] = -1;
4304 linux_nat_async_enabled = on;
4308 linux_nat_add_target (struct target_ops *t)
4310 /* Save the provided single-threaded target. We save this in a separate
4311 variable because another target we've inherited from (e.g. inf-ptrace)
4312 may have saved a pointer to T; we want to use it for the final
4313 process stratum target. */
4314 linux_ops_saved = *t;
4315 linux_ops = &linux_ops_saved;
4317 /* Override some methods for multithreading. */
4318 t->to_create_inferior = linux_nat_create_inferior;
4319 t->to_attach = linux_nat_attach;
4320 t->to_detach = linux_nat_detach;
4321 t->to_resume = linux_nat_resume;
4322 t->to_wait = linux_nat_wait;
4323 t->to_xfer_partial = linux_nat_xfer_partial;
4324 t->to_kill = linux_nat_kill;
4325 t->to_mourn_inferior = linux_nat_mourn_inferior;
4326 t->to_thread_alive = linux_nat_thread_alive;
4327 t->to_pid_to_str = linux_nat_pid_to_str;
4328 t->to_has_thread_control = tc_schedlock;
4330 t->to_can_async_p = linux_nat_can_async_p;
4331 t->to_is_async_p = linux_nat_is_async_p;
4332 t->to_async = linux_nat_async;
4333 t->to_async_mask = linux_nat_async_mask;
4334 t->to_terminal_inferior = linux_nat_terminal_inferior;
4335 t->to_terminal_ours = linux_nat_terminal_ours;
4337 /* We don't change the stratum; this target will sit at
4338 process_stratum and thread_db will set at thread_stratum. This
4339 is a little strange, since this is a multi-threaded-capable
4340 target, but we want to be on the stack below thread_db, and we
4341 also want to be used for single-threaded processes. */
4345 /* TODO: Eliminate this and have libthread_db use
4346 find_target_beneath. */
4350 /* Register a method to call whenever a new thread is attached. */
4352 linux_nat_set_new_thread (struct target_ops *t, void (*new_thread) (ptid_t))
4354 /* Save the pointer. We only support a single registered instance
4355 of the GNU/Linux native target, so we do not need to map this to
4357 linux_nat_new_thread = new_thread;
4360 /* Return the saved siginfo associated with PTID. */
4362 linux_nat_get_siginfo (ptid_t ptid)
4364 struct lwp_info *lp = find_lwp_pid (ptid);
4366 gdb_assert (lp != NULL);
4368 return &lp->siginfo;
4372 _initialize_linux_nat (void)
4376 add_info ("proc", linux_nat_info_proc_cmd, _("\
4377 Show /proc process information about any running process.\n\
4378 Specify any process id, or use the program being debugged by default.\n\
4379 Specify any of the following keywords for detailed info:\n\
4380 mappings -- list of mapped memory regions.\n\
4381 stat -- list a bunch of random process info.\n\
4382 status -- list a different bunch of random process info.\n\
4383 all -- list all available /proc info."));
4385 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance,
4386 &debug_linux_nat, _("\
4387 Set debugging of GNU/Linux lwp module."), _("\
4388 Show debugging of GNU/Linux lwp module."), _("\
4389 Enables printf debugging output."),
4391 show_debug_linux_nat,
4392 &setdebuglist, &showdebuglist);
4394 add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance,
4395 &debug_linux_nat_async, _("\
4396 Set debugging of GNU/Linux async lwp module."), _("\
4397 Show debugging of GNU/Linux async lwp module."), _("\
4398 Enables printf debugging output."),
4400 show_debug_linux_nat_async,
4401 &setdebuglist, &showdebuglist);
4403 add_setshow_boolean_cmd ("linux-async", class_maintenance,
4404 &linux_async_permitted_1, _("\
4405 Set whether gdb controls the GNU/Linux inferior in asynchronous mode."), _("\
4406 Show whether gdb controls the GNU/Linux inferior in asynchronous mode."), _("\
4407 Tells gdb whether to control the GNU/Linux inferior in asynchronous mode."),
4408 set_maintenance_linux_async_permitted,
4409 show_maintenance_linux_async_permitted,
4410 &maintenance_set_cmdlist,
4411 &maintenance_show_cmdlist);
4413 /* Get the default SIGCHLD action. Used while forking an inferior
4414 (see linux_nat_create_inferior/linux_nat_async_events). */
4415 sigaction (SIGCHLD, NULL, &sigchld_default_action);
4417 /* Block SIGCHLD by default. Doing this early prevents it getting
4418 unblocked if an exception is thrown due to an error while the
4419 inferior is starting (sigsetjmp/siglongjmp). */
4420 sigemptyset (&mask);
4421 sigaddset (&mask, SIGCHLD);
4422 sigprocmask (SIG_BLOCK, &mask, NULL);
4424 /* Save this mask as the default. */
4425 sigprocmask (SIG_SETMASK, NULL, &normal_mask);
4427 /* The synchronous SIGCHLD handler. */
4428 sync_sigchld_action.sa_handler = sigchld_handler;
4429 sigemptyset (&sync_sigchld_action.sa_mask);
4430 sync_sigchld_action.sa_flags = SA_RESTART;
4432 /* Make it the default. */
4433 sigaction (SIGCHLD, &sync_sigchld_action, NULL);
4435 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4436 sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
4437 sigdelset (&suspend_mask, SIGCHLD);
4439 /* SIGCHLD handler for async mode. */
4440 async_sigchld_action.sa_handler = async_sigchld_handler;
4441 sigemptyset (&async_sigchld_action.sa_mask);
4442 async_sigchld_action.sa_flags = SA_RESTART;
4444 /* Install the default mode. */
4445 linux_nat_set_async_mode (linux_async_permitted);
4447 add_setshow_boolean_cmd ("disable-randomization", class_support,
4448 &disable_randomization, _("\
4449 Set disabling of debuggee's virtual address space randomization."), _("\
4450 Show disabling of debuggee's virtual address space randomization."), _("\
4451 When this mode is on (which is the default), randomization of the virtual\n\
4452 address space is disabled. Standalone programs run with the randomization\n\
4453 enabled by default on some platforms."),
4454 &set_disable_randomization,
4455 &show_disable_randomization,
4456 &setlist, &showlist);
4460 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4461 the GNU/Linux Threads library and therefore doesn't really belong
4464 /* Read variable NAME in the target and return its value if found.
4465 Otherwise return zero. It is assumed that the type of the variable
4469 get_signo (const char *name)
4471 struct minimal_symbol *ms;
4474 ms = lookup_minimal_symbol (name, NULL, NULL);
4478 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
4479 sizeof (signo)) != 0)
4485 /* Return the set of signals used by the threads library in *SET. */
4488 lin_thread_get_thread_signals (sigset_t *set)
4490 struct sigaction action;
4491 int restart, cancel;
4492 sigset_t blocked_mask;
4494 sigemptyset (&blocked_mask);
4497 restart = get_signo ("__pthread_sig_restart");
4498 cancel = get_signo ("__pthread_sig_cancel");
4500 /* LinuxThreads normally uses the first two RT signals, but in some legacy
4501 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
4502 not provide any way for the debugger to query the signal numbers -
4503 fortunately they don't change! */
4506 restart = __SIGRTMIN;
4509 cancel = __SIGRTMIN + 1;
4511 sigaddset (set, restart);
4512 sigaddset (set, cancel);
4514 /* The GNU/Linux Threads library makes terminating threads send a
4515 special "cancel" signal instead of SIGCHLD. Make sure we catch
4516 those (to prevent them from terminating GDB itself, which is
4517 likely to be their default action) and treat them the same way as
4520 action.sa_handler = sigchld_handler;
4521 sigemptyset (&action.sa_mask);
4522 action.sa_flags = SA_RESTART;
4523 sigaction (cancel, &action, NULL);
4525 /* We block the "cancel" signal throughout this code ... */
4526 sigaddset (&blocked_mask, cancel);
4527 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
4529 /* ... except during a sigsuspend. */
4530 sigdelset (&suspend_mask, cancel);