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 return !linux_supports_tracefork (pid
);
984 linux_child_insert_vfork_catchpoint (int pid
)
986 return !linux_supports_tracefork (pid
);
990 linux_child_insert_exec_catchpoint (int pid
)
992 return !linux_supports_tracefork (pid
);
996 linux_child_set_syscall_catchpoint (int pid
, int needed
, int any_count
,
997 int table_size
, int *table
)
999 if (!linux_supports_tracesysgood (pid
))
1002 /* On GNU/Linux, we ignore the arguments. It means that we only
1003 enable the syscall catchpoints, but do not disable them.
1005 Also, we do not use the `table' information because we do not
1006 filter system calls here. We let GDB do the logic for us. */
1010 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
1011 are processes sharing the same VM space. A multi-threaded process
1012 is basically a group of such processes. However, such a grouping
1013 is almost entirely a user-space issue; the kernel doesn't enforce
1014 such a grouping at all (this might change in the future). In
1015 general, we'll rely on the threads library (i.e. the GNU/Linux
1016 Threads library) to provide such a grouping.
1018 It is perfectly well possible to write a multi-threaded application
1019 without the assistance of a threads library, by using the clone
1020 system call directly. This module should be able to give some
1021 rudimentary support for debugging such applications if developers
1022 specify the CLONE_PTRACE flag in the clone system call, and are
1023 using the Linux kernel 2.4 or above.
1025 Note that there are some peculiarities in GNU/Linux that affect
1028 - In general one should specify the __WCLONE flag to waitpid in
1029 order to make it report events for any of the cloned processes
1030 (and leave it out for the initial process). However, if a cloned
1031 process has exited the exit status is only reported if the
1032 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
1033 we cannot use it since GDB must work on older systems too.
1035 - When a traced, cloned process exits and is waited for by the
1036 debugger, the kernel reassigns it to the original parent and
1037 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
1038 library doesn't notice this, which leads to the "zombie problem":
1039 When debugged a multi-threaded process that spawns a lot of
1040 threads will run out of processes, even if the threads exit,
1041 because the "zombies" stay around. */
1043 /* List of known LWPs. */
1044 struct lwp_info
*lwp_list
;
1047 /* Original signal mask. */
1048 static sigset_t normal_mask
;
1050 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
1051 _initialize_linux_nat. */
1052 static sigset_t suspend_mask
;
1054 /* Signals to block to make that sigsuspend work. */
1055 static sigset_t blocked_mask
;
1057 /* SIGCHLD action. */
1058 struct sigaction sigchld_action
;
1060 /* Block child signals (SIGCHLD and linux threads signals), and store
1061 the previous mask in PREV_MASK. */
1064 block_child_signals (sigset_t
*prev_mask
)
1066 /* Make sure SIGCHLD is blocked. */
1067 if (!sigismember (&blocked_mask
, SIGCHLD
))
1068 sigaddset (&blocked_mask
, SIGCHLD
);
1070 sigprocmask (SIG_BLOCK
, &blocked_mask
, prev_mask
);
1073 /* Restore child signals mask, previously returned by
1074 block_child_signals. */
1077 restore_child_signals_mask (sigset_t
*prev_mask
)
1079 sigprocmask (SIG_SETMASK
, prev_mask
, NULL
);
1083 /* Prototypes for local functions. */
1084 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
1085 static int linux_thread_alive (ptid_t ptid
);
1086 static char *linux_child_pid_to_exec_file (int pid
);
1089 /* Convert wait status STATUS to a string. Used for printing debug
1093 status_to_str (int status
)
1095 static char buf
[64];
1097 if (WIFSTOPPED (status
))
1099 if (WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
1100 snprintf (buf
, sizeof (buf
), "%s (stopped at syscall)",
1101 strsignal (SIGTRAP
));
1103 snprintf (buf
, sizeof (buf
), "%s (stopped)",
1104 strsignal (WSTOPSIG (status
)));
1106 else if (WIFSIGNALED (status
))
1107 snprintf (buf
, sizeof (buf
), "%s (terminated)",
1108 strsignal (WTERMSIG (status
)));
1110 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
1115 /* Remove all LWPs belong to PID from the lwp list. */
1118 purge_lwp_list (int pid
)
1120 struct lwp_info
*lp
, *lpprev
, *lpnext
;
1124 for (lp
= lwp_list
; lp
; lp
= lpnext
)
1128 if (ptid_get_pid (lp
->ptid
) == pid
)
1131 lwp_list
= lp
->next
;
1133 lpprev
->next
= lp
->next
;
1142 /* Return the number of known LWPs in the tgid given by PID. */
1148 struct lwp_info
*lp
;
1150 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
1151 if (ptid_get_pid (lp
->ptid
) == pid
)
1157 /* Add the LWP specified by PID to the list. Return a pointer to the
1158 structure describing the new LWP. The LWP should already be stopped
1159 (with an exception for the very first LWP). */
1161 static struct lwp_info
*
1162 add_lwp (ptid_t ptid
)
1164 struct lwp_info
*lp
;
1166 gdb_assert (is_lwp (ptid
));
1168 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
1170 memset (lp
, 0, sizeof (struct lwp_info
));
1172 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
1177 lp
->next
= lwp_list
;
1180 if (num_lwps (GET_PID (ptid
)) > 1 && linux_nat_new_thread
!= NULL
)
1181 linux_nat_new_thread (ptid
);
1186 /* Remove the LWP specified by PID from the list. */
1189 delete_lwp (ptid_t ptid
)
1191 struct lwp_info
*lp
, *lpprev
;
1195 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
1196 if (ptid_equal (lp
->ptid
, ptid
))
1203 lpprev
->next
= lp
->next
;
1205 lwp_list
= lp
->next
;
1210 /* Return a pointer to the structure describing the LWP corresponding
1211 to PID. If no corresponding LWP could be found, return NULL. */
1213 static struct lwp_info
*
1214 find_lwp_pid (ptid_t ptid
)
1216 struct lwp_info
*lp
;
1220 lwp
= GET_LWP (ptid
);
1222 lwp
= GET_PID (ptid
);
1224 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
1225 if (lwp
== GET_LWP (lp
->ptid
))
1231 /* Call CALLBACK with its second argument set to DATA for every LWP in
1232 the list. If CALLBACK returns 1 for a particular LWP, return a
1233 pointer to the structure describing that LWP immediately.
1234 Otherwise return NULL. */
1237 iterate_over_lwps (ptid_t filter
,
1238 int (*callback
) (struct lwp_info
*, void *),
1241 struct lwp_info
*lp
, *lpnext
;
1243 for (lp
= lwp_list
; lp
; lp
= lpnext
)
1247 if (ptid_match (lp
->ptid
, filter
))
1249 if ((*callback
) (lp
, data
))
1257 /* Update our internal state when changing from one checkpoint to
1258 another indicated by NEW_PTID. We can only switch single-threaded
1259 applications, so we only create one new LWP, and the previous list
1263 linux_nat_switch_fork (ptid_t new_ptid
)
1265 struct lwp_info
*lp
;
1267 purge_lwp_list (GET_PID (inferior_ptid
));
1269 lp
= add_lwp (new_ptid
);
1272 /* This changes the thread's ptid while preserving the gdb thread
1273 num. Also changes the inferior pid, while preserving the
1275 thread_change_ptid (inferior_ptid
, new_ptid
);
1277 /* We've just told GDB core that the thread changed target id, but,
1278 in fact, it really is a different thread, with different register
1280 registers_changed ();
1283 /* Handle the exit of a single thread LP. */
1286 exit_lwp (struct lwp_info
*lp
)
1288 struct thread_info
*th
= find_thread_ptid (lp
->ptid
);
1292 if (print_thread_events
)
1293 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp
->ptid
));
1295 delete_thread (lp
->ptid
);
1298 delete_lwp (lp
->ptid
);
1301 /* Return an lwp's tgid, found in `/proc/PID/status'. */
1304 linux_proc_get_tgid (int lwpid
)
1310 snprintf (buf
, sizeof (buf
), "/proc/%d/status", (int) lwpid
);
1311 status_file
= fopen (buf
, "r");
1312 if (status_file
!= NULL
)
1314 while (fgets (buf
, sizeof (buf
), status_file
))
1316 if (strncmp (buf
, "Tgid:", 5) == 0)
1318 tgid
= strtoul (buf
+ strlen ("Tgid:"), NULL
, 10);
1323 fclose (status_file
);
1329 /* Detect `T (stopped)' in `/proc/PID/status'.
1330 Other states including `T (tracing stop)' are reported as false. */
1333 pid_is_stopped (pid_t pid
)
1339 snprintf (buf
, sizeof (buf
), "/proc/%d/status", (int) pid
);
1340 status_file
= fopen (buf
, "r");
1341 if (status_file
!= NULL
)
1345 while (fgets (buf
, sizeof (buf
), status_file
))
1347 if (strncmp (buf
, "State:", 6) == 0)
1353 if (have_state
&& strstr (buf
, "T (stopped)") != NULL
)
1355 fclose (status_file
);
1360 /* Wait for the LWP specified by LP, which we have just attached to.
1361 Returns a wait status for that LWP, to cache. */
1364 linux_nat_post_attach_wait (ptid_t ptid
, int first
, int *cloned
,
1367 pid_t new_pid
, pid
= GET_LWP (ptid
);
1370 if (pid_is_stopped (pid
))
1372 if (debug_linux_nat
)
1373 fprintf_unfiltered (gdb_stdlog
,
1374 "LNPAW: Attaching to a stopped process\n");
1376 /* The process is definitely stopped. It is in a job control
1377 stop, unless the kernel predates the TASK_STOPPED /
1378 TASK_TRACED distinction, in which case it might be in a
1379 ptrace stop. Make sure it is in a ptrace stop; from there we
1380 can kill it, signal it, et cetera.
1382 First make sure there is a pending SIGSTOP. Since we are
1383 already attached, the process can not transition from stopped
1384 to running without a PTRACE_CONT; so we know this signal will
1385 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1386 probably already in the queue (unless this kernel is old
1387 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1388 is not an RT signal, it can only be queued once. */
1389 kill_lwp (pid
, SIGSTOP
);
1391 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1392 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1393 ptrace (PTRACE_CONT
, pid
, 0, 0);
1396 /* Make sure the initial process is stopped. The user-level threads
1397 layer might want to poke around in the inferior, and that won't
1398 work if things haven't stabilized yet. */
1399 new_pid
= my_waitpid (pid
, &status
, 0);
1400 if (new_pid
== -1 && errno
== ECHILD
)
1403 warning (_("%s is a cloned process"), target_pid_to_str (ptid
));
1405 /* Try again with __WCLONE to check cloned processes. */
1406 new_pid
= my_waitpid (pid
, &status
, __WCLONE
);
1410 gdb_assert (pid
== new_pid
);
1412 if (!WIFSTOPPED (status
))
1414 /* The pid we tried to attach has apparently just exited. */
1415 if (debug_linux_nat
)
1416 fprintf_unfiltered (gdb_stdlog
, "LNPAW: Failed to stop %d: %s",
1417 pid
, status_to_str (status
));
1421 if (WSTOPSIG (status
) != SIGSTOP
)
1424 if (debug_linux_nat
)
1425 fprintf_unfiltered (gdb_stdlog
,
1426 "LNPAW: Received %s after attaching\n",
1427 status_to_str (status
));
1433 /* Attach to the LWP specified by PID. Return 0 if successful or -1
1434 if the new LWP could not be attached. */
1437 lin_lwp_attach_lwp (ptid_t ptid
)
1439 struct lwp_info
*lp
;
1442 gdb_assert (is_lwp (ptid
));
1444 block_child_signals (&prev_mask
);
1446 lp
= find_lwp_pid (ptid
);
1448 /* We assume that we're already attached to any LWP that has an id
1449 equal to the overall process id, and to any LWP that is already
1450 in our list of LWPs. If we're not seeing exit events from threads
1451 and we've had PID wraparound since we last tried to stop all threads,
1452 this assumption might be wrong; fortunately, this is very unlikely
1454 if (GET_LWP (ptid
) != GET_PID (ptid
) && lp
== NULL
)
1456 int status
, cloned
= 0, signalled
= 0;
1458 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
1460 /* If we fail to attach to the thread, issue a warning,
1461 but continue. One way this can happen is if thread
1462 creation is interrupted; as of Linux kernel 2.6.19, a
1463 bug may place threads in the thread list and then fail
1465 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
1466 safe_strerror (errno
));
1467 restore_child_signals_mask (&prev_mask
);
1471 if (debug_linux_nat
)
1472 fprintf_unfiltered (gdb_stdlog
,
1473 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1474 target_pid_to_str (ptid
));
1476 status
= linux_nat_post_attach_wait (ptid
, 0, &cloned
, &signalled
);
1477 if (!WIFSTOPPED (status
))
1480 lp
= add_lwp (ptid
);
1482 lp
->cloned
= cloned
;
1483 lp
->signalled
= signalled
;
1484 if (WSTOPSIG (status
) != SIGSTOP
)
1487 lp
->status
= status
;
1490 target_post_attach (GET_LWP (lp
->ptid
));
1492 if (debug_linux_nat
)
1494 fprintf_unfiltered (gdb_stdlog
,
1495 "LLAL: waitpid %s received %s\n",
1496 target_pid_to_str (ptid
),
1497 status_to_str (status
));
1502 /* We assume that the LWP representing the original process is
1503 already stopped. Mark it as stopped in the data structure
1504 that the GNU/linux ptrace layer uses to keep track of
1505 threads. Note that this won't have already been done since
1506 the main thread will have, we assume, been stopped by an
1507 attach from a different layer. */
1509 lp
= add_lwp (ptid
);
1513 restore_child_signals_mask (&prev_mask
);
1518 linux_nat_create_inferior (struct target_ops
*ops
,
1519 char *exec_file
, char *allargs
, char **env
,
1522 #ifdef HAVE_PERSONALITY
1523 int personality_orig
= 0, personality_set
= 0;
1524 #endif /* HAVE_PERSONALITY */
1526 /* The fork_child mechanism is synchronous and calls target_wait, so
1527 we have to mask the async mode. */
1529 #ifdef HAVE_PERSONALITY
1530 if (disable_randomization
)
1533 personality_orig
= personality (0xffffffff);
1534 if (errno
== 0 && !(personality_orig
& ADDR_NO_RANDOMIZE
))
1536 personality_set
= 1;
1537 personality (personality_orig
| ADDR_NO_RANDOMIZE
);
1539 if (errno
!= 0 || (personality_set
1540 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE
)))
1541 warning (_("Error disabling address space randomization: %s"),
1542 safe_strerror (errno
));
1544 #endif /* HAVE_PERSONALITY */
1546 linux_ops
->to_create_inferior (ops
, exec_file
, allargs
, env
, from_tty
);
1548 #ifdef HAVE_PERSONALITY
1549 if (personality_set
)
1552 personality (personality_orig
);
1554 warning (_("Error restoring address space randomization: %s"),
1555 safe_strerror (errno
));
1557 #endif /* HAVE_PERSONALITY */
1561 linux_nat_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1563 struct lwp_info
*lp
;
1567 linux_ops
->to_attach (ops
, args
, from_tty
);
1569 /* The ptrace base target adds the main thread with (pid,0,0)
1570 format. Decorate it with lwp info. */
1571 ptid
= BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
));
1572 thread_change_ptid (inferior_ptid
, ptid
);
1574 /* Add the initial process as the first LWP to the list. */
1575 lp
= add_lwp (ptid
);
1577 status
= linux_nat_post_attach_wait (lp
->ptid
, 1, &lp
->cloned
,
1579 if (!WIFSTOPPED (status
))
1581 if (WIFEXITED (status
))
1583 int exit_code
= WEXITSTATUS (status
);
1585 target_terminal_ours ();
1586 target_mourn_inferior ();
1588 error (_("Unable to attach: program exited normally."));
1590 error (_("Unable to attach: program exited with code %d."),
1593 else if (WIFSIGNALED (status
))
1595 enum target_signal signo
;
1597 target_terminal_ours ();
1598 target_mourn_inferior ();
1600 signo
= target_signal_from_host (WTERMSIG (status
));
1601 error (_("Unable to attach: program terminated with signal "
1603 target_signal_to_name (signo
),
1604 target_signal_to_string (signo
));
1607 internal_error (__FILE__
, __LINE__
,
1608 _("unexpected status %d for PID %ld"),
1609 status
, (long) GET_LWP (ptid
));
1614 /* Save the wait status to report later. */
1616 if (debug_linux_nat
)
1617 fprintf_unfiltered (gdb_stdlog
,
1618 "LNA: waitpid %ld, saving status %s\n",
1619 (long) GET_PID (lp
->ptid
), status_to_str (status
));
1621 lp
->status
= status
;
1623 if (target_can_async_p ())
1624 target_async (inferior_event_handler
, 0);
1627 /* Get pending status of LP. */
1629 get_pending_status (struct lwp_info
*lp
, int *status
)
1631 enum target_signal signo
= TARGET_SIGNAL_0
;
1633 /* If we paused threads momentarily, we may have stored pending
1634 events in lp->status or lp->waitstatus (see stop_wait_callback),
1635 and GDB core hasn't seen any signal for those threads.
1636 Otherwise, the last signal reported to the core is found in the
1637 thread object's stop_signal.
1639 There's a corner case that isn't handled here at present. Only
1640 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1641 stop_signal make sense as a real signal to pass to the inferior.
1642 Some catchpoint related events, like
1643 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1644 to TARGET_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1645 those traps are debug API (ptrace in our case) related and
1646 induced; the inferior wouldn't see them if it wasn't being
1647 traced. Hence, we should never pass them to the inferior, even
1648 when set to pass state. Since this corner case isn't handled by
1649 infrun.c when proceeding with a signal, for consistency, neither
1650 do we handle it here (or elsewhere in the file we check for
1651 signal pass state). Normally SIGTRAP isn't set to pass state, so
1652 this is really a corner case. */
1654 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
1655 signo
= TARGET_SIGNAL_0
; /* a pending ptrace event, not a real signal. */
1656 else if (lp
->status
)
1657 signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1658 else if (non_stop
&& !is_executing (lp
->ptid
))
1660 struct thread_info
*tp
= find_thread_ptid (lp
->ptid
);
1662 signo
= tp
->suspend
.stop_signal
;
1666 struct target_waitstatus last
;
1669 get_last_target_status (&last_ptid
, &last
);
1671 if (GET_LWP (lp
->ptid
) == GET_LWP (last_ptid
))
1673 struct thread_info
*tp
= find_thread_ptid (lp
->ptid
);
1675 signo
= tp
->suspend
.stop_signal
;
1681 if (signo
== TARGET_SIGNAL_0
)
1683 if (debug_linux_nat
)
1684 fprintf_unfiltered (gdb_stdlog
,
1685 "GPT: lwp %s has no pending signal\n",
1686 target_pid_to_str (lp
->ptid
));
1688 else if (!signal_pass_state (signo
))
1690 if (debug_linux_nat
)
1691 fprintf_unfiltered (gdb_stdlog
,
1692 "GPT: lwp %s had signal %s, "
1693 "but it is in no pass state\n",
1694 target_pid_to_str (lp
->ptid
),
1695 target_signal_to_string (signo
));
1699 *status
= W_STOPCODE (target_signal_to_host (signo
));
1701 if (debug_linux_nat
)
1702 fprintf_unfiltered (gdb_stdlog
,
1703 "GPT: lwp %s has pending signal %s\n",
1704 target_pid_to_str (lp
->ptid
),
1705 target_signal_to_string (signo
));
1712 detach_callback (struct lwp_info
*lp
, void *data
)
1714 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1716 if (debug_linux_nat
&& lp
->status
)
1717 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
1718 strsignal (WSTOPSIG (lp
->status
)),
1719 target_pid_to_str (lp
->ptid
));
1721 /* If there is a pending SIGSTOP, get rid of it. */
1724 if (debug_linux_nat
)
1725 fprintf_unfiltered (gdb_stdlog
,
1726 "DC: Sending SIGCONT to %s\n",
1727 target_pid_to_str (lp
->ptid
));
1729 kill_lwp (GET_LWP (lp
->ptid
), SIGCONT
);
1733 /* We don't actually detach from the LWP that has an id equal to the
1734 overall process id just yet. */
1735 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
1739 /* Pass on any pending signal for this LWP. */
1740 get_pending_status (lp
, &status
);
1743 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
1744 WSTOPSIG (status
)) < 0)
1745 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1746 safe_strerror (errno
));
1748 if (debug_linux_nat
)
1749 fprintf_unfiltered (gdb_stdlog
,
1750 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1751 target_pid_to_str (lp
->ptid
),
1752 strsignal (WSTOPSIG (status
)));
1754 delete_lwp (lp
->ptid
);
1761 linux_nat_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1765 struct lwp_info
*main_lwp
;
1767 pid
= GET_PID (inferior_ptid
);
1769 if (target_can_async_p ())
1770 linux_nat_async (NULL
, 0);
1772 /* Stop all threads before detaching. ptrace requires that the
1773 thread is stopped to sucessfully detach. */
1774 iterate_over_lwps (pid_to_ptid (pid
), stop_callback
, NULL
);
1775 /* ... and wait until all of them have reported back that
1776 they're no longer running. */
1777 iterate_over_lwps (pid_to_ptid (pid
), stop_wait_callback
, NULL
);
1779 iterate_over_lwps (pid_to_ptid (pid
), detach_callback
, NULL
);
1781 /* Only the initial process should be left right now. */
1782 gdb_assert (num_lwps (GET_PID (inferior_ptid
)) == 1);
1784 main_lwp
= find_lwp_pid (pid_to_ptid (pid
));
1786 /* Pass on any pending signal for the last LWP. */
1787 if ((args
== NULL
|| *args
== '\0')
1788 && get_pending_status (main_lwp
, &status
) != -1
1789 && WIFSTOPPED (status
))
1791 /* Put the signal number in ARGS so that inf_ptrace_detach will
1792 pass it along with PTRACE_DETACH. */
1794 sprintf (args
, "%d", (int) WSTOPSIG (status
));
1795 if (debug_linux_nat
)
1796 fprintf_unfiltered (gdb_stdlog
,
1797 "LND: Sending signal %s to %s\n",
1799 target_pid_to_str (main_lwp
->ptid
));
1802 delete_lwp (main_lwp
->ptid
);
1804 if (forks_exist_p ())
1806 /* Multi-fork case. The current inferior_ptid is being detached
1807 from, but there are other viable forks to debug. Detach from
1808 the current fork, and context-switch to the first
1810 linux_fork_detach (args
, from_tty
);
1812 if (non_stop
&& target_can_async_p ())
1813 target_async (inferior_event_handler
, 0);
1816 linux_ops
->to_detach (ops
, args
, from_tty
);
1822 resume_callback (struct lwp_info
*lp
, void *data
)
1824 struct inferior
*inf
= find_inferior_pid (GET_PID (lp
->ptid
));
1826 if (lp
->stopped
&& inf
->vfork_child
!= NULL
)
1828 if (debug_linux_nat
)
1829 fprintf_unfiltered (gdb_stdlog
,
1830 "RC: Not resuming %s (vfork parent)\n",
1831 target_pid_to_str (lp
->ptid
));
1833 else if (lp
->stopped
&& lp
->status
== 0)
1835 if (debug_linux_nat
)
1836 fprintf_unfiltered (gdb_stdlog
,
1837 "RC: PTRACE_CONT %s, 0, 0 (resuming sibling)\n",
1838 target_pid_to_str (lp
->ptid
));
1840 linux_ops
->to_resume (linux_ops
,
1841 pid_to_ptid (GET_LWP (lp
->ptid
)),
1842 0, TARGET_SIGNAL_0
);
1843 if (debug_linux_nat
)
1844 fprintf_unfiltered (gdb_stdlog
,
1845 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1846 target_pid_to_str (lp
->ptid
));
1849 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1850 lp
->stopped_by_watchpoint
= 0;
1852 else if (lp
->stopped
&& debug_linux_nat
)
1853 fprintf_unfiltered (gdb_stdlog
,
1854 "RC: Not resuming sibling %s (has pending)\n",
1855 target_pid_to_str (lp
->ptid
));
1856 else if (debug_linux_nat
)
1857 fprintf_unfiltered (gdb_stdlog
,
1858 "RC: Not resuming sibling %s (not stopped)\n",
1859 target_pid_to_str (lp
->ptid
));
1865 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1872 resume_set_callback (struct lwp_info
*lp
, void *data
)
1879 linux_nat_resume (struct target_ops
*ops
,
1880 ptid_t ptid
, int step
, enum target_signal signo
)
1883 struct lwp_info
*lp
;
1886 if (debug_linux_nat
)
1887 fprintf_unfiltered (gdb_stdlog
,
1888 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1889 step
? "step" : "resume",
1890 target_pid_to_str (ptid
),
1891 (signo
!= TARGET_SIGNAL_0
1892 ? strsignal (target_signal_to_host (signo
)) : "0"),
1893 target_pid_to_str (inferior_ptid
));
1895 block_child_signals (&prev_mask
);
1897 /* A specific PTID means `step only this process id'. */
1898 resume_many
= (ptid_equal (minus_one_ptid
, ptid
)
1899 || ptid_is_pid (ptid
));
1901 /* Mark the lwps we're resuming as resumed. */
1902 iterate_over_lwps (ptid
, resume_set_callback
, NULL
);
1904 /* See if it's the current inferior that should be handled
1907 lp
= find_lwp_pid (inferior_ptid
);
1909 lp
= find_lwp_pid (ptid
);
1910 gdb_assert (lp
!= NULL
);
1912 /* Remember if we're stepping. */
1915 /* If we have a pending wait status for this thread, there is no
1916 point in resuming the process. But first make sure that
1917 linux_nat_wait won't preemptively handle the event - we
1918 should never take this short-circuit if we are going to
1919 leave LP running, since we have skipped resuming all the
1920 other threads. This bit of code needs to be synchronized
1921 with linux_nat_wait. */
1923 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1925 enum target_signal saved_signo
;
1926 struct inferior
*inf
;
1928 inf
= find_inferior_pid (ptid_get_pid (lp
->ptid
));
1930 saved_signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1932 /* Defer to common code if we're gaining control of the
1934 if (inf
->control
.stop_soon
== NO_STOP_QUIETLY
1935 && signal_stop_state (saved_signo
) == 0
1936 && signal_print_state (saved_signo
) == 0
1937 && signal_pass_state (saved_signo
) == 1)
1939 if (debug_linux_nat
)
1940 fprintf_unfiltered (gdb_stdlog
,
1941 "LLR: Not short circuiting for ignored "
1942 "status 0x%x\n", lp
->status
);
1944 /* FIXME: What should we do if we are supposed to continue
1945 this thread with a signal? */
1946 gdb_assert (signo
== TARGET_SIGNAL_0
);
1947 signo
= saved_signo
;
1952 if (lp
->status
|| lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
1954 /* FIXME: What should we do if we are supposed to continue
1955 this thread with a signal? */
1956 gdb_assert (signo
== TARGET_SIGNAL_0
);
1958 if (debug_linux_nat
)
1959 fprintf_unfiltered (gdb_stdlog
,
1960 "LLR: Short circuiting for status 0x%x\n",
1963 restore_child_signals_mask (&prev_mask
);
1964 if (target_can_async_p ())
1966 target_async (inferior_event_handler
, 0);
1967 /* Tell the event loop we have something to process. */
1973 /* Mark LWP as not stopped to prevent it from being continued by
1978 iterate_over_lwps (ptid
, resume_callback
, NULL
);
1980 /* Convert to something the lower layer understands. */
1981 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
1983 linux_ops
->to_resume (linux_ops
, ptid
, step
, signo
);
1984 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1985 lp
->stopped_by_watchpoint
= 0;
1987 if (debug_linux_nat
)
1988 fprintf_unfiltered (gdb_stdlog
,
1989 "LLR: %s %s, %s (resume event thread)\n",
1990 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1991 target_pid_to_str (ptid
),
1992 (signo
!= TARGET_SIGNAL_0
1993 ? strsignal (target_signal_to_host (signo
)) : "0"));
1995 restore_child_signals_mask (&prev_mask
);
1996 if (target_can_async_p ())
1997 target_async (inferior_event_handler
, 0);
2000 /* Send a signal to an LWP. */
2003 kill_lwp (int lwpid
, int signo
)
2005 /* Use tkill, if possible, in case we are using nptl threads. If tkill
2006 fails, then we are not using nptl threads and we should be using kill. */
2008 #ifdef HAVE_TKILL_SYSCALL
2010 static int tkill_failed
;
2017 ret
= syscall (__NR_tkill
, lwpid
, signo
);
2018 if (errno
!= ENOSYS
)
2025 return kill (lwpid
, signo
);
2028 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
2029 event, check if the core is interested in it: if not, ignore the
2030 event, and keep waiting; otherwise, we need to toggle the LWP's
2031 syscall entry/exit status, since the ptrace event itself doesn't
2032 indicate it, and report the trap to higher layers. */
2035 linux_handle_syscall_trap (struct lwp_info
*lp
, int stopping
)
2037 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
2038 struct gdbarch
*gdbarch
= target_thread_architecture (lp
->ptid
);
2039 int syscall_number
= (int) gdbarch_get_syscall_number (gdbarch
, lp
->ptid
);
2043 /* If we're stopping threads, there's a SIGSTOP pending, which
2044 makes it so that the LWP reports an immediate syscall return,
2045 followed by the SIGSTOP. Skip seeing that "return" using
2046 PTRACE_CONT directly, and let stop_wait_callback collect the
2047 SIGSTOP. Later when the thread is resumed, a new syscall
2048 entry event. If we didn't do this (and returned 0), we'd
2049 leave a syscall entry pending, and our caller, by using
2050 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
2051 itself. Later, when the user re-resumes this LWP, we'd see
2052 another syscall entry event and we'd mistake it for a return.
2054 If stop_wait_callback didn't force the SIGSTOP out of the LWP
2055 (leaving immediately with LWP->signalled set, without issuing
2056 a PTRACE_CONT), it would still be problematic to leave this
2057 syscall enter pending, as later when the thread is resumed,
2058 it would then see the same syscall exit mentioned above,
2059 followed by the delayed SIGSTOP, while the syscall didn't
2060 actually get to execute. It seems it would be even more
2061 confusing to the user. */
2063 if (debug_linux_nat
)
2064 fprintf_unfiltered (gdb_stdlog
,
2065 "LHST: ignoring syscall %d "
2066 "for LWP %ld (stopping threads), "
2067 "resuming with PTRACE_CONT for SIGSTOP\n",
2069 GET_LWP (lp
->ptid
));
2071 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2072 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2076 if (catch_syscall_enabled ())
2078 /* Always update the entry/return state, even if this particular
2079 syscall isn't interesting to the core now. In async mode,
2080 the user could install a new catchpoint for this syscall
2081 between syscall enter/return, and we'll need to know to
2082 report a syscall return if that happens. */
2083 lp
->syscall_state
= (lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
2084 ? TARGET_WAITKIND_SYSCALL_RETURN
2085 : TARGET_WAITKIND_SYSCALL_ENTRY
);
2087 if (catching_syscall_number (syscall_number
))
2089 /* Alright, an event to report. */
2090 ourstatus
->kind
= lp
->syscall_state
;
2091 ourstatus
->value
.syscall_number
= syscall_number
;
2093 if (debug_linux_nat
)
2094 fprintf_unfiltered (gdb_stdlog
,
2095 "LHST: stopping for %s of syscall %d"
2098 == TARGET_WAITKIND_SYSCALL_ENTRY
2099 ? "entry" : "return",
2101 GET_LWP (lp
->ptid
));
2105 if (debug_linux_nat
)
2106 fprintf_unfiltered (gdb_stdlog
,
2107 "LHST: ignoring %s of syscall %d "
2109 lp
->syscall_state
== TARGET_WAITKIND_SYSCALL_ENTRY
2110 ? "entry" : "return",
2112 GET_LWP (lp
->ptid
));
2116 /* If we had been syscall tracing, and hence used PT_SYSCALL
2117 before on this LWP, it could happen that the user removes all
2118 syscall catchpoints before we get to process this event.
2119 There are two noteworthy issues here:
2121 - When stopped at a syscall entry event, resuming with
2122 PT_STEP still resumes executing the syscall and reports a
2125 - Only PT_SYSCALL catches syscall enters. If we last
2126 single-stepped this thread, then this event can't be a
2127 syscall enter. If we last single-stepped this thread, this
2128 has to be a syscall exit.
2130 The points above mean that the next resume, be it PT_STEP or
2131 PT_CONTINUE, can not trigger a syscall trace event. */
2132 if (debug_linux_nat
)
2133 fprintf_unfiltered (gdb_stdlog
,
2134 "LHST: caught syscall event "
2135 "with no syscall catchpoints."
2136 " %d for LWP %ld, ignoring\n",
2138 GET_LWP (lp
->ptid
));
2139 lp
->syscall_state
= TARGET_WAITKIND_IGNORE
;
2142 /* The core isn't interested in this event. For efficiency, avoid
2143 stopping all threads only to have the core resume them all again.
2144 Since we're not stopping threads, if we're still syscall tracing
2145 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
2146 subsequent syscall. Simply resume using the inf-ptrace layer,
2147 which knows when to use PT_SYSCALL or PT_CONTINUE. */
2149 /* Note that gdbarch_get_syscall_number may access registers, hence
2151 registers_changed ();
2152 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
2153 lp
->step
, TARGET_SIGNAL_0
);
2157 /* Handle a GNU/Linux extended wait response. If we see a clone
2158 event, we need to add the new LWP to our list (and not report the
2159 trap to higher layers). This function returns non-zero if the
2160 event should be ignored and we should wait again. If STOPPING is
2161 true, the new LWP remains stopped, otherwise it is continued. */
2164 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
2167 int pid
= GET_LWP (lp
->ptid
);
2168 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
2169 int event
= status
>> 16;
2171 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
2172 || event
== PTRACE_EVENT_CLONE
)
2174 unsigned long new_pid
;
2177 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
2179 /* If we haven't already seen the new PID stop, wait for it now. */
2180 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
2182 /* The new child has a pending SIGSTOP. We can't affect it until it
2183 hits the SIGSTOP, but we're already attached. */
2184 ret
= my_waitpid (new_pid
, &status
,
2185 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
2187 perror_with_name (_("waiting for new child"));
2188 else if (ret
!= new_pid
)
2189 internal_error (__FILE__
, __LINE__
,
2190 _("wait returned unexpected PID %d"), ret
);
2191 else if (!WIFSTOPPED (status
))
2192 internal_error (__FILE__
, __LINE__
,
2193 _("wait returned unexpected status 0x%x"), status
);
2196 ourstatus
->value
.related_pid
= ptid_build (new_pid
, new_pid
, 0);
2198 if (event
== PTRACE_EVENT_FORK
2199 && linux_fork_checkpointing_p (GET_PID (lp
->ptid
)))
2201 /* Handle checkpointing by linux-fork.c here as a special
2202 case. We don't want the follow-fork-mode or 'catch fork'
2203 to interfere with this. */
2205 /* This won't actually modify the breakpoint list, but will
2206 physically remove the breakpoints from the child. */
2207 detach_breakpoints (new_pid
);
2209 /* Retain child fork in ptrace (stopped) state. */
2210 if (!find_fork_pid (new_pid
))
2213 /* Report as spurious, so that infrun doesn't want to follow
2214 this fork. We're actually doing an infcall in
2216 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
2217 linux_enable_event_reporting (pid_to_ptid (new_pid
));
2219 /* Report the stop to the core. */
2223 if (event
== PTRACE_EVENT_FORK
)
2224 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
2225 else if (event
== PTRACE_EVENT_VFORK
)
2226 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
2229 struct lwp_info
*new_lp
;
2231 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2233 new_lp
= add_lwp (BUILD_LWP (new_pid
, GET_PID (lp
->ptid
)));
2235 new_lp
->stopped
= 1;
2237 if (WSTOPSIG (status
) != SIGSTOP
)
2239 /* This can happen if someone starts sending signals to
2240 the new thread before it gets a chance to run, which
2241 have a lower number than SIGSTOP (e.g. SIGUSR1).
2242 This is an unlikely case, and harder to handle for
2243 fork / vfork than for clone, so we do not try - but
2244 we handle it for clone events here. We'll send
2245 the other signal on to the thread below. */
2247 new_lp
->signalled
= 1;
2254 /* Add the new thread to GDB's lists as soon as possible
2257 1) the frontend doesn't have to wait for a stop to
2260 2) we tag it with the correct running state. */
2262 /* If the thread_db layer is active, let it know about
2263 this new thread, and add it to GDB's list. */
2264 if (!thread_db_attach_lwp (new_lp
->ptid
))
2266 /* We're not using thread_db. Add it to GDB's
2268 target_post_attach (GET_LWP (new_lp
->ptid
));
2269 add_thread (new_lp
->ptid
);
2274 set_running (new_lp
->ptid
, 1);
2275 set_executing (new_lp
->ptid
, 1);
2279 /* Note the need to use the low target ops to resume, to
2280 handle resuming with PT_SYSCALL if we have syscall
2284 enum target_signal signo
;
2286 new_lp
->stopped
= 0;
2287 new_lp
->resumed
= 1;
2290 ? target_signal_from_host (WSTOPSIG (status
))
2293 linux_ops
->to_resume (linux_ops
, pid_to_ptid (new_pid
),
2300 /* We created NEW_LP so it cannot yet contain STATUS. */
2301 gdb_assert (new_lp
->status
== 0);
2303 /* Save the wait status to report later. */
2304 if (debug_linux_nat
)
2305 fprintf_unfiltered (gdb_stdlog
,
2306 "LHEW: waitpid of new LWP %ld, "
2307 "saving status %s\n",
2308 (long) GET_LWP (new_lp
->ptid
),
2309 status_to_str (status
));
2310 new_lp
->status
= status
;
2314 if (debug_linux_nat
)
2315 fprintf_unfiltered (gdb_stdlog
,
2316 "LHEW: Got clone event "
2317 "from LWP %ld, resuming\n",
2318 GET_LWP (lp
->ptid
));
2319 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
2320 0, TARGET_SIGNAL_0
);
2328 if (event
== PTRACE_EVENT_EXEC
)
2330 if (debug_linux_nat
)
2331 fprintf_unfiltered (gdb_stdlog
,
2332 "LHEW: Got exec event from LWP %ld\n",
2333 GET_LWP (lp
->ptid
));
2335 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
2336 ourstatus
->value
.execd_pathname
2337 = xstrdup (linux_child_pid_to_exec_file (pid
));
2342 if (event
== PTRACE_EVENT_VFORK_DONE
)
2344 if (current_inferior ()->waiting_for_vfork_done
)
2346 if (debug_linux_nat
)
2347 fprintf_unfiltered (gdb_stdlog
,
2348 "LHEW: Got expected PTRACE_EVENT_"
2349 "VFORK_DONE from LWP %ld: stopping\n",
2350 GET_LWP (lp
->ptid
));
2352 ourstatus
->kind
= TARGET_WAITKIND_VFORK_DONE
;
2356 if (debug_linux_nat
)
2357 fprintf_unfiltered (gdb_stdlog
,
2358 "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2359 "from LWP %ld: resuming\n",
2360 GET_LWP (lp
->ptid
));
2361 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2365 internal_error (__FILE__
, __LINE__
,
2366 _("unknown ptrace event %d"), event
);
2369 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2373 wait_lwp (struct lwp_info
*lp
)
2377 int thread_dead
= 0;
2379 gdb_assert (!lp
->stopped
);
2380 gdb_assert (lp
->status
== 0);
2382 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, 0);
2383 if (pid
== -1 && errno
== ECHILD
)
2385 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
2386 if (pid
== -1 && errno
== ECHILD
)
2388 /* The thread has previously exited. We need to delete it
2389 now because, for some vendor 2.4 kernels with NPTL
2390 support backported, there won't be an exit event unless
2391 it is the main thread. 2.6 kernels will report an exit
2392 event for each thread that exits, as expected. */
2394 if (debug_linux_nat
)
2395 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
2396 target_pid_to_str (lp
->ptid
));
2402 gdb_assert (pid
== GET_LWP (lp
->ptid
));
2404 if (debug_linux_nat
)
2406 fprintf_unfiltered (gdb_stdlog
,
2407 "WL: waitpid %s received %s\n",
2408 target_pid_to_str (lp
->ptid
),
2409 status_to_str (status
));
2413 /* Check if the thread has exited. */
2414 if (WIFEXITED (status
) || WIFSIGNALED (status
))
2417 if (debug_linux_nat
)
2418 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
2419 target_pid_to_str (lp
->ptid
));
2428 gdb_assert (WIFSTOPPED (status
));
2430 /* Handle GNU/Linux's syscall SIGTRAPs. */
2431 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
2433 /* No longer need the sysgood bit. The ptrace event ends up
2434 recorded in lp->waitstatus if we care for it. We can carry
2435 on handling the event like a regular SIGTRAP from here
2437 status
= W_STOPCODE (SIGTRAP
);
2438 if (linux_handle_syscall_trap (lp
, 1))
2439 return wait_lwp (lp
);
2442 /* Handle GNU/Linux's extended waitstatus for trace events. */
2443 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
2445 if (debug_linux_nat
)
2446 fprintf_unfiltered (gdb_stdlog
,
2447 "WL: Handling extended status 0x%06x\n",
2449 if (linux_handle_extended_wait (lp
, status
, 1))
2450 return wait_lwp (lp
);
2456 /* Save the most recent siginfo for LP. This is currently only called
2457 for SIGTRAP; some ports use the si_addr field for
2458 target_stopped_data_address. In the future, it may also be used to
2459 restore the siginfo of requeued signals. */
2462 save_siginfo (struct lwp_info
*lp
)
2465 ptrace (PTRACE_GETSIGINFO
, GET_LWP (lp
->ptid
),
2466 (PTRACE_TYPE_ARG3
) 0, &lp
->siginfo
);
2469 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
2472 /* Send a SIGSTOP to LP. */
2475 stop_callback (struct lwp_info
*lp
, void *data
)
2477 if (!lp
->stopped
&& !lp
->signalled
)
2481 if (debug_linux_nat
)
2483 fprintf_unfiltered (gdb_stdlog
,
2484 "SC: kill %s **<SIGSTOP>**\n",
2485 target_pid_to_str (lp
->ptid
));
2488 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
2489 if (debug_linux_nat
)
2491 fprintf_unfiltered (gdb_stdlog
,
2492 "SC: lwp kill %d %s\n",
2494 errno
? safe_strerror (errno
) : "ERRNO-OK");
2498 gdb_assert (lp
->status
== 0);
2504 /* Return non-zero if LWP PID has a pending SIGINT. */
2507 linux_nat_has_pending_sigint (int pid
)
2509 sigset_t pending
, blocked
, ignored
;
2511 linux_proc_pending_signals (pid
, &pending
, &blocked
, &ignored
);
2513 if (sigismember (&pending
, SIGINT
)
2514 && !sigismember (&ignored
, SIGINT
))
2520 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2523 set_ignore_sigint (struct lwp_info
*lp
, void *data
)
2525 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2526 flag to consume the next one. */
2527 if (lp
->stopped
&& lp
->status
!= 0 && WIFSTOPPED (lp
->status
)
2528 && WSTOPSIG (lp
->status
) == SIGINT
)
2531 lp
->ignore_sigint
= 1;
2536 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2537 This function is called after we know the LWP has stopped; if the LWP
2538 stopped before the expected SIGINT was delivered, then it will never have
2539 arrived. Also, if the signal was delivered to a shared queue and consumed
2540 by a different thread, it will never be delivered to this LWP. */
2543 maybe_clear_ignore_sigint (struct lwp_info
*lp
)
2545 if (!lp
->ignore_sigint
)
2548 if (!linux_nat_has_pending_sigint (GET_LWP (lp
->ptid
)))
2550 if (debug_linux_nat
)
2551 fprintf_unfiltered (gdb_stdlog
,
2552 "MCIS: Clearing bogus flag for %s\n",
2553 target_pid_to_str (lp
->ptid
));
2554 lp
->ignore_sigint
= 0;
2558 /* Fetch the possible triggered data watchpoint info and store it in
2561 On some archs, like x86, that use debug registers to set
2562 watchpoints, it's possible that the way to know which watched
2563 address trapped, is to check the register that is used to select
2564 which address to watch. Problem is, between setting the watchpoint
2565 and reading back which data address trapped, the user may change
2566 the set of watchpoints, and, as a consequence, GDB changes the
2567 debug registers in the inferior. To avoid reading back a stale
2568 stopped-data-address when that happens, we cache in LP the fact
2569 that a watchpoint trapped, and the corresponding data address, as
2570 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2571 registers meanwhile, we have the cached data we can rely on. */
2574 save_sigtrap (struct lwp_info
*lp
)
2576 struct cleanup
*old_chain
;
2578 if (linux_ops
->to_stopped_by_watchpoint
== NULL
)
2580 lp
->stopped_by_watchpoint
= 0;
2584 old_chain
= save_inferior_ptid ();
2585 inferior_ptid
= lp
->ptid
;
2587 lp
->stopped_by_watchpoint
= linux_ops
->to_stopped_by_watchpoint ();
2589 if (lp
->stopped_by_watchpoint
)
2591 if (linux_ops
->to_stopped_data_address
!= NULL
)
2592 lp
->stopped_data_address_p
=
2593 linux_ops
->to_stopped_data_address (¤t_target
,
2594 &lp
->stopped_data_address
);
2596 lp
->stopped_data_address_p
= 0;
2599 do_cleanups (old_chain
);
2602 /* See save_sigtrap. */
2605 linux_nat_stopped_by_watchpoint (void)
2607 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2609 gdb_assert (lp
!= NULL
);
2611 return lp
->stopped_by_watchpoint
;
2615 linux_nat_stopped_data_address (struct target_ops
*ops
, CORE_ADDR
*addr_p
)
2617 struct lwp_info
*lp
= find_lwp_pid (inferior_ptid
);
2619 gdb_assert (lp
!= NULL
);
2621 *addr_p
= lp
->stopped_data_address
;
2623 return lp
->stopped_data_address_p
;
2626 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2629 sigtrap_is_event (int status
)
2631 return WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
;
2634 /* SIGTRAP-like events recognizer. */
2636 static int (*linux_nat_status_is_event
) (int status
) = sigtrap_is_event
;
2638 /* Check for SIGTRAP-like events in LP. */
2641 linux_nat_lp_status_is_event (struct lwp_info
*lp
)
2643 /* We check for lp->waitstatus in addition to lp->status, because we can
2644 have pending process exits recorded in lp->status
2645 and W_EXITCODE(0,0) == 0. We should probably have an additional
2646 lp->status_p flag. */
2648 return (lp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
2649 && linux_nat_status_is_event (lp
->status
));
2652 /* Set alternative SIGTRAP-like events recognizer. If
2653 breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2657 linux_nat_set_status_is_event (struct target_ops
*t
,
2658 int (*status_is_event
) (int status
))
2660 linux_nat_status_is_event
= status_is_event
;
2663 /* Wait until LP is stopped. */
2666 stop_wait_callback (struct lwp_info
*lp
, void *data
)
2668 struct inferior
*inf
= find_inferior_pid (GET_PID (lp
->ptid
));
2670 /* If this is a vfork parent, bail out, it is not going to report
2671 any SIGSTOP until the vfork is done with. */
2672 if (inf
->vfork_child
!= NULL
)
2679 status
= wait_lwp (lp
);
2683 if (lp
->ignore_sigint
&& WIFSTOPPED (status
)
2684 && WSTOPSIG (status
) == SIGINT
)
2686 lp
->ignore_sigint
= 0;
2689 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2690 if (debug_linux_nat
)
2691 fprintf_unfiltered (gdb_stdlog
,
2692 "PTRACE_CONT %s, 0, 0 (%s) "
2693 "(discarding SIGINT)\n",
2694 target_pid_to_str (lp
->ptid
),
2695 errno
? safe_strerror (errno
) : "OK");
2697 return stop_wait_callback (lp
, NULL
);
2700 maybe_clear_ignore_sigint (lp
);
2702 if (WSTOPSIG (status
) != SIGSTOP
)
2704 if (linux_nat_status_is_event (status
))
2706 /* If a LWP other than the LWP that we're reporting an
2707 event for has hit a GDB breakpoint (as opposed to
2708 some random trap signal), then just arrange for it to
2709 hit it again later. We don't keep the SIGTRAP status
2710 and don't forward the SIGTRAP signal to the LWP. We
2711 will handle the current event, eventually we will
2712 resume all LWPs, and this one will get its breakpoint
2715 If we do not do this, then we run the risk that the
2716 user will delete or disable the breakpoint, but the
2717 thread will have already tripped on it. */
2719 /* Save the trap's siginfo in case we need it later. */
2724 /* Now resume this LWP and get the SIGSTOP event. */
2726 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2727 if (debug_linux_nat
)
2729 fprintf_unfiltered (gdb_stdlog
,
2730 "PTRACE_CONT %s, 0, 0 (%s)\n",
2731 target_pid_to_str (lp
->ptid
),
2732 errno
? safe_strerror (errno
) : "OK");
2734 fprintf_unfiltered (gdb_stdlog
,
2735 "SWC: Candidate SIGTRAP event in %s\n",
2736 target_pid_to_str (lp
->ptid
));
2738 /* Hold this event/waitstatus while we check to see if
2739 there are any more (we still want to get that SIGSTOP). */
2740 stop_wait_callback (lp
, NULL
);
2742 /* Hold the SIGTRAP for handling by linux_nat_wait. If
2743 there's another event, throw it back into the
2747 if (debug_linux_nat
)
2748 fprintf_unfiltered (gdb_stdlog
,
2749 "SWC: kill %s, %s\n",
2750 target_pid_to_str (lp
->ptid
),
2751 status_to_str ((int) status
));
2752 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
2755 /* Save the sigtrap event. */
2756 lp
->status
= status
;
2761 /* The thread was stopped with a signal other than
2762 SIGSTOP, and didn't accidentally trip a breakpoint. */
2764 if (debug_linux_nat
)
2766 fprintf_unfiltered (gdb_stdlog
,
2767 "SWC: Pending event %s in %s\n",
2768 status_to_str ((int) status
),
2769 target_pid_to_str (lp
->ptid
));
2771 /* Now resume this LWP and get the SIGSTOP event. */
2773 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
2774 if (debug_linux_nat
)
2775 fprintf_unfiltered (gdb_stdlog
,
2776 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
2777 target_pid_to_str (lp
->ptid
),
2778 errno
? safe_strerror (errno
) : "OK");
2780 /* Hold this event/waitstatus while we check to see if
2781 there are any more (we still want to get that SIGSTOP). */
2782 stop_wait_callback (lp
, NULL
);
2784 /* If the lp->status field is still empty, use it to
2785 hold this event. If not, then this event must be
2786 returned to the event queue of the LWP. */
2789 if (debug_linux_nat
)
2791 fprintf_unfiltered (gdb_stdlog
,
2792 "SWC: kill %s, %s\n",
2793 target_pid_to_str (lp
->ptid
),
2794 status_to_str ((int) status
));
2796 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
2799 lp
->status
= status
;
2805 /* We caught the SIGSTOP that we intended to catch, so
2806 there's no SIGSTOP pending. */
2815 /* Return non-zero if LP has a wait status pending. */
2818 status_callback (struct lwp_info
*lp
, void *data
)
2820 /* Only report a pending wait status if we pretend that this has
2821 indeed been resumed. */
2825 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
2827 /* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
2828 or a pending process exit. Note that `W_EXITCODE(0,0) ==
2829 0', so a clean process exit can not be stored pending in
2830 lp->status, it is indistinguishable from
2831 no-pending-status. */
2835 if (lp
->status
!= 0)
2841 /* Return non-zero if LP isn't stopped. */
2844 running_callback (struct lwp_info
*lp
, void *data
)
2846 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
2849 /* Count the LWP's that have had events. */
2852 count_events_callback (struct lwp_info
*lp
, void *data
)
2856 gdb_assert (count
!= NULL
);
2858 /* Count only resumed LWPs that have a SIGTRAP event pending. */
2859 if (lp
->resumed
&& linux_nat_lp_status_is_event (lp
))
2865 /* Select the LWP (if any) that is currently being single-stepped. */
2868 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
2870 if (lp
->step
&& lp
->status
!= 0)
2876 /* Select the Nth LWP that has had a SIGTRAP event. */
2879 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
2881 int *selector
= data
;
2883 gdb_assert (selector
!= NULL
);
2885 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2886 if (lp
->resumed
&& linux_nat_lp_status_is_event (lp
))
2887 if ((*selector
)-- == 0)
2894 cancel_breakpoint (struct lwp_info
*lp
)
2896 /* Arrange for a breakpoint to be hit again later. We don't keep
2897 the SIGTRAP status and don't forward the SIGTRAP signal to the
2898 LWP. We will handle the current event, eventually we will resume
2899 this LWP, and this breakpoint will trap again.
2901 If we do not do this, then we run the risk that the user will
2902 delete or disable the breakpoint, but the LWP will have already
2905 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
2906 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2909 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
2910 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
2912 if (debug_linux_nat
)
2913 fprintf_unfiltered (gdb_stdlog
,
2914 "CB: Push back breakpoint for %s\n",
2915 target_pid_to_str (lp
->ptid
));
2917 /* Back up the PC if necessary. */
2918 if (gdbarch_decr_pc_after_break (gdbarch
))
2919 regcache_write_pc (regcache
, pc
);
2927 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
2929 struct lwp_info
*event_lp
= data
;
2931 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2935 /* If a LWP other than the LWP that we're reporting an event for has
2936 hit a GDB breakpoint (as opposed to some random trap signal),
2937 then just arrange for it to hit it again later. We don't keep
2938 the SIGTRAP status and don't forward the SIGTRAP signal to the
2939 LWP. We will handle the current event, eventually we will resume
2940 all LWPs, and this one will get its breakpoint trap again.
2942 If we do not do this, then we run the risk that the user will
2943 delete or disable the breakpoint, but the LWP will have already
2946 if (linux_nat_lp_status_is_event (lp
)
2947 && cancel_breakpoint (lp
))
2948 /* Throw away the SIGTRAP. */
2954 /* Select one LWP out of those that have events pending. */
2957 select_event_lwp (ptid_t filter
, struct lwp_info
**orig_lp
, int *status
)
2960 int random_selector
;
2961 struct lwp_info
*event_lp
;
2963 /* Record the wait status for the original LWP. */
2964 (*orig_lp
)->status
= *status
;
2966 /* Give preference to any LWP that is being single-stepped. */
2967 event_lp
= iterate_over_lwps (filter
,
2968 select_singlestep_lwp_callback
, NULL
);
2969 if (event_lp
!= NULL
)
2971 if (debug_linux_nat
)
2972 fprintf_unfiltered (gdb_stdlog
,
2973 "SEL: Select single-step %s\n",
2974 target_pid_to_str (event_lp
->ptid
));
2978 /* No single-stepping LWP. Select one at random, out of those
2979 which have had SIGTRAP events. */
2981 /* First see how many SIGTRAP events we have. */
2982 iterate_over_lwps (filter
, count_events_callback
, &num_events
);
2984 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2985 random_selector
= (int)
2986 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2988 if (debug_linux_nat
&& num_events
> 1)
2989 fprintf_unfiltered (gdb_stdlog
,
2990 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2991 num_events
, random_selector
);
2993 event_lp
= iterate_over_lwps (filter
,
2994 select_event_lwp_callback
,
2998 if (event_lp
!= NULL
)
3000 /* Switch the event LWP. */
3001 *orig_lp
= event_lp
;
3002 *status
= event_lp
->status
;
3005 /* Flush the wait status for the event LWP. */
3006 (*orig_lp
)->status
= 0;
3009 /* Return non-zero if LP has been resumed. */
3012 resumed_callback (struct lwp_info
*lp
, void *data
)
3017 /* Stop an active thread, verify it still exists, then resume it. */
3020 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
3022 struct lwp_info
*ptr
;
3024 if (!lp
->stopped
&& !lp
->signalled
)
3026 stop_callback (lp
, NULL
);
3027 stop_wait_callback (lp
, NULL
);
3028 /* Resume if the lwp still exists. */
3029 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
3032 resume_callback (lp
, NULL
);
3033 resume_set_callback (lp
, NULL
);
3039 /* Check if we should go on and pass this event to common code.
3040 Return the affected lwp if we are, or NULL otherwise. */
3041 static struct lwp_info
*
3042 linux_nat_filter_event (int lwpid
, int status
, int options
)
3044 struct lwp_info
*lp
;
3046 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
3048 /* Check for stop events reported by a process we didn't already
3049 know about - anything not already in our LWP list.
3051 If we're expecting to receive stopped processes after
3052 fork, vfork, and clone events, then we'll just add the
3053 new one to our list and go back to waiting for the event
3054 to be reported - the stopped process might be returned
3055 from waitpid before or after the event is. */
3056 if (WIFSTOPPED (status
) && !lp
)
3058 linux_record_stopped_pid (lwpid
, status
);
3062 /* Make sure we don't report an event for the exit of an LWP not in
3063 our list, i.e. not part of the current process. This can happen
3064 if we detach from a program we originally forked and then it
3066 if (!WIFSTOPPED (status
) && !lp
)
3069 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
3070 CLONE_PTRACE processes which do not use the thread library -
3071 otherwise we wouldn't find the new LWP this way. That doesn't
3072 currently work, and the following code is currently unreachable
3073 due to the two blocks above. If it's fixed some day, this code
3074 should be broken out into a function so that we can also pick up
3075 LWPs from the new interface. */
3078 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
3079 if (options
& __WCLONE
)
3082 gdb_assert (WIFSTOPPED (status
)
3083 && WSTOPSIG (status
) == SIGSTOP
);
3086 if (!in_thread_list (inferior_ptid
))
3088 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
3089 GET_PID (inferior_ptid
));
3090 add_thread (inferior_ptid
);
3093 add_thread (lp
->ptid
);
3096 /* Handle GNU/Linux's syscall SIGTRAPs. */
3097 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SYSCALL_SIGTRAP
)
3099 /* No longer need the sysgood bit. The ptrace event ends up
3100 recorded in lp->waitstatus if we care for it. We can carry
3101 on handling the event like a regular SIGTRAP from here
3103 status
= W_STOPCODE (SIGTRAP
);
3104 if (linux_handle_syscall_trap (lp
, 0))
3108 /* Handle GNU/Linux's extended waitstatus for trace events. */
3109 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
3111 if (debug_linux_nat
)
3112 fprintf_unfiltered (gdb_stdlog
,
3113 "LLW: Handling extended status 0x%06x\n",
3115 if (linux_handle_extended_wait (lp
, status
, 0))
3119 if (linux_nat_status_is_event (status
))
3121 /* Save the trap's siginfo in case we need it later. */
3127 /* Check if the thread has exited. */
3128 if ((WIFEXITED (status
) || WIFSIGNALED (status
))
3129 && num_lwps (GET_PID (lp
->ptid
)) > 1)
3131 /* If this is the main thread, we must stop all threads and verify
3132 if they are still alive. This is because in the nptl thread model
3133 on Linux 2.4, there is no signal issued for exiting LWPs
3134 other than the main thread. We only get the main thread exit
3135 signal once all child threads have already exited. If we
3136 stop all the threads and use the stop_wait_callback to check
3137 if they have exited we can determine whether this signal
3138 should be ignored or whether it means the end of the debugged
3139 application, regardless of which threading model is being
3141 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
3144 iterate_over_lwps (pid_to_ptid (GET_PID (lp
->ptid
)),
3145 stop_and_resume_callback
, NULL
);
3148 if (debug_linux_nat
)
3149 fprintf_unfiltered (gdb_stdlog
,
3150 "LLW: %s exited.\n",
3151 target_pid_to_str (lp
->ptid
));
3153 if (num_lwps (GET_PID (lp
->ptid
)) > 1)
3155 /* If there is at least one more LWP, then the exit signal
3156 was not the end of the debugged application and should be
3163 /* Check if the current LWP has previously exited. In the nptl
3164 thread model, LWPs other than the main thread do not issue
3165 signals when they exit so we must check whenever the thread has
3166 stopped. A similar check is made in stop_wait_callback(). */
3167 if (num_lwps (GET_PID (lp
->ptid
)) > 1 && !linux_thread_alive (lp
->ptid
))
3169 ptid_t ptid
= pid_to_ptid (GET_PID (lp
->ptid
));
3171 if (debug_linux_nat
)
3172 fprintf_unfiltered (gdb_stdlog
,
3173 "LLW: %s exited.\n",
3174 target_pid_to_str (lp
->ptid
));
3178 /* Make sure there is at least one thread running. */
3179 gdb_assert (iterate_over_lwps (ptid
, running_callback
, NULL
));
3181 /* Discard the event. */
3185 /* Make sure we don't report a SIGSTOP that we sent ourselves in
3186 an attempt to stop an LWP. */
3188 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
3190 if (debug_linux_nat
)
3191 fprintf_unfiltered (gdb_stdlog
,
3192 "LLW: Delayed SIGSTOP caught for %s.\n",
3193 target_pid_to_str (lp
->ptid
));
3195 /* This is a delayed SIGSTOP. */
3198 registers_changed ();
3200 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3201 lp
->step
, TARGET_SIGNAL_0
);
3202 if (debug_linux_nat
)
3203 fprintf_unfiltered (gdb_stdlog
,
3204 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
3206 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3207 target_pid_to_str (lp
->ptid
));
3210 gdb_assert (lp
->resumed
);
3212 /* Discard the event. */
3216 /* Make sure we don't report a SIGINT that we have already displayed
3217 for another thread. */
3218 if (lp
->ignore_sigint
3219 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGINT
)
3221 if (debug_linux_nat
)
3222 fprintf_unfiltered (gdb_stdlog
,
3223 "LLW: Delayed SIGINT caught for %s.\n",
3224 target_pid_to_str (lp
->ptid
));
3226 /* This is a delayed SIGINT. */
3227 lp
->ignore_sigint
= 0;
3229 registers_changed ();
3230 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3231 lp
->step
, TARGET_SIGNAL_0
);
3232 if (debug_linux_nat
)
3233 fprintf_unfiltered (gdb_stdlog
,
3234 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3236 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3237 target_pid_to_str (lp
->ptid
));
3240 gdb_assert (lp
->resumed
);
3242 /* Discard the event. */
3246 /* An interesting event. */
3248 lp
->status
= status
;
3253 linux_nat_wait_1 (struct target_ops
*ops
,
3254 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3257 static sigset_t prev_mask
;
3258 struct lwp_info
*lp
= NULL
;
3263 if (debug_linux_nat_async
)
3264 fprintf_unfiltered (gdb_stdlog
, "LLW: enter\n");
3266 /* The first time we get here after starting a new inferior, we may
3267 not have added it to the LWP list yet - this is the earliest
3268 moment at which we know its PID. */
3269 if (ptid_is_pid (inferior_ptid
))
3271 /* Upgrade the main thread's ptid. */
3272 thread_change_ptid (inferior_ptid
,
3273 BUILD_LWP (GET_PID (inferior_ptid
),
3274 GET_PID (inferior_ptid
)));
3276 lp
= add_lwp (inferior_ptid
);
3280 /* Make sure SIGCHLD is blocked. */
3281 block_child_signals (&prev_mask
);
3283 if (ptid_equal (ptid
, minus_one_ptid
))
3285 else if (ptid_is_pid (ptid
))
3286 /* A request to wait for a specific tgid. This is not possible
3287 with waitpid, so instead, we wait for any child, and leave
3288 children we're not interested in right now with a pending
3289 status to report later. */
3292 pid
= GET_LWP (ptid
);
3298 /* Make sure that of those LWPs we want to get an event from, there
3299 is at least one LWP that has been resumed. If there's none, just
3300 bail out. The core may just be flushing asynchronously all
3302 if (iterate_over_lwps (ptid
, resumed_callback
, NULL
) == NULL
)
3304 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3306 if (debug_linux_nat_async
)
3307 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (no resumed LWP)\n");
3309 restore_child_signals_mask (&prev_mask
);
3310 return minus_one_ptid
;
3313 /* First check if there is a LWP with a wait status pending. */
3316 /* Any LWP that's been resumed will do. */
3317 lp
= iterate_over_lwps (ptid
, status_callback
, NULL
);
3320 if (debug_linux_nat
&& lp
->status
)
3321 fprintf_unfiltered (gdb_stdlog
,
3322 "LLW: Using pending wait status %s for %s.\n",
3323 status_to_str (lp
->status
),
3324 target_pid_to_str (lp
->ptid
));
3327 /* But if we don't find one, we'll have to wait, and check both
3328 cloned and uncloned processes. We start with the cloned
3330 options
= __WCLONE
| WNOHANG
;
3332 else if (is_lwp (ptid
))
3334 if (debug_linux_nat
)
3335 fprintf_unfiltered (gdb_stdlog
,
3336 "LLW: Waiting for specific LWP %s.\n",
3337 target_pid_to_str (ptid
));
3339 /* We have a specific LWP to check. */
3340 lp
= find_lwp_pid (ptid
);
3343 if (debug_linux_nat
&& lp
->status
)
3344 fprintf_unfiltered (gdb_stdlog
,
3345 "LLW: Using pending wait status %s for %s.\n",
3346 status_to_str (lp
->status
),
3347 target_pid_to_str (lp
->ptid
));
3349 /* If we have to wait, take into account whether PID is a cloned
3350 process or not. And we have to convert it to something that
3351 the layer beneath us can understand. */
3352 options
= lp
->cloned
? __WCLONE
: 0;
3353 pid
= GET_LWP (ptid
);
3355 /* We check for lp->waitstatus in addition to lp->status,
3356 because we can have pending process exits recorded in
3357 lp->status and W_EXITCODE(0,0) == 0. We should probably have
3358 an additional lp->status_p flag. */
3359 if (lp
->status
== 0 && lp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
)
3363 if (lp
&& lp
->signalled
)
3365 /* A pending SIGSTOP may interfere with the normal stream of
3366 events. In a typical case where interference is a problem,
3367 we have a SIGSTOP signal pending for LWP A while
3368 single-stepping it, encounter an event in LWP B, and take the
3369 pending SIGSTOP while trying to stop LWP A. After processing
3370 the event in LWP B, LWP A is continued, and we'll never see
3371 the SIGTRAP associated with the last time we were
3372 single-stepping LWP A. */
3374 /* Resume the thread. It should halt immediately returning the
3376 registers_changed ();
3377 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3378 lp
->step
, TARGET_SIGNAL_0
);
3379 if (debug_linux_nat
)
3380 fprintf_unfiltered (gdb_stdlog
,
3381 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
3382 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3383 target_pid_to_str (lp
->ptid
));
3385 gdb_assert (lp
->resumed
);
3387 /* Catch the pending SIGSTOP. */
3388 status
= lp
->status
;
3391 stop_wait_callback (lp
, NULL
);
3393 /* If the lp->status field isn't empty, we caught another signal
3394 while flushing the SIGSTOP. Return it back to the event
3395 queue of the LWP, as we already have an event to handle. */
3398 if (debug_linux_nat
)
3399 fprintf_unfiltered (gdb_stdlog
,
3400 "LLW: kill %s, %s\n",
3401 target_pid_to_str (lp
->ptid
),
3402 status_to_str (lp
->status
));
3403 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
3406 lp
->status
= status
;
3409 if (!target_can_async_p ())
3411 /* Causes SIGINT to be passed on to the attached process. */
3415 /* Translate generic target_wait options into waitpid options. */
3416 if (target_options
& TARGET_WNOHANG
)
3423 lwpid
= my_waitpid (pid
, &status
, options
);
3427 gdb_assert (pid
== -1 || lwpid
== pid
);
3429 if (debug_linux_nat
)
3431 fprintf_unfiltered (gdb_stdlog
,
3432 "LLW: waitpid %ld received %s\n",
3433 (long) lwpid
, status_to_str (status
));
3436 lp
= linux_nat_filter_event (lwpid
, status
, options
);
3438 /* STATUS is now no longer valid, use LP->STATUS instead. */
3442 && ptid_is_pid (ptid
)
3443 && ptid_get_pid (lp
->ptid
) != ptid_get_pid (ptid
))
3445 gdb_assert (lp
->resumed
);
3447 if (debug_linux_nat
)
3449 "LWP %ld got an event %06x, leaving pending.\n",
3450 ptid_get_lwp (lp
->ptid
), lp
->status
);
3452 if (WIFSTOPPED (lp
->status
))
3454 if (WSTOPSIG (lp
->status
) != SIGSTOP
)
3456 /* Cancel breakpoint hits. The breakpoint may
3457 be removed before we fetch events from this
3458 process to report to the core. It is best
3459 not to assume the moribund breakpoints
3460 heuristic always handles these cases --- it
3461 could be too many events go through to the
3462 core before this one is handled. All-stop
3463 always cancels breakpoint hits in all
3466 && linux_nat_lp_status_is_event (lp
)
3467 && cancel_breakpoint (lp
))
3469 /* Throw away the SIGTRAP. */
3472 if (debug_linux_nat
)
3474 "LLW: LWP %ld hit a breakpoint while"
3475 " waiting for another process;"
3477 ptid_get_lwp (lp
->ptid
));
3487 else if (WIFEXITED (lp
->status
) || WIFSIGNALED (lp
->status
))
3489 if (debug_linux_nat
)
3491 "Process %ld exited while stopping LWPs\n",
3492 ptid_get_lwp (lp
->ptid
));
3494 /* This was the last lwp in the process. Since
3495 events are serialized to GDB core, and we can't
3496 report this one right now, but GDB core and the
3497 other target layers will want to be notified
3498 about the exit code/signal, leave the status
3499 pending for the next time we're able to report
3502 /* Prevent trying to stop this thread again. We'll
3503 never try to resume it because it has a pending
3507 /* Dead LWP's aren't expected to reported a pending
3511 /* Store the pending event in the waitstatus as
3512 well, because W_EXITCODE(0,0) == 0. */
3513 store_waitstatus (&lp
->waitstatus
, lp
->status
);
3527 /* waitpid did return something. Restart over. */
3528 options
|= __WCLONE
;
3536 /* Alternate between checking cloned and uncloned processes. */
3537 options
^= __WCLONE
;
3539 /* And every time we have checked both:
3540 In async mode, return to event loop;
3541 In sync mode, suspend waiting for a SIGCHLD signal. */
3542 if (options
& __WCLONE
)
3544 if (target_options
& TARGET_WNOHANG
)
3546 /* No interesting event. */
3547 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3549 if (debug_linux_nat_async
)
3550 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
3552 restore_child_signals_mask (&prev_mask
);
3553 return minus_one_ptid
;
3556 sigsuspend (&suspend_mask
);
3559 else if (target_options
& TARGET_WNOHANG
)
3561 /* No interesting event for PID yet. */
3562 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
3564 if (debug_linux_nat_async
)
3565 fprintf_unfiltered (gdb_stdlog
, "LLW: exit (ignore)\n");
3567 restore_child_signals_mask (&prev_mask
);
3568 return minus_one_ptid
;
3571 /* We shouldn't end up here unless we want to try again. */
3572 gdb_assert (lp
== NULL
);
3575 if (!target_can_async_p ())
3576 clear_sigint_trap ();
3580 status
= lp
->status
;
3583 /* Don't report signals that GDB isn't interested in, such as
3584 signals that are neither printed nor stopped upon. Stopping all
3585 threads can be a bit time-consuming so if we want decent
3586 performance with heavily multi-threaded programs, especially when
3587 they're using a high frequency timer, we'd better avoid it if we
3590 if (WIFSTOPPED (status
))
3592 enum target_signal signo
= target_signal_from_host (WSTOPSIG (status
));
3593 struct inferior
*inf
;
3595 inf
= find_inferior_pid (ptid_get_pid (lp
->ptid
));
3598 /* Defer to common code if we get a signal while
3599 single-stepping, since that may need special care, e.g. to
3600 skip the signal handler, or, if we're gaining control of the
3603 && inf
->control
.stop_soon
== NO_STOP_QUIETLY
3604 && signal_stop_state (signo
) == 0
3605 && signal_print_state (signo
) == 0
3606 && signal_pass_state (signo
) == 1)
3608 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
3609 here? It is not clear we should. GDB may not expect
3610 other threads to run. On the other hand, not resuming
3611 newly attached threads may cause an unwanted delay in
3612 getting them running. */
3613 registers_changed ();
3614 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3616 if (debug_linux_nat
)
3617 fprintf_unfiltered (gdb_stdlog
,
3618 "LLW: %s %s, %s (preempt 'handle')\n",
3620 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3621 target_pid_to_str (lp
->ptid
),
3622 (signo
!= TARGET_SIGNAL_0
3623 ? strsignal (target_signal_to_host (signo
))
3631 /* Only do the below in all-stop, as we currently use SIGINT
3632 to implement target_stop (see linux_nat_stop) in
3634 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
3636 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3637 forwarded to the entire process group, that is, all LWPs
3638 will receive it - unless they're using CLONE_THREAD to
3639 share signals. Since we only want to report it once, we
3640 mark it as ignored for all LWPs except this one. */
3641 iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid
)),
3642 set_ignore_sigint
, NULL
);
3643 lp
->ignore_sigint
= 0;
3646 maybe_clear_ignore_sigint (lp
);
3650 /* This LWP is stopped now. */
3653 if (debug_linux_nat
)
3654 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
3655 status_to_str (status
), target_pid_to_str (lp
->ptid
));
3659 /* Now stop all other LWP's ... */
3660 iterate_over_lwps (minus_one_ptid
, stop_callback
, NULL
);
3662 /* ... and wait until all of them have reported back that
3663 they're no longer running. */
3664 iterate_over_lwps (minus_one_ptid
, stop_wait_callback
, NULL
);
3666 /* If we're not waiting for a specific LWP, choose an event LWP
3667 from among those that have had events. Giving equal priority
3668 to all LWPs that have had events helps prevent
3671 select_event_lwp (ptid
, &lp
, &status
);
3673 /* Now that we've selected our final event LWP, cancel any
3674 breakpoints in other LWPs that have hit a GDB breakpoint.
3675 See the comment in cancel_breakpoints_callback to find out
3677 iterate_over_lwps (minus_one_ptid
, cancel_breakpoints_callback
, lp
);
3679 /* In all-stop, from the core's perspective, all LWPs are now
3680 stopped until a new resume action is sent over. */
3681 iterate_over_lwps (minus_one_ptid
, resume_clear_callback
, NULL
);
3686 if (linux_nat_status_is_event (status
))
3688 if (debug_linux_nat
)
3689 fprintf_unfiltered (gdb_stdlog
,
3690 "LLW: trap ptid is %s.\n",
3691 target_pid_to_str (lp
->ptid
));
3694 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
3696 *ourstatus
= lp
->waitstatus
;
3697 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
3700 store_waitstatus (ourstatus
, status
);
3702 if (debug_linux_nat_async
)
3703 fprintf_unfiltered (gdb_stdlog
, "LLW: exit\n");
3705 restore_child_signals_mask (&prev_mask
);
3707 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
3708 || ourstatus
->kind
== TARGET_WAITKIND_SIGNALLED
)
3711 lp
->core
= linux_nat_core_of_thread_1 (lp
->ptid
);
3716 /* Resume LWPs that are currently stopped without any pending status
3717 to report, but are resumed from the core's perspective. */
3720 resume_stopped_resumed_lwps (struct lwp_info
*lp
, void *data
)
3722 ptid_t
*wait_ptid_p
= data
;
3727 && lp
->waitstatus
.kind
== TARGET_WAITKIND_IGNORE
)
3729 gdb_assert (is_executing (lp
->ptid
));
3731 /* Don't bother if there's a breakpoint at PC that we'd hit
3732 immediately, and we're not waiting for this LWP. */
3733 if (!ptid_match (lp
->ptid
, *wait_ptid_p
))
3735 struct regcache
*regcache
= get_thread_regcache (lp
->ptid
);
3736 CORE_ADDR pc
= regcache_read_pc (regcache
);
3738 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
3742 if (debug_linux_nat
)
3743 fprintf_unfiltered (gdb_stdlog
,
3744 "RSRL: resuming stopped-resumed LWP %s\n",
3745 target_pid_to_str (lp
->ptid
));
3747 linux_ops
->to_resume (linux_ops
, pid_to_ptid (GET_LWP (lp
->ptid
)),
3748 lp
->step
, TARGET_SIGNAL_0
);
3750 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
3751 lp
->stopped_by_watchpoint
= 0;
3758 linux_nat_wait (struct target_ops
*ops
,
3759 ptid_t ptid
, struct target_waitstatus
*ourstatus
,
3764 if (debug_linux_nat
)
3765 fprintf_unfiltered (gdb_stdlog
,
3766 "linux_nat_wait: [%s]\n", target_pid_to_str (ptid
));
3768 /* Flush the async file first. */
3769 if (target_can_async_p ())
3770 async_file_flush ();
3772 /* Resume LWPs that are currently stopped without any pending status
3773 to report, but are resumed from the core's perspective. LWPs get
3774 in this state if we find them stopping at a time we're not
3775 interested in reporting the event (target_wait on a
3776 specific_process, for example, see linux_nat_wait_1), and
3777 meanwhile the event became uninteresting. Don't bother resuming
3778 LWPs we're not going to wait for if they'd stop immediately. */
3780 iterate_over_lwps (minus_one_ptid
, resume_stopped_resumed_lwps
, &ptid
);
3782 event_ptid
= linux_nat_wait_1 (ops
, ptid
, ourstatus
, target_options
);
3784 /* If we requested any event, and something came out, assume there
3785 may be more. If we requested a specific lwp or process, also
3786 assume there may be more. */
3787 if (target_can_async_p ()
3788 && (ourstatus
->kind
!= TARGET_WAITKIND_IGNORE
3789 || !ptid_equal (ptid
, minus_one_ptid
)))
3792 /* Get ready for the next event. */
3793 if (target_can_async_p ())
3794 target_async (inferior_event_handler
, 0);
3800 kill_callback (struct lwp_info
*lp
, void *data
)
3803 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
3804 if (debug_linux_nat
)
3805 fprintf_unfiltered (gdb_stdlog
,
3806 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
3807 target_pid_to_str (lp
->ptid
),
3808 errno
? safe_strerror (errno
) : "OK");
3814 kill_wait_callback (struct lwp_info
*lp
, void *data
)
3818 /* We must make sure that there are no pending events (delayed
3819 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3820 program doesn't interfere with any following debugging session. */
3822 /* For cloned processes we must check both with __WCLONE and
3823 without, since the exit status of a cloned process isn't reported
3829 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
3830 if (pid
!= (pid_t
) -1)
3832 if (debug_linux_nat
)
3833 fprintf_unfiltered (gdb_stdlog
,
3834 "KWC: wait %s received unknown.\n",
3835 target_pid_to_str (lp
->ptid
));
3836 /* The Linux kernel sometimes fails to kill a thread
3837 completely after PTRACE_KILL; that goes from the stop
3838 point in do_fork out to the one in
3839 get_signal_to_deliever and waits again. So kill it
3841 kill_callback (lp
, NULL
);
3844 while (pid
== GET_LWP (lp
->ptid
));
3846 gdb_assert (pid
== -1 && errno
== ECHILD
);
3851 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
3852 if (pid
!= (pid_t
) -1)
3854 if (debug_linux_nat
)
3855 fprintf_unfiltered (gdb_stdlog
,
3856 "KWC: wait %s received unk.\n",
3857 target_pid_to_str (lp
->ptid
));
3858 /* See the call to kill_callback above. */
3859 kill_callback (lp
, NULL
);
3862 while (pid
== GET_LWP (lp
->ptid
));
3864 gdb_assert (pid
== -1 && errno
== ECHILD
);
3869 linux_nat_kill (struct target_ops
*ops
)
3871 struct target_waitstatus last
;
3875 /* If we're stopped while forking and we haven't followed yet,
3876 kill the other task. We need to do this first because the
3877 parent will be sleeping if this is a vfork. */
3879 get_last_target_status (&last_ptid
, &last
);
3881 if (last
.kind
== TARGET_WAITKIND_FORKED
3882 || last
.kind
== TARGET_WAITKIND_VFORKED
)
3884 ptrace (PT_KILL
, PIDGET (last
.value
.related_pid
), 0, 0);
3888 if (forks_exist_p ())
3889 linux_fork_killall ();
3892 ptid_t ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
3894 /* Stop all threads before killing them, since ptrace requires
3895 that the thread is stopped to sucessfully PTRACE_KILL. */
3896 iterate_over_lwps (ptid
, stop_callback
, NULL
);
3897 /* ... and wait until all of them have reported back that
3898 they're no longer running. */
3899 iterate_over_lwps (ptid
, stop_wait_callback
, NULL
);
3901 /* Kill all LWP's ... */
3902 iterate_over_lwps (ptid
, kill_callback
, NULL
);
3904 /* ... and wait until we've flushed all events. */
3905 iterate_over_lwps (ptid
, kill_wait_callback
, NULL
);
3908 target_mourn_inferior ();
3912 linux_nat_mourn_inferior (struct target_ops
*ops
)
3914 purge_lwp_list (ptid_get_pid (inferior_ptid
));
3916 if (! forks_exist_p ())
3917 /* Normal case, no other forks available. */
3918 linux_ops
->to_mourn_inferior (ops
);
3920 /* Multi-fork case. The current inferior_ptid has exited, but
3921 there are other viable forks to debug. Delete the exiting
3922 one and context-switch to the first available. */
3923 linux_fork_mourn_inferior ();
3926 /* Convert a native/host siginfo object, into/from the siginfo in the
3927 layout of the inferiors' architecture. */
3930 siginfo_fixup (struct siginfo
*siginfo
, gdb_byte
*inf_siginfo
, int direction
)
3934 if (linux_nat_siginfo_fixup
!= NULL
)
3935 done
= linux_nat_siginfo_fixup (siginfo
, inf_siginfo
, direction
);
3937 /* If there was no callback, or the callback didn't do anything,
3938 then just do a straight memcpy. */
3942 memcpy (siginfo
, inf_siginfo
, sizeof (struct siginfo
));
3944 memcpy (inf_siginfo
, siginfo
, sizeof (struct siginfo
));
3949 linux_xfer_siginfo (struct target_ops
*ops
, enum target_object object
,
3950 const char *annex
, gdb_byte
*readbuf
,
3951 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3954 struct siginfo siginfo
;
3955 gdb_byte inf_siginfo
[sizeof (struct siginfo
)];
3957 gdb_assert (object
== TARGET_OBJECT_SIGNAL_INFO
);
3958 gdb_assert (readbuf
|| writebuf
);
3960 pid
= GET_LWP (inferior_ptid
);
3962 pid
= GET_PID (inferior_ptid
);
3964 if (offset
> sizeof (siginfo
))
3968 ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
3972 /* When GDB is built as a 64-bit application, ptrace writes into
3973 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3974 inferior with a 64-bit GDB should look the same as debugging it
3975 with a 32-bit GDB, we need to convert it. GDB core always sees
3976 the converted layout, so any read/write will have to be done
3978 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
3980 if (offset
+ len
> sizeof (siginfo
))
3981 len
= sizeof (siginfo
) - offset
;
3983 if (readbuf
!= NULL
)
3984 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
3987 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
3989 /* Convert back to ptrace layout before flushing it out. */
3990 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
3993 ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
4002 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4003 const char *annex
, gdb_byte
*readbuf
,
4004 const gdb_byte
*writebuf
,
4005 ULONGEST offset
, LONGEST len
)
4007 struct cleanup
*old_chain
;
4010 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
4011 return linux_xfer_siginfo (ops
, object
, annex
, readbuf
, writebuf
,
4014 /* The target is connected but no live inferior is selected. Pass
4015 this request down to a lower stratum (e.g., the executable
4017 if (object
== TARGET_OBJECT_MEMORY
&& ptid_equal (inferior_ptid
, null_ptid
))
4020 old_chain
= save_inferior_ptid ();
4022 if (is_lwp (inferior_ptid
))
4023 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
4025 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
4028 do_cleanups (old_chain
);
4033 linux_thread_alive (ptid_t ptid
)
4037 gdb_assert (is_lwp (ptid
));
4039 /* Send signal 0 instead of anything ptrace, because ptracing a
4040 running thread errors out claiming that the thread doesn't
4042 err
= kill_lwp (GET_LWP (ptid
), 0);
4044 if (debug_linux_nat
)
4045 fprintf_unfiltered (gdb_stdlog
,
4046 "LLTA: KILL(SIG0) %s (%s)\n",
4047 target_pid_to_str (ptid
),
4048 err
? safe_strerror (tmp_errno
) : "OK");
4057 linux_nat_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4059 return linux_thread_alive (ptid
);
4063 linux_nat_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
4065 static char buf
[64];
4068 && (GET_PID (ptid
) != GET_LWP (ptid
)
4069 || num_lwps (GET_PID (ptid
)) > 1))
4071 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
4075 return normal_pid_to_str (ptid
);
4079 linux_nat_thread_name (struct thread_info
*thr
)
4081 int pid
= ptid_get_pid (thr
->ptid
);
4082 long lwp
= ptid_get_lwp (thr
->ptid
);
4083 #define FORMAT "/proc/%d/task/%ld/comm"
4084 char buf
[sizeof (FORMAT
) + 30];
4086 char *result
= NULL
;
4088 snprintf (buf
, sizeof (buf
), FORMAT
, pid
, lwp
);
4089 comm_file
= fopen (buf
, "r");
4092 /* Not exported by the kernel, so we define it here. */
4094 static char line
[COMM_LEN
+ 1];
4096 if (fgets (line
, sizeof (line
), comm_file
))
4098 char *nl
= strchr (line
, '\n');
4115 /* Accepts an integer PID; Returns a string representing a file that
4116 can be opened to get the symbols for the child process. */
4119 linux_child_pid_to_exec_file (int pid
)
4121 char *name1
, *name2
;
4123 name1
= xmalloc (MAXPATHLEN
);
4124 name2
= xmalloc (MAXPATHLEN
);
4125 make_cleanup (xfree
, name1
);
4126 make_cleanup (xfree
, name2
);
4127 memset (name2
, 0, MAXPATHLEN
);
4129 sprintf (name1
, "/proc/%d/exe", pid
);
4130 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
4136 /* Service function for corefiles and info proc. */
4139 read_mapping (FILE *mapfile
,
4144 char *device
, long long *inode
, char *filename
)
4146 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
4147 addr
, endaddr
, permissions
, offset
, device
, inode
);
4150 if (ret
> 0 && ret
!= EOF
)
4152 /* Eat everything up to EOL for the filename. This will prevent
4153 weird filenames (such as one with embedded whitespace) from
4154 confusing this code. It also makes this code more robust in
4155 respect to annotations the kernel may add after the filename.
4157 Note the filename is used for informational purposes
4159 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
4162 return (ret
!= 0 && ret
!= EOF
);
4165 /* Fills the "to_find_memory_regions" target vector. Lists the memory
4166 regions in the inferior for a corefile. */
4169 linux_nat_find_memory_regions (find_memory_region_ftype func
, void *obfd
)
4171 int pid
= PIDGET (inferior_ptid
);
4172 char mapsfilename
[MAXPATHLEN
];
4174 long long addr
, endaddr
, size
, offset
, inode
;
4175 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
4176 int read
, write
, exec
;
4177 struct cleanup
*cleanup
;
4179 /* Compose the filename for the /proc memory map, and open it. */
4180 sprintf (mapsfilename
, "/proc/%d/maps", pid
);
4181 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
4182 error (_("Could not open %s."), mapsfilename
);
4183 cleanup
= make_cleanup_fclose (mapsfile
);
4186 fprintf_filtered (gdb_stdout
,
4187 "Reading memory regions from %s\n", mapsfilename
);
4189 /* Now iterate until end-of-file. */
4190 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
4191 &offset
, &device
[0], &inode
, &filename
[0]))
4193 size
= endaddr
- addr
;
4195 /* Get the segment's permissions. */
4196 read
= (strchr (permissions
, 'r') != 0);
4197 write
= (strchr (permissions
, 'w') != 0);
4198 exec
= (strchr (permissions
, 'x') != 0);
4202 fprintf_filtered (gdb_stdout
,
4203 "Save segment, %s bytes at %s (%c%c%c)",
4204 plongest (size
), paddress (target_gdbarch
, addr
),
4206 write
? 'w' : ' ', exec
? 'x' : ' ');
4208 fprintf_filtered (gdb_stdout
, " for %s", filename
);
4209 fprintf_filtered (gdb_stdout
, "\n");
4212 /* Invoke the callback function to create the corefile
4214 func (addr
, size
, read
, write
, exec
, obfd
);
4216 do_cleanups (cleanup
);
4221 find_signalled_thread (struct thread_info
*info
, void *data
)
4223 if (info
->suspend
.stop_signal
!= TARGET_SIGNAL_0
4224 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
4230 static enum target_signal
4231 find_stop_signal (void)
4233 struct thread_info
*info
=
4234 iterate_over_threads (find_signalled_thread
, NULL
);
4237 return info
->suspend
.stop_signal
;
4239 return TARGET_SIGNAL_0
;
4242 /* Records the thread's register state for the corefile note
4246 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
4247 char *note_data
, int *note_size
,
4248 enum target_signal stop_signal
)
4250 unsigned long lwp
= ptid_get_lwp (ptid
);
4251 struct gdbarch
*gdbarch
= target_gdbarch
;
4252 struct regcache
*regcache
= get_thread_arch_regcache (ptid
, gdbarch
);
4253 const struct regset
*regset
;
4255 struct cleanup
*old_chain
;
4256 struct core_regset_section
*sect_list
;
4259 old_chain
= save_inferior_ptid ();
4260 inferior_ptid
= ptid
;
4261 target_fetch_registers (regcache
, -1);
4262 do_cleanups (old_chain
);
4264 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
4265 sect_list
= gdbarch_core_regset_sections (gdbarch
);
4267 /* The loop below uses the new struct core_regset_section, which stores
4268 the supported section names and sizes for the core file. Note that
4269 note PRSTATUS needs to be treated specially. But the other notes are
4270 structurally the same, so they can benefit from the new struct. */
4271 if (core_regset_p
&& sect_list
!= NULL
)
4272 while (sect_list
->sect_name
!= NULL
)
4274 regset
= gdbarch_regset_from_core_section (gdbarch
,
4275 sect_list
->sect_name
,
4277 gdb_assert (regset
&& regset
->collect_regset
);
4278 gdb_regset
= xmalloc (sect_list
->size
);
4279 regset
->collect_regset (regset
, regcache
, -1,
4280 gdb_regset
, sect_list
->size
);
4282 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
4283 note_data
= (char *) elfcore_write_prstatus
4284 (obfd
, note_data
, note_size
,
4285 lwp
, target_signal_to_host (stop_signal
),
4288 note_data
= (char *) elfcore_write_register_note
4289 (obfd
, note_data
, note_size
,
4290 sect_list
->sect_name
, gdb_regset
,
4296 /* For architectures that does not have the struct core_regset_section
4297 implemented, we use the old method. When all the architectures have
4298 the new support, the code below should be deleted. */
4301 gdb_gregset_t gregs
;
4302 gdb_fpregset_t fpregs
;
4305 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
4307 != NULL
&& regset
->collect_regset
!= NULL
)
4308 regset
->collect_regset (regset
, regcache
, -1,
4309 &gregs
, sizeof (gregs
));
4311 fill_gregset (regcache
, &gregs
, -1);
4313 note_data
= (char *) elfcore_write_prstatus
4314 (obfd
, note_data
, note_size
, lwp
, target_signal_to_host (stop_signal
),
4318 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
4320 != NULL
&& regset
->collect_regset
!= NULL
)
4321 regset
->collect_regset (regset
, regcache
, -1,
4322 &fpregs
, sizeof (fpregs
));
4324 fill_fpregset (regcache
, &fpregs
, -1);
4326 note_data
= (char *) elfcore_write_prfpreg (obfd
,
4329 &fpregs
, sizeof (fpregs
));
4335 struct linux_nat_corefile_thread_data
4341 enum target_signal stop_signal
;
4344 /* Called by gdbthread.c once per thread. Records the thread's
4345 register state for the corefile note section. */
4348 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
4350 struct linux_nat_corefile_thread_data
*args
= data
;
4352 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
4362 /* Enumerate spufs IDs for process PID. */
4365 iterate_over_spus (int pid
, void (*callback
) (void *, int), void *data
)
4369 struct dirent
*entry
;
4371 xsnprintf (path
, sizeof path
, "/proc/%d/fd", pid
);
4372 dir
= opendir (path
);
4377 while ((entry
= readdir (dir
)) != NULL
)
4383 fd
= atoi (entry
->d_name
);
4387 xsnprintf (path
, sizeof path
, "/proc/%d/fd/%d", pid
, fd
);
4388 if (stat (path
, &st
) != 0)
4390 if (!S_ISDIR (st
.st_mode
))
4393 if (statfs (path
, &stfs
) != 0)
4395 if (stfs
.f_type
!= SPUFS_MAGIC
)
4398 callback (data
, fd
);
4404 /* Generate corefile notes for SPU contexts. */
4406 struct linux_spu_corefile_data
4414 linux_spu_corefile_callback (void *data
, int fd
)
4416 struct linux_spu_corefile_data
*args
= data
;
4419 static const char *spu_files
[] =
4441 for (i
= 0; i
< sizeof (spu_files
) / sizeof (spu_files
[0]); i
++)
4443 char annex
[32], note_name
[32];
4447 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[i
]);
4448 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
4452 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
4453 args
->note_data
= elfcore_write_note (args
->obfd
, args
->note_data
,
4454 args
->note_size
, note_name
,
4455 NT_SPU
, spu_data
, spu_len
);
4462 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
4464 struct linux_spu_corefile_data args
;
4467 args
.note_data
= note_data
;
4468 args
.note_size
= note_size
;
4470 iterate_over_spus (PIDGET (inferior_ptid
),
4471 linux_spu_corefile_callback
, &args
);
4473 return args
.note_data
;
4476 /* Fills the "to_make_corefile_note" target vector. Builds the note
4477 section for a corefile, and returns it in a malloc buffer. */
4480 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
4482 struct linux_nat_corefile_thread_data thread_args
;
4483 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
4484 char fname
[16] = { '\0' };
4485 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
4486 char psargs
[80] = { '\0' };
4487 char *note_data
= NULL
;
4488 ptid_t filter
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
4492 if (get_exec_file (0))
4494 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
4495 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
4496 if (get_inferior_args ())
4499 char *psargs_end
= psargs
+ sizeof (psargs
);
4501 /* linux_elfcore_write_prpsinfo () handles zero unterminated
4503 string_end
= memchr (psargs
, 0, sizeof (psargs
));
4504 if (string_end
!= NULL
)
4506 *string_end
++ = ' ';
4507 strncpy (string_end
, get_inferior_args (),
4508 psargs_end
- string_end
);
4511 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
4513 note_size
, fname
, psargs
);
4516 /* Dump information for threads. */
4517 thread_args
.obfd
= obfd
;
4518 thread_args
.note_data
= note_data
;
4519 thread_args
.note_size
= note_size
;
4520 thread_args
.num_notes
= 0;
4521 thread_args
.stop_signal
= find_stop_signal ();
4522 iterate_over_lwps (filter
, linux_nat_corefile_thread_callback
, &thread_args
);
4523 gdb_assert (thread_args
.num_notes
!= 0);
4524 note_data
= thread_args
.note_data
;
4526 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
4530 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
4531 "CORE", NT_AUXV
, auxv
, auxv_len
);
4535 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
4537 make_cleanup (xfree
, note_data
);
4541 /* Implement the "info proc" command. */
4544 linux_nat_info_proc_cmd (char *args
, int from_tty
)
4546 /* A long is used for pid instead of an int to avoid a loss of precision
4547 compiler warning from the output of strtoul. */
4548 long pid
= PIDGET (inferior_ptid
);
4551 char buffer
[MAXPATHLEN
];
4552 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
4564 /* Break up 'args' into an argv array. */
4565 argv
= gdb_buildargv (args
);
4566 make_cleanup_freeargv (argv
);
4568 while (argv
!= NULL
&& *argv
!= NULL
)
4570 if (isdigit (argv
[0][0]))
4572 pid
= strtoul (argv
[0], NULL
, 10);
4574 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
4578 else if (strcmp (argv
[0], "status") == 0)
4582 else if (strcmp (argv
[0], "stat") == 0)
4586 else if (strcmp (argv
[0], "cmd") == 0)
4590 else if (strncmp (argv
[0], "exe", strlen (argv
[0])) == 0)
4594 else if (strcmp (argv
[0], "cwd") == 0)
4598 else if (strncmp (argv
[0], "all", strlen (argv
[0])) == 0)
4604 /* [...] (future options here). */
4609 error (_("No current process: you must name one."));
4611 sprintf (fname1
, "/proc/%ld", pid
);
4612 if (stat (fname1
, &dummy
) != 0)
4613 error (_("No /proc directory: '%s'"), fname1
);
4615 printf_filtered (_("process %ld\n"), pid
);
4616 if (cmdline_f
|| all
)
4618 sprintf (fname1
, "/proc/%ld/cmdline", pid
);
4619 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4621 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4623 if (fgets (buffer
, sizeof (buffer
), procfile
))
4624 printf_filtered ("cmdline = '%s'\n", buffer
);
4626 warning (_("unable to read '%s'"), fname1
);
4627 do_cleanups (cleanup
);
4630 warning (_("unable to open /proc file '%s'"), fname1
);
4634 sprintf (fname1
, "/proc/%ld/cwd", pid
);
4635 memset (fname2
, 0, sizeof (fname2
));
4636 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
4637 printf_filtered ("cwd = '%s'\n", fname2
);
4639 warning (_("unable to read link '%s'"), fname1
);
4643 sprintf (fname1
, "/proc/%ld/exe", pid
);
4644 memset (fname2
, 0, sizeof (fname2
));
4645 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
4646 printf_filtered ("exe = '%s'\n", fname2
);
4648 warning (_("unable to read link '%s'"), fname1
);
4650 if (mappings_f
|| all
)
4652 sprintf (fname1
, "/proc/%ld/maps", pid
);
4653 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4655 long long addr
, endaddr
, size
, offset
, inode
;
4656 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
4657 struct cleanup
*cleanup
;
4659 cleanup
= make_cleanup_fclose (procfile
);
4660 printf_filtered (_("Mapped address spaces:\n\n"));
4661 if (gdbarch_addr_bit (target_gdbarch
) == 32)
4663 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
4666 " Size", " Offset", "objfile");
4670 printf_filtered (" %18s %18s %10s %10s %7s\n",
4673 " Size", " Offset", "objfile");
4676 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
4677 &offset
, &device
[0], &inode
, &filename
[0]))
4679 size
= endaddr
- addr
;
4681 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
4682 calls here (and possibly above) should be abstracted
4683 out into their own functions? Andrew suggests using
4684 a generic local_address_string instead to print out
4685 the addresses; that makes sense to me, too. */
4687 if (gdbarch_addr_bit (target_gdbarch
) == 32)
4689 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
4690 (unsigned long) addr
, /* FIXME: pr_addr */
4691 (unsigned long) endaddr
,
4693 (unsigned int) offset
,
4694 filename
[0] ? filename
: "");
4698 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
4699 (unsigned long) addr
, /* FIXME: pr_addr */
4700 (unsigned long) endaddr
,
4702 (unsigned int) offset
,
4703 filename
[0] ? filename
: "");
4707 do_cleanups (cleanup
);
4710 warning (_("unable to open /proc file '%s'"), fname1
);
4712 if (status_f
|| all
)
4714 sprintf (fname1
, "/proc/%ld/status", pid
);
4715 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4717 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4719 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
4720 puts_filtered (buffer
);
4721 do_cleanups (cleanup
);
4724 warning (_("unable to open /proc file '%s'"), fname1
);
4728 sprintf (fname1
, "/proc/%ld/stat", pid
);
4729 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4734 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4736 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4737 printf_filtered (_("Process: %d\n"), itmp
);
4738 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
4739 printf_filtered (_("Exec file: %s\n"), buffer
);
4740 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
4741 printf_filtered (_("State: %c\n"), ctmp
);
4742 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4743 printf_filtered (_("Parent process: %d\n"), itmp
);
4744 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4745 printf_filtered (_("Process group: %d\n"), itmp
);
4746 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4747 printf_filtered (_("Session id: %d\n"), itmp
);
4748 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4749 printf_filtered (_("TTY: %d\n"), itmp
);
4750 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4751 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
4752 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4753 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
4754 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4755 printf_filtered (_("Minor faults (no memory page): %lu\n"),
4756 (unsigned long) ltmp
);
4757 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4758 printf_filtered (_("Minor faults, children: %lu\n"),
4759 (unsigned long) ltmp
);
4760 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4761 printf_filtered (_("Major faults (memory page faults): %lu\n"),
4762 (unsigned long) ltmp
);
4763 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4764 printf_filtered (_("Major faults, children: %lu\n"),
4765 (unsigned long) ltmp
);
4766 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4767 printf_filtered (_("utime: %ld\n"), ltmp
);
4768 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4769 printf_filtered (_("stime: %ld\n"), ltmp
);
4770 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4771 printf_filtered (_("utime, children: %ld\n"), ltmp
);
4772 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4773 printf_filtered (_("stime, children: %ld\n"), ltmp
);
4774 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4775 printf_filtered (_("jiffies remaining in current "
4776 "time slice: %ld\n"), ltmp
);
4777 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4778 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
4779 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4780 printf_filtered (_("jiffies until next timeout: %lu\n"),
4781 (unsigned long) ltmp
);
4782 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4783 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
4784 (unsigned long) ltmp
);
4785 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4786 printf_filtered (_("start time (jiffies since "
4787 "system boot): %ld\n"), ltmp
);
4788 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4789 printf_filtered (_("Virtual memory size: %lu\n"),
4790 (unsigned long) ltmp
);
4791 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4792 printf_filtered (_("Resident set size: %lu\n"),
4793 (unsigned long) ltmp
);
4794 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4795 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
4796 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4797 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
4798 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4799 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
4800 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4801 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
4802 #if 0 /* Don't know how architecture-dependent the rest is...
4803 Anyway the signal bitmap info is available from "status". */
4804 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
4805 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
4806 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
4807 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
4808 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4809 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
4810 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4811 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
4812 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4813 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
4814 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4815 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
4816 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
4817 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
4819 do_cleanups (cleanup
);
4822 warning (_("unable to open /proc file '%s'"), fname1
);
4826 /* Implement the to_xfer_partial interface for memory reads using the /proc
4827 filesystem. Because we can use a single read() call for /proc, this
4828 can be much more efficient than banging away at PTRACE_PEEKTEXT,
4829 but it doesn't support writes. */
4832 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4833 const char *annex
, gdb_byte
*readbuf
,
4834 const gdb_byte
*writebuf
,
4835 ULONGEST offset
, LONGEST len
)
4841 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
4844 /* Don't bother for one word. */
4845 if (len
< 3 * sizeof (long))
4848 /* We could keep this file open and cache it - possibly one per
4849 thread. That requires some juggling, but is even faster. */
4850 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
4851 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
4855 /* If pread64 is available, use it. It's faster if the kernel
4856 supports it (only one syscall), and it's 64-bit safe even on
4857 32-bit platforms (for instance, SPARC debugging a SPARC64
4860 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
4862 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
4873 /* Enumerate spufs IDs for process PID. */
4875 spu_enumerate_spu_ids (int pid
, gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
4877 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4879 LONGEST written
= 0;
4882 struct dirent
*entry
;
4884 xsnprintf (path
, sizeof path
, "/proc/%d/fd", pid
);
4885 dir
= opendir (path
);
4890 while ((entry
= readdir (dir
)) != NULL
)
4896 fd
= atoi (entry
->d_name
);
4900 xsnprintf (path
, sizeof path
, "/proc/%d/fd/%d", pid
, fd
);
4901 if (stat (path
, &st
) != 0)
4903 if (!S_ISDIR (st
.st_mode
))
4906 if (statfs (path
, &stfs
) != 0)
4908 if (stfs
.f_type
!= SPUFS_MAGIC
)
4911 if (pos
>= offset
&& pos
+ 4 <= offset
+ len
)
4913 store_unsigned_integer (buf
+ pos
- offset
, 4, byte_order
, fd
);
4923 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
4924 object type, using the /proc file system. */
4926 linux_proc_xfer_spu (struct target_ops
*ops
, enum target_object object
,
4927 const char *annex
, gdb_byte
*readbuf
,
4928 const gdb_byte
*writebuf
,
4929 ULONGEST offset
, LONGEST len
)
4934 int pid
= PIDGET (inferior_ptid
);
4941 return spu_enumerate_spu_ids (pid
, readbuf
, offset
, len
);
4944 xsnprintf (buf
, sizeof buf
, "/proc/%d/fd/%s", pid
, annex
);
4945 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
4950 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
4957 ret
= write (fd
, writebuf
, (size_t) len
);
4959 ret
= read (fd
, readbuf
, (size_t) len
);
4966 /* Parse LINE as a signal set and add its set bits to SIGS. */
4969 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
4971 int len
= strlen (line
) - 1;
4975 if (line
[len
] != '\n')
4976 error (_("Could not parse signal set: %s"), line
);
4984 if (*p
>= '0' && *p
<= '9')
4986 else if (*p
>= 'a' && *p
<= 'f')
4987 digit
= *p
- 'a' + 10;
4989 error (_("Could not parse signal set: %s"), line
);
4994 sigaddset (sigs
, signum
+ 1);
4996 sigaddset (sigs
, signum
+ 2);
4998 sigaddset (sigs
, signum
+ 3);
5000 sigaddset (sigs
, signum
+ 4);
5006 /* Find process PID's pending signals from /proc/pid/status and set
5010 linux_proc_pending_signals (int pid
, sigset_t
*pending
,
5011 sigset_t
*blocked
, sigset_t
*ignored
)
5014 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
5015 struct cleanup
*cleanup
;
5017 sigemptyset (pending
);
5018 sigemptyset (blocked
);
5019 sigemptyset (ignored
);
5020 sprintf (fname
, "/proc/%d/status", pid
);
5021 procfile
= fopen (fname
, "r");
5022 if (procfile
== NULL
)
5023 error (_("Could not open %s"), fname
);
5024 cleanup
= make_cleanup_fclose (procfile
);
5026 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
5028 /* Normal queued signals are on the SigPnd line in the status
5029 file. However, 2.6 kernels also have a "shared" pending
5030 queue for delivering signals to a thread group, so check for
5033 Unfortunately some Red Hat kernels include the shared pending
5034 queue but not the ShdPnd status field. */
5036 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
5037 add_line_to_sigset (buffer
+ 8, pending
);
5038 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
5039 add_line_to_sigset (buffer
+ 8, pending
);
5040 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
5041 add_line_to_sigset (buffer
+ 8, blocked
);
5042 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
5043 add_line_to_sigset (buffer
+ 8, ignored
);
5046 do_cleanups (cleanup
);
5050 linux_nat_xfer_osdata (struct target_ops
*ops
, enum target_object object
,
5051 const char *annex
, gdb_byte
*readbuf
,
5052 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5054 /* We make the process list snapshot when the object starts to be
5056 static const char *buf
;
5057 static LONGEST len_avail
= -1;
5058 static struct obstack obstack
;
5062 gdb_assert (object
== TARGET_OBJECT_OSDATA
);
5068 if (len_avail
!= -1 && len_avail
!= 0)
5069 obstack_free (&obstack
, NULL
);
5072 obstack_init (&obstack
);
5073 obstack_grow_str (&obstack
, "<osdata type=\"types\">\n");
5075 obstack_xml_printf (&obstack
,
5077 "<column name=\"Type\">processes</column>"
5078 "<column name=\"Description\">"
5079 "Listing of all processes</column>"
5082 obstack_grow_str0 (&obstack
, "</osdata>\n");
5083 buf
= obstack_finish (&obstack
);
5084 len_avail
= strlen (buf
);
5087 if (offset
>= len_avail
)
5089 /* Done. Get rid of the obstack. */
5090 obstack_free (&obstack
, NULL
);
5096 if (len
> len_avail
- offset
)
5097 len
= len_avail
- offset
;
5098 memcpy (readbuf
, buf
+ offset
, len
);
5103 if (strcmp (annex
, "processes") != 0)
5106 gdb_assert (readbuf
&& !writebuf
);
5110 if (len_avail
!= -1 && len_avail
!= 0)
5111 obstack_free (&obstack
, NULL
);
5114 obstack_init (&obstack
);
5115 obstack_grow_str (&obstack
, "<osdata type=\"processes\">\n");
5117 dirp
= opendir ("/proc");
5122 while ((dp
= readdir (dirp
)) != NULL
)
5124 struct stat statbuf
;
5125 char procentry
[sizeof ("/proc/4294967295")];
5127 if (!isdigit (dp
->d_name
[0])
5128 || NAMELEN (dp
) > sizeof ("4294967295") - 1)
5131 sprintf (procentry
, "/proc/%s", dp
->d_name
);
5132 if (stat (procentry
, &statbuf
) == 0
5133 && S_ISDIR (statbuf
.st_mode
))
5137 char cmd
[MAXPATHLEN
+ 1];
5138 struct passwd
*entry
;
5140 pathname
= xstrprintf ("/proc/%s/cmdline", dp
->d_name
);
5141 entry
= getpwuid (statbuf
.st_uid
);
5143 if ((f
= fopen (pathname
, "r")) != NULL
)
5145 size_t length
= fread (cmd
, 1, sizeof (cmd
) - 1, f
);
5151 for (i
= 0; i
< length
; i
++)
5156 obstack_xml_printf (
5159 "<column name=\"pid\">%s</column>"
5160 "<column name=\"user\">%s</column>"
5161 "<column name=\"command\">%s</column>"
5164 entry
? entry
->pw_name
: "?",
5177 obstack_grow_str0 (&obstack
, "</osdata>\n");
5178 buf
= obstack_finish (&obstack
);
5179 len_avail
= strlen (buf
);
5182 if (offset
>= len_avail
)
5184 /* Done. Get rid of the obstack. */
5185 obstack_free (&obstack
, NULL
);
5191 if (len
> len_avail
- offset
)
5192 len
= len_avail
- offset
;
5193 memcpy (readbuf
, buf
+ offset
, len
);
5199 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5200 const char *annex
, gdb_byte
*readbuf
,
5201 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5205 if (object
== TARGET_OBJECT_AUXV
)
5206 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
5209 if (object
== TARGET_OBJECT_OSDATA
)
5210 return linux_nat_xfer_osdata (ops
, object
, annex
, readbuf
, writebuf
,
5213 if (object
== TARGET_OBJECT_SPU
)
5214 return linux_proc_xfer_spu (ops
, object
, annex
, readbuf
, writebuf
,
5217 /* GDB calculates all the addresses in possibly larget width of the address.
5218 Address width needs to be masked before its final use - either by
5219 linux_proc_xfer_partial or inf_ptrace_xfer_partial.
5221 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
5223 if (object
== TARGET_OBJECT_MEMORY
)
5225 int addr_bit
= gdbarch_addr_bit (target_gdbarch
);
5227 if (addr_bit
< (sizeof (ULONGEST
) * HOST_CHAR_BIT
))
5228 offset
&= ((ULONGEST
) 1 << addr_bit
) - 1;
5231 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
5236 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
5240 /* Create a prototype generic GNU/Linux target. The client can override
5241 it with local methods. */
5244 linux_target_install_ops (struct target_ops
*t
)
5246 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
5247 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
5248 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
5249 t
->to_set_syscall_catchpoint
= linux_child_set_syscall_catchpoint
;
5250 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
5251 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
5252 t
->to_post_attach
= linux_child_post_attach
;
5253 t
->to_follow_fork
= linux_child_follow_fork
;
5254 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
5255 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
5257 super_xfer_partial
= t
->to_xfer_partial
;
5258 t
->to_xfer_partial
= linux_xfer_partial
;
5264 struct target_ops
*t
;
5266 t
= inf_ptrace_target ();
5267 linux_target_install_ops (t
);
5273 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
5275 struct target_ops
*t
;
5277 t
= inf_ptrace_trad_target (register_u_offset
);
5278 linux_target_install_ops (t
);
5283 /* target_is_async_p implementation. */
5286 linux_nat_is_async_p (void)
5288 /* NOTE: palves 2008-03-21: We're only async when the user requests
5289 it explicitly with the "set target-async" command.
5290 Someday, linux will always be async. */
5291 if (!target_async_permitted
)
5294 /* See target.h/target_async_mask. */
5295 return linux_nat_async_mask_value
;
5298 /* target_can_async_p implementation. */
5301 linux_nat_can_async_p (void)
5303 /* NOTE: palves 2008-03-21: We're only async when the user requests
5304 it explicitly with the "set target-async" command.
5305 Someday, linux will always be async. */
5306 if (!target_async_permitted
)
5309 /* See target.h/target_async_mask. */
5310 return linux_nat_async_mask_value
;
5314 linux_nat_supports_non_stop (void)
5319 /* True if we want to support multi-process. To be removed when GDB
5320 supports multi-exec. */
5322 int linux_multi_process
= 1;
5325 linux_nat_supports_multi_process (void)
5327 return linux_multi_process
;
5330 /* target_async_mask implementation. */
5333 linux_nat_async_mask (int new_mask
)
5335 int curr_mask
= linux_nat_async_mask_value
;
5337 if (curr_mask
!= new_mask
)
5341 linux_nat_async (NULL
, 0);
5342 linux_nat_async_mask_value
= new_mask
;
5346 linux_nat_async_mask_value
= new_mask
;
5348 /* If we're going out of async-mask in all-stop, then the
5349 inferior is stopped. The next resume will call
5350 target_async. In non-stop, the target event source
5351 should be always registered in the event loop. Do so
5354 linux_nat_async (inferior_event_handler
, 0);
5361 static int async_terminal_is_ours
= 1;
5363 /* target_terminal_inferior implementation. */
5366 linux_nat_terminal_inferior (void)
5368 if (!target_is_async_p ())
5370 /* Async mode is disabled. */
5371 terminal_inferior ();
5375 terminal_inferior ();
5377 /* Calls to target_terminal_*() are meant to be idempotent. */
5378 if (!async_terminal_is_ours
)
5381 delete_file_handler (input_fd
);
5382 async_terminal_is_ours
= 0;
5386 /* target_terminal_ours implementation. */
5389 linux_nat_terminal_ours (void)
5391 if (!target_is_async_p ())
5393 /* Async mode is disabled. */
5398 /* GDB should never give the terminal to the inferior if the
5399 inferior is running in the background (run&, continue&, etc.),
5400 but claiming it sure should. */
5403 if (async_terminal_is_ours
)
5406 clear_sigint_trap ();
5407 add_file_handler (input_fd
, stdin_event_handler
, 0);
5408 async_terminal_is_ours
= 1;
5411 static void (*async_client_callback
) (enum inferior_event_type event_type
,
5413 static void *async_client_context
;
5415 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5416 so we notice when any child changes state, and notify the
5417 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
5418 above to wait for the arrival of a SIGCHLD. */
5421 sigchld_handler (int signo
)
5423 int old_errno
= errno
;
5425 if (debug_linux_nat_async
)
5426 fprintf_unfiltered (gdb_stdlog
, "sigchld\n");
5428 if (signo
== SIGCHLD
5429 && linux_nat_event_pipe
[0] != -1)
5430 async_file_mark (); /* Let the event loop know that there are
5431 events to handle. */
5436 /* Callback registered with the target events file descriptor. */
5439 handle_target_event (int error
, gdb_client_data client_data
)
5441 (*async_client_callback
) (INF_REG_EVENT
, async_client_context
);
5444 /* Create/destroy the target events pipe. Returns previous state. */
5447 linux_async_pipe (int enable
)
5449 int previous
= (linux_nat_event_pipe
[0] != -1);
5451 if (previous
!= enable
)
5455 block_child_signals (&prev_mask
);
5459 if (pipe (linux_nat_event_pipe
) == -1)
5460 internal_error (__FILE__
, __LINE__
,
5461 "creating event pipe failed.");
5463 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
5464 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
5468 close (linux_nat_event_pipe
[0]);
5469 close (linux_nat_event_pipe
[1]);
5470 linux_nat_event_pipe
[0] = -1;
5471 linux_nat_event_pipe
[1] = -1;
5474 restore_child_signals_mask (&prev_mask
);
5480 /* target_async implementation. */
5483 linux_nat_async (void (*callback
) (enum inferior_event_type event_type
,
5484 void *context
), void *context
)
5486 if (linux_nat_async_mask_value
== 0 || !target_async_permitted
)
5487 internal_error (__FILE__
, __LINE__
,
5488 "Calling target_async when async is masked");
5490 if (callback
!= NULL
)
5492 async_client_callback
= callback
;
5493 async_client_context
= context
;
5494 if (!linux_async_pipe (1))
5496 add_file_handler (linux_nat_event_pipe
[0],
5497 handle_target_event
, NULL
);
5498 /* There may be pending events to handle. Tell the event loop
5505 async_client_callback
= callback
;
5506 async_client_context
= context
;
5507 delete_file_handler (linux_nat_event_pipe
[0]);
5508 linux_async_pipe (0);
5513 /* Stop an LWP, and push a TARGET_SIGNAL_0 stop status if no other
5517 linux_nat_stop_lwp (struct lwp_info
*lwp
, void *data
)
5521 ptid_t ptid
= lwp
->ptid
;
5523 if (debug_linux_nat
)
5524 fprintf_unfiltered (gdb_stdlog
,
5525 "LNSL: running -> suspending %s\n",
5526 target_pid_to_str (lwp
->ptid
));
5529 stop_callback (lwp
, NULL
);
5530 stop_wait_callback (lwp
, NULL
);
5532 /* If the lwp exits while we try to stop it, there's nothing
5534 lwp
= find_lwp_pid (ptid
);
5538 /* If we didn't collect any signal other than SIGSTOP while
5539 stopping the LWP, push a SIGNAL_0 event. In either case, the
5540 event-loop will end up calling target_wait which will collect
5542 if (lwp
->status
== 0)
5543 lwp
->status
= W_STOPCODE (0);
5548 /* Already known to be stopped; do nothing. */
5550 if (debug_linux_nat
)
5552 if (find_thread_ptid (lwp
->ptid
)->stop_requested
)
5553 fprintf_unfiltered (gdb_stdlog
,
5554 "LNSL: already stopped/stop_requested %s\n",
5555 target_pid_to_str (lwp
->ptid
));
5557 fprintf_unfiltered (gdb_stdlog
,
5558 "LNSL: already stopped/no "
5559 "stop_requested yet %s\n",
5560 target_pid_to_str (lwp
->ptid
));
5567 linux_nat_stop (ptid_t ptid
)
5570 iterate_over_lwps (ptid
, linux_nat_stop_lwp
, NULL
);
5572 linux_ops
->to_stop (ptid
);
5576 linux_nat_close (int quitting
)
5578 /* Unregister from the event loop. */
5579 if (target_is_async_p ())
5580 target_async (NULL
, 0);
5582 /* Reset the async_masking. */
5583 linux_nat_async_mask_value
= 1;
5585 if (linux_ops
->to_close
)
5586 linux_ops
->to_close (quitting
);
5589 /* When requests are passed down from the linux-nat layer to the
5590 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
5591 used. The address space pointer is stored in the inferior object,
5592 but the common code that is passed such ptid can't tell whether
5593 lwpid is a "main" process id or not (it assumes so). We reverse
5594 look up the "main" process id from the lwp here. */
5596 struct address_space
*
5597 linux_nat_thread_address_space (struct target_ops
*t
, ptid_t ptid
)
5599 struct lwp_info
*lwp
;
5600 struct inferior
*inf
;
5603 pid
= GET_LWP (ptid
);
5604 if (GET_LWP (ptid
) == 0)
5606 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
5608 lwp
= find_lwp_pid (ptid
);
5609 pid
= GET_PID (lwp
->ptid
);
5613 /* A (pid,lwpid,0) ptid. */
5614 pid
= GET_PID (ptid
);
5617 inf
= find_inferior_pid (pid
);
5618 gdb_assert (inf
!= NULL
);
5623 linux_nat_core_of_thread_1 (ptid_t ptid
)
5625 struct cleanup
*back_to
;
5628 char *content
= NULL
;
5631 int content_read
= 0;
5635 filename
= xstrprintf ("/proc/%d/task/%ld/stat",
5636 GET_PID (ptid
), GET_LWP (ptid
));
5637 back_to
= make_cleanup (xfree
, filename
);
5639 f
= fopen (filename
, "r");
5642 do_cleanups (back_to
);
5646 make_cleanup_fclose (f
);
5652 content
= xrealloc (content
, content_read
+ 1024);
5653 n
= fread (content
+ content_read
, 1, 1024, f
);
5657 content
[content_read
] = '\0';
5662 make_cleanup (xfree
, content
);
5664 p
= strchr (content
, '(');
5668 p
= strchr (p
, ')');
5672 /* If the first field after program name has index 0, then core number is
5673 the field with index 36. There's no constant for that anywhere. */
5675 p
= strtok_r (p
, " ", &ts
);
5676 for (i
= 0; p
!= NULL
&& i
!= 36; ++i
)
5677 p
= strtok_r (NULL
, " ", &ts
);
5679 if (p
== NULL
|| sscanf (p
, "%d", &core
) == 0)
5682 do_cleanups (back_to
);
5687 /* Return the cached value of the processor core for thread PTID. */
5690 linux_nat_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
5692 struct lwp_info
*info
= find_lwp_pid (ptid
);
5700 linux_nat_add_target (struct target_ops
*t
)
5702 /* Save the provided single-threaded target. We save this in a separate
5703 variable because another target we've inherited from (e.g. inf-ptrace)
5704 may have saved a pointer to T; we want to use it for the final
5705 process stratum target. */
5706 linux_ops_saved
= *t
;
5707 linux_ops
= &linux_ops_saved
;
5709 /* Override some methods for multithreading. */
5710 t
->to_create_inferior
= linux_nat_create_inferior
;
5711 t
->to_attach
= linux_nat_attach
;
5712 t
->to_detach
= linux_nat_detach
;
5713 t
->to_resume
= linux_nat_resume
;
5714 t
->to_wait
= linux_nat_wait
;
5715 t
->to_xfer_partial
= linux_nat_xfer_partial
;
5716 t
->to_kill
= linux_nat_kill
;
5717 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
5718 t
->to_thread_alive
= linux_nat_thread_alive
;
5719 t
->to_pid_to_str
= linux_nat_pid_to_str
;
5720 t
->to_thread_name
= linux_nat_thread_name
;
5721 t
->to_has_thread_control
= tc_schedlock
;
5722 t
->to_thread_address_space
= linux_nat_thread_address_space
;
5723 t
->to_stopped_by_watchpoint
= linux_nat_stopped_by_watchpoint
;
5724 t
->to_stopped_data_address
= linux_nat_stopped_data_address
;
5726 t
->to_can_async_p
= linux_nat_can_async_p
;
5727 t
->to_is_async_p
= linux_nat_is_async_p
;
5728 t
->to_supports_non_stop
= linux_nat_supports_non_stop
;
5729 t
->to_async
= linux_nat_async
;
5730 t
->to_async_mask
= linux_nat_async_mask
;
5731 t
->to_terminal_inferior
= linux_nat_terminal_inferior
;
5732 t
->to_terminal_ours
= linux_nat_terminal_ours
;
5733 t
->to_close
= linux_nat_close
;
5735 /* Methods for non-stop support. */
5736 t
->to_stop
= linux_nat_stop
;
5738 t
->to_supports_multi_process
= linux_nat_supports_multi_process
;
5740 t
->to_core_of_thread
= linux_nat_core_of_thread
;
5742 /* We don't change the stratum; this target will sit at
5743 process_stratum and thread_db will set at thread_stratum. This
5744 is a little strange, since this is a multi-threaded-capable
5745 target, but we want to be on the stack below thread_db, and we
5746 also want to be used for single-threaded processes. */
5751 /* Register a method to call whenever a new thread is attached. */
5753 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
5755 /* Save the pointer. We only support a single registered instance
5756 of the GNU/Linux native target, so we do not need to map this to
5758 linux_nat_new_thread
= new_thread
;
5761 /* Register a method that converts a siginfo object between the layout
5762 that ptrace returns, and the layout in the architecture of the
5765 linux_nat_set_siginfo_fixup (struct target_ops
*t
,
5766 int (*siginfo_fixup
) (struct siginfo
*,
5770 /* Save the pointer. */
5771 linux_nat_siginfo_fixup
= siginfo_fixup
;
5774 /* Return the saved siginfo associated with PTID. */
5776 linux_nat_get_siginfo (ptid_t ptid
)
5778 struct lwp_info
*lp
= find_lwp_pid (ptid
);
5780 gdb_assert (lp
!= NULL
);
5782 return &lp
->siginfo
;
5785 /* Provide a prototype to silence -Wmissing-prototypes. */
5786 extern initialize_file_ftype _initialize_linux_nat
;
5789 _initialize_linux_nat (void)
5791 add_info ("proc", linux_nat_info_proc_cmd
, _("\
5792 Show /proc process information about any running process.\n\
5793 Specify any process id, or use the program being debugged by default.\n\
5794 Specify any of the following keywords for detailed info:\n\
5795 mappings -- list of mapped memory regions.\n\
5796 stat -- list a bunch of random process info.\n\
5797 status -- list a different bunch of random process info.\n\
5798 all -- list all available /proc info."));
5800 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance
,
5801 &debug_linux_nat
, _("\
5802 Set debugging of GNU/Linux lwp module."), _("\
5803 Show debugging of GNU/Linux lwp module."), _("\
5804 Enables printf debugging output."),
5806 show_debug_linux_nat
,
5807 &setdebuglist
, &showdebuglist
);
5809 add_setshow_zinteger_cmd ("lin-lwp-async", class_maintenance
,
5810 &debug_linux_nat_async
, _("\
5811 Set debugging of GNU/Linux async lwp module."), _("\
5812 Show debugging of GNU/Linux async lwp module."), _("\
5813 Enables printf debugging output."),
5815 show_debug_linux_nat_async
,
5816 &setdebuglist
, &showdebuglist
);
5818 /* Save this mask as the default. */
5819 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
5821 /* Install a SIGCHLD handler. */
5822 sigchld_action
.sa_handler
= sigchld_handler
;
5823 sigemptyset (&sigchld_action
.sa_mask
);
5824 sigchld_action
.sa_flags
= SA_RESTART
;
5826 /* Make it the default. */
5827 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
5829 /* Make sure we don't block SIGCHLD during a sigsuspend. */
5830 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
5831 sigdelset (&suspend_mask
, SIGCHLD
);
5833 sigemptyset (&blocked_mask
);
5835 add_setshow_boolean_cmd ("disable-randomization", class_support
,
5836 &disable_randomization
, _("\
5837 Set disabling of debuggee's virtual address space randomization."), _("\
5838 Show disabling of debuggee's virtual address space randomization."), _("\
5839 When this mode is on (which is the default), randomization of the virtual\n\
5840 address space is disabled. Standalone programs run with the randomization\n\
5841 enabled by default on some platforms."),
5842 &set_disable_randomization
,
5843 &show_disable_randomization
,
5844 &setlist
, &showlist
);
5848 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5849 the GNU/Linux Threads library and therefore doesn't really belong
5852 /* Read variable NAME in the target and return its value if found.
5853 Otherwise return zero. It is assumed that the type of the variable
5857 get_signo (const char *name
)
5859 struct minimal_symbol
*ms
;
5862 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
5866 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
5867 sizeof (signo
)) != 0)
5873 /* Return the set of signals used by the threads library in *SET. */
5876 lin_thread_get_thread_signals (sigset_t
*set
)
5878 struct sigaction action
;
5879 int restart
, cancel
;
5881 sigemptyset (&blocked_mask
);
5884 restart
= get_signo ("__pthread_sig_restart");
5885 cancel
= get_signo ("__pthread_sig_cancel");
5887 /* LinuxThreads normally uses the first two RT signals, but in some legacy
5888 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
5889 not provide any way for the debugger to query the signal numbers -
5890 fortunately they don't change! */
5893 restart
= __SIGRTMIN
;
5896 cancel
= __SIGRTMIN
+ 1;
5898 sigaddset (set
, restart
);
5899 sigaddset (set
, cancel
);
5901 /* The GNU/Linux Threads library makes terminating threads send a
5902 special "cancel" signal instead of SIGCHLD. Make sure we catch
5903 those (to prevent them from terminating GDB itself, which is
5904 likely to be their default action) and treat them the same way as
5907 action
.sa_handler
= sigchld_handler
;
5908 sigemptyset (&action
.sa_mask
);
5909 action
.sa_flags
= SA_RESTART
;
5910 sigaction (cancel
, &action
, NULL
);
5912 /* We block the "cancel" signal throughout this code ... */
5913 sigaddset (&blocked_mask
, cancel
);
5914 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
5916 /* ... except during a sigsuspend. */
5917 sigdelset (&suspend_mask
, cancel
);