1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 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 #include <sys/types.h>
54 #include "gdb_dirent.h"
55 #include "xml-support.h"
61 #define SPUFS_MAGIC 0x23c9b64e
64 #ifdef HAVE_PERSONALITY
65 # include <sys/personality.h>
66 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
67 # define ADDR_NO_RANDOMIZE 0x0040000
69 #endif /* HAVE_PERSONALITY */
71 /* This comment documents high-level logic of this file.
73 Waiting for events in sync mode
74 ===============================
76 When waiting for an event in a specific thread, we just use waitpid, passing
77 the specific pid, and not passing WNOHANG.
79 When waiting for an event in all threads, waitpid is not quite good. Prior to
80 version 2.4, Linux can either wait for event in main thread, or in secondary
81 threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
82 miss an event. The solution is to use non-blocking waitpid, together with
83 sigsuspend. First, we use non-blocking waitpid to get an event in the main
84 process, if any. Second, we use non-blocking waitpid with the __WCLONED
85 flag to check for events in cloned processes. If nothing is found, we use
86 sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
87 happened to a child process -- and SIGCHLD will be delivered both for events
88 in main debugged process and in cloned processes. As soon as we know there's
89 an event, we get back to calling nonblocking waitpid with and without
92 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
93 so that we don't miss a signal. If SIGCHLD arrives in between, when it's
94 blocked, the signal becomes pending and sigsuspend immediately
95 notices it and returns.
97 Waiting for events in async mode
98 ================================
100 In async mode, GDB should always be ready to handle both user input
101 and target events, so neither blocking waitpid nor sigsuspend are
102 viable options. Instead, we should asynchronously notify the GDB main
103 event loop whenever there's an unprocessed event from the target. We
104 detect asynchronous target events by handling SIGCHLD signals. To
105 notify the event loop about target events, the self-pipe trick is used
106 --- a pipe is registered as waitable event source in the event loop,
107 the event loop select/poll's on the read end of this pipe (as well on
108 other event sources, e.g., stdin), and the SIGCHLD handler writes a
109 byte to this pipe. This is more portable than relying on
110 pselect/ppoll, since on kernels that lack those syscalls, libc
111 emulates them with select/poll+sigprocmask, and that is racy
112 (a.k.a. plain broken).
114 Obviously, if we fail to notify the event loop if there's a target
115 event, it's bad. OTOH, if we notify the event loop when there's no
116 event from the target, linux_nat_wait will detect that there's no real
117 event to report, and return event of type TARGET_WAITKIND_IGNORE.
118 This is mostly harmless, but it will waste time and is better avoided.
120 The main design point is that every time GDB is outside linux-nat.c,
121 we have a SIGCHLD handler installed that is called when something
122 happens to the target and notifies the GDB event loop. Whenever GDB
123 core decides to handle the event, and calls into linux-nat.c, we
124 process things as in sync mode, except that the we never block in
127 While processing an event, we may end up momentarily blocked in
128 waitpid calls. Those waitpid calls, while blocking, are guarantied to
129 return quickly. E.g., in all-stop mode, before reporting to the core
130 that an LWP hit a breakpoint, all LWPs are stopped by sending them
131 SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
132 Note that this is different from blocking indefinitely waiting for the
133 next event --- here, we're already handling an event.
138 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
139 signal is not entirely significant; we just need for a signal to be delivered,
140 so that we can intercept it. SIGSTOP's advantage is that it can not be
141 blocked. A disadvantage is that it is not a real-time signal, so it can only
142 be queued once; we do not keep track of other sources of SIGSTOP.
144 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
145 use them, because they have special behavior when the signal is generated -
146 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
147 kills the entire thread group.
149 A delivered SIGSTOP would stop the entire thread group, not just the thread we
150 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
151 cancel it (by PTRACE_CONT without passing SIGSTOP).
153 We could use a real-time signal instead. This would solve those problems; we
154 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
155 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
156 generates it, and there are races with trying to find a signal that is not
160 #define O_LARGEFILE 0
163 /* If the system headers did not provide the constants, hard-code the normal
165 #ifndef PTRACE_EVENT_FORK
167 #define PTRACE_SETOPTIONS 0x4200
168 #define PTRACE_GETEVENTMSG 0x4201
170 /* options set using PTRACE_SETOPTIONS */
171 #define PTRACE_O_TRACESYSGOOD 0x00000001
172 #define PTRACE_O_TRACEFORK 0x00000002
173 #define PTRACE_O_TRACEVFORK 0x00000004
174 #define PTRACE_O_TRACECLONE 0x00000008
175 #define PTRACE_O_TRACEEXEC 0x00000010
176 #define PTRACE_O_TRACEVFORKDONE 0x00000020
177 #define PTRACE_O_TRACEEXIT 0x00000040
179 /* Wait extended result codes for the above trace options. */
180 #define PTRACE_EVENT_FORK 1
181 #define PTRACE_EVENT_VFORK 2
182 #define PTRACE_EVENT_CLONE 3
183 #define PTRACE_EVENT_EXEC 4
184 #define PTRACE_EVENT_VFORK_DONE 5
185 #define PTRACE_EVENT_EXIT 6
187 #endif /* PTRACE_EVENT_FORK */
189 /* Unlike other extended result codes, WSTOPSIG (status) on
190 PTRACE_O_TRACESYSGOOD syscall events doesn't return SIGTRAP, but
191 instead SIGTRAP with bit 7 set. */
192 #define SYSCALL_SIGTRAP (SIGTRAP | 0x80)
194 /* We can't always assume that this flag is available, but all systems
195 with the ptrace event handlers also have __WALL, so it's safe to use
198 #define __WALL 0x40000000 /* Wait for any child. */
201 #ifndef PTRACE_GETSIGINFO
202 # define PTRACE_GETSIGINFO 0x4202
203 # define PTRACE_SETSIGINFO 0x4203
206 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
207 the use of the multi-threaded target. */
208 static struct target_ops
*linux_ops
;
209 static struct target_ops linux_ops_saved
;
211 /* The method to call, if any, when a new thread is attached. */
212 static void (*linux_nat_new_thread
) (ptid_t
);
214 /* The method to call, if any, when the siginfo object needs to be
215 converted between the layout returned by ptrace, and the layout in
216 the architecture of the inferior. */
217 static int (*linux_nat_siginfo_fixup
) (struct siginfo
*,
221 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
222 Called by our to_xfer_partial. */
223 static LONGEST (*super_xfer_partial
) (struct target_ops
*,
225 const char *, gdb_byte
*,
229 static int debug_linux_nat
;
231 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
232 struct cmd_list_element
*c
, const char *value
)
234 fprintf_filtered (file
, _("Debugging of GNU/Linux lwp module is %s.\n"),
238 static int debug_linux_nat_async
= 0;
240 show_debug_linux_nat_async (struct ui_file
*file
, int from_tty
,
241 struct cmd_list_element
*c
, const char *value
)
243 fprintf_filtered (file
,
244 _("Debugging of GNU/Linux async lwp module is %s.\n"),
248 static int disable_randomization
= 1;
251 show_disable_randomization (struct ui_file
*file
, int from_tty
,
252 struct cmd_list_element
*c
, const char *value
)
254 #ifdef HAVE_PERSONALITY
255 fprintf_filtered (file
,
256 _("Disabling randomization of debuggee's "
257 "virtual address space is %s.\n"),
259 #else /* !HAVE_PERSONALITY */
260 fputs_filtered (_("Disabling randomization of debuggee's "
261 "virtual address space is unsupported on\n"
262 "this platform.\n"), file
);
263 #endif /* !HAVE_PERSONALITY */
267 set_disable_randomization (char *args
, int from_tty
,
268 struct cmd_list_element
*c
)
270 #ifndef HAVE_PERSONALITY
271 error (_("Disabling randomization of debuggee's "
272 "virtual address space is unsupported on\n"
274 #endif /* !HAVE_PERSONALITY */
277 struct simple_pid_list
281 struct simple_pid_list
*next
;
283 struct simple_pid_list
*stopped_pids
;
285 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
286 can not be used, 1 if it can. */
288 static int linux_supports_tracefork_flag
= -1;
290 /* This variable is a tri-state flag: -1 for unknown, 0 if
291 PTRACE_O_TRACESYSGOOD can not be used, 1 if it can. */
293 static int linux_supports_tracesysgood_flag
= -1;
295 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
296 PTRACE_O_TRACEVFORKDONE. */
298 static int linux_supports_tracevforkdone_flag
= -1;
300 /* Async mode support */
302 /* Zero if the async mode, although enabled, is masked, which means
303 linux_nat_wait should behave as if async mode was off. */
304 static int linux_nat_async_mask_value
= 1;
306 /* Stores the current used ptrace() options. */
307 static int current_ptrace_options
= 0;
309 /* The read/write ends of the pipe registered as waitable file in the
311 static int linux_nat_event_pipe
[2] = { -1, -1 };
313 /* Flush the event pipe. */
316 async_file_flush (void)
323 ret
= read (linux_nat_event_pipe
[0], &buf
, 1);
325 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
328 /* Put something (anything, doesn't matter what, or how much) in event
329 pipe, so that the select/poll in the event-loop realizes we have
330 something to process. */
333 async_file_mark (void)
337 /* It doesn't really matter what the pipe contains, as long we end
338 up with something in it. Might as well flush the previous
344 ret
= write (linux_nat_event_pipe
[1], "+", 1);
346 while (ret
== -1 && errno
== EINTR
);
348 /* Ignore EAGAIN. If the pipe is full, the event loop will already
349 be awakened anyway. */
352 static void linux_nat_async (void (*callback
)
353 (enum inferior_event_type event_type
,
356 static int linux_nat_async_mask (int mask
);
357 static int kill_lwp (int lwpid
, int signo
);
359 static int stop_callback (struct lwp_info
*lp
, void *data
);
361 static void block_child_signals (sigset_t
*prev_mask
);
362 static void restore_child_signals_mask (sigset_t
*prev_mask
);
365 static struct lwp_info
*add_lwp (ptid_t ptid
);
366 static void purge_lwp_list (int pid
);
367 static struct lwp_info
*find_lwp_pid (ptid_t ptid
);
370 /* Trivial list manipulation functions to keep track of a list of
371 new stopped processes. */
373 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
375 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
378 new_pid
->status
= status
;
379 new_pid
->next
= *listp
;
384 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
386 struct simple_pid_list
**p
;
388 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
389 if ((*p
)->pid
== pid
)
391 struct simple_pid_list
*next
= (*p
)->next
;
393 *statusp
= (*p
)->status
;
402 linux_record_stopped_pid (int pid
, int status
)
404 add_to_pid_list (&stopped_pids
, pid
, status
);
408 /* A helper function for linux_test_for_tracefork, called after fork (). */
411 linux_tracefork_child (void)
413 ptrace (PTRACE_TRACEME
, 0, 0, 0);
414 kill (getpid (), SIGSTOP
);
419 /* Wrapper function for waitpid which handles EINTR. */
422 my_waitpid (int pid
, int *statusp
, int flags
)
428 ret
= waitpid (pid
, statusp
, flags
);
430 while (ret
== -1 && errno
== EINTR
);
435 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
437 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
438 we know that the feature is not available. This may change the tracing
439 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
441 However, if it succeeds, we don't know for sure that the feature is
442 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
443 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
444 fork tracing, and let it fork. If the process exits, we assume that we
445 can't use TRACEFORK; if we get the fork notification, and we can extract
446 the new child's PID, then we assume that we can. */
449 linux_test_for_tracefork (int original_pid
)
451 int child_pid
, ret
, status
;
455 /* We don't want those ptrace calls to be interrupted. */
456 block_child_signals (&prev_mask
);
458 linux_supports_tracefork_flag
= 0;
459 linux_supports_tracevforkdone_flag
= 0;
461 ret
= ptrace (PTRACE_SETOPTIONS
, original_pid
, 0, PTRACE_O_TRACEFORK
);
464 restore_child_signals_mask (&prev_mask
);
470 perror_with_name (("fork"));
473 linux_tracefork_child ();
475 ret
= my_waitpid (child_pid
, &status
, 0);
477 perror_with_name (("waitpid"));
478 else if (ret
!= child_pid
)
479 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret
);
480 if (! WIFSTOPPED (status
))
481 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."),
484 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
487 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
490 warning (_("linux_test_for_tracefork: failed to kill child"));
491 restore_child_signals_mask (&prev_mask
);
495 ret
= my_waitpid (child_pid
, &status
, 0);
496 if (ret
!= child_pid
)
497 warning (_("linux_test_for_tracefork: failed "
498 "to wait for killed child"));
499 else if (!WIFSIGNALED (status
))
500 warning (_("linux_test_for_tracefork: unexpected "
501 "wait status 0x%x from killed child"), status
);
503 restore_child_signals_mask (&prev_mask
);
507 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
508 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0,
509 PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORKDONE
);
510 linux_supports_tracevforkdone_flag
= (ret
== 0);
512 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
514 warning (_("linux_test_for_tracefork: failed to resume child"));
516 ret
= my_waitpid (child_pid
, &status
, 0);
518 if (ret
== child_pid
&& WIFSTOPPED (status
)
519 && status
>> 16 == PTRACE_EVENT_FORK
)
522 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
523 if (ret
== 0 && second_pid
!= 0)
527 linux_supports_tracefork_flag
= 1;
528 my_waitpid (second_pid
, &second_status
, 0);
529 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
531 warning (_("linux_test_for_tracefork: "
532 "failed to kill second child"));
533 my_waitpid (second_pid
, &status
, 0);
537 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
538 "(%d, status 0x%x)"), ret
, status
);
540 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
542 warning (_("linux_test_for_tracefork: failed to kill child"));
543 my_waitpid (child_pid
, &status
, 0);
545 restore_child_signals_mask (&prev_mask
);
548 /* Determine if PTRACE_O_TRACESYSGOOD can be used to follow syscalls.
550 We try to enable syscall tracing on ORIGINAL_PID. If this fails,
551 we know that the feature is not available. This may change the tracing
552 options for ORIGINAL_PID, but we'll be setting them shortly anyway. */
555 linux_test_for_tracesysgood (int original_pid
)
560 /* We don't want those ptrace calls to be interrupted. */
561 block_child_signals (&prev_mask
);
563 linux_supports_tracesysgood_flag
= 0;
565 ret
= ptrace (PTRACE_SETOPTIONS
, original_pid
, 0, PTRACE_O_TRACESYSGOOD
);
569 linux_supports_tracesysgood_flag
= 1;
571 restore_child_signals_mask (&prev_mask
);
574 /* Determine wether we support PTRACE_O_TRACESYSGOOD option available.
575 This function also sets linux_supports_tracesysgood_flag. */
578 linux_supports_tracesysgood (int pid
)
580 if (linux_supports_tracesysgood_flag
== -1)
581 linux_test_for_tracesysgood (pid
);
582 return linux_supports_tracesysgood_flag
;
585 /* Return non-zero iff we have tracefork functionality available.
586 This function also sets linux_supports_tracefork_flag. */
589 linux_supports_tracefork (int pid
)
591 if (linux_supports_tracefork_flag
== -1)
592 linux_test_for_tracefork (pid
);
593 return linux_supports_tracefork_flag
;
597 linux_supports_tracevforkdone (int pid
)
599 if (linux_supports_tracefork_flag
== -1)
600 linux_test_for_tracefork (pid
);
601 return linux_supports_tracevforkdone_flag
;
605 linux_enable_tracesysgood (ptid_t ptid
)
607 int pid
= ptid_get_lwp (ptid
);
610 pid
= ptid_get_pid (ptid
);
612 if (linux_supports_tracesysgood (pid
) == 0)
615 current_ptrace_options
|= PTRACE_O_TRACESYSGOOD
;
617 ptrace (PTRACE_SETOPTIONS
, pid
, 0, current_ptrace_options
);
622 linux_enable_event_reporting (ptid_t ptid
)
624 int pid
= ptid_get_lwp (ptid
);
627 pid
= ptid_get_pid (ptid
);
629 if (! linux_supports_tracefork (pid
))
632 current_ptrace_options
|= PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK
633 | PTRACE_O_TRACEEXEC
| PTRACE_O_TRACECLONE
;
635 if (linux_supports_tracevforkdone (pid
))
636 current_ptrace_options
|= PTRACE_O_TRACEVFORKDONE
;
638 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
639 read-only process state. */
641 ptrace (PTRACE_SETOPTIONS
, pid
, 0, current_ptrace_options
);
645 linux_child_post_attach (int pid
)
647 linux_enable_event_reporting (pid_to_ptid (pid
));
648 check_for_thread_db ();
649 linux_enable_tracesysgood (pid_to_ptid (pid
));
653 linux_child_post_startup_inferior (ptid_t ptid
)
655 linux_enable_event_reporting (ptid
);
656 check_for_thread_db ();
657 linux_enable_tracesysgood (ptid
);
661 linux_child_follow_fork (struct target_ops
*ops
, int follow_child
)
665 int parent_pid
, child_pid
;
667 block_child_signals (&prev_mask
);
669 has_vforked
= (inferior_thread ()->pending_follow
.kind
670 == TARGET_WAITKIND_VFORKED
);
671 parent_pid
= ptid_get_lwp (inferior_ptid
);
673 parent_pid
= ptid_get_pid (inferior_ptid
);
674 child_pid
= PIDGET (inferior_thread ()->pending_follow
.value
.related_pid
);
677 linux_enable_event_reporting (pid_to_ptid (child_pid
));
680 && !non_stop
/* Non-stop always resumes both branches. */
681 && (!target_is_async_p () || sync_execution
)
682 && !(follow_child
|| detach_fork
|| sched_multi
))
684 /* The parent stays blocked inside the vfork syscall until the
685 child execs or exits. If we don't let the child run, then
686 the parent stays blocked. If we're telling the parent to run
687 in the foreground, the user will not be able to ctrl-c to get
688 back the terminal, effectively hanging the debug session. */
689 fprintf_filtered (gdb_stderr
, _("\
690 Can not resume the parent process over vfork in the foreground while\n\
691 holding the child stopped. Try \"set detach-on-fork\" or \
692 \"set schedule-multiple\".\n"));
693 /* FIXME output string > 80 columns. */
699 struct lwp_info
*child_lp
= NULL
;
701 /* We're already attached to the parent, by default. */
703 /* Detach new forked process? */
706 /* Before detaching from the child, remove all breakpoints
707 from it. If we forked, then this has already been taken
708 care of by infrun.c. If we vforked however, any
709 breakpoint inserted in the parent is visible in the
710 child, even those added while stopped in a vfork
711 catchpoint. This will remove the breakpoints from the
712 parent also, but they'll be reinserted below. */
715 /* keep breakpoints list in sync. */
716 remove_breakpoints_pid (GET_PID (inferior_ptid
));
719 if (info_verbose
|| debug_linux_nat
)
721 target_terminal_ours ();
722 fprintf_filtered (gdb_stdlog
,
723 "Detaching after fork from "
724 "child process %d.\n",
728 ptrace (PTRACE_DETACH
, child_pid
, 0, 0);
732 struct inferior
*parent_inf
, *child_inf
;
733 struct cleanup
*old_chain
;
735 /* Add process to GDB's tables. */
736 child_inf
= add_inferior (child_pid
);
738 parent_inf
= current_inferior ();
739 child_inf
->attach_flag
= parent_inf
->attach_flag
;
740 copy_terminal_info (child_inf
, parent_inf
);
742 old_chain
= save_inferior_ptid ();
743 save_current_program_space ();
745 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
746 add_thread (inferior_ptid
);
747 child_lp
= add_lwp (inferior_ptid
);
748 child_lp
->stopped
= 1;
749 child_lp
->resumed
= 1;
751 /* If this is a vfork child, then the address-space is
752 shared with the parent. */
755 child_inf
->pspace
= parent_inf
->pspace
;
756 child_inf
->aspace
= parent_inf
->aspace
;
758 /* The parent will be frozen until the child is done
759 with the shared region. Keep track of the
761 child_inf
->vfork_parent
= parent_inf
;
762 child_inf
->pending_detach
= 0;
763 parent_inf
->vfork_child
= child_inf
;
764 parent_inf
->pending_detach
= 0;
768 child_inf
->aspace
= new_address_space ();
769 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
770 child_inf
->removable
= 1;
771 set_current_program_space (child_inf
->pspace
);
772 clone_program_space (child_inf
->pspace
, parent_inf
->pspace
);
774 /* Let the shared library layer (solib-svr4) learn about
775 this new process, relocate the cloned exec, pull in
776 shared libraries, and install the solib event
777 breakpoint. If a "cloned-VM" event was propagated
778 better throughout the core, this wouldn't be
780 solib_create_inferior_hook (0);
783 /* Let the thread_db layer learn about this new process. */
784 check_for_thread_db ();
786 do_cleanups (old_chain
);
792 struct inferior
*parent_inf
;
794 parent_inf
= current_inferior ();
796 /* If we detached from the child, then we have to be careful
797 to not insert breakpoints in the parent until the child
798 is done with the shared memory region. However, if we're
799 staying attached to the child, then we can and should
800 insert breakpoints, so that we can debug it. A
801 subsequent child exec or exit is enough to know when does
802 the child stops using the parent's address space. */
803 parent_inf
->waiting_for_vfork_done
= detach_fork
;
804 parent_inf
->pspace
->breakpoints_not_allowed
= detach_fork
;
806 lp
= find_lwp_pid (pid_to_ptid (parent_pid
));
807 gdb_assert (linux_supports_tracefork_flag
>= 0);
808 if (linux_supports_tracevforkdone (0))
811 fprintf_unfiltered (gdb_stdlog
,
812 "LCFF: waiting for VFORK_DONE on %d\n",
818 /* We'll handle the VFORK_DONE event like any other
819 event, in target_wait. */
823 /* We can't insert breakpoints until the child has
824 finished with the shared memory region. We need to
825 wait until that happens. Ideal would be to just
827 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
828 - waitpid (parent_pid, &status, __WALL);
829 However, most architectures can't handle a syscall
830 being traced on the way out if it wasn't traced on
833 We might also think to loop, continuing the child
834 until it exits or gets a SIGTRAP. One problem is
835 that the child might call ptrace with PTRACE_TRACEME.
837 There's no simple and reliable way to figure out when
838 the vforked child will be done with its copy of the
839 shared memory. We could step it out of the syscall,
840 two instructions, let it go, and then single-step the
841 parent once. When we have hardware single-step, this
842 would work; with software single-step it could still
843 be made to work but we'd have to be able to insert
844 single-step breakpoints in the child, and we'd have
845 to insert -just- the single-step breakpoint in the
846 parent. Very awkward.
848 In the end, the best we can do is to make sure it
849 runs for a little while. Hopefully it will be out of
850 range of any breakpoints we reinsert. Usually this
851 is only the single-step breakpoint at vfork's return
855 fprintf_unfiltered (gdb_stdlog
,
856 "LCFF: no VFORK_DONE "
857 "support, sleeping a bit\n");
861 /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
862 and leave it pending. The next linux_nat_resume call
863 will notice a pending event, and bypasses actually
864 resuming the inferior. */
866 lp
->waitstatus
.kind
= TARGET_WAITKIND_VFORK_DONE
;
870 /* If we're in async mode, need to tell the event loop
871 there's something here to process. */
872 if (target_can_async_p ())
879 struct inferior
*parent_inf
, *child_inf
;
881 struct program_space
*parent_pspace
;
883 if (info_verbose
|| debug_linux_nat
)
885 target_terminal_ours ();
887 fprintf_filtered (gdb_stdlog
,
888 _("Attaching after process %d "
889 "vfork to child process %d.\n"),
890 parent_pid
, child_pid
);
892 fprintf_filtered (gdb_stdlog
,
893 _("Attaching after process %d "
894 "fork to child process %d.\n"),
895 parent_pid
, child_pid
);
898 /* Add the new inferior first, so that the target_detach below
899 doesn't unpush the target. */
901 child_inf
= add_inferior (child_pid
);
903 parent_inf
= current_inferior ();
904 child_inf
->attach_flag
= parent_inf
->attach_flag
;
905 copy_terminal_info (child_inf
, parent_inf
);
907 parent_pspace
= parent_inf
->pspace
;
909 /* If we're vforking, we want to hold on to the parent until the
910 child exits or execs. At child exec or exit time we can
911 remove the old breakpoints from the parent and detach or
912 resume debugging it. Otherwise, detach the parent now; we'll
913 want to reuse it's program/address spaces, but we can't set
914 them to the child before removing breakpoints from the
915 parent, otherwise, the breakpoints module could decide to
916 remove breakpoints from the wrong process (since they'd be
917 assigned to the same address space). */
921 gdb_assert (child_inf
->vfork_parent
== NULL
);
922 gdb_assert (parent_inf
->vfork_child
== NULL
);
923 child_inf
->vfork_parent
= parent_inf
;
924 child_inf
->pending_detach
= 0;
925 parent_inf
->vfork_child
= child_inf
;
926 parent_inf
->pending_detach
= detach_fork
;
927 parent_inf
->waiting_for_vfork_done
= 0;
929 else if (detach_fork
)
930 target_detach (NULL
, 0);
932 /* Note that the detach above makes PARENT_INF dangling. */
934 /* Add the child thread to the appropriate lists, and switch to
935 this new thread, before cloning the program space, and
936 informing the solib layer about this new process. */
938 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
939 add_thread (inferior_ptid
);
940 lp
= add_lwp (inferior_ptid
);
944 /* If this is a vfork child, then the address-space is shared
945 with the parent. If we detached from the parent, then we can
946 reuse the parent's program/address spaces. */
947 if (has_vforked
|| detach_fork
)
949 child_inf
->pspace
= parent_pspace
;
950 child_inf
->aspace
= child_inf
->pspace
->aspace
;
954 child_inf
->aspace
= new_address_space ();
955 child_inf
->pspace
= add_program_space (child_inf
->aspace
);
956 child_inf
->removable
= 1;
957 set_current_program_space (child_inf
->pspace
);
958 clone_program_space (child_inf
->pspace
, parent_pspace
);
960 /* Let the shared library layer (solib-svr4) learn about
961 this new process, relocate the cloned exec, pull in
962 shared libraries, and install the solib event breakpoint.
963 If a "cloned-VM" event was propagated better throughout
964 the core, this wouldn't be required. */
965 solib_create_inferior_hook (0);
968 /* Let the thread_db layer learn about this new process. */
969 check_for_thread_db ();
972 restore_child_signals_mask (&prev_mask
);
978 linux_child_insert_fork_catchpoint (int pid
)
980 if (! linux_supports_tracefork (pid
))
981 error (_("Your system does not support fork catchpoints."));
985 linux_child_insert_vfork_catchpoint (int pid
)
987 if (!linux_supports_tracefork (pid
))
988 error (_("Your system does not support vfork catchpoints."));
992 linux_child_insert_exec_catchpoint (int pid
)
994 if (!linux_supports_tracefork (pid
))
995 error (_("Your system does not support exec catchpoints."));
999 linux_child_set_syscall_catchpoint (int pid
, int needed
, int any_count
,
1000 int table_size
, int *table
)
1002 if (! linux_supports_tracesysgood (pid
))
1003 error (_("Your system does not support syscall catchpoints."));
1004 /* On GNU/Linux, we ignore the arguments. It means that we only
1005 enable the syscall catchpoints, but do not disable them.
1007 Also, we do not use the `table' information because we do not
1008 filter system calls here. We let GDB do the logic for us. */
1012 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
1013 are processes sharing the same VM space. A multi-threaded process
1014 is basically a group of such processes. However, such a grouping
1015 is almost entirely a user-space issue; the kernel doesn't enforce
1016 such a grouping at all (this might change in the future). In
1017 general, we'll rely on the threads library (i.e. the GNU/Linux
1018 Threads library) to provide such a grouping.
1020 It is perfectly well possible to write a multi-threaded application
1021 without the assistance of a threads library, by using the clone
1022 system call directly. This module should be able to give some
1023 rudimentary support for debugging such applications if developers
1024 specify the CLONE_PTRACE flag in the clone system call, and are
1025 using the Linux kernel 2.4 or above.
1027 Note that there are some peculiarities in GNU/Linux that affect
1030 - In general one should specify the __WCLONE flag to waitpid in
1031 order to make it report events for any of the cloned processes
1032 (and leave it out for the initial process). However, if a cloned
1033 process has exited the exit status is only reported if the
1034 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
1035 we cannot use it since GDB must work on older systems too.
1037 - When a traced, cloned process exits and is waited for by the
1038 debugger, the kernel reassigns it to the original parent and
1039 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
1040 library doesn't notice this, which leads to the "zombie problem":
1041 When debugged a multi-threaded process that spawns a lot of
1042 threads will run out of processes, even if the threads exit,
1043 because the "zombies" stay around. */
1045 /* List of known LWPs. */
1046 struct lwp_info
*lwp_list
;
1049 /* Original signal mask. */
1050 static sigset_t normal_mask
;
1052 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
1053 _initialize_linux_nat. */
1054 static sigset_t suspend_mask
;
1056 /* Signals to block to make that sigsuspend work. */
1057 static sigset_t blocked_mask
;
1059 /* SIGCHLD action. */
1060 struct sigaction sigchld_action
;
1062 /* Block child signals (SIGCHLD and linux threads signals), and store
1063 the previous mask in PREV_MASK. */
1066 block_child_signals (sigset_t
*prev_mask
)
1068 /* Make sure SIGCHLD is blocked. */
1069 if (!sigismember (&blocked_mask
, SIGCHLD
))
1070 sigaddset (&blocked_mask
, SIGCHLD
);
1072 sigprocmask (SIG_BLOCK
, &blocked_mask
, prev_mask
);
1075 /* Restore child signals mask, previously returned by
1076 block_child_signals. */
1079 restore_child_signals_mask (sigset_t
*prev_mask
)
1081 sigprocmask (SIG_SETMASK
, prev_mask
, NULL
);
1085 /* Prototypes for local functions. */
1086 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
1087 static int linux_thread_alive (ptid_t ptid
);
1088 static char *linux_child_pid_to_exec_file (int pid
);
1091 /* Convert wait status STATUS to a string. Used for printing debug
1095 status_to_str (int status
)
1097 static char buf
[64];
1099 if (WIFSTOPPED (status
))
1101 if (WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
1102 snprintf (buf
, sizeof (buf
), "%s (stopped at syscall)",
1103 strsignal (SIGTRAP
));
1105 snprintf (buf
, sizeof (buf
), "%s (stopped)",
1106 strsignal (WSTOPSIG (status
)));
1108 else if (WIFSIGNALED (status
))
1109 snprintf (buf
, sizeof (buf
), "%s (terminated)",
1110 strsignal (WTERMSIG (status
)));
1112 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
1117 /* Remove all LWPs belong to PID from the lwp list. */
1120 purge_lwp_list (int pid
)
1122 struct lwp_info
*lp
, *lpprev
, *lpnext
;
1126 for (lp
= lwp_list
; lp
; lp
= lpnext
)
1130 if (ptid_get_pid (lp
->ptid
) == pid
)
1133 lwp_list
= lp
->next
;
1135 lpprev
->next
= lp
->next
;
1144 /* Return the number of known LWPs in the tgid given by PID. */
1150 struct lwp_info
*lp
;
1152 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
1153 if (ptid_get_pid (lp
->ptid
) == pid
)
1159 /* Add the LWP specified by PID to the list. Return a pointer to the
1160 structure describing the new LWP. The LWP should already be stopped
1161 (with an exception for the very first LWP). */
1163 static struct lwp_info
*
1164 add_lwp (ptid_t ptid
)
1166 struct lwp_info
*lp
;
1168 gdb_assert (is_lwp (ptid
));
1170 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
1172 memset (lp
, 0, sizeof (struct lwp_info
));
1174 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
1179 lp
->next
= lwp_list
;
1182 if (num_lwps (GET_PID (ptid
)) > 1 && linux_nat_new_thread
!= NULL
)
1183 linux_nat_new_thread (ptid
);
1188 /* Remove the LWP specified by PID from the list. */
1191 delete_lwp (ptid_t ptid
)
1193 struct lwp_info
*lp
, *lpprev
;
1197 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
1198 if (ptid_equal (lp
->ptid
, ptid
))
1205 lpprev
->next
= lp
->next
;
1207 lwp_list
= lp
->next
;
1212 /* Return a pointer to the structure describing the LWP corresponding
1213 to PID. If no corresponding LWP could be found, return NULL. */
1215 static struct lwp_info
*
1216 find_lwp_pid (ptid_t ptid
)
1218 struct lwp_info
*lp
;
1222 lwp
= GET_LWP (ptid
);
1224 lwp
= GET_PID (ptid
);
1226 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
1227 if (lwp
== GET_LWP (lp
->ptid
))
1233 /* Call CALLBACK with its second argument set to DATA for every LWP in
1234 the list. If CALLBACK returns 1 for a particular LWP, return a
1235 pointer to the structure describing that LWP immediately.
1236 Otherwise return NULL. */
1239 iterate_over_lwps (ptid_t filter
,
1240 int (*callback
) (struct lwp_info
*, void *),
1243 struct lwp_info
*lp
, *lpnext
;
1245 for (lp
= lwp_list
; lp
; lp
= lpnext
)
1249 if (ptid_match (lp
->ptid
, filter
))
1251 if ((*callback
) (lp
, data
))
1259 /* Update our internal state when changing from one checkpoint to
1260 another indicated by NEW_PTID. We can only switch single-threaded
1261 applications, so we only create one new LWP, and the previous list
1265 linux_nat_switch_fork (ptid_t new_ptid
)
1267 struct lwp_info
*lp
;
1269 purge_lwp_list (GET_PID (inferior_ptid
));
1271 lp
= add_lwp (new_ptid
);
1274 /* This changes the thread's ptid while preserving the gdb thread
1275 num. Also changes the inferior pid, while preserving the
1277 thread_change_ptid (inferior_ptid
, new_ptid
);
1279 /* We've just told GDB core that the thread changed target id, but,
1280 in fact, it really is a different thread, with different register
1282 registers_changed ();
1285 /* Handle the exit of a single thread LP. */
1288 exit_lwp (struct lwp_info
*lp
)
1290 struct thread_info
*th
= find_thread_ptid (lp
->ptid
);
1294 if (print_thread_events
)
1295 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp
->ptid
));
1297 delete_thread (lp
->ptid
);
1300 delete_lwp (lp
->ptid
);
1303 /* Return an lwp's tgid, found in `/proc/PID/status'. */
1306 linux_proc_get_tgid (int lwpid
)
1312 snprintf (buf
, sizeof (buf
), "/proc/%d/status", (int) lwpid
);
1313 status_file
= fopen (buf
, "r");
1314 if (status_file
!= NULL
)
1316 while (fgets (buf
, sizeof (buf
), status_file
))
1318 if (strncmp (buf
, "Tgid:", 5) == 0)
1320 tgid
= strtoul (buf
+ strlen ("Tgid:"), NULL
, 10);
1325 fclose (status_file
);
1331 /* Detect `T (stopped)' in `/proc/PID/status'.
1332 Other states including `T (tracing stop)' are reported as false. */
1335 pid_is_stopped (pid_t pid
)
1341 snprintf (buf
, sizeof (buf
), "/proc/%d/status", (int) pid
);
1342 status_file
= fopen (buf
, "r");
1343 if (status_file
!= NULL
)
1347 while (fgets (buf
, sizeof (buf
), status_file
))
1349 if (strncmp (buf
, "State:", 6) == 0)
1355 if (have_state
&& strstr (buf
, "T (stopped)") != NULL
)
1357 fclose (status_file
);
1362 /* Wait for the LWP specified by LP, which we have just attached to.
1363 Returns a wait status for that LWP, to cache. */
1366 linux_nat_post_attach_wait (ptid_t ptid
, int first
, int *cloned
,
1369 pid_t new_pid
, pid
= GET_LWP (ptid
);
1372 if (pid_is_stopped (pid
))
1374 if (debug_linux_nat
)
1375 fprintf_unfiltered (gdb_stdlog
,
1376 "LNPAW: Attaching to a stopped process\n");
1378 /* The process is definitely stopped. It is in a job control
1379 stop, unless the kernel predates the TASK_STOPPED /
1380 TASK_TRACED distinction, in which case it might be in a
1381 ptrace stop. Make sure it is in a ptrace stop; from there we
1382 can kill it, signal it, et cetera.
1384 First make sure there is a pending SIGSTOP. Since we are
1385 already attached, the process can not transition from stopped
1386 to running without a PTRACE_CONT; so we know this signal will
1387 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1388 probably already in the queue (unless this kernel is old
1389 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1390 is not an RT signal, it can only be queued once. */
1391 kill_lwp (pid
, SIGSTOP
);
1393 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1394 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1395 ptrace (PTRACE_CONT
, pid
, 0, 0);
1398 /* Make sure the initial process is stopped. The user-level threads
1399 layer might want to poke around in the inferior, and that won't
1400 work if things haven't stabilized yet. */
1401 new_pid
= my_waitpid (pid
, &status
, 0);
1402 if (new_pid
== -1 && errno
== ECHILD
)
1405 warning (_("%s is a cloned process"), target_pid_to_str (ptid
));
1407 /* Try again with __WCLONE to check cloned processes. */
1408 new_pid
= my_waitpid (pid
, &status
, __WCLONE
);
1412 gdb_assert (pid
== new_pid
);
1414 if (!WIFSTOPPED (status
))
1416 /* The pid we tried to attach has apparently just exited. */
1417 if (debug_linux_nat
)
1418 fprintf_unfiltered (gdb_stdlog
, "LNPAW: Failed to stop %d: %s",
1419 pid
, status_to_str (status
));
1423 if (WSTOPSIG (status
) != SIGSTOP
)
1426 if (debug_linux_nat
)
1427 fprintf_unfiltered (gdb_stdlog
,
1428 "LNPAW: Received %s after attaching\n",
1429 status_to_str (status
));
1435 /* Attach to the LWP specified by PID. Return 0 if successful or -1
1436 if the new LWP could not be attached. */
1439 lin_lwp_attach_lwp (ptid_t ptid
)
1441 struct lwp_info
*lp
;
1444 gdb_assert (is_lwp (ptid
));
1446 block_child_signals (&prev_mask
);
1448 lp
= find_lwp_pid (ptid
);
1450 /* We assume that we're already attached to any LWP that has an id
1451 equal to the overall process id, and to any LWP that is already
1452 in our list of LWPs. If we're not seeing exit events from threads
1453 and we've had PID wraparound since we last tried to stop all threads,
1454 this assumption might be wrong; fortunately, this is very unlikely
1456 if (GET_LWP (ptid
) != GET_PID (ptid
) && lp
== NULL
)
1458 int status
, cloned
= 0, signalled
= 0;
1460 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
1462 /* If we fail to attach to the thread, issue a warning,
1463 but continue. One way this can happen is if thread
1464 creation is interrupted; as of Linux kernel 2.6.19, a
1465 bug may place threads in the thread list and then fail
1467 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
1468 safe_strerror (errno
));
1469 restore_child_signals_mask (&prev_mask
);
1473 if (debug_linux_nat
)
1474 fprintf_unfiltered (gdb_stdlog
,
1475 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1476 target_pid_to_str (ptid
));
1478 status
= linux_nat_post_attach_wait (ptid
, 0, &cloned
, &signalled
);
1479 if (!WIFSTOPPED (status
))
1482 lp
= add_lwp (ptid
);
1484 lp
->cloned
= cloned
;
1485 lp
->signalled
= signalled
;
1486 if (WSTOPSIG (status
) != SIGSTOP
)
1489 lp
->status
= status
;
1492 target_post_attach (GET_LWP (lp
->ptid
));
1494 if (debug_linux_nat
)
1496 fprintf_unfiltered (gdb_stdlog
,
1497 "LLAL: waitpid %s received %s\n",
1498 target_pid_to_str (ptid
),
1499 status_to_str (status
));
1504 /* We assume that the LWP representing the original process is
1505 already stopped. Mark it as stopped in the data structure
1506 that the GNU/linux ptrace layer uses to keep track of
1507 threads. Note that this won't have already been done since
1508 the main thread will have, we assume, been stopped by an
1509 attach from a different layer. */
1511 lp
= add_lwp (ptid
);
1515 restore_child_signals_mask (&prev_mask
);
1520 linux_nat_create_inferior (struct target_ops
*ops
,
1521 char *exec_file
, char *allargs
, char **env
,
1524 #ifdef HAVE_PERSONALITY
1525 int personality_orig
= 0, personality_set
= 0;
1526 #endif /* HAVE_PERSONALITY */
1528 /* The fork_child mechanism is synchronous and calls target_wait, so
1529 we have to mask the async mode. */
1531 #ifdef HAVE_PERSONALITY
1532 if (disable_randomization
)
1535 personality_orig
= personality (0xffffffff);
1536 if (errno
== 0 && !(personality_orig
& ADDR_NO_RANDOMIZE
))
1538 personality_set
= 1;
1539 personality (personality_orig
| ADDR_NO_RANDOMIZE
);
1541 if (errno
!= 0 || (personality_set
1542 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE
)))
1543 warning (_("Error disabling address space randomization: %s"),
1544 safe_strerror (errno
));
1546 #endif /* HAVE_PERSONALITY */
1548 linux_ops
->to_create_inferior (ops
, exec_file
, allargs
, env
, from_tty
);
1550 #ifdef HAVE_PERSONALITY
1551 if (personality_set
)
1554 personality (personality_orig
);
1556 warning (_("Error restoring address space randomization: %s"),
1557 safe_strerror (errno
));
1559 #endif /* HAVE_PERSONALITY */
1563 linux_nat_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1565 struct lwp_info
*lp
;
1569 linux_ops
->to_attach (ops
, args
, from_tty
);
1571 /* The ptrace base target adds the main thread with (pid,0,0)
1572 format. Decorate it with lwp info. */
1573 ptid
= BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
));
1574 thread_change_ptid (inferior_ptid
, ptid
);
1576 /* Add the initial process as the first LWP to the list. */
1577 lp
= add_lwp (ptid
);
1579 status
= linux_nat_post_attach_wait (lp
->ptid
, 1, &lp
->cloned
,
1581 if (!WIFSTOPPED (status
))
1583 if (WIFEXITED (status
))
1585 int exit_code
= WEXITSTATUS (status
);
1587 target_terminal_ours ();
1588 target_mourn_inferior ();
1590 error (_("Unable to attach: program exited normally."));
1592 error (_("Unable to attach: program exited with code %d."),
1595 else if (WIFSIGNALED (status
))
1597 enum target_signal signo
;
1599 target_terminal_ours ();
1600 target_mourn_inferior ();
1602 signo
= target_signal_from_host (WTERMSIG (status
));
1603 error (_("Unable to attach: program terminated with signal "
1605 target_signal_to_name (signo
),
1606 target_signal_to_string (signo
));
1609 internal_error (__FILE__
, __LINE__
,
1610 _("unexpected status %d for PID %ld"),
1611 status
, (long) GET_LWP (ptid
));
1616 /* Save the wait status to report later. */
1618 if (debug_linux_nat
)
1619 fprintf_unfiltered (gdb_stdlog
,
1620 "LNA: waitpid %ld, saving status %s\n",
1621 (long) GET_PID (lp
->ptid
), status_to_str (status
));
1623 lp
->status
= status
;
1625 if (target_can_async_p ())
1626 target_async (inferior_event_handler
, 0);
1629 /* Get pending status of LP. */
1631 get_pending_status (struct lwp_info
*lp
, int *status
)
1633 enum target_signal signo
= TARGET_SIGNAL_0
;
1635 /* If we paused threads momentarily, we may have stored pending
1636 events in lp->status or lp->waitstatus (see stop_wait_callback),
1637 and GDB core hasn't seen any signal for those threads.
1638 Otherwise, the last signal reported to the core is found in the
1639 thread object's stop_signal.
1641 There's a corner case that isn't handled here at present. Only
1642 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1643 stop_signal make sense as a real signal to pass to the inferior.
1644 Some catchpoint related events, like
1645 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1646 to TARGET_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1647 those traps are debug API (ptrace in our case) related and
1648 induced; the inferior wouldn't see them if it wasn't being
1649 traced. Hence, we should never pass them to the inferior, even
1650 when set to pass state. Since this corner case isn't handled by
1651 infrun.c when proceeding with a signal, for consistency, neither
1652 do we handle it here (or elsewhere in the file we check for
1653 signal pass state). Normally SIGTRAP isn't set to pass state, so
1654 this is really a corner case. */
1656 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
1657 signo
= TARGET_SIGNAL_0
; /* a pending ptrace event, not a real signal. */
1658 else if (lp
->status
)
1659 signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1660 else if (non_stop
&& !is_executing (lp
->ptid
))
1662 struct thread_info
*tp
= find_thread_ptid (lp
->ptid
);
1664 signo
= tp
->suspend
.stop_signal
;
1668 struct target_waitstatus last
;
1671 get_last_target_status (&last_ptid
, &last
);
1673 if (GET_LWP (lp
->ptid
) == GET_LWP (last_ptid
))
1675 struct thread_info
*tp
= find_thread_ptid (lp
->ptid
);
1677 signo
= tp
->suspend
.stop_signal
;
1683 if (signo
== TARGET_SIGNAL_0
)
1685 if (debug_linux_nat
)
1686 fprintf_unfiltered (gdb_stdlog
,
1687 "GPT: lwp %s has no pending signal\n",
1688 target_pid_to_str (lp
->ptid
));
1690 else if (!signal_pass_state (signo
))
1692 if (debug_linux_nat
)
1693 fprintf_unfiltered (gdb_stdlog
,
1694 "GPT: lwp %s had signal %s, "
1695 "but it is in no pass state\n",
1696 target_pid_to_str (lp
->ptid
),
1697 target_signal_to_string (signo
));
1701 *status
= W_STOPCODE (target_signal_to_host (signo
));
1703 if (debug_linux_nat
)
1704 fprintf_unfiltered (gdb_stdlog
,
1705 "GPT: lwp %s has pending signal %s\n",
1706 target_pid_to_str (lp
->ptid
),
1707 target_signal_to_string (signo
));
1714 detach_callback (struct lwp_info
*lp
, void *data
)
1716 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1718 if (debug_linux_nat
&& lp
->status
)
1719 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
1720 strsignal (WSTOPSIG (lp
->status
)),
1721 target_pid_to_str (lp
->ptid
));
1723 /* If there is a pending SIGSTOP, get rid of it. */
1726 if (debug_linux_nat
)
1727 fprintf_unfiltered (gdb_stdlog
,
1728 "DC: Sending SIGCONT to %s\n",
1729 target_pid_to_str (lp
->ptid
));
1731 kill_lwp (GET_LWP (lp
->ptid
), SIGCONT
);
1735 /* We don't actually detach from the LWP that has an id equal to the
1736 overall process id just yet. */
1737 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
1741 /* Pass on any pending signal for this LWP. */
1742 get_pending_status (lp
, &status
);
1745 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
1746 WSTOPSIG (status
)) < 0)
1747 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1748 safe_strerror (errno
));
1750 if (debug_linux_nat
)
1751 fprintf_unfiltered (gdb_stdlog
,
1752 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1753 target_pid_to_str (lp
->ptid
),
1754 strsignal (WSTOPSIG (status
)));
1756 delete_lwp (lp
->ptid
);
1763 linux_nat_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1767 struct lwp_info
*main_lwp
;
1769 pid
= GET_PID (inferior_ptid
);
1771 if (target_can_async_p ())
1772 linux_nat_async (NULL
, 0);
1774 /* Stop all threads before detaching. ptrace requires that the
1775 thread is stopped to sucessfully detach. */
1776 iterate_over_lwps (pid_to_ptid (pid
), stop_callback
, NULL
);
1777 /* ... and wait until all of them have reported back that
1778 they're no longer running. */
1779 iterate_over_lwps (pid_to_ptid (pid
), stop_wait_callback
, NULL
);
1781 iterate_over_lwps (pid_to_ptid (pid
), detach_callback
, NULL
);
1783 /* Only the initial process should be left right now. */
1784 gdb_assert (num_lwps (GET_PID (inferior_ptid
)) == 1);
1786 main_lwp
= find_lwp_pid (pid_to_ptid (pid
));
1788 /* Pass on any pending signal for the last LWP. */
1789 if ((args
== NULL
|| *args
== '\0')
1790 && get_pending_status (main_lwp
, &status
) != -1
1791 && WIFSTOPPED (status
))
1793 /* Put the signal number in ARGS so that inf_ptrace_detach will
1794 pass it along with PTRACE_DETACH. */
1796 sprintf (args
, "%d", (int) WSTOPSIG (status
));
1797 if (debug_linux_nat
)
1798 fprintf_unfiltered (gdb_stdlog
,
1799 "LND: Sending signal %s to %s\n",
1801 target_pid_to_str (main_lwp
->ptid
));
1804 delete_lwp (main_lwp
->ptid
);
1806 if (forks_exist_p ())
1808 /* Multi-fork case. The current inferior_ptid is being detached
1809 from, but there are other viable forks to debug. Detach from
1810 the current fork, and context-switch to the first
1812 linux_fork_detach (args
, from_tty
);
1814 if (non_stop
&& target_can_async_p ())
1815 target_async (inferior_event_handler
, 0);
1818 linux_ops
->to_detach (ops
, args
, from_tty
);
1824 resume_callback (struct lwp_info
*lp
, void *data
)
1826 struct inferior
*inf
= find_inferior_pid (GET_PID (lp
->ptid
));
1828 if (lp
->stopped
&& inf
->vfork_child
!= NULL
)
1830 if (debug_linux_nat
)
1831 fprintf_unfiltered (gdb_stdlog
,
1832 "RC: Not resuming %s (vfork parent)\n",
1833 target_pid_to_str (lp
->ptid
));
1835 else if (lp
->stopped
&& lp
->status
== 0)
1837 if (debug_linux_nat
)
1838 fprintf_unfiltered (gdb_stdlog
,
1839 "RC: PTRACE_CONT %s, 0, 0 (resuming sibling)\n",
1840 target_pid_to_str (lp
->ptid
));
1842 linux_ops
->to_resume (linux_ops
,
1843 pid_to_ptid (GET_LWP (lp
->ptid
)),
1844 0, TARGET_SIGNAL_0
);
1845 if (debug_linux_nat
)
1846 fprintf_unfiltered (gdb_stdlog
,
1847 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1848 target_pid_to_str (lp
->ptid
));
1851 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1852 lp
->stopped_by_watchpoint
= 0;
1854 else if (lp
->stopped
&& debug_linux_nat
)
1855 fprintf_unfiltered (gdb_stdlog
,
1856 "RC: Not resuming sibling %s (has pending)\n",
1857 target_pid_to_str (lp
->ptid
));
1858 else if (debug_linux_nat
)
1859 fprintf_unfiltered (gdb_stdlog
,
1860 "RC: Not resuming sibling %s (not stopped)\n",
1861 target_pid_to_str (lp
->ptid
));
1867 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1874 resume_set_callback (struct lwp_info
*lp
, void *data
)
1881 linux_nat_resume (struct target_ops
*ops
,
1882 ptid_t ptid
, int step
, enum target_signal signo
)
1885 struct lwp_info
*lp
;
1888 if (debug_linux_nat
)
1889 fprintf_unfiltered (gdb_stdlog
,
1890 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1891 step
? "step" : "resume",
1892 target_pid_to_str (ptid
),
1893 (signo
!= TARGET_SIGNAL_0
1894 ? strsignal (target_signal_to_host (signo
)) : "0"),
1895 target_pid_to_str (inferior_ptid
));
1897 block_child_signals (&prev_mask
);
1899 /* A specific PTID means `step only this process id'. */
1900 resume_many
= (ptid_equal (minus_one_ptid
, ptid
)
1901 || ptid_is_pid (ptid
));
1903 /* Mark the lwps we're resuming as resumed. */
1904 iterate_over_lwps (ptid
, resume_set_callback
, NULL
);
1906 /* See if it's the current inferior that should be handled
1909 lp
= find_lwp_pid (inferior_ptid
);
1911 lp
= find_lwp_pid (ptid
);
1912 gdb_assert (lp
!= NULL
);
1914 /* Remember if we're stepping. */
1917 /* If we have a pending wait status for this thread, there is no
1918 point in resuming the process. But first make sure that
1919 linux_nat_wait won't preemptively handle the event - we
1920 should never take this short-circuit if we are going to
1921 leave LP running, since we have skipped resuming all the
1922 other threads. This bit of code needs to be synchronized
1923 with linux_nat_wait. */
1925 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1927 enum target_signal saved_signo
;
1928 struct inferior
*inf
;
1930 inf
= find_inferior_pid (ptid_get_pid (lp
->ptid
));
1932 saved_signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1934 /* Defer to common code if we're gaining control of the
1936 if (inf
->control
.stop_soon
== NO_STOP_QUIETLY
1937 && signal_stop_state (saved_signo
) == 0
1938 && signal_print_state (saved_signo
) == 0
1939 && signal_pass_state (saved_signo
) == 1)
1941 if (debug_linux_nat
)
1942 fprintf_unfiltered (gdb_stdlog
,
1943 "LLR: Not short circuiting for ignored "
1944 "status 0x%x\n", lp
->status
);
1946 /* FIXME: What should we do if we are supposed to continue
1947 this thread with a signal? */
1948 gdb_assert (signo
== TARGET_SIGNAL_0
);
1949 signo
= saved_signo
;
1954 if (lp
->status
|| lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
1956 /* FIXME: What should we do if we are supposed to continue
1957 this thread with a signal? */
1958 gdb_assert (signo
== TARGET_SIGNAL_0
);
1960 if (debug_linux_nat
)
1961 fprintf_unfiltered (gdb_stdlog
,
1962 "LLR: Short circuiting for status 0x%x\n",
1965 restore_child_signals_mask (&prev_mask
);
1966 if (target_can_async_p ())
1968 target_async (inferior_event_handler
, 0);
1969 /* Tell the event loop we have something to process. */
1975 /* Mark LWP as not stopped to prevent it from being continued by
1980 iterate_over_lwps (ptid
, resume_callback
, NULL
);
1982 /* Convert to something the lower layer understands. */
1983 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
1985 linux_ops
->to_resume (linux_ops
, ptid
, step
, signo
);
1986 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1987 lp
->stopped_by_watchpoint
= 0;
1989 if (debug_linux_nat
)
1990 fprintf_unfiltered (gdb_stdlog
,
1991 "LLR: %s %s, %s (resume event thread)\n",
1992 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1993 target_pid_to_str (ptid
),
1994 (signo
!= TARGET_SIGNAL_0
1995 ? strsignal (target_signal_to_host (signo
)) : "0"));
1997 restore_child_signals_mask (&prev_mask
);
1998 if (target_can_async_p ())
1999 target_async (inferior_event_handler
, 0);
2002 /* Send a signal to an LWP. */
2005 kill_lwp (int lwpid
, int signo
)
2007 /* Use tkill, if possible, in case we are using nptl threads. If tkill
2008 fails, then we are not using nptl threads and we should be using kill. */
2010 #ifdef HAVE_TKILL_SYSCALL
2012 static int tkill_failed
;
2019 ret
= syscall (__NR_tkill
, lwpid
, signo
);
2020 if (errno
!= ENOSYS
)
2027 return kill (lwpid
, signo
);
2030 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
2031 event, check if the core is interested in it: if not, ignore the
2032 event, and keep waiting; otherwise, we need to toggle the LWP's
2033 syscall entry/exit status, since the ptrace event itself doesn't
2034 indicate it, and report the trap to higher layers. */
2037 linux_handle_syscall_trap (struct lwp_info
*lp
, int stopping
)
2039 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
2040 struct gdbarch
*gdbarch
= target_thread_architecture (lp
->ptid
);
2041 int syscall_number
= (int) gdbarch_get_syscall_number (gdbarch
, lp
->ptid
);
2045 /* If we're stopping threads, there's a SIGSTOP pending, which
2046 makes it so that the LWP reports an immediate syscall return,
2047 followed by the SIGSTOP. Skip seeing that "return" using
2048 PTRACE_CONT directly, and let stop_wait_callback collect the
2049 SIGSTOP. Later when the thread is resumed, a new syscall
2050 entry event. If we didn't do this (and returned 0), we'd
2051 leave a syscall entry pending, and our caller, by using
2052 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
2053 itself. Later, when the user re-resumes this LWP, we'd see
2054 another syscall entry event and we'd mistake it for a return.
2056 If stop_wait_callback didn't force the SIGSTOP out of the LWP
2057 (leaving immediately with LWP->signalled set, without issuing
2058 a PTRACE_CONT), it would still be problematic to leave this
2059 syscall enter pending, as later when the thread is resumed,
2060 it would then see the same syscall exit mentioned above,
2061 followed by the delayed SIGSTOP, while the syscall didn't
2062 actually get to execute. It seems it would be even more
2063 confusing to the user. */
2065 if (debug_linux_nat
)
2066 fprintf_unfiltered (gdb_stdlog
,
2067 "LHST: ignoring syscall %d "
2068 "for LWP %ld (stopping threads), "
2069 "resuming with PTRACE_CONT for SIGSTOP\n",
2071 GET_LWP (lp
->ptid
));
2073 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2074 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2078 if (catch_syscall_enabled ())
2080 /* Always update the entry/return state, even if this particular
2081 syscall isn't interesting to the core now. In async mode,
2082 the user could install a new catchpoint for this syscall
2083 between syscall enter/return, and we'll need to know to
2084 report a syscall return if that happens. */
2085 lp
->syscall_state
= (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
2086 ? TARGET_WAITKIND_SYSCALL_RETURN
2087 : TARGET_WAITKIND_SYSCALL_ENTRY
);
2089 if (catching_syscall_number (syscall_number
))
2091 /* Alright, an event to report. */
2092 ourstatus
->kind
= lp
->syscall_state
;
2093 ourstatus
->value
.syscall_number
= syscall_number
;
2095 if (debug_linux_nat
)
2096 fprintf_unfiltered (gdb_stdlog
,
2097 "LHST: stopping for %s of syscall %d"
2100 == TARGET_WAITKIND_SYSCALL_ENTRY
2101 ? "entry" : "return",
2103 GET_LWP (lp
->ptid
));
2107 if (debug_linux_nat
)
2108 fprintf_unfiltered (gdb_stdlog
,
2109 "LHST: ignoring %s of syscall %d "
2111 lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
2112 ? "entry" : "return",
2114 GET_LWP (lp
->ptid
));
2118 /* If we had been syscall tracing, and hence used PT_SYSCALL
2119 before on this LWP, it could happen that the user removes all
2120 syscall catchpoints before we get to process this event.
2121 There are two noteworthy issues here:
2123 - When stopped at a syscall entry event, resuming with
2124 PT_STEP still resumes executing the syscall and reports a
2127 - Only PT_SYSCALL catches syscall enters. If we last
2128 single-stepped this thread, then this event can't be a
2129 syscall enter. If we last single-stepped this thread, this
2130 has to be a syscall exit.
2132 The points above mean that the next resume, be it PT_STEP or
2133 PT_CONTINUE, can not trigger a syscall trace event. */
2134 if (debug_linux_nat
)
2135 fprintf_unfiltered (gdb_stdlog
,
2136 "LHST: caught syscall event "
2137 "with no syscall catchpoints."
2138 " %d for LWP %ld, ignoring\n",
2140 GET_LWP (lp
->ptid
));
2141 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2144 /* The core isn't interested in this event. For efficiency, avoid
2145 stopping all threads only to have the core resume them all again.
2146 Since we're not stopping threads, if we're still syscall tracing
2147 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
2148 subsequent syscall. Simply resume using the inf-ptrace layer,
2149 which knows when to use PT_SYSCALL or PT_CONTINUE. */
2151 /* Note that gdbarch_get_syscall_number may access registers, hence
2153 registers_changed ();
2154 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
2155 lp
->step
, TARGET_SIGNAL_0
);
2159 /* Handle a GNU/Linux extended wait response. If we see a clone
2160 event, we need to add the new LWP to our list (and not report the
2161 trap to higher layers). This function returns non-zero if the
2162 event should be ignored and we should wait again. If STOPPING is
2163 true, the new LWP remains stopped, otherwise it is continued. */
2166 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
2169 int pid
= GET_LWP (lp
->ptid
);
2170 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
2171 int event
= status
>> 16;
2173 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
2174 || event
== PTRACE_EVENT_CLONE
)
2176 unsigned long new_pid
;
2179 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
2181 /* If we haven't already seen the new PID stop, wait for it now. */
2182 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
2184 /* The new child has a pending SIGSTOP. We can't affect it until it
2185 hits the SIGSTOP, but we're already attached. */
2186 ret
= my_waitpid (new_pid
, &status
,
2187 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
2189 perror_with_name (_("waiting for new child"));
2190 else if (ret
!= new_pid
)
2191 internal_error (__FILE__
, __LINE__
,
2192 _("wait returned unexpected PID %d"), ret
);
2193 else if (!WIFSTOPPED (status
))
2194 internal_error (__FILE__
, __LINE__
,
2195 _("wait returned unexpected status 0x%x"), status
);
2198 ourstatus
->value
.related_pid
= ptid_build (new_pid
, new_pid
, 0);
2200 if (event
== PTRACE_EVENT_FORK
2201 && linux_fork_checkpointing_p (GET_PID (lp
->ptid
)))
2203 struct fork_info
*fp
;
2205 /* Handle checkpointing by linux-fork.c here as a special
2206 case. We don't want the follow-fork-mode or 'catch fork'
2207 to interfere with this. */
2209 /* This won't actually modify the breakpoint list, but will
2210 physically remove the breakpoints from the child. */
2211 detach_breakpoints (new_pid
);
2213 /* Retain child fork in ptrace (stopped) state. */
2214 fp
= find_fork_pid (new_pid
);
2216 fp
= add_fork (new_pid
);
2218 /* Report as spurious, so that infrun doesn't want to follow
2219 this fork. We're actually doing an infcall in
2221 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
2222 linux_enable_event_reporting (pid_to_ptid (new_pid
));
2224 /* Report the stop to the core. */
2228 if (event
== PTRACE_EVENT_FORK
)
2229 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
2230 else if (event
== PTRACE_EVENT_VFORK
)
2231 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
2234 struct lwp_info
*new_lp
;
2236 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2238 new_lp
= add_lwp (BUILD_LWP (new_pid
, GET_PID (lp
->ptid
)));
2240 new_lp
->stopped
= 1;
2242 if (WSTOPSIG (status
) != SIGSTOP
)
2244 /* This can happen if someone starts sending signals to
2245 the new thread before it gets a chance to run, which
2246 have a lower number than SIGSTOP (e.g. SIGUSR1).
2247 This is an unlikely case, and harder to handle for
2248 fork / vfork than for clone, so we do not try - but
2249 we handle it for clone events here. We'll send
2250 the other signal on to the thread below. */
2252 new_lp
->signalled
= 1;
2259 /* Add the new thread to GDB's lists as soon as possible
2262 1) the frontend doesn't have to wait for a stop to
2265 2) we tag it with the correct running state. */
2267 /* If the thread_db layer is active, let it know about
2268 this new thread, and add it to GDB's list. */
2269 if (!thread_db_attach_lwp (new_lp
->ptid
))
2271 /* We're not using thread_db. Add it to GDB's
2273 target_post_attach (GET_LWP (new_lp
->ptid
));
2274 add_thread (new_lp
->ptid
);
2279 set_running (new_lp
->ptid
, 1);
2280 set_executing (new_lp
->ptid
, 1);
2284 /* Note the need to use the low target ops to resume, to
2285 handle resuming with PT_SYSCALL if we have syscall
2289 enum target_signal signo
;
2291 new_lp
->stopped
= 0;
2292 new_lp
->resumed
= 1;
2295 ? target_signal_from_host (WSTOPSIG (status
))
2298 linux_ops
->to_resume (linux_ops
, pid_to_ptid (new_pid
),
2305 /* We created NEW_LP so it cannot yet contain STATUS. */
2306 gdb_assert (new_lp
->status
== 0);
2308 /* Save the wait status to report later. */
2309 if (debug_linux_nat
)
2310 fprintf_unfiltered (gdb_stdlog
,
2311 "LHEW: waitpid of new LWP %ld, "
2312 "saving status %s\n",
2313 (long) GET_LWP (new_lp
->ptid
),
2314 status_to_str (status
));
2315 new_lp
->status
= status
;
2319 if (debug_linux_nat
)
2320 fprintf_unfiltered (gdb_stdlog
,
2321 "LHEW: Got clone event "
2322 "from LWP %ld, resuming\n",
2323 GET_LWP (lp
->ptid
));
2324 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
2325 0, TARGET_SIGNAL_0
);
2333 if (event
== PTRACE_EVENT_EXEC
)
2335 if (debug_linux_nat
)
2336 fprintf_unfiltered (gdb_stdlog
,
2337 "LHEW: Got exec event from LWP %ld\n",
2338 GET_LWP (lp
->ptid
));
2340 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
2341 ourstatus
->value
.execd_pathname
2342 = xstrdup (linux_child_pid_to_exec_file (pid
));
2347 if (event
== PTRACE_EVENT_VFORK_DONE
)
2349 if (current_inferior ()->waiting_for_vfork_done
)
2351 if (debug_linux_nat
)
2352 fprintf_unfiltered (gdb_stdlog
,
2353 "LHEW: Got expected PTRACE_EVENT_"
2354 "VFORK_DONE from LWP %ld: stopping\n",
2355 GET_LWP (lp
->ptid
));
2357 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
2361 if (debug_linux_nat
)
2362 fprintf_unfiltered (gdb_stdlog
,
2363 "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2364 "from LWP %ld: resuming\n",
2365 GET_LWP (lp
->ptid
));
2366 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2370 internal_error (__FILE__
, __LINE__
,
2371 _("unknown ptrace event %d"), event
);
2374 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2378 wait_lwp (struct lwp_info
*lp
)
2382 int thread_dead
= 0;
2384 gdb_assert (!lp
->stopped
);
2385 gdb_assert (lp
->status
== 0);
2387 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, 0);
2388 if (pid
== -1 && errno
== ECHILD
)
2390 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
2391 if (pid
== -1 && errno
== ECHILD
)
2393 /* The thread has previously exited. We need to delete it
2394 now because, for some vendor 2.4 kernels with NPTL
2395 support backported, there won't be an exit event unless
2396 it is the main thread. 2.6 kernels will report an exit
2397 event for each thread that exits, as expected. */
2399 if (debug_linux_nat
)
2400 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
2401 target_pid_to_str (lp
->ptid
));
2407 gdb_assert (pid
== GET_LWP (lp
->ptid
));
2409 if (debug_linux_nat
)
2411 fprintf_unfiltered (gdb_stdlog
,
2412 "WL: waitpid %s received %s\n",
2413 target_pid_to_str (lp
->ptid
),
2414 status_to_str (status
));
2418 /* Check if the thread has exited. */
2419 if (WIFEXITED (status
) || WIFSIGNALED (status
))
2422 if (debug_linux_nat
)
2423 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
2424 target_pid_to_str (lp
->ptid
));
2433 gdb_assert (WIFSTOPPED (status
));
2435 /* Handle GNU/Linux's syscall SIGTRAPs. */
2436 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
2438 /* No longer need the sysgood bit. The ptrace event ends up
2439 recorded in lp->waitstatus if we care for it. We can carry
2440 on handling the event like a regular SIGTRAP from here
2442 status
= W_STOPCODE (SIGTRAP
);
2443 if (linux_handle_syscall_trap (lp
, 1))
2444 return wait_lwp (lp
);
2447 /* Handle GNU/Linux's extended waitstatus for trace events. */
2448 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
2450 if (debug_linux_nat
)
2451 fprintf_unfiltered (gdb_stdlog
,
2452 "WL: Handling extended status 0x%06x\n",
2454 if (linux_handle_extended_wait (lp
, status
, 1))
2455 return wait_lwp (lp
);
2461 /* Save the most recent siginfo for LP. This is currently only called
2462 for SIGTRAP; some ports use the si_addr field for
2463 target_stopped_data_address. In the future, it may also be used to
2464 restore the siginfo of requeued signals. */
2467 save_siginfo (struct lwp_info
*lp
)
2470 ptrace (PTRACE_GETSIGINFO
, GET_LWP (lp
->ptid
),
2471 (PTRACE_TYPE_ARG3
) 0, &lp
->siginfo
);
2474 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
2477 /* Send a SIGSTOP to LP. */
2480 stop_callback (struct lwp_info
*lp
, void *data
)
2482 if (!lp
->stopped
&& !lp
->signalled
)
2486 if (debug_linux_nat
)
2488 fprintf_unfiltered (gdb_stdlog
,
2489 "SC: kill %s **<SIGSTOP>**\n",
2490 target_pid_to_str (lp
->ptid
));
2493 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
2494 if (debug_linux_nat
)
2496 fprintf_unfiltered (gdb_stdlog
,
2497 "SC: lwp kill %d %s\n",
2499 errno
? safe_strerror (errno
) : "ERRNO-OK");
2503 gdb_assert (lp
->status
== 0);
2509 /* Return non-zero if LWP PID has a pending SIGINT. */
2512 linux_nat_has_pending_sigint (int pid
)
2514 sigset_t pending
, blocked
, ignored
;
2516 linux_proc_pending_signals (pid
, &pending
, &blocked
, &ignored
);
2518 if (sigismember (&pending
, SIGINT
)
2519 && !sigismember (&ignored
, SIGINT
))
2525 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2528 set_ignore_sigint (struct lwp_info
*lp
, void *data
)
2530 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2531 flag to consume the next one. */
2532 if (lp
->stopped
&& lp
->status
!= 0 && WIFSTOPPED (lp
->status
)
2533 && WSTOPSIG (lp
->status
) == SIGINT
)
2536 lp
->ignore_sigint
= 1;
2541 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2542 This function is called after we know the LWP has stopped; if the LWP
2543 stopped before the expected SIGINT was delivered, then it will never have
2544 arrived. Also, if the signal was delivered to a shared queue and consumed
2545 by a different thread, it will never be delivered to this LWP. */
2548 maybe_clear_ignore_sigint (struct lwp_info
*lp
)
2550 if (!lp
->ignore_sigint
)
2553 if (!linux_nat_has_pending_sigint (GET_LWP (lp
->ptid
)))
2555 if (debug_linux_nat
)
2556 fprintf_unfiltered (gdb_stdlog
,
2557 "MCIS: Clearing bogus flag for %s\n",
2558 target_pid_to_str (lp
->ptid
));
2559 lp
->ignore_sigint
= 0;
2563 /* Fetch the possible triggered data watchpoint info and store it in
2566 On some archs, like x86, that use debug registers to set
2567 watchpoints, it's possible that the way to know which watched
2568 address trapped, is to check the register that is used to select
2569 which address to watch. Problem is, between setting the watchpoint
2570 and reading back which data address trapped, the user may change
2571 the set of watchpoints, and, as a consequence, GDB changes the
2572 debug registers in the inferior. To avoid reading back a stale
2573 stopped-data-address when that happens, we cache in LP the fact
2574 that a watchpoint trapped, and the corresponding data address, as
2575 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2576 registers meanwhile, we have the cached data we can rely on. */
2579 save_sigtrap (struct lwp_info
*lp
)
2581 struct cleanup
*old_chain
;
2583 if (linux_ops
->to_stopped_by_watchpoint
== NULL
)
2585 lp
->stopped_by_watchpoint
= 0;
2589 old_chain
= save_inferior_ptid ();
2590 inferior_ptid
= lp
->ptid
;
2592 lp
->stopped_by_watchpoint
= linux_ops
->to_stopped_by_watchpoint ();
2594 if (lp
->stopped_by_watchpoint
)
2596 if (linux_ops
->to_stopped_data_address
!= NULL
)
2597 lp
->stopped_data_address_p
=
2598 linux_ops
->to_stopped_data_address (¤t_target
,
2599 &lp
->stopped_data_address
);
2601 lp
->stopped_data_address_p
= 0;
2604 do_cleanups (old_chain
);
2607 /* See save_sigtrap. */
2610 linux_nat_stopped_by_watchpoint (void)
2612 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2614 gdb_assert (lp
!= NULL
);
2616 return lp
->stopped_by_watchpoint
;
2620 linux_nat_stopped_data_address (struct target_ops
*ops
, CORE_ADDR
*addr_p
)
2622 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2624 gdb_assert (lp
!= NULL
);
2626 *addr_p
= lp
->stopped_data_address
;
2628 return lp
->stopped_data_address_p
;
2631 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2634 sigtrap_is_event (int status
)
2636 return WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
;
2639 /* SIGTRAP-like events recognizer. */
2641 static int (*linux_nat_status_is_event
) (int status
) = sigtrap_is_event
;
2643 /* Check for SIGTRAP-like events in LP. */
2646 linux_nat_lp_status_is_event (struct lwp_info
*lp
)
2648 /* We check for lp->waitstatus in addition to lp->status, because we can
2649 have pending process exits recorded in lp->status
2650 and W_EXITCODE(0,0) == 0. We should probably have an additional
2651 lp->status_p flag. */
2653 return (lp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
2654 && linux_nat_status_is_event (lp
->status
));
2657 /* Set alternative SIGTRAP-like events recognizer. If
2658 breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2662 linux_nat_set_status_is_event (struct target_ops
*t
,
2663 int (*status_is_event
) (int status
))
2665 linux_nat_status_is_event
= status_is_event
;
2668 /* Wait until LP is stopped. */
2671 stop_wait_callback (struct lwp_info
*lp
, void *data
)
2673 struct inferior
*inf
= find_inferior_pid (GET_PID (lp
->ptid
));
2675 /* If this is a vfork parent, bail out, it is not going to report
2676 any SIGSTOP until the vfork is done with. */
2677 if (inf
->vfork_child
!= NULL
)
2684 status
= wait_lwp (lp
);
2688 if (lp
->ignore_sigint
&& WIFSTOPPED (status
)
2689 && WSTOPSIG (status
) == SIGINT
)
2691 lp
->ignore_sigint
= 0;
2694 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2695 if (debug_linux_nat
)
2696 fprintf_unfiltered (gdb_stdlog
,
2697 "PTRACE_CONT %s, 0, 0 (%s) "
2698 "(discarding SIGINT)\n",
2699 target_pid_to_str (lp
->ptid
),
2700 errno
? safe_strerror (errno
) : "OK");
2702 return stop_wait_callback (lp
, NULL
);
2705 maybe_clear_ignore_sigint (lp
);
2707 if (WSTOPSIG (status
) != SIGSTOP
)
2709 if (linux_nat_status_is_event (status
))
2711 /* If a LWP other than the LWP that we're reporting an
2712 event for has hit a GDB breakpoint (as opposed to
2713 some random trap signal), then just arrange for it to
2714 hit it again later. We don't keep the SIGTRAP status
2715 and don't forward the SIGTRAP signal to the LWP. We
2716 will handle the current event, eventually we will
2717 resume all LWPs, and this one will get its breakpoint
2720 If we do not do this, then we run the risk that the
2721 user will delete or disable the breakpoint, but the
2722 thread will have already tripped on it. */
2724 /* Save the trap's siginfo in case we need it later. */
2729 /* Now resume this LWP and get the SIGSTOP event. */
2731 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2732 if (debug_linux_nat
)
2734 fprintf_unfiltered (gdb_stdlog
,
2735 "PTRACE_CONT %s, 0, 0 (%s)\n",
2736 target_pid_to_str (lp
->ptid
),
2737 errno
? safe_strerror (errno
) : "OK");
2739 fprintf_unfiltered (gdb_stdlog
,
2740 "SWC: Candidate SIGTRAP event in %s\n",
2741 target_pid_to_str (lp
->ptid
));
2743 /* Hold this event/waitstatus while we check to see if
2744 there are any more (we still want to get that SIGSTOP). */
2745 stop_wait_callback (lp
, NULL
);
2747 /* Hold the SIGTRAP for handling by linux_nat_wait. If
2748 there's another event, throw it back into the
2752 if (debug_linux_nat
)
2753 fprintf_unfiltered (gdb_stdlog
,
2754 "SWC: kill %s, %s\n",
2755 target_pid_to_str (lp
->ptid
),
2756 status_to_str ((int) status
));
2757 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
2760 /* Save the sigtrap event. */
2761 lp
->status
= status
;
2766 /* The thread was stopped with a signal other than
2767 SIGSTOP, and didn't accidentally trip a breakpoint. */
2769 if (debug_linux_nat
)
2771 fprintf_unfiltered (gdb_stdlog
,
2772 "SWC: Pending event %s in %s\n",
2773 status_to_str ((int) status
),
2774 target_pid_to_str (lp
->ptid
));
2776 /* Now resume this LWP and get the SIGSTOP event. */
2778 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2779 if (debug_linux_nat
)
2780 fprintf_unfiltered (gdb_stdlog
,
2781 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
2782 target_pid_to_str (lp
->ptid
),
2783 errno
? safe_strerror (errno
) : "OK");
2785 /* Hold this event/waitstatus while we check to see if
2786 there are any more (we still want to get that SIGSTOP). */
2787 stop_wait_callback (lp
, NULL
);
2789 /* If the lp->status field is still empty, use it to
2790 hold this event. If not, then this event must be
2791 returned to the event queue of the LWP. */
2794 if (debug_linux_nat
)
2796 fprintf_unfiltered (gdb_stdlog
,
2797 "SWC: kill %s, %s\n",
2798 target_pid_to_str (lp
->ptid
),
2799 status_to_str ((int) status
));
2801 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
2804 lp
->status
= status
;
2810 /* We caught the SIGSTOP that we intended to catch, so
2811 there's no SIGSTOP pending. */
2820 /* Return non-zero if LP has a wait status pending. */
2823 status_callback (struct lwp_info
*lp
, void *data
)
2825 /* Only report a pending wait status if we pretend that this has
2826 indeed been resumed. */
2830 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
2832 /* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
2833 or a a pending process exit. Note that `W_EXITCODE(0,0) ==
2834 0', so a clean process exit can not be stored pending in
2835 lp->status, it is indistinguishable from
2836 no-pending-status. */
2840 if (lp
->status
!= 0)
2846 /* Return non-zero if LP isn't stopped. */
2849 running_callback (struct lwp_info
*lp
, void *data
)
2851 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
2854 /* Count the LWP's that have had events. */
2857 count_events_callback (struct lwp_info
*lp
, void *data
)
2861 gdb_assert (count
!= NULL
);
2863 /* Count only resumed LWPs that have a SIGTRAP event pending. */
2864 if (lp
->resumed
&& linux_nat_lp_status_is_event (lp
))
2870 /* Select the LWP (if any) that is currently being single-stepped. */
2873 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
2875 if (lp
->step
&& lp
->status
!= 0)
2881 /* Select the Nth LWP that has had a SIGTRAP event. */
2884 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
2886 int *selector
= data
;
2888 gdb_assert (selector
!= NULL
);
2890 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2891 if (lp
->resumed
&& linux_nat_lp_status_is_event (lp
))
2892 if ((*selector
)-- == 0)
2899 cancel_breakpoint (struct lwp_info
*lp
)
2901 /* Arrange for a breakpoint to be hit again later. We don't keep
2902 the SIGTRAP status and don't forward the SIGTRAP signal to the
2903 LWP. We will handle the current event, eventually we will resume
2904 this LWP, and this breakpoint will trap again.
2906 If we do not do this, then we run the risk that the user will
2907 delete or disable the breakpoint, but the LWP will have already
2910 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
2911 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2914 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
2915 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
2917 if (debug_linux_nat
)
2918 fprintf_unfiltered (gdb_stdlog
,
2919 "CB: Push back breakpoint for %s\n",
2920 target_pid_to_str (lp
->ptid
));
2922 /* Back up the PC if necessary. */
2923 if (gdbarch_decr_pc_after_break (gdbarch
))
2924 regcache_write_pc (regcache
, pc
);
2932 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
2934 struct lwp_info
*event_lp
= data
;
2936 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2940 /* If a LWP other than the LWP that we're reporting an event for has
2941 hit a GDB breakpoint (as opposed to some random trap signal),
2942 then just arrange for it to hit it again later. We don't keep
2943 the SIGTRAP status and don't forward the SIGTRAP signal to the
2944 LWP. We will handle the current event, eventually we will resume
2945 all LWPs, and this one will get its breakpoint trap again.
2947 If we do not do this, then we run the risk that the user will
2948 delete or disable the breakpoint, but the LWP will have already
2951 if (linux_nat_lp_status_is_event (lp
)
2952 && cancel_breakpoint (lp
))
2953 /* Throw away the SIGTRAP. */
2959 /* Select one LWP out of those that have events pending. */
2962 select_event_lwp (ptid_t filter
, struct lwp_info
**orig_lp
, int *status
)
2965 int random_selector
;
2966 struct lwp_info
*event_lp
;
2968 /* Record the wait status for the original LWP. */
2969 (*orig_lp
)->status
= *status
;
2971 /* Give preference to any LWP that is being single-stepped. */
2972 event_lp
= iterate_over_lwps (filter
,
2973 select_singlestep_lwp_callback
, NULL
);
2974 if (event_lp
!= NULL
)
2976 if (debug_linux_nat
)
2977 fprintf_unfiltered (gdb_stdlog
,
2978 "SEL: Select single-step %s\n",
2979 target_pid_to_str (event_lp
->ptid
));
2983 /* No single-stepping LWP. Select one at random, out of those
2984 which have had SIGTRAP events. */
2986 /* First see how many SIGTRAP events we have. */
2987 iterate_over_lwps (filter
, count_events_callback
, &num_events
);
2989 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2990 random_selector
= (int)
2991 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2993 if (debug_linux_nat
&& num_events
> 1)
2994 fprintf_unfiltered (gdb_stdlog
,
2995 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2996 num_events
, random_selector
);
2998 event_lp
= iterate_over_lwps (filter
,
2999 select_event_lwp_callback
,
3003 if (event_lp
!= NULL
)
3005 /* Switch the event LWP. */
3006 *orig_lp
= event_lp
;
3007 *status
= event_lp
->status
;
3010 /* Flush the wait status for the event LWP. */
3011 (*orig_lp
)->status
= 0;
3014 /* Return non-zero if LP has been resumed. */
3017 resumed_callback (struct lwp_info
*lp
, void *data
)
3022 /* Stop an active thread, verify it still exists, then resume it. */
3025 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
3027 struct lwp_info
*ptr
;
3029 if (!lp
->stopped
&& !lp
->signalled
)
3031 stop_callback (lp
, NULL
);
3032 stop_wait_callback (lp
, NULL
);
3033 /* Resume if the lwp still exists. */
3034 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
3037 resume_callback (lp
, NULL
);
3038 resume_set_callback (lp
, NULL
);
3044 /* Check if we should go on and pass this event to common code.
3045 Return the affected lwp if we are, or NULL otherwise. */
3046 static struct lwp_info
*
3047 linux_nat_filter_event (int lwpid
, int status
, int options
)
3049 struct lwp_info
*lp
;
3051 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
3053 /* Check for stop events reported by a process we didn't already
3054 know about - anything not already in our LWP list.
3056 If we're expecting to receive stopped processes after
3057 fork, vfork, and clone events, then we'll just add the
3058 new one to our list and go back to waiting for the event
3059 to be reported - the stopped process might be returned
3060 from waitpid before or after the event is. */
3061 if (WIFSTOPPED (status
) && !lp
)
3063 linux_record_stopped_pid (lwpid
, status
);
3067 /* Make sure we don't report an event for the exit of an LWP not in
3068 our list, i.e. not part of the current process. This can happen
3069 if we detach from a program we original forked and then it
3071 if (!WIFSTOPPED (status
) && !lp
)
3074 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
3075 CLONE_PTRACE processes which do not use the thread library -
3076 otherwise we wouldn't find the new LWP this way. That doesn't
3077 currently work, and the following code is currently unreachable
3078 due to the two blocks above. If it's fixed some day, this code
3079 should be broken out into a function so that we can also pick up
3080 LWPs from the new interface. */
3083 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
3084 if (options
& __WCLONE
)
3087 gdb_assert (WIFSTOPPED (status
)
3088 && WSTOPSIG (status
) == SIGSTOP
);
3091 if (!in_thread_list (inferior_ptid
))
3093 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
3094 GET_PID (inferior_ptid
));
3095 add_thread (inferior_ptid
);
3098 add_thread (lp
->ptid
);
3101 /* Handle GNU/Linux's syscall SIGTRAPs. */
3102 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
3104 /* No longer need the sysgood bit. The ptrace event ends up
3105 recorded in lp->waitstatus if we care for it. We can carry
3106 on handling the event like a regular SIGTRAP from here
3108 status
= W_STOPCODE (SIGTRAP
);
3109 if (linux_handle_syscall_trap (lp
, 0))
3113 /* Handle GNU/Linux's extended waitstatus for trace events. */
3114 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
3116 if (debug_linux_nat
)
3117 fprintf_unfiltered (gdb_stdlog
,
3118 "LLW: Handling extended status 0x%06x\n",
3120 if (linux_handle_extended_wait (lp
, status
, 0))
3124 if (linux_nat_status_is_event (status
))
3126 /* Save the trap's siginfo in case we need it later. */
3132 /* Check if the thread has exited. */
3133 if ((WIFEXITED (status
) || WIFSIGNALED (status
))
3134 && num_lwps (GET_PID (lp
->ptid
)) > 1)
3136 /* If this is the main thread, we must stop all threads and verify
3137 if they are still alive. This is because in the nptl thread model
3138 on Linux 2.4, there is no signal issued for exiting LWPs
3139 other than the main thread. We only get the main thread exit
3140 signal once all child threads have already exited. If we
3141 stop all the threads and use the stop_wait_callback to check
3142 if they have exited we can determine whether this signal
3143 should be ignored or whether it means the end of the debugged
3144 application, regardless of which threading model is being
3146 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
3149 iterate_over_lwps (pid_to_ptid (GET_PID (lp
->ptid
)),
3150 stop_and_resume_callback
, NULL
);
3153 if (debug_linux_nat
)
3154 fprintf_unfiltered (gdb_stdlog
,
3155 "LLW: %s exited.\n",
3156 target_pid_to_str (lp
->ptid
));
3158 if (num_lwps (GET_PID (lp
->ptid
)) > 1)
3160 /* If there is at least one more LWP, then the exit signal
3161 was not the end of the debugged application and should be
3168 /* Check if the current LWP has previously exited. In the nptl
3169 thread model, LWPs other than the main thread do not issue
3170 signals when they exit so we must check whenever the thread has
3171 stopped. A similar check is made in stop_wait_callback(). */
3172 if (num_lwps (GET_PID (lp
->ptid
)) > 1 && !linux_thread_alive (lp
->ptid
))
3174 ptid_t ptid
= pid_to_ptid (GET_PID (lp
->ptid
));
3176 if (debug_linux_nat
)
3177 fprintf_unfiltered (gdb_stdlog
,
3178 "LLW: %s exited.\n",
3179 target_pid_to_str (lp
->ptid
));
3183 /* Make sure there is at least one thread running. */
3184 gdb_assert (iterate_over_lwps (ptid
, running_callback
, NULL
));
3186 /* Discard the event. */
3190 /* Make sure we don't report a SIGSTOP that we sent ourselves in
3191 an attempt to stop an LWP. */
3193 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
3195 if (debug_linux_nat
)
3196 fprintf_unfiltered (gdb_stdlog
,
3197 "LLW: Delayed SIGSTOP caught for %s.\n",
3198 target_pid_to_str (lp
->ptid
));
3200 /* This is a delayed SIGSTOP. */
3203 registers_changed ();
3205 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3206 lp
->step
, TARGET_SIGNAL_0
);
3207 if (debug_linux_nat
)
3208 fprintf_unfiltered (gdb_stdlog
,
3209 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
3211 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3212 target_pid_to_str (lp
->ptid
));
3215 gdb_assert (lp
->resumed
);
3217 /* Discard the event. */
3221 /* Make sure we don't report a SIGINT that we have already displayed
3222 for another thread. */
3223 if (lp
->ignore_sigint
3224 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGINT
)
3226 if (debug_linux_nat
)
3227 fprintf_unfiltered (gdb_stdlog
,
3228 "LLW: Delayed SIGINT caught for %s.\n",
3229 target_pid_to_str (lp
->ptid
));
3231 /* This is a delayed SIGINT. */
3232 lp
->ignore_sigint
= 0;
3234 registers_changed ();
3235 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3236 lp
->step
, TARGET_SIGNAL_0
);
3237 if (debug_linux_nat
)
3238 fprintf_unfiltered (gdb_stdlog
,
3239 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3241 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3242 target_pid_to_str (lp
->ptid
));
3245 gdb_assert (lp
->resumed
);
3247 /* Discard the event. */
3251 /* An interesting event. */
3253 lp
->status
= status
;
3258 linux_nat_wait_1 (struct target_ops
*ops
,
3259 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3262 static sigset_t prev_mask
;
3263 struct lwp_info
*lp
= NULL
;
3268 if (debug_linux_nat_async
)
3269 fprintf_unfiltered (gdb_stdlog
, "LLW: enter\n");
3271 /* The first time we get here after starting a new inferior, we may
3272 not have added it to the LWP list yet - this is the earliest
3273 moment at which we know its PID. */
3274 if (ptid_is_pid (inferior_ptid
))
3276 /* Upgrade the main thread's ptid. */
3277 thread_change_ptid (inferior_ptid
,
3278 BUILD_LWP (GET_PID (inferior_ptid
),
3279 GET_PID (inferior_ptid
)));
3281 lp
= add_lwp (inferior_ptid
);
3285 /* Make sure SIGCHLD is blocked. */
3286 block_child_signals (&prev_mask
);
3288 if (ptid_equal (ptid
, minus_one_ptid
))
3290 else if (ptid_is_pid (ptid
))
3291 /* A request to wait for a specific tgid. This is not possible
3292 with waitpid, so instead, we wait for any child, and leave
3293 children we're not interested in right now with a pending
3294 status to report later. */
3297 pid
= GET_LWP (ptid
);
3303 /* Make sure that of those LWPs we want to get an event from, there
3304 is at least one LWP that has been resumed. If there's none, just
3305 bail out. The core may just be flushing asynchronously all
3307 if (iterate_over_lwps (ptid
, resumed_callback
, NULL
) == NULL
)
3309 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3311 if (debug_linux_nat_async
)
3312 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (no resumed LWP)\n");
3314 restore_child_signals_mask (&prev_mask
);
3315 return minus_one_ptid
;
3318 /* First check if there is a LWP with a wait status pending. */
3321 /* Any LWP that's been resumed will do. */
3322 lp
= iterate_over_lwps (ptid
, status_callback
, NULL
);
3325 if (debug_linux_nat
&& lp
->status
)
3326 fprintf_unfiltered (gdb_stdlog
,
3327 "LLW: Using pending wait status %s for %s.\n",
3328 status_to_str (lp
->status
),
3329 target_pid_to_str (lp
->ptid
));
3332 /* But if we don't find one, we'll have to wait, and check both
3333 cloned and uncloned processes. We start with the cloned
3335 options
= __WCLONE
| WNOHANG
;
3337 else if (is_lwp (ptid
))
3339 if (debug_linux_nat
)
3340 fprintf_unfiltered (gdb_stdlog
,
3341 "LLW: Waiting for specific LWP %s.\n",
3342 target_pid_to_str (ptid
));
3344 /* We have a specific LWP to check. */
3345 lp
= find_lwp_pid (ptid
);
3348 if (debug_linux_nat
&& lp
->status
)
3349 fprintf_unfiltered (gdb_stdlog
,
3350 "LLW: Using pending wait status %s for %s.\n",
3351 status_to_str (lp
->status
),
3352 target_pid_to_str (lp
->ptid
));
3354 /* If we have to wait, take into account whether PID is a cloned
3355 process or not. And we have to convert it to something that
3356 the layer beneath us can understand. */
3357 options
= lp
->cloned
? __WCLONE
: 0;
3358 pid
= GET_LWP (ptid
);
3360 /* We check for lp->waitstatus in addition to lp->status,
3361 because we can have pending process exits recorded in
3362 lp->status and W_EXITCODE(0,0) == 0. We should probably have
3363 an additional lp->status_p flag. */
3364 if (lp
->status
== 0 && lp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
)
3368 if (lp
&& lp
->signalled
)
3370 /* A pending SIGSTOP may interfere with the normal stream of
3371 events. In a typical case where interference is a problem,
3372 we have a SIGSTOP signal pending for LWP A while
3373 single-stepping it, encounter an event in LWP B, and take the
3374 pending SIGSTOP while trying to stop LWP A. After processing
3375 the event in LWP B, LWP A is continued, and we'll never see
3376 the SIGTRAP associated with the last time we were
3377 single-stepping LWP A. */
3379 /* Resume the thread. It should halt immediately returning the
3381 registers_changed ();
3382 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3383 lp
->step
, TARGET_SIGNAL_0
);
3384 if (debug_linux_nat
)
3385 fprintf_unfiltered (gdb_stdlog
,
3386 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
3387 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3388 target_pid_to_str (lp
->ptid
));
3390 gdb_assert (lp
->resumed
);
3392 /* Catch the pending SIGSTOP. */
3393 status
= lp
->status
;
3396 stop_wait_callback (lp
, NULL
);
3398 /* If the lp->status field isn't empty, we caught another signal
3399 while flushing the SIGSTOP. Return it back to the event
3400 queue of the LWP, as we already have an event to handle. */
3403 if (debug_linux_nat
)
3404 fprintf_unfiltered (gdb_stdlog
,
3405 "LLW: kill %s, %s\n",
3406 target_pid_to_str (lp
->ptid
),
3407 status_to_str (lp
->status
));
3408 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
3411 lp
->status
= status
;
3414 if (!target_can_async_p ())
3416 /* Causes SIGINT to be passed on to the attached process. */
3420 /* Translate generic target_wait options into waitpid options. */
3421 if (target_options
& TARGET_WNOHANG
)
3428 lwpid
= my_waitpid (pid
, &status
, options
);
3432 gdb_assert (pid
== -1 || lwpid
== pid
);
3434 if (debug_linux_nat
)
3436 fprintf_unfiltered (gdb_stdlog
,
3437 "LLW: waitpid %ld received %s\n",
3438 (long) lwpid
, status_to_str (status
));
3441 lp
= linux_nat_filter_event (lwpid
, status
, options
);
3443 /* STATUS is now no longer valid, use LP->STATUS instead. */
3447 && ptid_is_pid (ptid
)
3448 && ptid_get_pid (lp
->ptid
) != ptid_get_pid (ptid
))
3450 gdb_assert (lp
->resumed
);
3452 if (debug_linux_nat
)
3454 "LWP %ld got an event %06x, leaving pending.\n",
3455 ptid_get_lwp (lp
->ptid
), lp
->status
);
3457 if (WIFSTOPPED (lp
->status
))
3459 if (WSTOPSIG (lp
->status
) != SIGSTOP
)
3461 /* Cancel breakpoint hits. The breakpoint may
3462 be removed before we fetch events from this
3463 process to report to the core. It is best
3464 not to assume the moribund breakpoints
3465 heuristic always handles these cases --- it
3466 could be too many events go through to the
3467 core before this one is handled. All-stop
3468 always cancels breakpoint hits in all
3471 && linux_nat_lp_status_is_event (lp
)
3472 && cancel_breakpoint (lp
))
3474 /* Throw away the SIGTRAP. */
3477 if (debug_linux_nat
)
3479 "LLW: LWP %ld hit a breakpoint while"
3480 " waiting for another process;"
3482 ptid_get_lwp (lp
->ptid
));
3492 else if (WIFEXITED (lp
->status
) || WIFSIGNALED (lp
->status
))
3494 if (debug_linux_nat
)
3496 "Process %ld exited while stopping LWPs\n",
3497 ptid_get_lwp (lp
->ptid
));
3499 /* This was the last lwp in the process. Since
3500 events are serialized to GDB core, and we can't
3501 report this one right now, but GDB core and the
3502 other target layers will want to be notified
3503 about the exit code/signal, leave the status
3504 pending for the next time we're able to report
3507 /* Prevent trying to stop this thread again. We'll
3508 never try to resume it because it has a pending
3512 /* Dead LWP's aren't expected to reported a pending
3516 /* Store the pending event in the waitstatus as
3517 well, because W_EXITCODE(0,0) == 0. */
3518 store_waitstatus (&lp
->waitstatus
, lp
->status
);
3532 /* waitpid did return something. Restart over. */
3533 options
|= __WCLONE
;
3541 /* Alternate between checking cloned and uncloned processes. */
3542 options
^= __WCLONE
;
3544 /* And every time we have checked both:
3545 In async mode, return to event loop;
3546 In sync mode, suspend waiting for a SIGCHLD signal. */
3547 if (options
& __WCLONE
)
3549 if (target_options
& TARGET_WNOHANG
)
3551 /* No interesting event. */
3552 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3554 if (debug_linux_nat_async
)
3555 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
3557 restore_child_signals_mask (&prev_mask
);
3558 return minus_one_ptid
;
3561 sigsuspend (&suspend_mask
);
3564 else if (target_options
& TARGET_WNOHANG
)
3566 /* No interesting event for PID yet. */
3567 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3569 if (debug_linux_nat_async
)
3570 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
3572 restore_child_signals_mask (&prev_mask
);
3573 return minus_one_ptid
;
3576 /* We shouldn't end up here unless we want to try again. */
3577 gdb_assert (lp
== NULL
);
3580 if (!target_can_async_p ())
3581 clear_sigint_trap ();
3585 status
= lp
->status
;
3588 /* Don't report signals that GDB isn't interested in, such as
3589 signals that are neither printed nor stopped upon. Stopping all
3590 threads can be a bit time-consuming so if we want decent
3591 performance with heavily multi-threaded programs, especially when
3592 they're using a high frequency timer, we'd better avoid it if we
3595 if (WIFSTOPPED (status
))
3597 enum target_signal signo
= target_signal_from_host (WSTOPSIG (status
));
3598 struct inferior
*inf
;
3600 inf
= find_inferior_pid (ptid_get_pid (lp
->ptid
));
3603 /* Defer to common code if we get a signal while
3604 single-stepping, since that may need special care, e.g. to
3605 skip the signal handler, or, if we're gaining control of the
3608 && inf
->control
.stop_soon
== NO_STOP_QUIETLY
3609 && signal_stop_state (signo
) == 0
3610 && signal_print_state (signo
) == 0
3611 && signal_pass_state (signo
) == 1)
3613 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
3614 here? It is not clear we should. GDB may not expect
3615 other threads to run. On the other hand, not resuming
3616 newly attached threads may cause an unwanted delay in
3617 getting them running. */
3618 registers_changed ();
3619 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3621 if (debug_linux_nat
)
3622 fprintf_unfiltered (gdb_stdlog
,
3623 "LLW: %s %s, %s (preempt 'handle')\n",
3625 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3626 target_pid_to_str (lp
->ptid
),
3627 (signo
!= TARGET_SIGNAL_0
3628 ? strsignal (target_signal_to_host (signo
))
3636 /* Only do the below in all-stop, as we currently use SIGINT
3637 to implement target_stop (see linux_nat_stop) in
3639 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
3641 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3642 forwarded to the entire process group, that is, all LWPs
3643 will receive it - unless they're using CLONE_THREAD to
3644 share signals. Since we only want to report it once, we
3645 mark it as ignored for all LWPs except this one. */
3646 iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid
)),
3647 set_ignore_sigint
, NULL
);
3648 lp
->ignore_sigint
= 0;
3651 maybe_clear_ignore_sigint (lp
);
3655 /* This LWP is stopped now. */
3658 if (debug_linux_nat
)
3659 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
3660 status_to_str (status
), target_pid_to_str (lp
->ptid
));
3664 /* Now stop all other LWP's ... */
3665 iterate_over_lwps (minus_one_ptid
, stop_callback
, NULL
);
3667 /* ... and wait until all of them have reported back that
3668 they're no longer running. */
3669 iterate_over_lwps (minus_one_ptid
, stop_wait_callback
, NULL
);
3671 /* If we're not waiting for a specific LWP, choose an event LWP
3672 from among those that have had events. Giving equal priority
3673 to all LWPs that have had events helps prevent
3676 select_event_lwp (ptid
, &lp
, &status
);
3678 /* Now that we've selected our final event LWP, cancel any
3679 breakpoints in other LWPs that have hit a GDB breakpoint.
3680 See the comment in cancel_breakpoints_callback to find out
3682 iterate_over_lwps (minus_one_ptid
, cancel_breakpoints_callback
, lp
);
3684 /* In all-stop, from the core's perspective, all LWPs are now
3685 stopped until a new resume action is sent over. */
3686 iterate_over_lwps (minus_one_ptid
, resume_clear_callback
, NULL
);
3691 if (linux_nat_status_is_event (status
))
3693 if (debug_linux_nat
)
3694 fprintf_unfiltered (gdb_stdlog
,
3695 "LLW: trap ptid is %s.\n",
3696 target_pid_to_str (lp
->ptid
));
3699 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3701 *ourstatus
= lp
->waitstatus
;
3702 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
3705 store_waitstatus (ourstatus
, status
);
3707 if (debug_linux_nat_async
)
3708 fprintf_unfiltered (gdb_stdlog
, "LLW: exit\n");
3710 restore_child_signals_mask (&prev_mask
);
3712 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
3713 || ourstatus
->kind
== TARGET_WAITKIND_SIGNALLED
)
3716 lp
->core
= linux_nat_core_of_thread_1 (lp
->ptid
);
3721 /* Resume LWPs that are currently stopped without any pending status
3722 to report, but are resumed from the core's perspective. */
3725 resume_stopped_resumed_lwps (struct lwp_info
*lp
, void *data
)
3727 ptid_t
*wait_ptid_p
= data
;
3732 && lp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
)
3734 gdb_assert (is_executing (lp
->ptid
));
3736 /* Don't bother if there's a breakpoint at PC that we'd hit
3737 immediately, and we're not waiting for this LWP. */
3738 if (!ptid_match (lp
->ptid
, *wait_ptid_p
))
3740 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
3741 CORE_ADDR pc
= regcache_read_pc (regcache
);
3743 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
3747 if (debug_linux_nat
)
3748 fprintf_unfiltered (gdb_stdlog
,
3749 "RSRL: resuming stopped-resumed LWP %s\n",
3750 target_pid_to_str (lp
->ptid
));
3752 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3753 lp
->step
, TARGET_SIGNAL_0
);
3755 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
3756 lp
->stopped_by_watchpoint
= 0;
3763 linux_nat_wait (struct target_ops
*ops
,
3764 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3769 if (debug_linux_nat
)
3770 fprintf_unfiltered (gdb_stdlog
,
3771 "linux_nat_wait: [%s]\n", target_pid_to_str (ptid
));
3773 /* Flush the async file first. */
3774 if (target_can_async_p ())
3775 async_file_flush ();
3777 /* Resume LWPs that are currently stopped without any pending status
3778 to report, but are resumed from the core's perspective. LWPs get
3779 in this state if we find them stopping at a time we're not
3780 interested in reporting the event (target_wait on a
3781 specific_process, for example, see linux_nat_wait_1), and
3782 meanwhile the event became uninteresting. Don't bother resuming
3783 LWPs we're not going to wait for if they'd stop immediately. */
3785 iterate_over_lwps (minus_one_ptid
, resume_stopped_resumed_lwps
, &ptid
);
3787 event_ptid
= linux_nat_wait_1 (ops
, ptid
, ourstatus
, target_options
);
3789 /* If we requested any event, and something came out, assume there
3790 may be more. If we requested a specific lwp or process, also
3791 assume there may be more. */
3792 if (target_can_async_p ()
3793 && (ourstatus
->kind
!= TARGET_WAITKIND_IGNORE
3794 || !ptid_equal (ptid
, minus_one_ptid
)))
3797 /* Get ready for the next event. */
3798 if (target_can_async_p ())
3799 target_async (inferior_event_handler
, 0);
3805 kill_callback (struct lwp_info
*lp
, void *data
)
3808 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
3809 if (debug_linux_nat
)
3810 fprintf_unfiltered (gdb_stdlog
,
3811 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
3812 target_pid_to_str (lp
->ptid
),
3813 errno
? safe_strerror (errno
) : "OK");
3819 kill_wait_callback (struct lwp_info
*lp
, void *data
)
3823 /* We must make sure that there are no pending events (delayed
3824 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3825 program doesn't interfere with any following debugging session. */
3827 /* For cloned processes we must check both with __WCLONE and
3828 without, since the exit status of a cloned process isn't reported
3834 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
3835 if (pid
!= (pid_t
) -1)
3837 if (debug_linux_nat
)
3838 fprintf_unfiltered (gdb_stdlog
,
3839 "KWC: wait %s received unknown.\n",
3840 target_pid_to_str (lp
->ptid
));
3841 /* The Linux kernel sometimes fails to kill a thread
3842 completely after PTRACE_KILL; that goes from the stop
3843 point in do_fork out to the one in
3844 get_signal_to_deliever and waits again. So kill it
3846 kill_callback (lp
, NULL
);
3849 while (pid
== GET_LWP (lp
->ptid
));
3851 gdb_assert (pid
== -1 && errno
== ECHILD
);
3856 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
3857 if (pid
!= (pid_t
) -1)
3859 if (debug_linux_nat
)
3860 fprintf_unfiltered (gdb_stdlog
,
3861 "KWC: wait %s received unk.\n",
3862 target_pid_to_str (lp
->ptid
));
3863 /* See the call to kill_callback above. */
3864 kill_callback (lp
, NULL
);
3867 while (pid
== GET_LWP (lp
->ptid
));
3869 gdb_assert (pid
== -1 && errno
== ECHILD
);
3874 linux_nat_kill (struct target_ops
*ops
)
3876 struct target_waitstatus last
;
3880 /* If we're stopped while forking and we haven't followed yet,
3881 kill the other task. We need to do this first because the
3882 parent will be sleeping if this is a vfork. */
3884 get_last_target_status (&last_ptid
, &last
);
3886 if (last
.kind
== TARGET_WAITKIND_FORKED
3887 || last
.kind
== TARGET_WAITKIND_VFORKED
)
3889 ptrace (PT_KILL
, PIDGET (last
.value
.related_pid
), 0, 0);
3893 if (forks_exist_p ())
3894 linux_fork_killall ();
3897 ptid_t ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
3899 /* Stop all threads before killing them, since ptrace requires
3900 that the thread is stopped to sucessfully PTRACE_KILL. */
3901 iterate_over_lwps (ptid
, stop_callback
, NULL
);
3902 /* ... and wait until all of them have reported back that
3903 they're no longer running. */
3904 iterate_over_lwps (ptid
, stop_wait_callback
, NULL
);
3906 /* Kill all LWP's ... */
3907 iterate_over_lwps (ptid
, kill_callback
, NULL
);
3909 /* ... and wait until we've flushed all events. */
3910 iterate_over_lwps (ptid
, kill_wait_callback
, NULL
);
3913 target_mourn_inferior ();
3917 linux_nat_mourn_inferior (struct target_ops
*ops
)
3919 purge_lwp_list (ptid_get_pid (inferior_ptid
));
3921 if (! forks_exist_p ())
3922 /* Normal case, no other forks available. */
3923 linux_ops
->to_mourn_inferior (ops
);
3925 /* Multi-fork case. The current inferior_ptid has exited, but
3926 there are other viable forks to debug. Delete the exiting
3927 one and context-switch to the first available. */
3928 linux_fork_mourn_inferior ();
3931 /* Convert a native/host siginfo object, into/from the siginfo in the
3932 layout of the inferiors' architecture. */
3935 siginfo_fixup (struct siginfo
*siginfo
, gdb_byte
*inf_siginfo
, int direction
)
3939 if (linux_nat_siginfo_fixup
!= NULL
)
3940 done
= linux_nat_siginfo_fixup (siginfo
, inf_siginfo
, direction
);
3942 /* If there was no callback, or the callback didn't do anything,
3943 then just do a straight memcpy. */
3947 memcpy (siginfo
, inf_siginfo
, sizeof (struct siginfo
));
3949 memcpy (inf_siginfo
, siginfo
, sizeof (struct siginfo
));
3954 linux_xfer_siginfo (struct target_ops
*ops
, enum target_object object
,
3955 const char *annex
, gdb_byte
*readbuf
,
3956 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3959 struct siginfo siginfo
;
3960 gdb_byte inf_siginfo
[sizeof (struct siginfo
)];
3962 gdb_assert (object
== TARGET_OBJECT_SIGNAL_INFO
);
3963 gdb_assert (readbuf
|| writebuf
);
3965 pid
= GET_LWP (inferior_ptid
);
3967 pid
= GET_PID (inferior_ptid
);
3969 if (offset
> sizeof (siginfo
))
3973 ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
3977 /* When GDB is built as a 64-bit application, ptrace writes into
3978 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3979 inferior with a 64-bit GDB should look the same as debugging it
3980 with a 32-bit GDB, we need to convert it. GDB core always sees
3981 the converted layout, so any read/write will have to be done
3983 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
3985 if (offset
+ len
> sizeof (siginfo
))
3986 len
= sizeof (siginfo
) - offset
;
3988 if (readbuf
!= NULL
)
3989 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
3992 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
3994 /* Convert back to ptrace layout before flushing it out. */
3995 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
3998 ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
4007 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4008 const char *annex
, gdb_byte
*readbuf
,
4009 const gdb_byte
*writebuf
,
4010 ULONGEST offset
, LONGEST len
)
4012 struct cleanup
*old_chain
;
4015 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
4016 return linux_xfer_siginfo (ops
, object
, annex
, readbuf
, writebuf
,
4019 /* The target is connected but no live inferior is selected. Pass
4020 this request down to a lower stratum (e.g., the executable
4022 if (object
== TARGET_OBJECT_MEMORY
&& ptid_equal (inferior_ptid
, null_ptid
))
4025 old_chain
= save_inferior_ptid ();
4027 if (is_lwp (inferior_ptid
))
4028 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
4030 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
4033 do_cleanups (old_chain
);
4038 linux_thread_alive (ptid_t ptid
)
4042 gdb_assert (is_lwp (ptid
));
4044 /* Send signal 0 instead of anything ptrace, because ptracing a
4045 running thread errors out claiming that the thread doesn't
4047 err
= kill_lwp (GET_LWP (ptid
), 0);
4049 if (debug_linux_nat
)
4050 fprintf_unfiltered (gdb_stdlog
,
4051 "LLTA: KILL(SIG0) %s (%s)\n",
4052 target_pid_to_str (ptid
),
4053 err
? safe_strerror (err
) : "OK");
4062 linux_nat_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4064 return linux_thread_alive (ptid
);
4068 linux_nat_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
4070 static char buf
[64];
4073 && (GET_PID (ptid
) != GET_LWP (ptid
)
4074 || num_lwps (GET_PID (ptid
)) > 1))
4076 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
4080 return normal_pid_to_str (ptid
);
4083 /* Accepts an integer PID; Returns a string representing a file that
4084 can be opened to get the symbols for the child process. */
4087 linux_child_pid_to_exec_file (int pid
)
4089 char *name1
, *name2
;
4091 name1
= xmalloc (MAXPATHLEN
);
4092 name2
= xmalloc (MAXPATHLEN
);
4093 make_cleanup (xfree
, name1
);
4094 make_cleanup (xfree
, name2
);
4095 memset (name2
, 0, MAXPATHLEN
);
4097 sprintf (name1
, "/proc/%d/exe", pid
);
4098 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
4104 /* Service function for corefiles and info proc. */
4107 read_mapping (FILE *mapfile
,
4112 char *device
, long long *inode
, char *filename
)
4114 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
4115 addr
, endaddr
, permissions
, offset
, device
, inode
);
4118 if (ret
> 0 && ret
!= EOF
)
4120 /* Eat everything up to EOL for the filename. This will prevent
4121 weird filenames (such as one with embedded whitespace) from
4122 confusing this code. It also makes this code more robust in
4123 respect to annotations the kernel may add after the filename.
4125 Note the filename is used for informational purposes
4127 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
4130 return (ret
!= 0 && ret
!= EOF
);
4133 /* Fills the "to_find_memory_regions" target vector. Lists the memory
4134 regions in the inferior for a corefile. */
4137 linux_nat_find_memory_regions (find_memory_region_ftype func
, void *obfd
)
4139 int pid
= PIDGET (inferior_ptid
);
4140 char mapsfilename
[MAXPATHLEN
];
4142 long long addr
, endaddr
, size
, offset
, inode
;
4143 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
4144 int read
, write
, exec
;
4145 struct cleanup
*cleanup
;
4147 /* Compose the filename for the /proc memory map, and open it. */
4148 sprintf (mapsfilename
, "/proc/%d/maps", pid
);
4149 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
4150 error (_("Could not open %s."), mapsfilename
);
4151 cleanup
= make_cleanup_fclose (mapsfile
);
4154 fprintf_filtered (gdb_stdout
,
4155 "Reading memory regions from %s\n", mapsfilename
);
4157 /* Now iterate until end-of-file. */
4158 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
4159 &offset
, &device
[0], &inode
, &filename
[0]))
4161 size
= endaddr
- addr
;
4163 /* Get the segment's permissions. */
4164 read
= (strchr (permissions
, 'r') != 0);
4165 write
= (strchr (permissions
, 'w') != 0);
4166 exec
= (strchr (permissions
, 'x') != 0);
4170 fprintf_filtered (gdb_stdout
,
4171 "Save segment, %s bytes at %s (%c%c%c)",
4172 plongest (size
), paddress (target_gdbarch
, addr
),
4174 write
? 'w' : ' ', exec
? 'x' : ' ');
4176 fprintf_filtered (gdb_stdout
, " for %s", filename
);
4177 fprintf_filtered (gdb_stdout
, "\n");
4180 /* Invoke the callback function to create the corefile
4182 func (addr
, size
, read
, write
, exec
, obfd
);
4184 do_cleanups (cleanup
);
4189 find_signalled_thread (struct thread_info
*info
, void *data
)
4191 if (info
->suspend
.stop_signal
!= TARGET_SIGNAL_0
4192 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
4198 static enum target_signal
4199 find_stop_signal (void)
4201 struct thread_info
*info
=
4202 iterate_over_threads (find_signalled_thread
, NULL
);
4205 return info
->suspend
.stop_signal
;
4207 return TARGET_SIGNAL_0
;
4210 /* Records the thread's register state for the corefile note
4214 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
4215 char *note_data
, int *note_size
,
4216 enum target_signal stop_signal
)
4218 unsigned long lwp
= ptid_get_lwp (ptid
);
4219 struct gdbarch
*gdbarch
= target_gdbarch
;
4220 struct regcache
*regcache
= get_thread_arch_regcache (ptid
, gdbarch
);
4221 const struct regset
*regset
;
4223 struct cleanup
*old_chain
;
4224 struct core_regset_section
*sect_list
;
4227 old_chain
= save_inferior_ptid ();
4228 inferior_ptid
= ptid
;
4229 target_fetch_registers (regcache
, -1);
4230 do_cleanups (old_chain
);
4232 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
4233 sect_list
= gdbarch_core_regset_sections (gdbarch
);
4235 /* The loop below uses the new struct core_regset_section, which stores
4236 the supported section names and sizes for the core file. Note that
4237 note PRSTATUS needs to be treated specially. But the other notes are
4238 structurally the same, so they can benefit from the new struct. */
4239 if (core_regset_p
&& sect_list
!= NULL
)
4240 while (sect_list
->sect_name
!= NULL
)
4242 regset
= gdbarch_regset_from_core_section (gdbarch
,
4243 sect_list
->sect_name
,
4245 gdb_assert (regset
&& regset
->collect_regset
);
4246 gdb_regset
= xmalloc (sect_list
->size
);
4247 regset
->collect_regset (regset
, regcache
, -1,
4248 gdb_regset
, sect_list
->size
);
4250 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
4251 note_data
= (char *) elfcore_write_prstatus
4252 (obfd
, note_data
, note_size
,
4253 lwp
, target_signal_to_host (stop_signal
),
4256 note_data
= (char *) elfcore_write_register_note
4257 (obfd
, note_data
, note_size
,
4258 sect_list
->sect_name
, gdb_regset
,
4264 /* For architectures that does not have the struct core_regset_section
4265 implemented, we use the old method. When all the architectures have
4266 the new support, the code below should be deleted. */
4269 gdb_gregset_t gregs
;
4270 gdb_fpregset_t fpregs
;
4273 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
4275 != NULL
&& regset
->collect_regset
!= NULL
)
4276 regset
->collect_regset (regset
, regcache
, -1,
4277 &gregs
, sizeof (gregs
));
4279 fill_gregset (regcache
, &gregs
, -1);
4281 note_data
= (char *) elfcore_write_prstatus
4282 (obfd
, note_data
, note_size
, lwp
, target_signal_to_host (stop_signal
),
4286 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
4288 != NULL
&& regset
->collect_regset
!= NULL
)
4289 regset
->collect_regset (regset
, regcache
, -1,
4290 &fpregs
, sizeof (fpregs
));
4292 fill_fpregset (regcache
, &fpregs
, -1);
4294 note_data
= (char *) elfcore_write_prfpreg (obfd
,
4297 &fpregs
, sizeof (fpregs
));
4303 struct linux_nat_corefile_thread_data
4309 enum target_signal stop_signal
;
4312 /* Called by gdbthread.c once per thread. Records the thread's
4313 register state for the corefile note section. */
4316 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
4318 struct linux_nat_corefile_thread_data
*args
= data
;
4320 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
4330 /* Enumerate spufs IDs for process PID. */
4333 iterate_over_spus (int pid
, void (*callback
) (void *, int), void *data
)
4337 struct dirent
*entry
;
4339 xsnprintf (path
, sizeof path
, "/proc/%d/fd", pid
);
4340 dir
= opendir (path
);
4345 while ((entry
= readdir (dir
)) != NULL
)
4351 fd
= atoi (entry
->d_name
);
4355 xsnprintf (path
, sizeof path
, "/proc/%d/fd/%d", pid
, fd
);
4356 if (stat (path
, &st
) != 0)
4358 if (!S_ISDIR (st
.st_mode
))
4361 if (statfs (path
, &stfs
) != 0)
4363 if (stfs
.f_type
!= SPUFS_MAGIC
)
4366 callback (data
, fd
);
4372 /* Generate corefile notes for SPU contexts. */
4374 struct linux_spu_corefile_data
4382 linux_spu_corefile_callback (void *data
, int fd
)
4384 struct linux_spu_corefile_data
*args
= data
;
4387 static const char *spu_files
[] =
4409 for (i
= 0; i
< sizeof (spu_files
) / sizeof (spu_files
[0]); i
++)
4411 char annex
[32], note_name
[32];
4415 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[i
]);
4416 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
4420 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
4421 args
->note_data
= elfcore_write_note (args
->obfd
, args
->note_data
,
4422 args
->note_size
, note_name
,
4423 NT_SPU
, spu_data
, spu_len
);
4430 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
4432 struct linux_spu_corefile_data args
;
4435 args
.note_data
= note_data
;
4436 args
.note_size
= note_size
;
4438 iterate_over_spus (PIDGET (inferior_ptid
),
4439 linux_spu_corefile_callback
, &args
);
4441 return args
.note_data
;
4444 /* Fills the "to_make_corefile_note" target vector. Builds the note
4445 section for a corefile, and returns it in a malloc buffer. */
4448 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
4450 struct linux_nat_corefile_thread_data thread_args
;
4451 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
4452 char fname
[16] = { '\0' };
4453 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
4454 char psargs
[80] = { '\0' };
4455 char *note_data
= NULL
;
4456 ptid_t filter
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
4460 if (get_exec_file (0))
4462 strncpy (fname
, strrchr (get_exec_file (0), '/') + 1, sizeof (fname
));
4463 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
4464 if (get_inferior_args ())
4467 char *psargs_end
= psargs
+ sizeof (psargs
);
4469 /* linux_elfcore_write_prpsinfo () handles zero unterminated
4471 string_end
= memchr (psargs
, 0, sizeof (psargs
));
4472 if (string_end
!= NULL
)
4474 *string_end
++ = ' ';
4475 strncpy (string_end
, get_inferior_args (),
4476 psargs_end
- string_end
);
4479 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
4481 note_size
, fname
, psargs
);
4484 /* Dump information for threads. */
4485 thread_args
.obfd
= obfd
;
4486 thread_args
.note_data
= note_data
;
4487 thread_args
.note_size
= note_size
;
4488 thread_args
.num_notes
= 0;
4489 thread_args
.stop_signal
= find_stop_signal ();
4490 iterate_over_lwps (filter
, linux_nat_corefile_thread_callback
, &thread_args
);
4491 gdb_assert (thread_args
.num_notes
!= 0);
4492 note_data
= thread_args
.note_data
;
4494 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
4498 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
4499 "CORE", NT_AUXV
, auxv
, auxv_len
);
4503 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
4505 make_cleanup (xfree
, note_data
);
4509 /* Implement the "info proc" command. */
4512 linux_nat_info_proc_cmd (char *args
, int from_tty
)
4514 /* A long is used for pid instead of an int to avoid a loss of precision
4515 compiler warning from the output of strtoul. */
4516 long pid
= PIDGET (inferior_ptid
);
4519 char buffer
[MAXPATHLEN
];
4520 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
4532 /* Break up 'args' into an argv array. */
4533 argv
= gdb_buildargv (args
);
4534 make_cleanup_freeargv (argv
);
4536 while (argv
!= NULL
&& *argv
!= NULL
)
4538 if (isdigit (argv
[0][0]))
4540 pid
= strtoul (argv
[0], NULL
, 10);
4542 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
4546 else if (strcmp (argv
[0], "status") == 0)
4550 else if (strcmp (argv
[0], "stat") == 0)
4554 else if (strcmp (argv
[0], "cmd") == 0)
4558 else if (strncmp (argv
[0], "exe", strlen (argv
[0])) == 0)
4562 else if (strcmp (argv
[0], "cwd") == 0)
4566 else if (strncmp (argv
[0], "all", strlen (argv
[0])) == 0)
4572 /* [...] (future options here) */
4577 error (_("No current process: you must name one."));
4579 sprintf (fname1
, "/proc/%ld", pid
);
4580 if (stat (fname1
, &dummy
) != 0)
4581 error (_("No /proc directory: '%s'"), fname1
);
4583 printf_filtered (_("process %ld\n"), pid
);
4584 if (cmdline_f
|| all
)
4586 sprintf (fname1
, "/proc/%ld/cmdline", pid
);
4587 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4589 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4591 if (fgets (buffer
, sizeof (buffer
), procfile
))
4592 printf_filtered ("cmdline = '%s'\n", buffer
);
4594 warning (_("unable to read '%s'"), fname1
);
4595 do_cleanups (cleanup
);
4598 warning (_("unable to open /proc file '%s'"), fname1
);
4602 sprintf (fname1
, "/proc/%ld/cwd", pid
);
4603 memset (fname2
, 0, sizeof (fname2
));
4604 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
4605 printf_filtered ("cwd = '%s'\n", fname2
);
4607 warning (_("unable to read link '%s'"), fname1
);
4611 sprintf (fname1
, "/proc/%ld/exe", pid
);
4612 memset (fname2
, 0, sizeof (fname2
));
4613 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
4614 printf_filtered ("exe = '%s'\n", fname2
);
4616 warning (_("unable to read link '%s'"), fname1
);
4618 if (mappings_f
|| all
)
4620 sprintf (fname1
, "/proc/%ld/maps", pid
);
4621 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4623 long long addr
, endaddr
, size
, offset
, inode
;
4624 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
4625 struct cleanup
*cleanup
;
4627 cleanup
= make_cleanup_fclose (procfile
);
4628 printf_filtered (_("Mapped address spaces:\n\n"));
4629 if (gdbarch_addr_bit (target_gdbarch
) == 32)
4631 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
4634 " Size", " Offset", "objfile");
4638 printf_filtered (" %18s %18s %10s %10s %7s\n",
4641 " Size", " Offset", "objfile");
4644 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
4645 &offset
, &device
[0], &inode
, &filename
[0]))
4647 size
= endaddr
- addr
;
4649 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
4650 calls here (and possibly above) should be abstracted
4651 out into their own functions? Andrew suggests using
4652 a generic local_address_string instead to print out
4653 the addresses; that makes sense to me, too. */
4655 if (gdbarch_addr_bit (target_gdbarch
) == 32)
4657 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
4658 (unsigned long) addr
, /* FIXME: pr_addr */
4659 (unsigned long) endaddr
,
4661 (unsigned int) offset
,
4662 filename
[0] ? filename
: "");
4666 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
4667 (unsigned long) addr
, /* FIXME: pr_addr */
4668 (unsigned long) endaddr
,
4670 (unsigned int) offset
,
4671 filename
[0] ? filename
: "");
4675 do_cleanups (cleanup
);
4678 warning (_("unable to open /proc file '%s'"), fname1
);
4680 if (status_f
|| all
)
4682 sprintf (fname1
, "/proc/%ld/status", pid
);
4683 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4685 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4687 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
4688 puts_filtered (buffer
);
4689 do_cleanups (cleanup
);
4692 warning (_("unable to open /proc file '%s'"), fname1
);
4696 sprintf (fname1
, "/proc/%ld/stat", pid
);
4697 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4702 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4704 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4705 printf_filtered (_("Process: %d\n"), itmp
);
4706 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
4707 printf_filtered (_("Exec file: %s\n"), buffer
);
4708 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
4709 printf_filtered (_("State: %c\n"), ctmp
);
4710 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4711 printf_filtered (_("Parent process: %d\n"), itmp
);
4712 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4713 printf_filtered (_("Process group: %d\n"), itmp
);
4714 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4715 printf_filtered (_("Session id: %d\n"), itmp
);
4716 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4717 printf_filtered (_("TTY: %d\n"), itmp
);
4718 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4719 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
4720 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4721 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
4722 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4723 printf_filtered (_("Minor faults (no memory page): %lu\n"),
4724 (unsigned long) ltmp
);
4725 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4726 printf_filtered (_("Minor faults, children: %lu\n"),
4727 (unsigned long) ltmp
);
4728 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4729 printf_filtered (_("Major faults (memory page faults): %lu\n"),
4730 (unsigned long) ltmp
);
4731 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4732 printf_filtered (_("Major faults, children: %lu\n"),
4733 (unsigned long) ltmp
);
4734 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4735 printf_filtered (_("utime: %ld\n"), ltmp
);
4736 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4737 printf_filtered (_("stime: %ld\n"), ltmp
);
4738 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4739 printf_filtered (_("utime, children: %ld\n"), ltmp
);
4740 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4741 printf_filtered (_("stime, children: %ld\n"), ltmp
);
4742 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4743 printf_filtered (_("jiffies remaining in current "
4744 "time slice: %ld\n"), ltmp
);
4745 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4746 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
4747 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4748 printf_filtered (_("jiffies until next timeout: %lu\n"),
4749 (unsigned long) ltmp
);
4750 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4751 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
4752 (unsigned long) ltmp
);
4753 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4754 printf_filtered (_("start time (jiffies since "
4755 "system boot): %ld\n"), ltmp
);
4756 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4757 printf_filtered (_("Virtual memory size: %lu\n"),
4758 (unsigned long) ltmp
);
4759 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4760 printf_filtered (_("Resident set size: %lu\n"),
4761 (unsigned long) ltmp
);
4762 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4763 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
4764 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4765 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
4766 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4767 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
4768 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4769 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
4770 #if 0 /* Don't know how architecture-dependent the rest is...
4771 Anyway the signal bitmap info is available from "status". */
4772 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
4773 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
4774 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
4775 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
4776 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4777 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
4778 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4779 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
4780 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4781 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
4782 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4783 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
4784 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
4785 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
4787 do_cleanups (cleanup
);
4790 warning (_("unable to open /proc file '%s'"), fname1
);
4794 /* Implement the to_xfer_partial interface for memory reads using the /proc
4795 filesystem. Because we can use a single read() call for /proc, this
4796 can be much more efficient than banging away at PTRACE_PEEKTEXT,
4797 but it doesn't support writes. */
4800 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4801 const char *annex
, gdb_byte
*readbuf
,
4802 const gdb_byte
*writebuf
,
4803 ULONGEST offset
, LONGEST len
)
4809 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
4812 /* Don't bother for one word. */
4813 if (len
< 3 * sizeof (long))
4816 /* We could keep this file open and cache it - possibly one per
4817 thread. That requires some juggling, but is even faster. */
4818 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
4819 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
4823 /* If pread64 is available, use it. It's faster if the kernel
4824 supports it (only one syscall), and it's 64-bit safe even on
4825 32-bit platforms (for instance, SPARC debugging a SPARC64
4828 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
4830 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
4841 /* Enumerate spufs IDs for process PID. */
4843 spu_enumerate_spu_ids (int pid
, gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
4845 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4847 LONGEST written
= 0;
4850 struct dirent
*entry
;
4852 xsnprintf (path
, sizeof path
, "/proc/%d/fd", pid
);
4853 dir
= opendir (path
);
4858 while ((entry
= readdir (dir
)) != NULL
)
4864 fd
= atoi (entry
->d_name
);
4868 xsnprintf (path
, sizeof path
, "/proc/%d/fd/%d", pid
, fd
);
4869 if (stat (path
, &st
) != 0)
4871 if (!S_ISDIR (st
.st_mode
))
4874 if (statfs (path
, &stfs
) != 0)
4876 if (stfs
.f_type
!= SPUFS_MAGIC
)
4879 if (pos
>= offset
&& pos
+ 4 <= offset
+ len
)
4881 store_unsigned_integer (buf
+ pos
- offset
, 4, byte_order
, fd
);
4891 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
4892 object type, using the /proc file system. */
4894 linux_proc_xfer_spu (struct target_ops
*ops
, enum target_object object
,
4895 const char *annex
, gdb_byte
*readbuf
,
4896 const gdb_byte
*writebuf
,
4897 ULONGEST offset
, LONGEST len
)
4902 int pid
= PIDGET (inferior_ptid
);
4909 return spu_enumerate_spu_ids (pid
, readbuf
, offset
, len
);
4912 xsnprintf (buf
, sizeof buf
, "/proc/%d/fd/%s", pid
, annex
);
4913 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
4918 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
4925 ret
= write (fd
, writebuf
, (size_t) len
);
4927 ret
= read (fd
, readbuf
, (size_t) len
);
4934 /* Parse LINE as a signal set and add its set bits to SIGS. */
4937 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
4939 int len
= strlen (line
) - 1;
4943 if (line
[len
] != '\n')
4944 error (_("Could not parse signal set: %s"), line
);
4952 if (*p
>= '0' && *p
<= '9')
4954 else if (*p
>= 'a' && *p
<= 'f')
4955 digit
= *p
- 'a' + 10;
4957 error (_("Could not parse signal set: %s"), line
);
4962 sigaddset (sigs
, signum
+ 1);
4964 sigaddset (sigs
, signum
+ 2);
4966 sigaddset (sigs
, signum
+ 3);
4968 sigaddset (sigs
, signum
+ 4);
4974 /* Find process PID's pending signals from /proc/pid/status and set
4978 linux_proc_pending_signals (int pid
, sigset_t
*pending
,
4979 sigset_t
*blocked
, sigset_t
*ignored
)
4982 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
4983 struct cleanup
*cleanup
;
4985 sigemptyset (pending
);
4986 sigemptyset (blocked
);
4987 sigemptyset (ignored
);
4988 sprintf (fname
, "/proc/%d/status", pid
);
4989 procfile
= fopen (fname
, "r");
4990 if (procfile
== NULL
)
4991 error (_("Could not open %s"), fname
);
4992 cleanup
= make_cleanup_fclose (procfile
);
4994 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
4996 /* Normal queued signals are on the SigPnd line in the status
4997 file. However, 2.6 kernels also have a "shared" pending
4998 queue for delivering signals to a thread group, so check for
5001 Unfortunately some Red Hat kernels include the shared pending
5002 queue but not the ShdPnd status field. */
5004 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
5005 add_line_to_sigset (buffer
+ 8, pending
);
5006 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
5007 add_line_to_sigset (buffer
+ 8, pending
);
5008 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
5009 add_line_to_sigset (buffer
+ 8, blocked
);
5010 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
5011 add_line_to_sigset (buffer
+ 8, ignored
);
5014 do_cleanups (cleanup
);
5018 linux_nat_xfer_osdata (struct target_ops
*ops
, enum target_object object
,
5019 const char *annex
, gdb_byte
*readbuf
,
5020 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5022 /* We make the process list snapshot when the object starts to be
5024 static const char *buf
;
5025 static LONGEST len_avail
= -1;
5026 static struct obstack obstack
;
5030 gdb_assert (object
== TARGET_OBJECT_OSDATA
);
5036 if (len_avail
!= -1 && len_avail
!= 0)
5037 obstack_free (&obstack
, NULL
);
5040 obstack_init (&obstack
);
5041 obstack_grow_str (&obstack
, "<osdata type=\"types\">\n");
5043 obstack_xml_printf (&obstack
,
5045 "<column name=\"Type\">processes</column>"
5046 "<column name=\"Description\">"
5047 "Listing of all processes</column>"
5050 obstack_grow_str0 (&obstack
, "</osdata>\n");
5051 buf
= obstack_finish (&obstack
);
5052 len_avail
= strlen (buf
);
5055 if (offset
>= len_avail
)
5057 /* Done. Get rid of the obstack. */
5058 obstack_free (&obstack
, NULL
);
5064 if (len
> len_avail
- offset
)
5065 len
= len_avail
- offset
;
5066 memcpy (readbuf
, buf
+ offset
, len
);
5071 if (strcmp (annex
, "processes") != 0)
5074 gdb_assert (readbuf
&& !writebuf
);
5078 if (len_avail
!= -1 && len_avail
!= 0)
5079 obstack_free (&obstack
, NULL
);
5082 obstack_init (&obstack
);
5083 obstack_grow_str (&obstack
, "<osdata type=\"processes\">\n");
5085 dirp
= opendir ("/proc");
5090 while ((dp
= readdir (dirp
)) != NULL
)
5092 struct stat statbuf
;
5093 char procentry
[sizeof ("/proc/4294967295")];
5095 if (!isdigit (dp
->d_name
[0])
5096 || NAMELEN (dp
) > sizeof ("4294967295") - 1)
5099 sprintf (procentry
, "/proc/%s", dp
->d_name
);
5100 if (stat (procentry
, &statbuf
) == 0
5101 && S_ISDIR (statbuf
.st_mode
))
5105 char cmd
[MAXPATHLEN
+ 1];
5106 struct passwd
*entry
;
5108 pathname
= xstrprintf ("/proc/%s/cmdline", dp
->d_name
);
5109 entry
= getpwuid (statbuf
.st_uid
);
5111 if ((f
= fopen (pathname
, "r")) != NULL
)
5113 size_t len
= fread (cmd
, 1, sizeof (cmd
) - 1, f
);
5119 for (i
= 0; i
< len
; i
++)
5124 obstack_xml_printf (
5127 "<column name=\"pid\">%s</column>"
5128 "<column name=\"user\">%s</column>"
5129 "<column name=\"command\">%s</column>"
5132 entry
? entry
->pw_name
: "?",
5145 obstack_grow_str0 (&obstack
, "</osdata>\n");
5146 buf
= obstack_finish (&obstack
);
5147 len_avail
= strlen (buf
);
5150 if (offset
>= len_avail
)
5152 /* Done. Get rid of the obstack. */
5153 obstack_free (&obstack
, NULL
);
5159 if (len
> len_avail
- offset
)
5160 len
= len_avail
- offset
;
5161 memcpy (readbuf
, buf
+ offset
, len
);
5167 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5168 const char *annex
, gdb_byte
*readbuf
,
5169 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5173 if (object
== TARGET_OBJECT_AUXV
)
5174 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
5177 if (object
== TARGET_OBJECT_OSDATA
)
5178 return linux_nat_xfer_osdata (ops
, object
, annex
, readbuf
, writebuf
,
5181 if (object
== TARGET_OBJECT_SPU
)
5182 return linux_proc_xfer_spu (ops
, object
, annex
, readbuf
, writebuf
,
5185 /* GDB calculates all the addresses in possibly larget width of the address.
5186 Address width needs to be masked before its final use - either by
5187 linux_proc_xfer_partial or inf_ptrace_xfer_partial.
5189 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
5191 if (object
== TARGET_OBJECT_MEMORY
)
5193 int addr_bit
= gdbarch_addr_bit (target_gdbarch
);
5195 if (addr_bit
< (sizeof (ULONGEST
) * HOST_CHAR_BIT
))
5196 offset
&= ((ULONGEST
) 1 << addr_bit
) - 1;
5199 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
5204 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
5208 /* Create a prototype generic GNU/Linux target. The client can override
5209 it with local methods. */
5212 linux_target_install_ops (struct target_ops
*t
)
5214 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
5215 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
5216 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
5217 t
->to_set_syscall_catchpoint
= linux_child_set_syscall_catchpoint
;
5218 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
5219 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
5220 t
->to_post_attach
= linux_child_post_attach
;
5221 t
->to_follow_fork
= linux_child_follow_fork
;
5222 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
5223 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
5225 super_xfer_partial
= t
->to_xfer_partial
;
5226 t
->to_xfer_partial
= linux_xfer_partial
;
5232 struct target_ops
*t
;
5234 t
= inf_ptrace_target ();
5235 linux_target_install_ops (t
);
5241 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
5243 struct target_ops
*t
;
5245 t
= inf_ptrace_trad_target (register_u_offset
);
5246 linux_target_install_ops (t
);
5251 /* target_is_async_p implementation. */
5254 linux_nat_is_async_p (void)
5256 /* NOTE: palves 2008-03-21: We're only async when the user requests
5257 it explicitly with the "set target-async" command.
5258 Someday, linux will always be async. */
5259 if (!target_async_permitted
)
5262 /* See target.h/target_async_mask. */
5263 return linux_nat_async_mask_value
;
5266 /* target_can_async_p implementation. */
5269 linux_nat_can_async_p (void)
5271 /* NOTE: palves 2008-03-21: We're only async when the user requests
5272 it explicitly with the "set target-async" command.
5273 Someday, linux will always be async. */
5274 if (!target_async_permitted
)
5277 /* See target.h/target_async_mask. */
5278 return linux_nat_async_mask_value
;
5282 linux_nat_supports_non_stop (void)
5287 /* True if we want to support multi-process. To be removed when GDB
5288 supports multi-exec. */
5290 int linux_multi_process
= 1;
5293 linux_nat_supports_multi_process (void)
5295 return linux_multi_process
;
5298 /* target_async_mask implementation. */
5301 linux_nat_async_mask (int new_mask
)
5303 int curr_mask
= linux_nat_async_mask_value
;
5305 if (curr_mask
!= new_mask
)
5309 linux_nat_async (NULL
, 0);
5310 linux_nat_async_mask_value
= new_mask
;
5314 linux_nat_async_mask_value
= new_mask
;
5316 /* If we're going out of async-mask in all-stop, then the
5317 inferior is stopped. The next resume will call
5318 target_async. In non-stop, the target event source
5319 should be always registered in the event loop. Do so
5322 linux_nat_async (inferior_event_handler
, 0);
5329 static int async_terminal_is_ours
= 1;
5331 /* target_terminal_inferior implementation. */
5334 linux_nat_terminal_inferior (void)
5336 if (!target_is_async_p ())
5338 /* Async mode is disabled. */
5339 terminal_inferior ();
5343 terminal_inferior ();
5345 /* Calls to target_terminal_*() are meant to be idempotent. */
5346 if (!async_terminal_is_ours
)
5349 delete_file_handler (input_fd
);
5350 async_terminal_is_ours
= 0;
5354 /* target_terminal_ours implementation. */
5357 linux_nat_terminal_ours (void)
5359 if (!target_is_async_p ())
5361 /* Async mode is disabled. */
5366 /* GDB should never give the terminal to the inferior if the
5367 inferior is running in the background (run&, continue&, etc.),
5368 but claiming it sure should. */
5371 if (async_terminal_is_ours
)
5374 clear_sigint_trap ();
5375 add_file_handler (input_fd
, stdin_event_handler
, 0);
5376 async_terminal_is_ours
= 1;
5379 static void (*async_client_callback
) (enum inferior_event_type event_type
,
5381 static void *async_client_context
;
5383 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5384 so we notice when any child changes state, and notify the
5385 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
5386 above to wait for the arrival of a SIGCHLD. */
5389 sigchld_handler (int signo
)
5391 int old_errno
= errno
;
5393 if (debug_linux_nat_async
)
5394 fprintf_unfiltered (gdb_stdlog
, "sigchld\n");
5396 if (signo
== SIGCHLD
5397 && linux_nat_event_pipe
[0] != -1)
5398 async_file_mark (); /* Let the event loop know that there are
5399 events to handle. */
5404 /* Callback registered with the target events file descriptor. */
5407 handle_target_event (int error
, gdb_client_data client_data
)
5409 (*async_client_callback
) (INF_REG_EVENT
, async_client_context
);
5412 /* Create/destroy the target events pipe. Returns previous state. */
5415 linux_async_pipe (int enable
)
5417 int previous
= (linux_nat_event_pipe
[0] != -1);
5419 if (previous
!= enable
)
5423 block_child_signals (&prev_mask
);
5427 if (pipe (linux_nat_event_pipe
) == -1)
5428 internal_error (__FILE__
, __LINE__
,
5429 "creating event pipe failed.");
5431 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
5432 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
5436 close (linux_nat_event_pipe
[0]);
5437 close (linux_nat_event_pipe
[1]);
5438 linux_nat_event_pipe
[0] = -1;
5439 linux_nat_event_pipe
[1] = -1;
5442 restore_child_signals_mask (&prev_mask
);
5448 /* target_async implementation. */
5451 linux_nat_async (void (*callback
) (enum inferior_event_type event_type
,
5452 void *context
), void *context
)
5454 if (linux_nat_async_mask_value
== 0 || !target_async_permitted
)
5455 internal_error (__FILE__
, __LINE__
,
5456 "Calling target_async when async is masked");
5458 if (callback
!= NULL
)
5460 async_client_callback
= callback
;
5461 async_client_context
= context
;
5462 if (!linux_async_pipe (1))
5464 add_file_handler (linux_nat_event_pipe
[0],
5465 handle_target_event
, NULL
);
5466 /* There may be pending events to handle. Tell the event loop
5473 async_client_callback
= callback
;
5474 async_client_context
= context
;
5475 delete_file_handler (linux_nat_event_pipe
[0]);
5476 linux_async_pipe (0);
5481 /* Stop an LWP, and push a TARGET_SIGNAL_0 stop status if no other
5485 linux_nat_stop_lwp (struct lwp_info
*lwp
, void *data
)
5489 ptid_t ptid
= lwp
->ptid
;
5491 if (debug_linux_nat
)
5492 fprintf_unfiltered (gdb_stdlog
,
5493 "LNSL: running -> suspending %s\n",
5494 target_pid_to_str (lwp
->ptid
));
5497 stop_callback (lwp
, NULL
);
5498 stop_wait_callback (lwp
, NULL
);
5500 /* If the lwp exits while we try to stop it, there's nothing
5502 lwp
= find_lwp_pid (ptid
);
5506 /* If we didn't collect any signal other than SIGSTOP while
5507 stopping the LWP, push a SIGNAL_0 event. In either case, the
5508 event-loop will end up calling target_wait which will collect
5510 if (lwp
->status
== 0)
5511 lwp
->status
= W_STOPCODE (0);
5516 /* Already known to be stopped; do nothing. */
5518 if (debug_linux_nat
)
5520 if (find_thread_ptid (lwp
->ptid
)->stop_requested
)
5521 fprintf_unfiltered (gdb_stdlog
,
5522 "LNSL: already stopped/stop_requested %s\n",
5523 target_pid_to_str (lwp
->ptid
));
5525 fprintf_unfiltered (gdb_stdlog
,
5526 "LNSL: already stopped/no "
5527 "stop_requested yet %s\n",
5528 target_pid_to_str (lwp
->ptid
));
5535 linux_nat_stop (ptid_t ptid
)
5538 iterate_over_lwps (ptid
, linux_nat_stop_lwp
, NULL
);
5540 linux_ops
->to_stop (ptid
);
5544 linux_nat_close (int quitting
)
5546 /* Unregister from the event loop. */
5547 if (target_is_async_p ())
5548 target_async (NULL
, 0);
5550 /* Reset the async_masking. */
5551 linux_nat_async_mask_value
= 1;
5553 if (linux_ops
->to_close
)
5554 linux_ops
->to_close (quitting
);
5557 /* When requests are passed down from the linux-nat layer to the
5558 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
5559 used. The address space pointer is stored in the inferior object,
5560 but the common code that is passed such ptid can't tell whether
5561 lwpid is a "main" process id or not (it assumes so). We reverse
5562 look up the "main" process id from the lwp here. */
5564 struct address_space
*
5565 linux_nat_thread_address_space (struct target_ops
*t
, ptid_t ptid
)
5567 struct lwp_info
*lwp
;
5568 struct inferior
*inf
;
5571 pid
= GET_LWP (ptid
);
5572 if (GET_LWP (ptid
) == 0)
5574 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
5576 lwp
= find_lwp_pid (ptid
);
5577 pid
= GET_PID (lwp
->ptid
);
5581 /* A (pid,lwpid,0) ptid. */
5582 pid
= GET_PID (ptid
);
5585 inf
= find_inferior_pid (pid
);
5586 gdb_assert (inf
!= NULL
);
5591 linux_nat_core_of_thread_1 (ptid_t ptid
)
5593 struct cleanup
*back_to
;
5596 char *content
= NULL
;
5599 int content_read
= 0;
5603 filename
= xstrprintf ("/proc/%d/task/%ld/stat",
5604 GET_PID (ptid
), GET_LWP (ptid
));
5605 back_to
= make_cleanup (xfree
, filename
);
5607 f
= fopen (filename
, "r");
5610 do_cleanups (back_to
);
5614 make_cleanup_fclose (f
);
5620 content
= xrealloc (content
, content_read
+ 1024);
5621 n
= fread (content
+ content_read
, 1, 1024, f
);
5625 content
[content_read
] = '\0';
5630 make_cleanup (xfree
, content
);
5632 p
= strchr (content
, '(');
5636 p
= strchr (p
, ')');
5640 /* If the first field after program name has index 0, then core number is
5641 the field with index 36. There's no constant for that anywhere. */
5643 p
= strtok_r (p
, " ", &ts
);
5644 for (i
= 0; p
!= NULL
&& i
!= 36; ++i
)
5645 p
= strtok_r (NULL
, " ", &ts
);
5647 if (p
== NULL
|| sscanf (p
, "%d", &core
) == 0)
5650 do_cleanups (back_to
);
5655 /* Return the cached value of the processor core for thread PTID. */
5658 linux_nat_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
5660 struct lwp_info
*info
= find_lwp_pid (ptid
);
5668 linux_nat_add_target (struct target_ops
*t
)
5670 /* Save the provided single-threaded target. We save this in a separate
5671 variable because another target we've inherited from (e.g. inf-ptrace)
5672 may have saved a pointer to T; we want to use it for the final
5673 process stratum target. */
5674 linux_ops_saved
= *t
;
5675 linux_ops
= &linux_ops_saved
;
5677 /* Override some methods for multithreading. */
5678 t
->to_create_inferior
= linux_nat_create_inferior
;
5679 t
->to_attach
= linux_nat_attach
;
5680 t
->to_detach
= linux_nat_detach
;
5681 t
->to_resume
= linux_nat_resume
;
5682 t
->to_wait
= linux_nat_wait
;
5683 t
->to_xfer_partial
= linux_nat_xfer_partial
;
5684 t
->to_kill
= linux_nat_kill
;
5685 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
5686 t
->to_thread_alive
= linux_nat_thread_alive
;
5687 t
->to_pid_to_str
= linux_nat_pid_to_str
;
5688 t
->to_has_thread_control
= tc_schedlock
;
5689 t
->to_thread_address_space
= linux_nat_thread_address_space
;
5690 t
->to_stopped_by_watchpoint
= linux_nat_stopped_by_watchpoint
;
5691 t
->to_stopped_data_address
= linux_nat_stopped_data_address
;
5693 t
->to_can_async_p
= linux_nat_can_async_p
;
5694 t
->to_is_async_p
= linux_nat_is_async_p
;
5695 t
->to_supports_non_stop
= linux_nat_supports_non_stop
;
5696 t
->to_async
= linux_nat_async
;
5697 t
->to_async_mask
= linux_nat_async_mask
;
5698 t
->to_terminal_inferior
= linux_nat_terminal_inferior
;
5699 t
->to_terminal_ours
= linux_nat_terminal_ours
;
5700 t
->to_close
= linux_nat_close
;
5702 /* Methods for non-stop support. */
5703 t
->to_stop
= linux_nat_stop
;
5705 t
->to_supports_multi_process
= linux_nat_supports_multi_process
;
5707 t
->to_core_of_thread
= linux_nat_core_of_thread
;
5709 /* We don't change the stratum; this target will sit at
5710 process_stratum and thread_db will set at thread_stratum. This
5711 is a little strange, since this is a multi-threaded-capable
5712 target, but we want to be on the stack below thread_db, and we
5713 also want to be used for single-threaded processes. */
5718 /* Register a method to call whenever a new thread is attached. */
5720 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
5722 /* Save the pointer. We only support a single registered instance
5723 of the GNU/Linux native target, so we do not need to map this to
5725 linux_nat_new_thread
= new_thread
;
5728 /* Register a method that converts a siginfo object between the layout
5729 that ptrace returns, and the layout in the architecture of the
5732 linux_nat_set_siginfo_fixup (struct target_ops
*t
,
5733 int (*siginfo_fixup
) (struct siginfo
*,
5737 /* Save the pointer. */
5738 linux_nat_siginfo_fixup
= siginfo_fixup
;
5741 /* Return the saved siginfo associated with PTID. */
5743 linux_nat_get_siginfo (ptid_t ptid
)
5745 struct lwp_info
*lp
= find_lwp_pid (ptid
);
5747 gdb_assert (lp
!= NULL
);
5749 return &lp
->siginfo
;
5752 /* Provide a prototype to silence -Wmissing-prototypes. */
5753 extern initialize_file_ftype _initialize_linux_nat
;
5756 _initialize_linux_nat (void)
5758 add_info ("proc", linux_nat_info_proc_cmd
, _("\
5759 Show /proc process information about any running process.\n\
5760 Specify any process id, or use the program being debugged by default.\n\
5761 Specify any of the following keywords for detailed info:\n\
5762 mappings -- list of mapped memory regions.\n\
5763 stat -- list a bunch of random process info.\n\
5764 status -- list a different bunch of random process info.\n\
5765 all -- list all available /proc info."));
5767 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance
,
5768 &debug_linux_nat
, _("\
5769 Set debugging of GNU/Linux lwp module."), _("\
5770 Show debugging of GNU/Linux lwp module."), _("\
5771 Enables printf debugging output."),
5773 show_debug_linux_nat
,
5774 &setdebuglist
, &showdebuglist
);
5776 add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance
,
5777 &debug_linux_nat_async
, _("\
5778 Set debugging of GNU/Linux async lwp module."), _("\
5779 Show debugging of GNU/Linux async lwp module."), _("\
5780 Enables printf debugging output."),
5782 show_debug_linux_nat_async
,
5783 &setdebuglist
, &showdebuglist
);
5785 /* Save this mask as the default. */
5786 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
5788 /* Install a SIGCHLD handler. */
5789 sigchld_action
.sa_handler
= sigchld_handler
;
5790 sigemptyset (&sigchld_action
.sa_mask
);
5791 sigchld_action
.sa_flags
= SA_RESTART
;
5793 /* Make it the default. */
5794 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
5796 /* Make sure we don't block SIGCHLD during a sigsuspend. */
5797 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
5798 sigdelset (&suspend_mask
, SIGCHLD
);
5800 sigemptyset (&blocked_mask
);
5802 add_setshow_boolean_cmd ("disable-randomization", class_support
,
5803 &disable_randomization
, _("\
5804 Set disabling of debuggee's virtual address space randomization."), _("\
5805 Show disabling of debuggee's virtual address space randomization."), _("\
5806 When this mode is on (which is the default), randomization of the virtual\n\
5807 address space is disabled. Standalone programs run with the randomization\n\
5808 enabled by default on some platforms."),
5809 &set_disable_randomization
,
5810 &show_disable_randomization
,
5811 &setlist
, &showlist
);
5815 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5816 the GNU/Linux Threads library and therefore doesn't really belong
5819 /* Read variable NAME in the target and return its value if found.
5820 Otherwise return zero. It is assumed that the type of the variable
5824 get_signo (const char *name
)
5826 struct minimal_symbol
*ms
;
5829 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
5833 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
5834 sizeof (signo
)) != 0)
5840 /* Return the set of signals used by the threads library in *SET. */
5843 lin_thread_get_thread_signals (sigset_t
*set
)
5845 struct sigaction action
;
5846 int restart
, cancel
;
5848 sigemptyset (&blocked_mask
);
5851 restart
= get_signo ("__pthread_sig_restart");
5852 cancel
= get_signo ("__pthread_sig_cancel");
5854 /* LinuxThreads normally uses the first two RT signals, but in some legacy
5855 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
5856 not provide any way for the debugger to query the signal numbers -
5857 fortunately they don't change! */
5860 restart
= __SIGRTMIN
;
5863 cancel
= __SIGRTMIN
+ 1;
5865 sigaddset (set
, restart
);
5866 sigaddset (set
, cancel
);
5868 /* The GNU/Linux Threads library makes terminating threads send a
5869 special "cancel" signal instead of SIGCHLD. Make sure we catch
5870 those (to prevent them from terminating GDB itself, which is
5871 likely to be their default action) and treat them the same way as
5874 action
.sa_handler
= sigchld_handler
;
5875 sigemptyset (&action
.sa_mask
);
5876 action
.sa_flags
= SA_RESTART
;
5877 sigaction (cancel
, &action
, NULL
);
5879 /* We block the "cancel" signal throughout this code ... */
5880 sigaddset (&blocked_mask
, cancel
);
5881 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
5883 /* ... except during a sigsuspend. */
5884 sigdelset (&suspend_mask
, cancel
);