1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
26 #include "gdb_assert.h"
27 #ifdef HAVE_TKILL_SYSCALL
29 #include <sys/syscall.h>
31 #include <sys/ptrace.h>
32 #include "linux-nat.h"
33 #include "linux-fork.h"
34 #include "gdbthread.h"
38 #include "inf-ptrace.h"
40 #include <sys/param.h> /* for MAXPATHLEN */
41 #include <sys/procfs.h> /* for elf_gregset etc. */
42 #include "elf-bfd.h" /* for elfcore_write_* */
43 #include "gregset.h" /* for gregset */
44 #include "gdbcore.h" /* for get_exec_file */
45 #include <ctype.h> /* for isdigit */
46 #include "gdbthread.h" /* for struct thread_info etc. */
47 #include "gdb_stat.h" /* for struct stat */
48 #include <fcntl.h> /* for O_RDONLY */
54 /* If the system headers did not provide the constants, hard-code the normal
56 #ifndef PTRACE_EVENT_FORK
58 #define PTRACE_SETOPTIONS 0x4200
59 #define PTRACE_GETEVENTMSG 0x4201
61 /* options set using PTRACE_SETOPTIONS */
62 #define PTRACE_O_TRACESYSGOOD 0x00000001
63 #define PTRACE_O_TRACEFORK 0x00000002
64 #define PTRACE_O_TRACEVFORK 0x00000004
65 #define PTRACE_O_TRACECLONE 0x00000008
66 #define PTRACE_O_TRACEEXEC 0x00000010
67 #define PTRACE_O_TRACEVFORKDONE 0x00000020
68 #define PTRACE_O_TRACEEXIT 0x00000040
70 /* Wait extended result codes for the above trace options. */
71 #define PTRACE_EVENT_FORK 1
72 #define PTRACE_EVENT_VFORK 2
73 #define PTRACE_EVENT_CLONE 3
74 #define PTRACE_EVENT_EXEC 4
75 #define PTRACE_EVENT_VFORK_DONE 5
76 #define PTRACE_EVENT_EXIT 6
78 #endif /* PTRACE_EVENT_FORK */
80 /* We can't always assume that this flag is available, but all systems
81 with the ptrace event handlers also have __WALL, so it's safe to use
84 #define __WALL 0x40000000 /* Wait for any child. */
87 #ifndef PTRACE_GETSIGINFO
88 #define PTRACE_GETSIGINFO 0x4202
91 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
92 the use of the multi-threaded target. */
93 static struct target_ops
*linux_ops
;
94 static struct target_ops linux_ops_saved
;
96 /* The method to call, if any, when a new thread is attached. */
97 static void (*linux_nat_new_thread
) (ptid_t
);
99 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
100 Called by our to_xfer_partial. */
101 static LONGEST (*super_xfer_partial
) (struct target_ops
*,
103 const char *, gdb_byte
*,
107 static int debug_linux_nat
;
109 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
110 struct cmd_list_element
*c
, const char *value
)
112 fprintf_filtered (file
, _("Debugging of GNU/Linux lwp module is %s.\n"),
116 static int linux_parent_pid
;
118 struct simple_pid_list
122 struct simple_pid_list
*next
;
124 struct simple_pid_list
*stopped_pids
;
126 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
127 can not be used, 1 if it can. */
129 static int linux_supports_tracefork_flag
= -1;
131 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
132 PTRACE_O_TRACEVFORKDONE. */
134 static int linux_supports_tracevforkdone_flag
= -1;
137 /* Trivial list manipulation functions to keep track of a list of
138 new stopped processes. */
140 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
142 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
144 new_pid
->status
= status
;
145 new_pid
->next
= *listp
;
150 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *status
)
152 struct simple_pid_list
**p
;
154 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
155 if ((*p
)->pid
== pid
)
157 struct simple_pid_list
*next
= (*p
)->next
;
158 *status
= (*p
)->status
;
167 linux_record_stopped_pid (int pid
, int status
)
169 add_to_pid_list (&stopped_pids
, pid
, status
);
173 /* A helper function for linux_test_for_tracefork, called after fork (). */
176 linux_tracefork_child (void)
180 ptrace (PTRACE_TRACEME
, 0, 0, 0);
181 kill (getpid (), SIGSTOP
);
186 /* Wrapper function for waitpid which handles EINTR. */
189 my_waitpid (int pid
, int *status
, int flags
)
194 ret
= waitpid (pid
, status
, flags
);
196 while (ret
== -1 && errno
== EINTR
);
201 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
203 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
204 we know that the feature is not available. This may change the tracing
205 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
207 However, if it succeeds, we don't know for sure that the feature is
208 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
209 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
210 fork tracing, and let it fork. If the process exits, we assume that we
211 can't use TRACEFORK; if we get the fork notification, and we can extract
212 the new child's PID, then we assume that we can. */
215 linux_test_for_tracefork (int original_pid
)
217 int child_pid
, ret
, status
;
220 linux_supports_tracefork_flag
= 0;
221 linux_supports_tracevforkdone_flag
= 0;
223 ret
= ptrace (PTRACE_SETOPTIONS
, original_pid
, 0, PTRACE_O_TRACEFORK
);
229 perror_with_name (("fork"));
232 linux_tracefork_child ();
234 ret
= my_waitpid (child_pid
, &status
, 0);
236 perror_with_name (("waitpid"));
237 else if (ret
!= child_pid
)
238 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret
);
239 if (! WIFSTOPPED (status
))
240 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status
);
242 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
245 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
248 warning (_("linux_test_for_tracefork: failed to kill child"));
252 ret
= my_waitpid (child_pid
, &status
, 0);
253 if (ret
!= child_pid
)
254 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
255 else if (!WIFSIGNALED (status
))
256 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
257 "killed child"), status
);
262 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
263 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0,
264 PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORKDONE
);
265 linux_supports_tracevforkdone_flag
= (ret
== 0);
267 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
269 warning (_("linux_test_for_tracefork: failed to resume child"));
271 ret
= my_waitpid (child_pid
, &status
, 0);
273 if (ret
== child_pid
&& WIFSTOPPED (status
)
274 && status
>> 16 == PTRACE_EVENT_FORK
)
277 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
278 if (ret
== 0 && second_pid
!= 0)
282 linux_supports_tracefork_flag
= 1;
283 my_waitpid (second_pid
, &second_status
, 0);
284 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
286 warning (_("linux_test_for_tracefork: failed to kill second child"));
287 my_waitpid (second_pid
, &status
, 0);
291 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
292 "(%d, status 0x%x)"), ret
, status
);
294 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
296 warning (_("linux_test_for_tracefork: failed to kill child"));
297 my_waitpid (child_pid
, &status
, 0);
300 /* Return non-zero iff we have tracefork functionality available.
301 This function also sets linux_supports_tracefork_flag. */
304 linux_supports_tracefork (int pid
)
306 if (linux_supports_tracefork_flag
== -1)
307 linux_test_for_tracefork (pid
);
308 return linux_supports_tracefork_flag
;
312 linux_supports_tracevforkdone (int pid
)
314 if (linux_supports_tracefork_flag
== -1)
315 linux_test_for_tracefork (pid
);
316 return linux_supports_tracevforkdone_flag
;
321 linux_enable_event_reporting (ptid_t ptid
)
323 int pid
= ptid_get_lwp (ptid
);
327 pid
= ptid_get_pid (ptid
);
329 if (! linux_supports_tracefork (pid
))
332 options
= PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEEXEC
333 | PTRACE_O_TRACECLONE
;
334 if (linux_supports_tracevforkdone (pid
))
335 options
|= PTRACE_O_TRACEVFORKDONE
;
337 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
338 read-only process state. */
340 ptrace (PTRACE_SETOPTIONS
, pid
, 0, options
);
344 linux_child_post_attach (int pid
)
346 linux_enable_event_reporting (pid_to_ptid (pid
));
347 check_for_thread_db ();
351 linux_child_post_startup_inferior (ptid_t ptid
)
353 linux_enable_event_reporting (ptid
);
354 check_for_thread_db ();
358 linux_child_follow_fork (struct target_ops
*ops
, int follow_child
)
361 struct target_waitstatus last_status
;
363 int parent_pid
, child_pid
;
365 get_last_target_status (&last_ptid
, &last_status
);
366 has_vforked
= (last_status
.kind
== TARGET_WAITKIND_VFORKED
);
367 parent_pid
= ptid_get_lwp (last_ptid
);
369 parent_pid
= ptid_get_pid (last_ptid
);
370 child_pid
= last_status
.value
.related_pid
;
374 /* We're already attached to the parent, by default. */
376 /* Before detaching from the child, remove all breakpoints from
377 it. (This won't actually modify the breakpoint list, but will
378 physically remove the breakpoints from the child.) */
379 /* If we vforked this will remove the breakpoints from the parent
380 also, but they'll be reinserted below. */
381 detach_breakpoints (child_pid
);
383 /* Detach new forked process? */
386 if (info_verbose
|| debug_linux_nat
)
388 target_terminal_ours ();
389 fprintf_filtered (gdb_stdlog
,
390 "Detaching after fork from child process %d.\n",
394 ptrace (PTRACE_DETACH
, child_pid
, 0, 0);
398 struct fork_info
*fp
;
399 /* Retain child fork in ptrace (stopped) state. */
400 fp
= find_fork_pid (child_pid
);
402 fp
= add_fork (child_pid
);
403 fork_save_infrun_state (fp
, 0);
408 gdb_assert (linux_supports_tracefork_flag
>= 0);
409 if (linux_supports_tracevforkdone (0))
413 ptrace (PTRACE_CONT
, parent_pid
, 0, 0);
414 my_waitpid (parent_pid
, &status
, __WALL
);
415 if ((status
>> 16) != PTRACE_EVENT_VFORK_DONE
)
416 warning (_("Unexpected waitpid result %06x when waiting for "
417 "vfork-done"), status
);
421 /* We can't insert breakpoints until the child has
422 finished with the shared memory region. We need to
423 wait until that happens. Ideal would be to just
425 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
426 - waitpid (parent_pid, &status, __WALL);
427 However, most architectures can't handle a syscall
428 being traced on the way out if it wasn't traced on
431 We might also think to loop, continuing the child
432 until it exits or gets a SIGTRAP. One problem is
433 that the child might call ptrace with PTRACE_TRACEME.
435 There's no simple and reliable way to figure out when
436 the vforked child will be done with its copy of the
437 shared memory. We could step it out of the syscall,
438 two instructions, let it go, and then single-step the
439 parent once. When we have hardware single-step, this
440 would work; with software single-step it could still
441 be made to work but we'd have to be able to insert
442 single-step breakpoints in the child, and we'd have
443 to insert -just- the single-step breakpoint in the
444 parent. Very awkward.
446 In the end, the best we can do is to make sure it
447 runs for a little while. Hopefully it will be out of
448 range of any breakpoints we reinsert. Usually this
449 is only the single-step breakpoint at vfork's return
455 /* Since we vforked, breakpoints were removed in the parent
456 too. Put them back. */
457 reattach_breakpoints (parent_pid
);
462 char child_pid_spelling
[40];
464 /* Needed to keep the breakpoint lists in sync. */
466 detach_breakpoints (child_pid
);
468 /* Before detaching from the parent, remove all breakpoints from it. */
469 remove_breakpoints ();
471 if (info_verbose
|| debug_linux_nat
)
473 target_terminal_ours ();
474 fprintf_filtered (gdb_stdlog
,
475 "Attaching after fork to child process %d.\n",
479 /* If we're vforking, we may want to hold on to the parent until
480 the child exits or execs. At exec time we can remove the old
481 breakpoints from the parent and detach it; at exit time we
482 could do the same (or even, sneakily, resume debugging it - the
483 child's exec has failed, or something similar).
485 This doesn't clean up "properly", because we can't call
486 target_detach, but that's OK; if the current target is "child",
487 then it doesn't need any further cleanups, and lin_lwp will
488 generally not encounter vfork (vfork is defined to fork
491 The holding part is very easy if we have VFORKDONE events;
492 but keeping track of both processes is beyond GDB at the
493 moment. So we don't expose the parent to the rest of GDB.
494 Instead we quietly hold onto it until such time as we can
498 linux_parent_pid
= parent_pid
;
499 else if (!detach_fork
)
501 struct fork_info
*fp
;
502 /* Retain parent fork in ptrace (stopped) state. */
503 fp
= find_fork_pid (parent_pid
);
505 fp
= add_fork (parent_pid
);
506 fork_save_infrun_state (fp
, 0);
510 target_detach (NULL
, 0);
513 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
515 /* Reinstall ourselves, since we might have been removed in
516 target_detach (which does other necessary cleanup). */
519 linux_nat_switch_fork (inferior_ptid
);
520 check_for_thread_db ();
522 /* Reset breakpoints in the child as appropriate. */
523 follow_inferior_reset_breakpoints ();
531 linux_child_insert_fork_catchpoint (int pid
)
533 if (! linux_supports_tracefork (pid
))
534 error (_("Your system does not support fork catchpoints."));
538 linux_child_insert_vfork_catchpoint (int pid
)
540 if (!linux_supports_tracefork (pid
))
541 error (_("Your system does not support vfork catchpoints."));
545 linux_child_insert_exec_catchpoint (int pid
)
547 if (!linux_supports_tracefork (pid
))
548 error (_("Your system does not support exec catchpoints."));
551 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
552 are processes sharing the same VM space. A multi-threaded process
553 is basically a group of such processes. However, such a grouping
554 is almost entirely a user-space issue; the kernel doesn't enforce
555 such a grouping at all (this might change in the future). In
556 general, we'll rely on the threads library (i.e. the GNU/Linux
557 Threads library) to provide such a grouping.
559 It is perfectly well possible to write a multi-threaded application
560 without the assistance of a threads library, by using the clone
561 system call directly. This module should be able to give some
562 rudimentary support for debugging such applications if developers
563 specify the CLONE_PTRACE flag in the clone system call, and are
564 using the Linux kernel 2.4 or above.
566 Note that there are some peculiarities in GNU/Linux that affect
569 - In general one should specify the __WCLONE flag to waitpid in
570 order to make it report events for any of the cloned processes
571 (and leave it out for the initial process). However, if a cloned
572 process has exited the exit status is only reported if the
573 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
574 we cannot use it since GDB must work on older systems too.
576 - When a traced, cloned process exits and is waited for by the
577 debugger, the kernel reassigns it to the original parent and
578 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
579 library doesn't notice this, which leads to the "zombie problem":
580 When debugged a multi-threaded process that spawns a lot of
581 threads will run out of processes, even if the threads exit,
582 because the "zombies" stay around. */
584 /* List of known LWPs. */
585 struct lwp_info
*lwp_list
;
587 /* Number of LWPs in the list. */
591 /* If the last reported event was a SIGTRAP, this variable is set to
592 the process id of the LWP/thread that got it. */
596 /* Since we cannot wait (in linux_nat_wait) for the initial process and
597 any cloned processes with a single call to waitpid, we have to use
598 the WNOHANG flag and call waitpid in a loop. To optimize
599 things a bit we use `sigsuspend' to wake us up when a process has
600 something to report (it will send us a SIGCHLD if it has). To make
601 this work we have to juggle with the signal mask. We save the
602 original signal mask such that we can restore it before creating a
603 new process in order to avoid blocking certain signals in the
604 inferior. We then block SIGCHLD during the waitpid/sigsuspend
607 /* Original signal mask. */
608 static sigset_t normal_mask
;
610 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
611 _initialize_linux_nat. */
612 static sigset_t suspend_mask
;
614 /* Signals to block to make that sigsuspend work. */
615 static sigset_t blocked_mask
;
618 /* Prototypes for local functions. */
619 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
620 static int linux_nat_thread_alive (ptid_t ptid
);
621 static char *linux_child_pid_to_exec_file (int pid
);
623 /* Convert wait status STATUS to a string. Used for printing debug
627 status_to_str (int status
)
631 if (WIFSTOPPED (status
))
632 snprintf (buf
, sizeof (buf
), "%s (stopped)",
633 strsignal (WSTOPSIG (status
)));
634 else if (WIFSIGNALED (status
))
635 snprintf (buf
, sizeof (buf
), "%s (terminated)",
636 strsignal (WSTOPSIG (status
)));
638 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
643 /* Initialize the list of LWPs. Note that this module, contrary to
644 what GDB's generic threads layer does for its thread list,
645 re-initializes the LWP lists whenever we mourn or detach (which
646 doesn't involve mourning) the inferior. */
651 struct lwp_info
*lp
, *lpnext
;
653 for (lp
= lwp_list
; lp
; lp
= lpnext
)
663 /* Add the LWP specified by PID to the list. Return a pointer to the
664 structure describing the new LWP. The LWP should already be stopped
665 (with an exception for the very first LWP). */
667 static struct lwp_info
*
668 add_lwp (ptid_t ptid
)
672 gdb_assert (is_lwp (ptid
));
674 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
676 memset (lp
, 0, sizeof (struct lwp_info
));
678 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
686 if (num_lwps
> 1 && linux_nat_new_thread
!= NULL
)
687 linux_nat_new_thread (ptid
);
692 /* Remove the LWP specified by PID from the list. */
695 delete_lwp (ptid_t ptid
)
697 struct lwp_info
*lp
, *lpprev
;
701 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
702 if (ptid_equal (lp
->ptid
, ptid
))
711 lpprev
->next
= lp
->next
;
718 /* Return a pointer to the structure describing the LWP corresponding
719 to PID. If no corresponding LWP could be found, return NULL. */
721 static struct lwp_info
*
722 find_lwp_pid (ptid_t ptid
)
728 lwp
= GET_LWP (ptid
);
730 lwp
= GET_PID (ptid
);
732 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
733 if (lwp
== GET_LWP (lp
->ptid
))
739 /* Call CALLBACK with its second argument set to DATA for every LWP in
740 the list. If CALLBACK returns 1 for a particular LWP, return a
741 pointer to the structure describing that LWP immediately.
742 Otherwise return NULL. */
745 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
747 struct lwp_info
*lp
, *lpnext
;
749 for (lp
= lwp_list
; lp
; lp
= lpnext
)
752 if ((*callback
) (lp
, data
))
759 /* Update our internal state when changing from one fork (checkpoint,
760 et cetera) to another indicated by NEW_PTID. We can only switch
761 single-threaded applications, so we only create one new LWP, and
762 the previous list is discarded. */
765 linux_nat_switch_fork (ptid_t new_ptid
)
770 lp
= add_lwp (new_ptid
);
774 /* Record a PTID for later deletion. */
779 struct saved_ptids
*next
;
781 static struct saved_ptids
*threads_to_delete
;
784 record_dead_thread (ptid_t ptid
)
786 struct saved_ptids
*p
= xmalloc (sizeof (struct saved_ptids
));
788 p
->next
= threads_to_delete
;
789 threads_to_delete
= p
;
792 /* Delete any dead threads which are not the current thread. */
797 struct saved_ptids
**p
= &threads_to_delete
;
800 if (! ptid_equal ((*p
)->ptid
, inferior_ptid
))
802 struct saved_ptids
*tmp
= *p
;
803 delete_thread (tmp
->ptid
);
811 /* Handle the exit of a single thread LP. */
814 exit_lwp (struct lwp_info
*lp
)
816 if (in_thread_list (lp
->ptid
))
818 if (print_thread_events
)
819 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp
->ptid
));
821 /* Core GDB cannot deal with us deleting the current thread. */
822 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
823 delete_thread (lp
->ptid
);
825 record_dead_thread (lp
->ptid
);
828 delete_lwp (lp
->ptid
);
831 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
832 a message telling the user that a new LWP has been added to the
833 process. Return 0 if successful or -1 if the new LWP could not
837 lin_lwp_attach_lwp (ptid_t ptid
)
841 gdb_assert (is_lwp (ptid
));
843 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
844 to interrupt either the ptrace() or waitpid() calls below. */
845 if (!sigismember (&blocked_mask
, SIGCHLD
))
847 sigaddset (&blocked_mask
, SIGCHLD
);
848 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
851 lp
= find_lwp_pid (ptid
);
853 /* We assume that we're already attached to any LWP that has an id
854 equal to the overall process id, and to any LWP that is already
855 in our list of LWPs. If we're not seeing exit events from threads
856 and we've had PID wraparound since we last tried to stop all threads,
857 this assumption might be wrong; fortunately, this is very unlikely
859 if (GET_LWP (ptid
) != GET_PID (ptid
) && lp
== NULL
)
865 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
867 /* If we fail to attach to the thread, issue a warning,
868 but continue. One way this can happen is if thread
869 creation is interrupted; as of Linux kernel 2.6.19, a
870 bug may place threads in the thread list and then fail
872 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
873 safe_strerror (errno
));
878 fprintf_unfiltered (gdb_stdlog
,
879 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
880 target_pid_to_str (ptid
));
882 pid
= my_waitpid (GET_LWP (ptid
), &status
, 0);
883 if (pid
== -1 && errno
== ECHILD
)
885 /* Try again with __WCLONE to check cloned processes. */
886 pid
= my_waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
890 gdb_assert (pid
== GET_LWP (ptid
)
891 && WIFSTOPPED (status
) && WSTOPSIG (status
));
897 target_post_attach (pid
);
903 fprintf_unfiltered (gdb_stdlog
,
904 "LLAL: waitpid %s received %s\n",
905 target_pid_to_str (ptid
),
906 status_to_str (status
));
911 /* We assume that the LWP representing the original process is
912 already stopped. Mark it as stopped in the data structure
913 that the GNU/linux ptrace layer uses to keep track of
914 threads. Note that this won't have already been done since
915 the main thread will have, we assume, been stopped by an
916 attach from a different layer. */
926 linux_nat_attach (char *args
, int from_tty
)
933 /* FIXME: We should probably accept a list of process id's, and
934 attach all of them. */
935 linux_ops
->to_attach (args
, from_tty
);
937 /* Make sure the initial process is stopped. The user-level threads
938 layer might want to poke around in the inferior, and that won't
939 work if things haven't stabilized yet. */
940 pid
= my_waitpid (GET_PID (inferior_ptid
), &status
, 0);
941 if (pid
== -1 && errno
== ECHILD
)
943 warning (_("%s is a cloned process"), target_pid_to_str (inferior_ptid
));
945 /* Try again with __WCLONE to check cloned processes. */
946 pid
= my_waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
950 gdb_assert (pid
== GET_PID (inferior_ptid
)
951 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
953 /* Add the initial process as the first LWP to the list. */
954 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
));
955 lp
= add_lwp (inferior_ptid
);
960 /* Fake the SIGSTOP that core GDB expects. */
961 lp
->status
= W_STOPCODE (SIGSTOP
);
965 fprintf_unfiltered (gdb_stdlog
,
966 "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid
);
971 detach_callback (struct lwp_info
*lp
, void *data
)
973 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
975 if (debug_linux_nat
&& lp
->status
)
976 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
977 strsignal (WSTOPSIG (lp
->status
)),
978 target_pid_to_str (lp
->ptid
));
980 while (lp
->signalled
&& lp
->stopped
)
983 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
984 WSTOPSIG (lp
->status
)) < 0)
985 error (_("Can't continue %s: %s"), target_pid_to_str (lp
->ptid
),
986 safe_strerror (errno
));
989 fprintf_unfiltered (gdb_stdlog
,
990 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
991 target_pid_to_str (lp
->ptid
),
992 status_to_str (lp
->status
));
997 /* FIXME drow/2003-08-26: There was a call to stop_wait_callback
998 here. But since lp->signalled was cleared above,
999 stop_wait_callback didn't do anything; the process was left
1000 running. Shouldn't we be waiting for it to stop?
1001 I've removed the call, since stop_wait_callback now does do
1002 something when called with lp->signalled == 0. */
1004 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1007 /* We don't actually detach from the LWP that has an id equal to the
1008 overall process id just yet. */
1009 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
1012 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
1013 WSTOPSIG (lp
->status
)) < 0)
1014 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1015 safe_strerror (errno
));
1017 if (debug_linux_nat
)
1018 fprintf_unfiltered (gdb_stdlog
,
1019 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1020 target_pid_to_str (lp
->ptid
),
1021 strsignal (WSTOPSIG (lp
->status
)));
1023 delete_lwp (lp
->ptid
);
1030 linux_nat_detach (char *args
, int from_tty
)
1032 iterate_over_lwps (detach_callback
, NULL
);
1034 /* Only the initial process should be left right now. */
1035 gdb_assert (num_lwps
== 1);
1037 trap_ptid
= null_ptid
;
1039 /* Destroy LWP info; it's no longer valid. */
1042 /* Restore the original signal mask. */
1043 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1044 sigemptyset (&blocked_mask
);
1046 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
1047 linux_ops
->to_detach (args
, from_tty
);
1053 resume_callback (struct lwp_info
*lp
, void *data
)
1055 if (lp
->stopped
&& lp
->status
== 0)
1057 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
1058 0, TARGET_SIGNAL_0
);
1059 if (debug_linux_nat
)
1060 fprintf_unfiltered (gdb_stdlog
,
1061 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1062 target_pid_to_str (lp
->ptid
));
1065 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1072 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1079 resume_set_callback (struct lwp_info
*lp
, void *data
)
1086 linux_nat_resume (ptid_t ptid
, int step
, enum target_signal signo
)
1088 struct lwp_info
*lp
;
1091 if (debug_linux_nat
)
1092 fprintf_unfiltered (gdb_stdlog
,
1093 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1094 step
? "step" : "resume",
1095 target_pid_to_str (ptid
),
1096 signo
? strsignal (signo
) : "0",
1097 target_pid_to_str (inferior_ptid
));
1101 /* A specific PTID means `step only this process id'. */
1102 resume_all
= (PIDGET (ptid
) == -1);
1105 iterate_over_lwps (resume_set_callback
, NULL
);
1107 iterate_over_lwps (resume_clear_callback
, NULL
);
1109 /* If PID is -1, it's the current inferior that should be
1110 handled specially. */
1111 if (PIDGET (ptid
) == -1)
1112 ptid
= inferior_ptid
;
1114 lp
= find_lwp_pid (ptid
);
1115 gdb_assert (lp
!= NULL
);
1117 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
1119 /* Remember if we're stepping. */
1122 /* Mark this LWP as resumed. */
1125 /* If we have a pending wait status for this thread, there is no
1126 point in resuming the process. But first make sure that
1127 linux_nat_wait won't preemptively handle the event - we
1128 should never take this short-circuit if we are going to
1129 leave LP running, since we have skipped resuming all the
1130 other threads. This bit of code needs to be synchronized
1131 with linux_nat_wait. */
1133 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1135 int saved_signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1137 if (signal_stop_state (saved_signo
) == 0
1138 && signal_print_state (saved_signo
) == 0
1139 && signal_pass_state (saved_signo
) == 1)
1141 if (debug_linux_nat
)
1142 fprintf_unfiltered (gdb_stdlog
,
1143 "LLR: Not short circuiting for ignored "
1144 "status 0x%x\n", lp
->status
);
1146 /* FIXME: What should we do if we are supposed to continue
1147 this thread with a signal? */
1148 gdb_assert (signo
== TARGET_SIGNAL_0
);
1149 signo
= saved_signo
;
1156 /* FIXME: What should we do if we are supposed to continue
1157 this thread with a signal? */
1158 gdb_assert (signo
== TARGET_SIGNAL_0
);
1160 if (debug_linux_nat
)
1161 fprintf_unfiltered (gdb_stdlog
,
1162 "LLR: Short circuiting for status 0x%x\n",
1168 /* Mark LWP as not stopped to prevent it from being continued by
1173 iterate_over_lwps (resume_callback
, NULL
);
1175 linux_ops
->to_resume (ptid
, step
, signo
);
1176 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1178 if (debug_linux_nat
)
1179 fprintf_unfiltered (gdb_stdlog
,
1180 "LLR: %s %s, %s (resume event thread)\n",
1181 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1182 target_pid_to_str (ptid
),
1183 signo
? strsignal (signo
) : "0");
1186 /* Issue kill to specified lwp. */
1188 static int tkill_failed
;
1191 kill_lwp (int lwpid
, int signo
)
1195 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1196 fails, then we are not using nptl threads and we should be using kill. */
1198 #ifdef HAVE_TKILL_SYSCALL
1201 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
1202 if (errno
!= ENOSYS
)
1209 return kill (lwpid
, signo
);
1212 /* Handle a GNU/Linux extended wait response. If we see a clone
1213 event, we need to add the new LWP to our list (and not report the
1214 trap to higher layers). This function returns non-zero if the
1215 event should be ignored and we should wait again. If STOPPING is
1216 true, the new LWP remains stopped, otherwise it is continued. */
1219 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
1222 int pid
= GET_LWP (lp
->ptid
);
1223 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1224 struct lwp_info
*new_lp
= NULL
;
1225 int event
= status
>> 16;
1227 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1228 || event
== PTRACE_EVENT_CLONE
)
1230 unsigned long new_pid
;
1233 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1235 /* If we haven't already seen the new PID stop, wait for it now. */
1236 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1238 /* The new child has a pending SIGSTOP. We can't affect it until it
1239 hits the SIGSTOP, but we're already attached. */
1240 ret
= my_waitpid (new_pid
, &status
,
1241 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
1243 perror_with_name (_("waiting for new child"));
1244 else if (ret
!= new_pid
)
1245 internal_error (__FILE__
, __LINE__
,
1246 _("wait returned unexpected PID %d"), ret
);
1247 else if (!WIFSTOPPED (status
))
1248 internal_error (__FILE__
, __LINE__
,
1249 _("wait returned unexpected status 0x%x"), status
);
1252 ourstatus
->value
.related_pid
= new_pid
;
1254 if (event
== PTRACE_EVENT_FORK
)
1255 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1256 else if (event
== PTRACE_EVENT_VFORK
)
1257 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1260 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1261 new_lp
= add_lwp (BUILD_LWP (new_pid
, GET_PID (inferior_ptid
)));
1264 if (WSTOPSIG (status
) != SIGSTOP
)
1266 /* This can happen if someone starts sending signals to
1267 the new thread before it gets a chance to run, which
1268 have a lower number than SIGSTOP (e.g. SIGUSR1).
1269 This is an unlikely case, and harder to handle for
1270 fork / vfork than for clone, so we do not try - but
1271 we handle it for clone events here. We'll send
1272 the other signal on to the thread below. */
1274 new_lp
->signalled
= 1;
1280 new_lp
->stopped
= 1;
1283 new_lp
->resumed
= 1;
1284 ptrace (PTRACE_CONT
, lp
->waitstatus
.value
.related_pid
, 0,
1285 status
? WSTOPSIG (status
) : 0);
1288 if (debug_linux_nat
)
1289 fprintf_unfiltered (gdb_stdlog
,
1290 "LHEW: Got clone event from LWP %ld, resuming\n",
1291 GET_LWP (lp
->ptid
));
1292 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1300 if (event
== PTRACE_EVENT_EXEC
)
1302 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1303 ourstatus
->value
.execd_pathname
1304 = xstrdup (linux_child_pid_to_exec_file (pid
));
1306 if (linux_parent_pid
)
1308 detach_breakpoints (linux_parent_pid
);
1309 ptrace (PTRACE_DETACH
, linux_parent_pid
, 0, 0);
1311 linux_parent_pid
= 0;
1317 internal_error (__FILE__
, __LINE__
,
1318 _("unknown ptrace event %d"), event
);
1321 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1325 wait_lwp (struct lwp_info
*lp
)
1329 int thread_dead
= 0;
1331 gdb_assert (!lp
->stopped
);
1332 gdb_assert (lp
->status
== 0);
1334 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, 0);
1335 if (pid
== -1 && errno
== ECHILD
)
1337 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
1338 if (pid
== -1 && errno
== ECHILD
)
1340 /* The thread has previously exited. We need to delete it
1341 now because, for some vendor 2.4 kernels with NPTL
1342 support backported, there won't be an exit event unless
1343 it is the main thread. 2.6 kernels will report an exit
1344 event for each thread that exits, as expected. */
1346 if (debug_linux_nat
)
1347 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
1348 target_pid_to_str (lp
->ptid
));
1354 gdb_assert (pid
== GET_LWP (lp
->ptid
));
1356 if (debug_linux_nat
)
1358 fprintf_unfiltered (gdb_stdlog
,
1359 "WL: waitpid %s received %s\n",
1360 target_pid_to_str (lp
->ptid
),
1361 status_to_str (status
));
1365 /* Check if the thread has exited. */
1366 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1369 if (debug_linux_nat
)
1370 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
1371 target_pid_to_str (lp
->ptid
));
1380 gdb_assert (WIFSTOPPED (status
));
1382 /* Handle GNU/Linux's extended waitstatus for trace events. */
1383 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1385 if (debug_linux_nat
)
1386 fprintf_unfiltered (gdb_stdlog
,
1387 "WL: Handling extended status 0x%06x\n",
1389 if (linux_handle_extended_wait (lp
, status
, 1))
1390 return wait_lwp (lp
);
1396 /* Save the most recent siginfo for LP. This is currently only called
1397 for SIGTRAP; some ports use the si_addr field for
1398 target_stopped_data_address. In the future, it may also be used to
1399 restore the siginfo of requeued signals. */
1402 save_siginfo (struct lwp_info
*lp
)
1405 ptrace (PTRACE_GETSIGINFO
, GET_LWP (lp
->ptid
),
1406 (PTRACE_TYPE_ARG3
) 0, &lp
->siginfo
);
1409 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1412 /* Send a SIGSTOP to LP. */
1415 stop_callback (struct lwp_info
*lp
, void *data
)
1417 if (!lp
->stopped
&& !lp
->signalled
)
1421 if (debug_linux_nat
)
1423 fprintf_unfiltered (gdb_stdlog
,
1424 "SC: kill %s **<SIGSTOP>**\n",
1425 target_pid_to_str (lp
->ptid
));
1428 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
1429 if (debug_linux_nat
)
1431 fprintf_unfiltered (gdb_stdlog
,
1432 "SC: lwp kill %d %s\n",
1434 errno
? safe_strerror (errno
) : "ERRNO-OK");
1438 gdb_assert (lp
->status
== 0);
1444 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
1445 a pointer to a set of signals to be flushed immediately. */
1448 stop_wait_callback (struct lwp_info
*lp
, void *data
)
1450 sigset_t
*flush_mask
= data
;
1456 status
= wait_lwp (lp
);
1460 /* Ignore any signals in FLUSH_MASK. */
1461 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
1470 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1471 if (debug_linux_nat
)
1472 fprintf_unfiltered (gdb_stdlog
,
1473 "PTRACE_CONT %s, 0, 0 (%s)\n",
1474 target_pid_to_str (lp
->ptid
),
1475 errno
? safe_strerror (errno
) : "OK");
1477 return stop_wait_callback (lp
, flush_mask
);
1480 if (WSTOPSIG (status
) != SIGSTOP
)
1482 if (WSTOPSIG (status
) == SIGTRAP
)
1484 /* If a LWP other than the LWP that we're reporting an
1485 event for has hit a GDB breakpoint (as opposed to
1486 some random trap signal), then just arrange for it to
1487 hit it again later. We don't keep the SIGTRAP status
1488 and don't forward the SIGTRAP signal to the LWP. We
1489 will handle the current event, eventually we will
1490 resume all LWPs, and this one will get its breakpoint
1493 If we do not do this, then we run the risk that the
1494 user will delete or disable the breakpoint, but the
1495 thread will have already tripped on it. */
1497 /* Save the trap's siginfo in case we need it later. */
1500 /* Now resume this LWP and get the SIGSTOP event. */
1502 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1503 if (debug_linux_nat
)
1505 fprintf_unfiltered (gdb_stdlog
,
1506 "PTRACE_CONT %s, 0, 0 (%s)\n",
1507 target_pid_to_str (lp
->ptid
),
1508 errno
? safe_strerror (errno
) : "OK");
1510 fprintf_unfiltered (gdb_stdlog
,
1511 "SWC: Candidate SIGTRAP event in %s\n",
1512 target_pid_to_str (lp
->ptid
));
1514 /* Hold the SIGTRAP for handling by linux_nat_wait. */
1515 stop_wait_callback (lp
, data
);
1516 /* If there's another event, throw it back into the queue. */
1519 if (debug_linux_nat
)
1521 fprintf_unfiltered (gdb_stdlog
,
1522 "SWC: kill %s, %s\n",
1523 target_pid_to_str (lp
->ptid
),
1524 status_to_str ((int) status
));
1526 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
1528 /* Save the sigtrap event. */
1529 lp
->status
= status
;
1534 /* The thread was stopped with a signal other than
1535 SIGSTOP, and didn't accidentally trip a breakpoint. */
1537 if (debug_linux_nat
)
1539 fprintf_unfiltered (gdb_stdlog
,
1540 "SWC: Pending event %s in %s\n",
1541 status_to_str ((int) status
),
1542 target_pid_to_str (lp
->ptid
));
1544 /* Now resume this LWP and get the SIGSTOP event. */
1546 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1547 if (debug_linux_nat
)
1548 fprintf_unfiltered (gdb_stdlog
,
1549 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
1550 target_pid_to_str (lp
->ptid
),
1551 errno
? safe_strerror (errno
) : "OK");
1553 /* Hold this event/waitstatus while we check to see if
1554 there are any more (we still want to get that SIGSTOP). */
1555 stop_wait_callback (lp
, data
);
1556 /* If the lp->status field is still empty, use it to hold
1557 this event. If not, then this event must be returned
1558 to the event queue of the LWP. */
1559 if (lp
->status
== 0)
1560 lp
->status
= status
;
1563 if (debug_linux_nat
)
1565 fprintf_unfiltered (gdb_stdlog
,
1566 "SWC: kill %s, %s\n",
1567 target_pid_to_str (lp
->ptid
),
1568 status_to_str ((int) status
));
1570 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
1577 /* We caught the SIGSTOP that we intended to catch, so
1578 there's no SIGSTOP pending. */
1587 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
1588 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
1591 linux_nat_has_pending (int pid
, sigset_t
*pending
, sigset_t
*flush_mask
)
1593 sigset_t blocked
, ignored
;
1596 linux_proc_pending_signals (pid
, pending
, &blocked
, &ignored
);
1601 for (i
= 1; i
< NSIG
; i
++)
1602 if (sigismember (pending
, i
))
1603 if (!sigismember (flush_mask
, i
)
1604 || sigismember (&blocked
, i
)
1605 || sigismember (&ignored
, i
))
1606 sigdelset (pending
, i
);
1608 if (sigisemptyset (pending
))
1614 /* DATA is interpreted as a mask of signals to flush. If LP has
1615 signals pending, and they are all in the flush mask, then arrange
1616 to flush them. LP should be stopped, as should all other threads
1617 it might share a signal queue with. */
1620 flush_callback (struct lwp_info
*lp
, void *data
)
1622 sigset_t
*flush_mask
= data
;
1623 sigset_t pending
, intersection
, blocked
, ignored
;
1626 /* Normally, when an LWP exits, it is removed from the LWP list. The
1627 last LWP isn't removed till later, however. So if there is only
1628 one LWP on the list, make sure it's alive. */
1629 if (lwp_list
== lp
&& lp
->next
== NULL
)
1630 if (!linux_nat_thread_alive (lp
->ptid
))
1633 /* Just because the LWP is stopped doesn't mean that new signals
1634 can't arrive from outside, so this function must be careful of
1635 race conditions. However, because all threads are stopped, we
1636 can assume that the pending mask will not shrink unless we resume
1637 the LWP, and that it will then get another signal. We can't
1638 control which one, however. */
1642 if (debug_linux_nat
)
1643 printf_unfiltered (_("FC: LP has pending status %06x\n"), lp
->status
);
1644 if (WIFSTOPPED (lp
->status
) && sigismember (flush_mask
, WSTOPSIG (lp
->status
)))
1648 /* While there is a pending signal we would like to flush, continue
1649 the inferior and collect another signal. But if there's already
1650 a saved status that we don't want to flush, we can't resume the
1651 inferior - if it stopped for some other reason we wouldn't have
1652 anywhere to save the new status. In that case, we must leave the
1653 signal unflushed (and possibly generate an extra SIGINT stop).
1654 That's much less bad than losing a signal. */
1655 while (lp
->status
== 0
1656 && linux_nat_has_pending (GET_LWP (lp
->ptid
), &pending
, flush_mask
))
1661 ret
= ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1662 if (debug_linux_nat
)
1663 fprintf_unfiltered (gdb_stderr
,
1664 "FC: Sent PTRACE_CONT, ret %d %d\n", ret
, errno
);
1667 stop_wait_callback (lp
, flush_mask
);
1668 if (debug_linux_nat
)
1669 fprintf_unfiltered (gdb_stderr
,
1670 "FC: Wait finished; saved status is %d\n",
1677 /* Return non-zero if LP has a wait status pending. */
1680 status_callback (struct lwp_info
*lp
, void *data
)
1682 /* Only report a pending wait status if we pretend that this has
1683 indeed been resumed. */
1684 return (lp
->status
!= 0 && lp
->resumed
);
1687 /* Return non-zero if LP isn't stopped. */
1690 running_callback (struct lwp_info
*lp
, void *data
)
1692 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
1695 /* Count the LWP's that have had events. */
1698 count_events_callback (struct lwp_info
*lp
, void *data
)
1702 gdb_assert (count
!= NULL
);
1704 /* Count only LWPs that have a SIGTRAP event pending. */
1706 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
1712 /* Select the LWP (if any) that is currently being single-stepped. */
1715 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
1717 if (lp
->step
&& lp
->status
!= 0)
1723 /* Select the Nth LWP that has had a SIGTRAP event. */
1726 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
1728 int *selector
= data
;
1730 gdb_assert (selector
!= NULL
);
1732 /* Select only LWPs that have a SIGTRAP event pending. */
1734 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
1735 if ((*selector
)-- == 0)
1742 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
1744 struct lwp_info
*event_lp
= data
;
1746 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
1750 /* If a LWP other than the LWP that we're reporting an event for has
1751 hit a GDB breakpoint (as opposed to some random trap signal),
1752 then just arrange for it to hit it again later. We don't keep
1753 the SIGTRAP status and don't forward the SIGTRAP signal to the
1754 LWP. We will handle the current event, eventually we will resume
1755 all LWPs, and this one will get its breakpoint trap again.
1757 If we do not do this, then we run the risk that the user will
1758 delete or disable the breakpoint, but the LWP will have already
1762 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
1763 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
1764 gdbarch_decr_pc_after_break
1767 if (debug_linux_nat
)
1768 fprintf_unfiltered (gdb_stdlog
,
1769 "CBC: Push back breakpoint for %s\n",
1770 target_pid_to_str (lp
->ptid
));
1772 /* Back up the PC if necessary. */
1773 if (gdbarch_decr_pc_after_break (current_gdbarch
))
1774 write_pc_pid (read_pc_pid (lp
->ptid
) - gdbarch_decr_pc_after_break
1778 /* Throw away the SIGTRAP. */
1785 /* Select one LWP out of those that have events pending. */
1788 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
1791 int random_selector
;
1792 struct lwp_info
*event_lp
;
1794 /* Record the wait status for the original LWP. */
1795 (*orig_lp
)->status
= *status
;
1797 /* Give preference to any LWP that is being single-stepped. */
1798 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
1799 if (event_lp
!= NULL
)
1801 if (debug_linux_nat
)
1802 fprintf_unfiltered (gdb_stdlog
,
1803 "SEL: Select single-step %s\n",
1804 target_pid_to_str (event_lp
->ptid
));
1808 /* No single-stepping LWP. Select one at random, out of those
1809 which have had SIGTRAP events. */
1811 /* First see how many SIGTRAP events we have. */
1812 iterate_over_lwps (count_events_callback
, &num_events
);
1814 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
1815 random_selector
= (int)
1816 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
1818 if (debug_linux_nat
&& num_events
> 1)
1819 fprintf_unfiltered (gdb_stdlog
,
1820 "SEL: Found %d SIGTRAP events, selecting #%d\n",
1821 num_events
, random_selector
);
1823 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
1827 if (event_lp
!= NULL
)
1829 /* Switch the event LWP. */
1830 *orig_lp
= event_lp
;
1831 *status
= event_lp
->status
;
1834 /* Flush the wait status for the event LWP. */
1835 (*orig_lp
)->status
= 0;
1838 /* Return non-zero if LP has been resumed. */
1841 resumed_callback (struct lwp_info
*lp
, void *data
)
1846 /* Stop an active thread, verify it still exists, then resume it. */
1849 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
1851 struct lwp_info
*ptr
;
1853 if (!lp
->stopped
&& !lp
->signalled
)
1855 stop_callback (lp
, NULL
);
1856 stop_wait_callback (lp
, NULL
);
1857 /* Resume if the lwp still exists. */
1858 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
1861 resume_callback (lp
, NULL
);
1862 resume_set_callback (lp
, NULL
);
1868 /* Check if we should go on and pass this event to common code.
1869 Return the affected lwp if we are, or NULL otherwise. */
1870 static struct lwp_info
*
1871 linux_nat_filter_event (int lwpid
, int status
, int options
)
1873 struct lwp_info
*lp
;
1875 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1877 /* Check for stop events reported by a process we didn't already
1878 know about - anything not already in our LWP list.
1880 If we're expecting to receive stopped processes after
1881 fork, vfork, and clone events, then we'll just add the
1882 new one to our list and go back to waiting for the event
1883 to be reported - the stopped process might be returned
1884 from waitpid before or after the event is. */
1885 if (WIFSTOPPED (status
) && !lp
)
1887 linux_record_stopped_pid (lwpid
, status
);
1891 /* Make sure we don't report an event for the exit of an LWP not in
1892 our list, i.e. not part of the current process. This can happen
1893 if we detach from a program we original forked and then it
1895 if (!WIFSTOPPED (status
) && !lp
)
1898 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
1899 CLONE_PTRACE processes which do not use the thread library -
1900 otherwise we wouldn't find the new LWP this way. That doesn't
1901 currently work, and the following code is currently unreachable
1902 due to the two blocks above. If it's fixed some day, this code
1903 should be broken out into a function so that we can also pick up
1904 LWPs from the new interface. */
1907 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1908 if (options
& __WCLONE
)
1911 gdb_assert (WIFSTOPPED (status
)
1912 && WSTOPSIG (status
) == SIGSTOP
);
1915 if (!in_thread_list (inferior_ptid
))
1917 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1918 GET_PID (inferior_ptid
));
1919 add_thread (inferior_ptid
);
1922 add_thread (lp
->ptid
);
1925 /* Save the trap's siginfo in case we need it later. */
1926 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1929 /* Handle GNU/Linux's extended waitstatus for trace events. */
1930 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1932 if (debug_linux_nat
)
1933 fprintf_unfiltered (gdb_stdlog
,
1934 "LLW: Handling extended status 0x%06x\n",
1936 if (linux_handle_extended_wait (lp
, status
, 0))
1940 /* Check if the thread has exited. */
1941 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1943 /* If this is the main thread, we must stop all threads and
1944 verify if they are still alive. This is because in the nptl
1945 thread model, there is no signal issued for exiting LWPs
1946 other than the main thread. We only get the main thread exit
1947 signal once all child threads have already exited. If we
1948 stop all the threads and use the stop_wait_callback to check
1949 if they have exited we can determine whether this signal
1950 should be ignored or whether it means the end of the debugged
1951 application, regardless of which threading model is being
1953 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
1956 iterate_over_lwps (stop_and_resume_callback
, NULL
);
1959 if (debug_linux_nat
)
1960 fprintf_unfiltered (gdb_stdlog
,
1961 "LLW: %s exited.\n",
1962 target_pid_to_str (lp
->ptid
));
1966 /* If there is at least one more LWP, then the exit signal was
1967 not the end of the debugged application and should be
1971 /* Make sure there is at least one thread running. */
1972 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1974 /* Discard the event. */
1979 /* Check if the current LWP has previously exited. In the nptl
1980 thread model, LWPs other than the main thread do not issue
1981 signals when they exit so we must check whenever the thread has
1982 stopped. A similar check is made in stop_wait_callback(). */
1983 if (num_lwps
> 1 && !linux_nat_thread_alive (lp
->ptid
))
1985 if (debug_linux_nat
)
1986 fprintf_unfiltered (gdb_stdlog
,
1987 "LLW: %s exited.\n",
1988 target_pid_to_str (lp
->ptid
));
1992 /* Make sure there is at least one thread running. */
1993 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1995 /* Discard the event. */
1999 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2000 an attempt to stop an LWP. */
2002 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
2004 if (debug_linux_nat
)
2005 fprintf_unfiltered (gdb_stdlog
,
2006 "LLW: Delayed SIGSTOP caught for %s.\n",
2007 target_pid_to_str (lp
->ptid
));
2009 /* This is a delayed SIGSTOP. */
2012 registers_changed ();
2014 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2015 lp
->step
, TARGET_SIGNAL_0
);
2016 if (debug_linux_nat
)
2017 fprintf_unfiltered (gdb_stdlog
,
2018 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2020 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2021 target_pid_to_str (lp
->ptid
));
2024 gdb_assert (lp
->resumed
);
2026 /* Discard the event. */
2030 /* An interesting event. */
2036 linux_nat_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
2038 struct lwp_info
*lp
= NULL
;
2041 pid_t pid
= PIDGET (ptid
);
2042 sigset_t flush_mask
;
2044 /* The first time we get here after starting a new inferior, we may
2045 not have added it to the LWP list yet - this is the earliest
2046 moment at which we know its PID. */
2049 gdb_assert (!is_lwp (inferior_ptid
));
2051 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2052 GET_PID (inferior_ptid
));
2053 lp
= add_lwp (inferior_ptid
);
2057 sigemptyset (&flush_mask
);
2059 /* Make sure SIGCHLD is blocked. */
2060 if (!sigismember (&blocked_mask
, SIGCHLD
))
2062 sigaddset (&blocked_mask
, SIGCHLD
);
2063 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
2068 /* Make sure there is at least one LWP that has been resumed. */
2069 gdb_assert (iterate_over_lwps (resumed_callback
, NULL
));
2071 /* First check if there is a LWP with a wait status pending. */
2074 /* Any LWP that's been resumed will do. */
2075 lp
= iterate_over_lwps (status_callback
, NULL
);
2078 status
= lp
->status
;
2081 if (debug_linux_nat
&& status
)
2082 fprintf_unfiltered (gdb_stdlog
,
2083 "LLW: Using pending wait status %s for %s.\n",
2084 status_to_str (status
),
2085 target_pid_to_str (lp
->ptid
));
2088 /* But if we don't fine one, we'll have to wait, and check both
2089 cloned and uncloned processes. We start with the cloned
2091 options
= __WCLONE
| WNOHANG
;
2093 else if (is_lwp (ptid
))
2095 if (debug_linux_nat
)
2096 fprintf_unfiltered (gdb_stdlog
,
2097 "LLW: Waiting for specific LWP %s.\n",
2098 target_pid_to_str (ptid
));
2100 /* We have a specific LWP to check. */
2101 lp
= find_lwp_pid (ptid
);
2103 status
= lp
->status
;
2106 if (debug_linux_nat
&& status
)
2107 fprintf_unfiltered (gdb_stdlog
,
2108 "LLW: Using pending wait status %s for %s.\n",
2109 status_to_str (status
),
2110 target_pid_to_str (lp
->ptid
));
2112 /* If we have to wait, take into account whether PID is a cloned
2113 process or not. And we have to convert it to something that
2114 the layer beneath us can understand. */
2115 options
= lp
->cloned
? __WCLONE
: 0;
2116 pid
= GET_LWP (ptid
);
2119 if (status
&& lp
->signalled
)
2121 /* A pending SIGSTOP may interfere with the normal stream of
2122 events. In a typical case where interference is a problem,
2123 we have a SIGSTOP signal pending for LWP A while
2124 single-stepping it, encounter an event in LWP B, and take the
2125 pending SIGSTOP while trying to stop LWP A. After processing
2126 the event in LWP B, LWP A is continued, and we'll never see
2127 the SIGTRAP associated with the last time we were
2128 single-stepping LWP A. */
2130 /* Resume the thread. It should halt immediately returning the
2132 registers_changed ();
2133 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2134 lp
->step
, TARGET_SIGNAL_0
);
2135 if (debug_linux_nat
)
2136 fprintf_unfiltered (gdb_stdlog
,
2137 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
2138 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2139 target_pid_to_str (lp
->ptid
));
2141 gdb_assert (lp
->resumed
);
2143 /* This should catch the pending SIGSTOP. */
2144 stop_wait_callback (lp
, NULL
);
2147 set_sigint_trap (); /* Causes SIGINT to be passed on to the
2148 attached process. */
2155 lwpid
= my_waitpid (pid
, &status
, options
);
2158 gdb_assert (pid
== -1 || lwpid
== pid
);
2160 if (debug_linux_nat
)
2162 fprintf_unfiltered (gdb_stdlog
,
2163 "LLW: waitpid %ld received %s\n",
2164 (long) lwpid
, status_to_str (status
));
2167 lp
= linux_nat_filter_event (lwpid
, status
, options
);
2170 /* A discarded event. */
2180 /* Alternate between checking cloned and uncloned processes. */
2181 options
^= __WCLONE
;
2183 /* And suspend every time we have checked both. */
2184 if (options
& __WCLONE
)
2185 sigsuspend (&suspend_mask
);
2188 /* We shouldn't end up here unless we want to try again. */
2189 gdb_assert (status
== 0);
2192 clear_sigio_trap ();
2193 clear_sigint_trap ();
2197 /* Don't report signals that GDB isn't interested in, such as
2198 signals that are neither printed nor stopped upon. Stopping all
2199 threads can be a bit time-consuming so if we want decent
2200 performance with heavily multi-threaded programs, especially when
2201 they're using a high frequency timer, we'd better avoid it if we
2204 if (WIFSTOPPED (status
))
2206 int signo
= target_signal_from_host (WSTOPSIG (status
));
2208 /* If we get a signal while single-stepping, we may need special
2209 care, e.g. to skip the signal handler. Defer to common code. */
2211 && signal_stop_state (signo
) == 0
2212 && signal_print_state (signo
) == 0
2213 && signal_pass_state (signo
) == 1)
2215 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2216 here? It is not clear we should. GDB may not expect
2217 other threads to run. On the other hand, not resuming
2218 newly attached threads may cause an unwanted delay in
2219 getting them running. */
2220 registers_changed ();
2221 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2223 if (debug_linux_nat
)
2224 fprintf_unfiltered (gdb_stdlog
,
2225 "LLW: %s %s, %s (preempt 'handle')\n",
2227 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2228 target_pid_to_str (lp
->ptid
),
2229 signo
? strsignal (signo
) : "0");
2235 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
2237 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2238 forwarded to the entire process group, that is, all LWP's
2239 will receive it. Since we only want to report it once,
2240 we try to flush it from all LWPs except this one. */
2241 sigaddset (&flush_mask
, SIGINT
);
2245 /* This LWP is stopped now. */
2248 if (debug_linux_nat
)
2249 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
2250 status_to_str (status
), target_pid_to_str (lp
->ptid
));
2252 /* Now stop all other LWP's ... */
2253 iterate_over_lwps (stop_callback
, NULL
);
2255 /* ... and wait until all of them have reported back that they're no
2257 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
2258 iterate_over_lwps (flush_callback
, &flush_mask
);
2260 /* If we're not waiting for a specific LWP, choose an event LWP from
2261 among those that have had events. Giving equal priority to all
2262 LWPs that have had events helps prevent starvation. */
2264 select_event_lwp (&lp
, &status
);
2266 /* Now that we've selected our final event LWP, cancel any
2267 breakpoints in other LWPs that have hit a GDB breakpoint. See
2268 the comment in cancel_breakpoints_callback to find out why. */
2269 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
2271 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2273 trap_ptid
= lp
->ptid
;
2274 if (debug_linux_nat
)
2275 fprintf_unfiltered (gdb_stdlog
,
2276 "LLW: trap_ptid is %s.\n",
2277 target_pid_to_str (trap_ptid
));
2280 trap_ptid
= null_ptid
;
2282 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
2284 *ourstatus
= lp
->waitstatus
;
2285 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
2288 store_waitstatus (ourstatus
, status
);
2294 kill_callback (struct lwp_info
*lp
, void *data
)
2297 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
2298 if (debug_linux_nat
)
2299 fprintf_unfiltered (gdb_stdlog
,
2300 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
2301 target_pid_to_str (lp
->ptid
),
2302 errno
? safe_strerror (errno
) : "OK");
2308 kill_wait_callback (struct lwp_info
*lp
, void *data
)
2312 /* We must make sure that there are no pending events (delayed
2313 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
2314 program doesn't interfere with any following debugging session. */
2316 /* For cloned processes we must check both with __WCLONE and
2317 without, since the exit status of a cloned process isn't reported
2323 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
2324 if (pid
!= (pid_t
) -1)
2326 if (debug_linux_nat
)
2327 fprintf_unfiltered (gdb_stdlog
,
2328 "KWC: wait %s received unknown.\n",
2329 target_pid_to_str (lp
->ptid
));
2330 /* The Linux kernel sometimes fails to kill a thread
2331 completely after PTRACE_KILL; that goes from the stop
2332 point in do_fork out to the one in
2333 get_signal_to_deliever and waits again. So kill it
2335 kill_callback (lp
, NULL
);
2338 while (pid
== GET_LWP (lp
->ptid
));
2340 gdb_assert (pid
== -1 && errno
== ECHILD
);
2345 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
2346 if (pid
!= (pid_t
) -1)
2348 if (debug_linux_nat
)
2349 fprintf_unfiltered (gdb_stdlog
,
2350 "KWC: wait %s received unk.\n",
2351 target_pid_to_str (lp
->ptid
));
2352 /* See the call to kill_callback above. */
2353 kill_callback (lp
, NULL
);
2356 while (pid
== GET_LWP (lp
->ptid
));
2358 gdb_assert (pid
== -1 && errno
== ECHILD
);
2363 linux_nat_kill (void)
2365 struct target_waitstatus last
;
2369 /* If we're stopped while forking and we haven't followed yet,
2370 kill the other task. We need to do this first because the
2371 parent will be sleeping if this is a vfork. */
2373 get_last_target_status (&last_ptid
, &last
);
2375 if (last
.kind
== TARGET_WAITKIND_FORKED
2376 || last
.kind
== TARGET_WAITKIND_VFORKED
)
2378 ptrace (PT_KILL
, last
.value
.related_pid
, 0, 0);
2382 if (forks_exist_p ())
2383 linux_fork_killall ();
2386 /* Kill all LWP's ... */
2387 iterate_over_lwps (kill_callback
, NULL
);
2389 /* ... and wait until we've flushed all events. */
2390 iterate_over_lwps (kill_wait_callback
, NULL
);
2393 target_mourn_inferior ();
2397 linux_nat_mourn_inferior (void)
2399 trap_ptid
= null_ptid
;
2401 /* Destroy LWP info; it's no longer valid. */
2404 /* Restore the original signal mask. */
2405 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
2406 sigemptyset (&blocked_mask
);
2408 if (! forks_exist_p ())
2409 /* Normal case, no other forks available. */
2410 linux_ops
->to_mourn_inferior ();
2412 /* Multi-fork case. The current inferior_ptid has exited, but
2413 there are other viable forks to debug. Delete the exiting
2414 one and context-switch to the first available. */
2415 linux_fork_mourn_inferior ();
2419 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2420 const char *annex
, gdb_byte
*readbuf
,
2421 const gdb_byte
*writebuf
,
2422 ULONGEST offset
, LONGEST len
)
2424 struct cleanup
*old_chain
= save_inferior_ptid ();
2427 if (is_lwp (inferior_ptid
))
2428 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
2430 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
2433 do_cleanups (old_chain
);
2438 linux_nat_thread_alive (ptid_t ptid
)
2440 gdb_assert (is_lwp (ptid
));
2443 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
2444 if (debug_linux_nat
)
2445 fprintf_unfiltered (gdb_stdlog
,
2446 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
2447 target_pid_to_str (ptid
),
2448 errno
? safe_strerror (errno
) : "OK");
2450 /* Not every Linux kernel implements PTRACE_PEEKUSER. But we can
2451 handle that case gracefully since ptrace will first do a lookup
2452 for the process based upon the passed-in pid. If that fails we
2453 will get either -ESRCH or -EPERM, otherwise the child exists and
2455 if (errno
== ESRCH
|| errno
== EPERM
)
2462 linux_nat_pid_to_str (ptid_t ptid
)
2464 static char buf
[64];
2466 if (lwp_list
&& lwp_list
->next
&& is_lwp (ptid
))
2468 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
2472 return normal_pid_to_str (ptid
);
2476 sigchld_handler (int signo
)
2478 /* Do nothing. The only reason for this handler is that it allows
2479 us to use sigsuspend in linux_nat_wait above to wait for the
2480 arrival of a SIGCHLD. */
2483 /* Accepts an integer PID; Returns a string representing a file that
2484 can be opened to get the symbols for the child process. */
2487 linux_child_pid_to_exec_file (int pid
)
2489 char *name1
, *name2
;
2491 name1
= xmalloc (MAXPATHLEN
);
2492 name2
= xmalloc (MAXPATHLEN
);
2493 make_cleanup (xfree
, name1
);
2494 make_cleanup (xfree
, name2
);
2495 memset (name2
, 0, MAXPATHLEN
);
2497 sprintf (name1
, "/proc/%d/exe", pid
);
2498 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
2504 /* Service function for corefiles and info proc. */
2507 read_mapping (FILE *mapfile
,
2512 char *device
, long long *inode
, char *filename
)
2514 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
2515 addr
, endaddr
, permissions
, offset
, device
, inode
);
2518 if (ret
> 0 && ret
!= EOF
)
2520 /* Eat everything up to EOL for the filename. This will prevent
2521 weird filenames (such as one with embedded whitespace) from
2522 confusing this code. It also makes this code more robust in
2523 respect to annotations the kernel may add after the filename.
2525 Note the filename is used for informational purposes
2527 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
2530 return (ret
!= 0 && ret
!= EOF
);
2533 /* Fills the "to_find_memory_regions" target vector. Lists the memory
2534 regions in the inferior for a corefile. */
2537 linux_nat_find_memory_regions (int (*func
) (CORE_ADDR
,
2539 int, int, int, void *), void *obfd
)
2541 long long pid
= PIDGET (inferior_ptid
);
2542 char mapsfilename
[MAXPATHLEN
];
2544 long long addr
, endaddr
, size
, offset
, inode
;
2545 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
2546 int read
, write
, exec
;
2549 /* Compose the filename for the /proc memory map, and open it. */
2550 sprintf (mapsfilename
, "/proc/%lld/maps", pid
);
2551 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
2552 error (_("Could not open %s."), mapsfilename
);
2555 fprintf_filtered (gdb_stdout
,
2556 "Reading memory regions from %s\n", mapsfilename
);
2558 /* Now iterate until end-of-file. */
2559 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
2560 &offset
, &device
[0], &inode
, &filename
[0]))
2562 size
= endaddr
- addr
;
2564 /* Get the segment's permissions. */
2565 read
= (strchr (permissions
, 'r') != 0);
2566 write
= (strchr (permissions
, 'w') != 0);
2567 exec
= (strchr (permissions
, 'x') != 0);
2571 fprintf_filtered (gdb_stdout
,
2572 "Save segment, %lld bytes at 0x%s (%c%c%c)",
2573 size
, paddr_nz (addr
),
2575 write
? 'w' : ' ', exec
? 'x' : ' ');
2577 fprintf_filtered (gdb_stdout
, " for %s", filename
);
2578 fprintf_filtered (gdb_stdout
, "\n");
2581 /* Invoke the callback function to create the corefile
2583 func (addr
, size
, read
, write
, exec
, obfd
);
2589 /* Records the thread's register state for the corefile note
2593 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
2594 char *note_data
, int *note_size
)
2596 gdb_gregset_t gregs
;
2597 gdb_fpregset_t fpregs
;
2598 #ifdef FILL_FPXREGSET
2599 gdb_fpxregset_t fpxregs
;
2601 unsigned long lwp
= ptid_get_lwp (ptid
);
2602 struct regcache
*regcache
= get_thread_regcache (ptid
);
2603 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2604 const struct regset
*regset
;
2606 struct cleanup
*old_chain
;
2608 old_chain
= save_inferior_ptid ();
2609 inferior_ptid
= ptid
;
2610 target_fetch_registers (regcache
, -1);
2611 do_cleanups (old_chain
);
2613 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
2615 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
2616 sizeof (gregs
))) != NULL
2617 && regset
->collect_regset
!= NULL
)
2618 regset
->collect_regset (regset
, regcache
, -1,
2619 &gregs
, sizeof (gregs
));
2621 fill_gregset (regcache
, &gregs
, -1);
2623 note_data
= (char *) elfcore_write_prstatus (obfd
,
2627 stop_signal
, &gregs
);
2630 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
2631 sizeof (fpregs
))) != NULL
2632 && regset
->collect_regset
!= NULL
)
2633 regset
->collect_regset (regset
, regcache
, -1,
2634 &fpregs
, sizeof (fpregs
));
2636 fill_fpregset (regcache
, &fpregs
, -1);
2638 note_data
= (char *) elfcore_write_prfpreg (obfd
,
2641 &fpregs
, sizeof (fpregs
));
2643 #ifdef FILL_FPXREGSET
2645 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg-xfp",
2646 sizeof (fpxregs
))) != NULL
2647 && regset
->collect_regset
!= NULL
)
2648 regset
->collect_regset (regset
, regcache
, -1,
2649 &fpxregs
, sizeof (fpxregs
));
2651 fill_fpxregset (regcache
, &fpxregs
, -1);
2653 note_data
= (char *) elfcore_write_prxfpreg (obfd
,
2656 &fpxregs
, sizeof (fpxregs
));
2661 struct linux_nat_corefile_thread_data
2669 /* Called by gdbthread.c once per thread. Records the thread's
2670 register state for the corefile note section. */
2673 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
2675 struct linux_nat_corefile_thread_data
*args
= data
;
2677 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
2686 /* Records the register state for the corefile note section. */
2689 linux_nat_do_registers (bfd
*obfd
, ptid_t ptid
,
2690 char *note_data
, int *note_size
)
2692 return linux_nat_do_thread_registers (obfd
,
2693 ptid_build (ptid_get_pid (inferior_ptid
),
2694 ptid_get_pid (inferior_ptid
),
2696 note_data
, note_size
);
2699 /* Fills the "to_make_corefile_note" target vector. Builds the note
2700 section for a corefile, and returns it in a malloc buffer. */
2703 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
2705 struct linux_nat_corefile_thread_data thread_args
;
2706 struct cleanup
*old_chain
;
2707 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
2708 char fname
[16] = { '\0' };
2709 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
2710 char psargs
[80] = { '\0' };
2711 char *note_data
= NULL
;
2712 ptid_t current_ptid
= inferior_ptid
;
2716 if (get_exec_file (0))
2718 strncpy (fname
, strrchr (get_exec_file (0), '/') + 1, sizeof (fname
));
2719 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
2720 if (get_inferior_args ())
2723 char *psargs_end
= psargs
+ sizeof (psargs
);
2725 /* linux_elfcore_write_prpsinfo () handles zero unterminated
2727 string_end
= memchr (psargs
, 0, sizeof (psargs
));
2728 if (string_end
!= NULL
)
2730 *string_end
++ = ' ';
2731 strncpy (string_end
, get_inferior_args (),
2732 psargs_end
- string_end
);
2735 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
2737 note_size
, fname
, psargs
);
2740 /* Dump information for threads. */
2741 thread_args
.obfd
= obfd
;
2742 thread_args
.note_data
= note_data
;
2743 thread_args
.note_size
= note_size
;
2744 thread_args
.num_notes
= 0;
2745 iterate_over_lwps (linux_nat_corefile_thread_callback
, &thread_args
);
2746 if (thread_args
.num_notes
== 0)
2748 /* iterate_over_threads didn't come up with any threads; just
2749 use inferior_ptid. */
2750 note_data
= linux_nat_do_registers (obfd
, inferior_ptid
,
2751 note_data
, note_size
);
2755 note_data
= thread_args
.note_data
;
2758 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
2762 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
2763 "CORE", NT_AUXV
, auxv
, auxv_len
);
2767 make_cleanup (xfree
, note_data
);
2771 /* Implement the "info proc" command. */
2774 linux_nat_info_proc_cmd (char *args
, int from_tty
)
2776 long long pid
= PIDGET (inferior_ptid
);
2779 char buffer
[MAXPATHLEN
];
2780 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
2793 /* Break up 'args' into an argv array. */
2794 if ((argv
= buildargv (args
)) == NULL
)
2797 make_cleanup_freeargv (argv
);
2799 while (argv
!= NULL
&& *argv
!= NULL
)
2801 if (isdigit (argv
[0][0]))
2803 pid
= strtoul (argv
[0], NULL
, 10);
2805 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
2809 else if (strcmp (argv
[0], "status") == 0)
2813 else if (strcmp (argv
[0], "stat") == 0)
2817 else if (strcmp (argv
[0], "cmd") == 0)
2821 else if (strncmp (argv
[0], "exe", strlen (argv
[0])) == 0)
2825 else if (strcmp (argv
[0], "cwd") == 0)
2829 else if (strncmp (argv
[0], "all", strlen (argv
[0])) == 0)
2835 /* [...] (future options here) */
2840 error (_("No current process: you must name one."));
2842 sprintf (fname1
, "/proc/%lld", pid
);
2843 if (stat (fname1
, &dummy
) != 0)
2844 error (_("No /proc directory: '%s'"), fname1
);
2846 printf_filtered (_("process %lld\n"), pid
);
2847 if (cmdline_f
|| all
)
2849 sprintf (fname1
, "/proc/%lld/cmdline", pid
);
2850 if ((procfile
= fopen (fname1
, "r")) != NULL
)
2852 fgets (buffer
, sizeof (buffer
), procfile
);
2853 printf_filtered ("cmdline = '%s'\n", buffer
);
2857 warning (_("unable to open /proc file '%s'"), fname1
);
2861 sprintf (fname1
, "/proc/%lld/cwd", pid
);
2862 memset (fname2
, 0, sizeof (fname2
));
2863 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
2864 printf_filtered ("cwd = '%s'\n", fname2
);
2866 warning (_("unable to read link '%s'"), fname1
);
2870 sprintf (fname1
, "/proc/%lld/exe", pid
);
2871 memset (fname2
, 0, sizeof (fname2
));
2872 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
2873 printf_filtered ("exe = '%s'\n", fname2
);
2875 warning (_("unable to read link '%s'"), fname1
);
2877 if (mappings_f
|| all
)
2879 sprintf (fname1
, "/proc/%lld/maps", pid
);
2880 if ((procfile
= fopen (fname1
, "r")) != NULL
)
2882 long long addr
, endaddr
, size
, offset
, inode
;
2883 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
2885 printf_filtered (_("Mapped address spaces:\n\n"));
2886 if (gdbarch_addr_bit (current_gdbarch
) == 32)
2888 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
2891 " Size", " Offset", "objfile");
2895 printf_filtered (" %18s %18s %10s %10s %7s\n",
2898 " Size", " Offset", "objfile");
2901 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
2902 &offset
, &device
[0], &inode
, &filename
[0]))
2904 size
= endaddr
- addr
;
2906 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
2907 calls here (and possibly above) should be abstracted
2908 out into their own functions? Andrew suggests using
2909 a generic local_address_string instead to print out
2910 the addresses; that makes sense to me, too. */
2912 if (gdbarch_addr_bit (current_gdbarch
) == 32)
2914 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
2915 (unsigned long) addr
, /* FIXME: pr_addr */
2916 (unsigned long) endaddr
,
2918 (unsigned int) offset
,
2919 filename
[0] ? filename
: "");
2923 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
2924 (unsigned long) addr
, /* FIXME: pr_addr */
2925 (unsigned long) endaddr
,
2927 (unsigned int) offset
,
2928 filename
[0] ? filename
: "");
2935 warning (_("unable to open /proc file '%s'"), fname1
);
2937 if (status_f
|| all
)
2939 sprintf (fname1
, "/proc/%lld/status", pid
);
2940 if ((procfile
= fopen (fname1
, "r")) != NULL
)
2942 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
2943 puts_filtered (buffer
);
2947 warning (_("unable to open /proc file '%s'"), fname1
);
2951 sprintf (fname1
, "/proc/%lld/stat", pid
);
2952 if ((procfile
= fopen (fname1
, "r")) != NULL
)
2958 if (fscanf (procfile
, "%d ", &itmp
) > 0)
2959 printf_filtered (_("Process: %d\n"), itmp
);
2960 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
2961 printf_filtered (_("Exec file: %s\n"), buffer
);
2962 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
2963 printf_filtered (_("State: %c\n"), ctmp
);
2964 if (fscanf (procfile
, "%d ", &itmp
) > 0)
2965 printf_filtered (_("Parent process: %d\n"), itmp
);
2966 if (fscanf (procfile
, "%d ", &itmp
) > 0)
2967 printf_filtered (_("Process group: %d\n"), itmp
);
2968 if (fscanf (procfile
, "%d ", &itmp
) > 0)
2969 printf_filtered (_("Session id: %d\n"), itmp
);
2970 if (fscanf (procfile
, "%d ", &itmp
) > 0)
2971 printf_filtered (_("TTY: %d\n"), itmp
);
2972 if (fscanf (procfile
, "%d ", &itmp
) > 0)
2973 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
2974 if (fscanf (procfile
, "%lu ", <mp
) > 0)
2975 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
2976 if (fscanf (procfile
, "%lu ", <mp
) > 0)
2977 printf_filtered (_("Minor faults (no memory page): %lu\n"),
2978 (unsigned long) ltmp
);
2979 if (fscanf (procfile
, "%lu ", <mp
) > 0)
2980 printf_filtered (_("Minor faults, children: %lu\n"),
2981 (unsigned long) ltmp
);
2982 if (fscanf (procfile
, "%lu ", <mp
) > 0)
2983 printf_filtered (_("Major faults (memory page faults): %lu\n"),
2984 (unsigned long) ltmp
);
2985 if (fscanf (procfile
, "%lu ", <mp
) > 0)
2986 printf_filtered (_("Major faults, children: %lu\n"),
2987 (unsigned long) ltmp
);
2988 if (fscanf (procfile
, "%ld ", <mp
) > 0)
2989 printf_filtered (_("utime: %ld\n"), ltmp
);
2990 if (fscanf (procfile
, "%ld ", <mp
) > 0)
2991 printf_filtered (_("stime: %ld\n"), ltmp
);
2992 if (fscanf (procfile
, "%ld ", <mp
) > 0)
2993 printf_filtered (_("utime, children: %ld\n"), ltmp
);
2994 if (fscanf (procfile
, "%ld ", <mp
) > 0)
2995 printf_filtered (_("stime, children: %ld\n"), ltmp
);
2996 if (fscanf (procfile
, "%ld ", <mp
) > 0)
2997 printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
2999 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3000 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
3001 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3002 printf_filtered (_("jiffies until next timeout: %lu\n"),
3003 (unsigned long) ltmp
);
3004 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3005 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
3006 (unsigned long) ltmp
);
3007 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3008 printf_filtered (_("start time (jiffies since system boot): %ld\n"),
3010 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3011 printf_filtered (_("Virtual memory size: %lu\n"),
3012 (unsigned long) ltmp
);
3013 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3014 printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp
);
3015 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3016 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
3017 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3018 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
3019 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3020 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
3021 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3022 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
3023 #if 0 /* Don't know how architecture-dependent the rest is...
3024 Anyway the signal bitmap info is available from "status". */
3025 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3026 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
3027 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3028 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
3029 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3030 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
3031 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3032 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
3033 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3034 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
3035 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3036 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
3037 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3038 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
3043 warning (_("unable to open /proc file '%s'"), fname1
);
3047 /* Implement the to_xfer_partial interface for memory reads using the /proc
3048 filesystem. Because we can use a single read() call for /proc, this
3049 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3050 but it doesn't support writes. */
3053 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3054 const char *annex
, gdb_byte
*readbuf
,
3055 const gdb_byte
*writebuf
,
3056 ULONGEST offset
, LONGEST len
)
3062 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
3065 /* Don't bother for one word. */
3066 if (len
< 3 * sizeof (long))
3069 /* We could keep this file open and cache it - possibly one per
3070 thread. That requires some juggling, but is even faster. */
3071 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
3072 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
3076 /* If pread64 is available, use it. It's faster if the kernel
3077 supports it (only one syscall), and it's 64-bit safe even on
3078 32-bit platforms (for instance, SPARC debugging a SPARC64
3081 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
3083 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
3093 /* Parse LINE as a signal set and add its set bits to SIGS. */
3096 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
3098 int len
= strlen (line
) - 1;
3102 if (line
[len
] != '\n')
3103 error (_("Could not parse signal set: %s"), line
);
3111 if (*p
>= '0' && *p
<= '9')
3113 else if (*p
>= 'a' && *p
<= 'f')
3114 digit
= *p
- 'a' + 10;
3116 error (_("Could not parse signal set: %s"), line
);
3121 sigaddset (sigs
, signum
+ 1);
3123 sigaddset (sigs
, signum
+ 2);
3125 sigaddset (sigs
, signum
+ 3);
3127 sigaddset (sigs
, signum
+ 4);
3133 /* Find process PID's pending signals from /proc/pid/status and set
3137 linux_proc_pending_signals (int pid
, sigset_t
*pending
, sigset_t
*blocked
, sigset_t
*ignored
)
3140 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
3143 sigemptyset (pending
);
3144 sigemptyset (blocked
);
3145 sigemptyset (ignored
);
3146 sprintf (fname
, "/proc/%d/status", pid
);
3147 procfile
= fopen (fname
, "r");
3148 if (procfile
== NULL
)
3149 error (_("Could not open %s"), fname
);
3151 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
3153 /* Normal queued signals are on the SigPnd line in the status
3154 file. However, 2.6 kernels also have a "shared" pending
3155 queue for delivering signals to a thread group, so check for
3158 Unfortunately some Red Hat kernels include the shared pending
3159 queue but not the ShdPnd status field. */
3161 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
3162 add_line_to_sigset (buffer
+ 8, pending
);
3163 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
3164 add_line_to_sigset (buffer
+ 8, pending
);
3165 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
3166 add_line_to_sigset (buffer
+ 8, blocked
);
3167 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
3168 add_line_to_sigset (buffer
+ 8, ignored
);
3175 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3176 const char *annex
, gdb_byte
*readbuf
,
3177 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3181 if (object
== TARGET_OBJECT_AUXV
)
3182 return procfs_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
3185 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3190 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3194 /* Create a prototype generic GNU/Linux target. The client can override
3195 it with local methods. */
3198 linux_target_install_ops (struct target_ops
*t
)
3200 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
3201 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
3202 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
3203 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
3204 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
3205 t
->to_post_attach
= linux_child_post_attach
;
3206 t
->to_follow_fork
= linux_child_follow_fork
;
3207 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
3208 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
3210 super_xfer_partial
= t
->to_xfer_partial
;
3211 t
->to_xfer_partial
= linux_xfer_partial
;
3217 struct target_ops
*t
;
3219 t
= inf_ptrace_target ();
3220 linux_target_install_ops (t
);
3226 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
3228 struct target_ops
*t
;
3230 t
= inf_ptrace_trad_target (register_u_offset
);
3231 linux_target_install_ops (t
);
3237 linux_nat_add_target (struct target_ops
*t
)
3239 /* Save the provided single-threaded target. We save this in a separate
3240 variable because another target we've inherited from (e.g. inf-ptrace)
3241 may have saved a pointer to T; we want to use it for the final
3242 process stratum target. */
3243 linux_ops_saved
= *t
;
3244 linux_ops
= &linux_ops_saved
;
3246 /* Override some methods for multithreading. */
3247 t
->to_attach
= linux_nat_attach
;
3248 t
->to_detach
= linux_nat_detach
;
3249 t
->to_resume
= linux_nat_resume
;
3250 t
->to_wait
= linux_nat_wait
;
3251 t
->to_xfer_partial
= linux_nat_xfer_partial
;
3252 t
->to_kill
= linux_nat_kill
;
3253 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
3254 t
->to_thread_alive
= linux_nat_thread_alive
;
3255 t
->to_pid_to_str
= linux_nat_pid_to_str
;
3256 t
->to_has_thread_control
= tc_schedlock
;
3258 /* We don't change the stratum; this target will sit at
3259 process_stratum and thread_db will set at thread_stratum. This
3260 is a little strange, since this is a multi-threaded-capable
3261 target, but we want to be on the stack below thread_db, and we
3262 also want to be used for single-threaded processes. */
3266 /* TODO: Eliminate this and have libthread_db use
3267 find_target_beneath. */
3271 /* Register a method to call whenever a new thread is attached. */
3273 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
3275 /* Save the pointer. We only support a single registered instance
3276 of the GNU/Linux native target, so we do not need to map this to
3278 linux_nat_new_thread
= new_thread
;
3281 /* Return the saved siginfo associated with PTID. */
3283 linux_nat_get_siginfo (ptid_t ptid
)
3285 struct lwp_info
*lp
= find_lwp_pid (ptid
);
3287 gdb_assert (lp
!= NULL
);
3289 return &lp
->siginfo
;
3293 _initialize_linux_nat (void)
3295 struct sigaction action
;
3297 add_info ("proc", linux_nat_info_proc_cmd
, _("\
3298 Show /proc process information about any running process.\n\
3299 Specify any process id, or use the program being debugged by default.\n\
3300 Specify any of the following keywords for detailed info:\n\
3301 mappings -- list of mapped memory regions.\n\
3302 stat -- list a bunch of random process info.\n\
3303 status -- list a different bunch of random process info.\n\
3304 all -- list all available /proc info."));
3306 /* Save the original signal mask. */
3307 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
3309 action
.sa_handler
= sigchld_handler
;
3310 sigemptyset (&action
.sa_mask
);
3311 action
.sa_flags
= SA_RESTART
;
3312 sigaction (SIGCHLD
, &action
, NULL
);
3314 /* Make sure we don't block SIGCHLD during a sigsuspend. */
3315 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
3316 sigdelset (&suspend_mask
, SIGCHLD
);
3318 sigemptyset (&blocked_mask
);
3320 add_setshow_zinteger_cmd ("lin-lwp", no_class
, &debug_linux_nat
, _("\
3321 Set debugging of GNU/Linux lwp module."), _("\
3322 Show debugging of GNU/Linux lwp module."), _("\
3323 Enables printf debugging output."),
3325 show_debug_linux_nat
,
3326 &setdebuglist
, &showdebuglist
);
3330 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
3331 the GNU/Linux Threads library and therefore doesn't really belong
3334 /* Read variable NAME in the target and return its value if found.
3335 Otherwise return zero. It is assumed that the type of the variable
3339 get_signo (const char *name
)
3341 struct minimal_symbol
*ms
;
3344 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
3348 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
3349 sizeof (signo
)) != 0)
3355 /* Return the set of signals used by the threads library in *SET. */
3358 lin_thread_get_thread_signals (sigset_t
*set
)
3360 struct sigaction action
;
3361 int restart
, cancel
;
3365 restart
= get_signo ("__pthread_sig_restart");
3366 cancel
= get_signo ("__pthread_sig_cancel");
3368 /* LinuxThreads normally uses the first two RT signals, but in some legacy
3369 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
3370 not provide any way for the debugger to query the signal numbers -
3371 fortunately they don't change! */
3374 restart
= __SIGRTMIN
;
3377 cancel
= __SIGRTMIN
+ 1;
3379 sigaddset (set
, restart
);
3380 sigaddset (set
, cancel
);
3382 /* The GNU/Linux Threads library makes terminating threads send a
3383 special "cancel" signal instead of SIGCHLD. Make sure we catch
3384 those (to prevent them from terminating GDB itself, which is
3385 likely to be their default action) and treat them the same way as
3388 action
.sa_handler
= sigchld_handler
;
3389 sigemptyset (&action
.sa_mask
);
3390 action
.sa_flags
= SA_RESTART
;
3391 sigaction (cancel
, &action
, NULL
);
3393 /* We block the "cancel" signal throughout this code ... */
3394 sigaddset (&blocked_mask
, cancel
);
3395 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
3397 /* ... except during a sigsuspend. */
3398 sigdelset (&suspend_mask
, cancel
);