1b725ae77Skettenis /* GNU/Linux native-dependent code common to multiple platforms.
2*11efff7fSkettenis
3*11efff7fSkettenis Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4b725ae77Skettenis
5b725ae77Skettenis This file is part of GDB.
6b725ae77Skettenis
7b725ae77Skettenis This program is free software; you can redistribute it and/or modify
8b725ae77Skettenis it under the terms of the GNU General Public License as published by
9b725ae77Skettenis the Free Software Foundation; either version 2 of the License, or
10b725ae77Skettenis (at your option) any later version.
11b725ae77Skettenis
12b725ae77Skettenis This program is distributed in the hope that it will be useful,
13b725ae77Skettenis but WITHOUT ANY WARRANTY; without even the implied warranty of
14b725ae77Skettenis MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15b725ae77Skettenis GNU General Public License for more details.
16b725ae77Skettenis
17b725ae77Skettenis You should have received a copy of the GNU General Public License
18b725ae77Skettenis along with this program; if not, write to the Free Software
19b725ae77Skettenis Foundation, Inc., 59 Temple Place - Suite 330,
20b725ae77Skettenis Boston, MA 02111-1307, USA. */
21b725ae77Skettenis
22b725ae77Skettenis #include "defs.h"
23b725ae77Skettenis #include "inferior.h"
24b725ae77Skettenis #include "target.h"
25*11efff7fSkettenis #include "gdb_string.h"
26b725ae77Skettenis #include "gdb_wait.h"
27*11efff7fSkettenis #include "gdb_assert.h"
28*11efff7fSkettenis #ifdef HAVE_TKILL_SYSCALL
29*11efff7fSkettenis #include <unistd.h>
30*11efff7fSkettenis #include <sys/syscall.h>
31*11efff7fSkettenis #endif
32b725ae77Skettenis #include <sys/ptrace.h>
33b725ae77Skettenis #include "linux-nat.h"
34*11efff7fSkettenis #include "gdbthread.h"
35*11efff7fSkettenis #include "gdbcmd.h"
36*11efff7fSkettenis #include "regcache.h"
37*11efff7fSkettenis #include <sys/param.h> /* for MAXPATHLEN */
38*11efff7fSkettenis #include <sys/procfs.h> /* for elf_gregset etc. */
39*11efff7fSkettenis #include "elf-bfd.h" /* for elfcore_write_* */
40*11efff7fSkettenis #include "gregset.h" /* for gregset */
41*11efff7fSkettenis #include "gdbcore.h" /* for get_exec_file */
42*11efff7fSkettenis #include <ctype.h> /* for isdigit */
43*11efff7fSkettenis #include "gdbthread.h" /* for struct thread_info etc. */
44*11efff7fSkettenis #include "gdb_stat.h" /* for struct stat */
45*11efff7fSkettenis #include <fcntl.h> /* for O_RDONLY */
46*11efff7fSkettenis
47*11efff7fSkettenis #ifndef O_LARGEFILE
48*11efff7fSkettenis #define O_LARGEFILE 0
49*11efff7fSkettenis #endif
50b725ae77Skettenis
51b725ae77Skettenis /* If the system headers did not provide the constants, hard-code the normal
52b725ae77Skettenis values. */
53b725ae77Skettenis #ifndef PTRACE_EVENT_FORK
54b725ae77Skettenis
55b725ae77Skettenis #define PTRACE_SETOPTIONS 0x4200
56b725ae77Skettenis #define PTRACE_GETEVENTMSG 0x4201
57b725ae77Skettenis
58b725ae77Skettenis /* options set using PTRACE_SETOPTIONS */
59b725ae77Skettenis #define PTRACE_O_TRACESYSGOOD 0x00000001
60b725ae77Skettenis #define PTRACE_O_TRACEFORK 0x00000002
61b725ae77Skettenis #define PTRACE_O_TRACEVFORK 0x00000004
62b725ae77Skettenis #define PTRACE_O_TRACECLONE 0x00000008
63b725ae77Skettenis #define PTRACE_O_TRACEEXEC 0x00000010
64b725ae77Skettenis #define PTRACE_O_TRACEVFORKDONE 0x00000020
65b725ae77Skettenis #define PTRACE_O_TRACEEXIT 0x00000040
66b725ae77Skettenis
67b725ae77Skettenis /* Wait extended result codes for the above trace options. */
68b725ae77Skettenis #define PTRACE_EVENT_FORK 1
69b725ae77Skettenis #define PTRACE_EVENT_VFORK 2
70b725ae77Skettenis #define PTRACE_EVENT_CLONE 3
71b725ae77Skettenis #define PTRACE_EVENT_EXEC 4
72b725ae77Skettenis #define PTRACE_EVENT_VFORKDONE 5
73b725ae77Skettenis #define PTRACE_EVENT_EXIT 6
74b725ae77Skettenis
75b725ae77Skettenis #endif /* PTRACE_EVENT_FORK */
76b725ae77Skettenis
77b725ae77Skettenis /* We can't always assume that this flag is available, but all systems
78b725ae77Skettenis with the ptrace event handlers also have __WALL, so it's safe to use
79b725ae77Skettenis here. */
80b725ae77Skettenis #ifndef __WALL
81b725ae77Skettenis #define __WALL 0x40000000 /* Wait for any child. */
82b725ae77Skettenis #endif
83b725ae77Skettenis
84*11efff7fSkettenis static int debug_linux_nat;
85b725ae77Skettenis
86b725ae77Skettenis static int linux_parent_pid;
87b725ae77Skettenis
88b725ae77Skettenis struct simple_pid_list
89b725ae77Skettenis {
90b725ae77Skettenis int pid;
91b725ae77Skettenis struct simple_pid_list *next;
92b725ae77Skettenis };
93b725ae77Skettenis struct simple_pid_list *stopped_pids;
94b725ae77Skettenis
95b725ae77Skettenis /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
96b725ae77Skettenis can not be used, 1 if it can. */
97b725ae77Skettenis
98b725ae77Skettenis static int linux_supports_tracefork_flag = -1;
99b725ae77Skettenis
100b725ae77Skettenis /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
101b725ae77Skettenis PTRACE_O_TRACEVFORKDONE. */
102b725ae77Skettenis
103b725ae77Skettenis static int linux_supports_tracevforkdone_flag = -1;
104b725ae77Skettenis
105b725ae77Skettenis
106b725ae77Skettenis /* Trivial list manipulation functions to keep track of a list of
107b725ae77Skettenis new stopped processes. */
108b725ae77Skettenis static void
add_to_pid_list(struct simple_pid_list ** listp,int pid)109b725ae77Skettenis add_to_pid_list (struct simple_pid_list **listp, int pid)
110b725ae77Skettenis {
111b725ae77Skettenis struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
112b725ae77Skettenis new_pid->pid = pid;
113b725ae77Skettenis new_pid->next = *listp;
114b725ae77Skettenis *listp = new_pid;
115b725ae77Skettenis }
116b725ae77Skettenis
117b725ae77Skettenis static int
pull_pid_from_list(struct simple_pid_list ** listp,int pid)118b725ae77Skettenis pull_pid_from_list (struct simple_pid_list **listp, int pid)
119b725ae77Skettenis {
120b725ae77Skettenis struct simple_pid_list **p;
121b725ae77Skettenis
122b725ae77Skettenis for (p = listp; *p != NULL; p = &(*p)->next)
123b725ae77Skettenis if ((*p)->pid == pid)
124b725ae77Skettenis {
125b725ae77Skettenis struct simple_pid_list *next = (*p)->next;
126b725ae77Skettenis xfree (*p);
127b725ae77Skettenis *p = next;
128b725ae77Skettenis return 1;
129b725ae77Skettenis }
130b725ae77Skettenis return 0;
131b725ae77Skettenis }
132b725ae77Skettenis
133b725ae77Skettenis void
linux_record_stopped_pid(int pid)134b725ae77Skettenis linux_record_stopped_pid (int pid)
135b725ae77Skettenis {
136b725ae77Skettenis add_to_pid_list (&stopped_pids, pid);
137b725ae77Skettenis }
138b725ae77Skettenis
139b725ae77Skettenis
140b725ae77Skettenis /* A helper function for linux_test_for_tracefork, called after fork (). */
141b725ae77Skettenis
142b725ae77Skettenis static void
linux_tracefork_child(void)143b725ae77Skettenis linux_tracefork_child (void)
144b725ae77Skettenis {
145b725ae77Skettenis int ret;
146b725ae77Skettenis
147b725ae77Skettenis ptrace (PTRACE_TRACEME, 0, 0, 0);
148b725ae77Skettenis kill (getpid (), SIGSTOP);
149b725ae77Skettenis fork ();
150b725ae77Skettenis exit (0);
151b725ae77Skettenis }
152b725ae77Skettenis
153b725ae77Skettenis /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. We
154b725ae77Skettenis create a child process, attach to it, use PTRACE_SETOPTIONS to enable
155b725ae77Skettenis fork tracing, and let it fork. If the process exits, we assume that
156b725ae77Skettenis we can't use TRACEFORK; if we get the fork notification, and we can
157b725ae77Skettenis extract the new child's PID, then we assume that we can. */
158b725ae77Skettenis
159b725ae77Skettenis static void
linux_test_for_tracefork(void)160b725ae77Skettenis linux_test_for_tracefork (void)
161b725ae77Skettenis {
162b725ae77Skettenis int child_pid, ret, status;
163b725ae77Skettenis long second_pid;
164b725ae77Skettenis
165b725ae77Skettenis child_pid = fork ();
166b725ae77Skettenis if (child_pid == -1)
167b725ae77Skettenis perror_with_name ("linux_test_for_tracefork: fork");
168b725ae77Skettenis
169b725ae77Skettenis if (child_pid == 0)
170b725ae77Skettenis linux_tracefork_child ();
171b725ae77Skettenis
172b725ae77Skettenis ret = waitpid (child_pid, &status, 0);
173b725ae77Skettenis if (ret == -1)
174b725ae77Skettenis perror_with_name ("linux_test_for_tracefork: waitpid");
175b725ae77Skettenis else if (ret != child_pid)
176b725ae77Skettenis error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
177b725ae77Skettenis if (! WIFSTOPPED (status))
178b725ae77Skettenis error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
179b725ae77Skettenis
180b725ae77Skettenis linux_supports_tracefork_flag = 0;
181b725ae77Skettenis
182b725ae77Skettenis ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
183b725ae77Skettenis if (ret != 0)
184b725ae77Skettenis {
185b725ae77Skettenis ptrace (PTRACE_KILL, child_pid, 0, 0);
186b725ae77Skettenis waitpid (child_pid, &status, 0);
187b725ae77Skettenis return;
188b725ae77Skettenis }
189b725ae77Skettenis
190b725ae77Skettenis /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
191b725ae77Skettenis ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
192b725ae77Skettenis PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
193b725ae77Skettenis linux_supports_tracevforkdone_flag = (ret == 0);
194b725ae77Skettenis
195b725ae77Skettenis ptrace (PTRACE_CONT, child_pid, 0, 0);
196b725ae77Skettenis ret = waitpid (child_pid, &status, 0);
197b725ae77Skettenis if (ret == child_pid && WIFSTOPPED (status)
198b725ae77Skettenis && status >> 16 == PTRACE_EVENT_FORK)
199b725ae77Skettenis {
200b725ae77Skettenis second_pid = 0;
201b725ae77Skettenis ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
202b725ae77Skettenis if (ret == 0 && second_pid != 0)
203b725ae77Skettenis {
204b725ae77Skettenis int second_status;
205b725ae77Skettenis
206b725ae77Skettenis linux_supports_tracefork_flag = 1;
207b725ae77Skettenis waitpid (second_pid, &second_status, 0);
208b725ae77Skettenis ptrace (PTRACE_DETACH, second_pid, 0, 0);
209b725ae77Skettenis }
210b725ae77Skettenis }
211b725ae77Skettenis
212b725ae77Skettenis if (WIFSTOPPED (status))
213b725ae77Skettenis {
214b725ae77Skettenis ptrace (PTRACE_DETACH, child_pid, 0, 0);
215b725ae77Skettenis waitpid (child_pid, &status, 0);
216b725ae77Skettenis }
217b725ae77Skettenis }
218b725ae77Skettenis
219b725ae77Skettenis /* Return non-zero iff we have tracefork functionality available.
220b725ae77Skettenis This function also sets linux_supports_tracefork_flag. */
221b725ae77Skettenis
222b725ae77Skettenis static int
linux_supports_tracefork(void)223b725ae77Skettenis linux_supports_tracefork (void)
224b725ae77Skettenis {
225b725ae77Skettenis if (linux_supports_tracefork_flag == -1)
226b725ae77Skettenis linux_test_for_tracefork ();
227b725ae77Skettenis return linux_supports_tracefork_flag;
228b725ae77Skettenis }
229b725ae77Skettenis
230b725ae77Skettenis static int
linux_supports_tracevforkdone(void)231b725ae77Skettenis linux_supports_tracevforkdone (void)
232b725ae77Skettenis {
233b725ae77Skettenis if (linux_supports_tracefork_flag == -1)
234b725ae77Skettenis linux_test_for_tracefork ();
235b725ae77Skettenis return linux_supports_tracevforkdone_flag;
236b725ae77Skettenis }
237b725ae77Skettenis
238b725ae77Skettenis
239b725ae77Skettenis void
linux_enable_event_reporting(ptid_t ptid)240b725ae77Skettenis linux_enable_event_reporting (ptid_t ptid)
241b725ae77Skettenis {
242b725ae77Skettenis int pid = ptid_get_pid (ptid);
243b725ae77Skettenis int options;
244b725ae77Skettenis
245b725ae77Skettenis if (! linux_supports_tracefork ())
246b725ae77Skettenis return;
247b725ae77Skettenis
248*11efff7fSkettenis options = PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK | PTRACE_O_TRACEEXEC
249*11efff7fSkettenis | PTRACE_O_TRACECLONE;
250b725ae77Skettenis if (linux_supports_tracevforkdone ())
251b725ae77Skettenis options |= PTRACE_O_TRACEVFORKDONE;
252b725ae77Skettenis
253b725ae77Skettenis /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
254b725ae77Skettenis read-only process state. */
255b725ae77Skettenis
256b725ae77Skettenis ptrace (PTRACE_SETOPTIONS, pid, 0, options);
257b725ae77Skettenis }
258b725ae77Skettenis
259b725ae77Skettenis void
child_post_attach(int pid)260b725ae77Skettenis child_post_attach (int pid)
261b725ae77Skettenis {
262b725ae77Skettenis linux_enable_event_reporting (pid_to_ptid (pid));
263b725ae77Skettenis }
264b725ae77Skettenis
265b725ae77Skettenis void
linux_child_post_startup_inferior(ptid_t ptid)266b725ae77Skettenis linux_child_post_startup_inferior (ptid_t ptid)
267b725ae77Skettenis {
268b725ae77Skettenis linux_enable_event_reporting (ptid);
269b725ae77Skettenis }
270b725ae77Skettenis
271b725ae77Skettenis #ifndef LINUX_CHILD_POST_STARTUP_INFERIOR
272b725ae77Skettenis void
child_post_startup_inferior(ptid_t ptid)273b725ae77Skettenis child_post_startup_inferior (ptid_t ptid)
274b725ae77Skettenis {
275b725ae77Skettenis linux_child_post_startup_inferior (ptid);
276b725ae77Skettenis }
277b725ae77Skettenis #endif
278b725ae77Skettenis
279b725ae77Skettenis int
child_follow_fork(int follow_child)280b725ae77Skettenis child_follow_fork (int follow_child)
281b725ae77Skettenis {
282b725ae77Skettenis ptid_t last_ptid;
283b725ae77Skettenis struct target_waitstatus last_status;
284b725ae77Skettenis int has_vforked;
285b725ae77Skettenis int parent_pid, child_pid;
286b725ae77Skettenis
287b725ae77Skettenis get_last_target_status (&last_ptid, &last_status);
288b725ae77Skettenis has_vforked = (last_status.kind == TARGET_WAITKIND_VFORKED);
289b725ae77Skettenis parent_pid = ptid_get_pid (last_ptid);
290b725ae77Skettenis child_pid = last_status.value.related_pid;
291b725ae77Skettenis
292b725ae77Skettenis if (! follow_child)
293b725ae77Skettenis {
294b725ae77Skettenis /* We're already attached to the parent, by default. */
295b725ae77Skettenis
296b725ae77Skettenis /* Before detaching from the child, remove all breakpoints from
297b725ae77Skettenis it. (This won't actually modify the breakpoint list, but will
298b725ae77Skettenis physically remove the breakpoints from the child.) */
299b725ae77Skettenis /* If we vforked this will remove the breakpoints from the parent
300b725ae77Skettenis also, but they'll be reinserted below. */
301b725ae77Skettenis detach_breakpoints (child_pid);
302b725ae77Skettenis
303b725ae77Skettenis fprintf_filtered (gdb_stdout,
304b725ae77Skettenis "Detaching after fork from child process %d.\n",
305b725ae77Skettenis child_pid);
306b725ae77Skettenis
307b725ae77Skettenis ptrace (PTRACE_DETACH, child_pid, 0, 0);
308b725ae77Skettenis
309b725ae77Skettenis if (has_vforked)
310b725ae77Skettenis {
311b725ae77Skettenis if (linux_supports_tracevforkdone ())
312b725ae77Skettenis {
313b725ae77Skettenis int status;
314b725ae77Skettenis
315b725ae77Skettenis ptrace (PTRACE_CONT, parent_pid, 0, 0);
316b725ae77Skettenis waitpid (parent_pid, &status, __WALL);
317b725ae77Skettenis if ((status >> 16) != PTRACE_EVENT_VFORKDONE)
318b725ae77Skettenis warning ("Unexpected waitpid result %06x when waiting for "
319b725ae77Skettenis "vfork-done", status);
320b725ae77Skettenis }
321b725ae77Skettenis else
322b725ae77Skettenis {
323b725ae77Skettenis /* We can't insert breakpoints until the child has
324b725ae77Skettenis finished with the shared memory region. We need to
325b725ae77Skettenis wait until that happens. Ideal would be to just
326b725ae77Skettenis call:
327b725ae77Skettenis - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
328b725ae77Skettenis - waitpid (parent_pid, &status, __WALL);
329b725ae77Skettenis However, most architectures can't handle a syscall
330b725ae77Skettenis being traced on the way out if it wasn't traced on
331b725ae77Skettenis the way in.
332b725ae77Skettenis
333b725ae77Skettenis We might also think to loop, continuing the child
334b725ae77Skettenis until it exits or gets a SIGTRAP. One problem is
335b725ae77Skettenis that the child might call ptrace with PTRACE_TRACEME.
336b725ae77Skettenis
337b725ae77Skettenis There's no simple and reliable way to figure out when
338b725ae77Skettenis the vforked child will be done with its copy of the
339b725ae77Skettenis shared memory. We could step it out of the syscall,
340b725ae77Skettenis two instructions, let it go, and then single-step the
341b725ae77Skettenis parent once. When we have hardware single-step, this
342b725ae77Skettenis would work; with software single-step it could still
343b725ae77Skettenis be made to work but we'd have to be able to insert
344b725ae77Skettenis single-step breakpoints in the child, and we'd have
345b725ae77Skettenis to insert -just- the single-step breakpoint in the
346b725ae77Skettenis parent. Very awkward.
347b725ae77Skettenis
348b725ae77Skettenis In the end, the best we can do is to make sure it
349b725ae77Skettenis runs for a little while. Hopefully it will be out of
350b725ae77Skettenis range of any breakpoints we reinsert. Usually this
351b725ae77Skettenis is only the single-step breakpoint at vfork's return
352b725ae77Skettenis point. */
353b725ae77Skettenis
354b725ae77Skettenis usleep (10000);
355b725ae77Skettenis }
356b725ae77Skettenis
357b725ae77Skettenis /* Since we vforked, breakpoints were removed in the parent
358b725ae77Skettenis too. Put them back. */
359b725ae77Skettenis reattach_breakpoints (parent_pid);
360b725ae77Skettenis }
361b725ae77Skettenis }
362b725ae77Skettenis else
363b725ae77Skettenis {
364b725ae77Skettenis char child_pid_spelling[40];
365b725ae77Skettenis
366b725ae77Skettenis /* Needed to keep the breakpoint lists in sync. */
367b725ae77Skettenis if (! has_vforked)
368b725ae77Skettenis detach_breakpoints (child_pid);
369b725ae77Skettenis
370b725ae77Skettenis /* Before detaching from the parent, remove all breakpoints from it. */
371b725ae77Skettenis remove_breakpoints ();
372b725ae77Skettenis
373b725ae77Skettenis fprintf_filtered (gdb_stdout,
374b725ae77Skettenis "Attaching after fork to child process %d.\n",
375b725ae77Skettenis child_pid);
376b725ae77Skettenis
377b725ae77Skettenis /* If we're vforking, we may want to hold on to the parent until
378b725ae77Skettenis the child exits or execs. At exec time we can remove the old
379b725ae77Skettenis breakpoints from the parent and detach it; at exit time we
380b725ae77Skettenis could do the same (or even, sneakily, resume debugging it - the
381b725ae77Skettenis child's exec has failed, or something similar).
382b725ae77Skettenis
383b725ae77Skettenis This doesn't clean up "properly", because we can't call
384b725ae77Skettenis target_detach, but that's OK; if the current target is "child",
385b725ae77Skettenis then it doesn't need any further cleanups, and lin_lwp will
386b725ae77Skettenis generally not encounter vfork (vfork is defined to fork
387b725ae77Skettenis in libpthread.so).
388b725ae77Skettenis
389b725ae77Skettenis The holding part is very easy if we have VFORKDONE events;
390b725ae77Skettenis but keeping track of both processes is beyond GDB at the
391b725ae77Skettenis moment. So we don't expose the parent to the rest of GDB.
392b725ae77Skettenis Instead we quietly hold onto it until such time as we can
393b725ae77Skettenis safely resume it. */
394b725ae77Skettenis
395b725ae77Skettenis if (has_vforked)
396b725ae77Skettenis linux_parent_pid = parent_pid;
397b725ae77Skettenis else
398b725ae77Skettenis target_detach (NULL, 0);
399b725ae77Skettenis
400b725ae77Skettenis inferior_ptid = pid_to_ptid (child_pid);
401*11efff7fSkettenis push_target (&deprecated_child_ops);
402b725ae77Skettenis
403b725ae77Skettenis /* Reset breakpoints in the child as appropriate. */
404b725ae77Skettenis follow_inferior_reset_breakpoints ();
405b725ae77Skettenis }
406b725ae77Skettenis
407b725ae77Skettenis return 0;
408b725ae77Skettenis }
409b725ae77Skettenis
410b725ae77Skettenis ptid_t
linux_handle_extended_wait(int pid,int status,struct target_waitstatus * ourstatus)411b725ae77Skettenis linux_handle_extended_wait (int pid, int status,
412b725ae77Skettenis struct target_waitstatus *ourstatus)
413b725ae77Skettenis {
414b725ae77Skettenis int event = status >> 16;
415b725ae77Skettenis
416*11efff7fSkettenis if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
417*11efff7fSkettenis || event == PTRACE_EVENT_CLONE)
418b725ae77Skettenis {
419b725ae77Skettenis unsigned long new_pid;
420b725ae77Skettenis int ret;
421b725ae77Skettenis
422b725ae77Skettenis ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
423b725ae77Skettenis
424b725ae77Skettenis /* If we haven't already seen the new PID stop, wait for it now. */
425b725ae77Skettenis if (! pull_pid_from_list (&stopped_pids, new_pid))
426b725ae77Skettenis {
427b725ae77Skettenis /* The new child has a pending SIGSTOP. We can't affect it until it
428*11efff7fSkettenis hits the SIGSTOP, but we're already attached. */
429b725ae77Skettenis do {
430*11efff7fSkettenis ret = waitpid (new_pid, &status,
431*11efff7fSkettenis (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
432b725ae77Skettenis } while (ret == -1 && errno == EINTR);
433b725ae77Skettenis if (ret == -1)
434b725ae77Skettenis perror_with_name ("waiting for new child");
435b725ae77Skettenis else if (ret != new_pid)
436b725ae77Skettenis internal_error (__FILE__, __LINE__,
437b725ae77Skettenis "wait returned unexpected PID %d", ret);
438b725ae77Skettenis else if (!WIFSTOPPED (status) || WSTOPSIG (status) != SIGSTOP)
439b725ae77Skettenis internal_error (__FILE__, __LINE__,
440b725ae77Skettenis "wait returned unexpected status 0x%x", status);
441b725ae77Skettenis }
442b725ae77Skettenis
443*11efff7fSkettenis if (event == PTRACE_EVENT_FORK)
444*11efff7fSkettenis ourstatus->kind = TARGET_WAITKIND_FORKED;
445*11efff7fSkettenis else if (event == PTRACE_EVENT_VFORK)
446*11efff7fSkettenis ourstatus->kind = TARGET_WAITKIND_VFORKED;
447*11efff7fSkettenis else
448*11efff7fSkettenis ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
449*11efff7fSkettenis
450b725ae77Skettenis ourstatus->value.related_pid = new_pid;
451b725ae77Skettenis return inferior_ptid;
452b725ae77Skettenis }
453b725ae77Skettenis
454b725ae77Skettenis if (event == PTRACE_EVENT_EXEC)
455b725ae77Skettenis {
456b725ae77Skettenis ourstatus->kind = TARGET_WAITKIND_EXECD;
457b725ae77Skettenis ourstatus->value.execd_pathname
458b725ae77Skettenis = xstrdup (child_pid_to_exec_file (pid));
459b725ae77Skettenis
460b725ae77Skettenis if (linux_parent_pid)
461b725ae77Skettenis {
462b725ae77Skettenis detach_breakpoints (linux_parent_pid);
463b725ae77Skettenis ptrace (PTRACE_DETACH, linux_parent_pid, 0, 0);
464b725ae77Skettenis
465b725ae77Skettenis linux_parent_pid = 0;
466b725ae77Skettenis }
467b725ae77Skettenis
468b725ae77Skettenis return inferior_ptid;
469b725ae77Skettenis }
470b725ae77Skettenis
471b725ae77Skettenis internal_error (__FILE__, __LINE__,
472b725ae77Skettenis "unknown ptrace event %d", event);
473b725ae77Skettenis }
474b725ae77Skettenis
475b725ae77Skettenis
476b725ae77Skettenis int
child_insert_fork_catchpoint(int pid)477b725ae77Skettenis child_insert_fork_catchpoint (int pid)
478b725ae77Skettenis {
479b725ae77Skettenis if (! linux_supports_tracefork ())
480b725ae77Skettenis error ("Your system does not support fork catchpoints.");
481b725ae77Skettenis
482b725ae77Skettenis return 0;
483b725ae77Skettenis }
484b725ae77Skettenis
485b725ae77Skettenis int
child_insert_vfork_catchpoint(int pid)486b725ae77Skettenis child_insert_vfork_catchpoint (int pid)
487b725ae77Skettenis {
488b725ae77Skettenis if (!linux_supports_tracefork ())
489b725ae77Skettenis error ("Your system does not support vfork catchpoints.");
490b725ae77Skettenis
491b725ae77Skettenis return 0;
492b725ae77Skettenis }
493b725ae77Skettenis
494b725ae77Skettenis int
child_insert_exec_catchpoint(int pid)495b725ae77Skettenis child_insert_exec_catchpoint (int pid)
496b725ae77Skettenis {
497b725ae77Skettenis if (!linux_supports_tracefork ())
498b725ae77Skettenis error ("Your system does not support exec catchpoints.");
499b725ae77Skettenis
500b725ae77Skettenis return 0;
501b725ae77Skettenis }
502b725ae77Skettenis
503b725ae77Skettenis void
kill_inferior(void)504b725ae77Skettenis kill_inferior (void)
505b725ae77Skettenis {
506b725ae77Skettenis int status;
507b725ae77Skettenis int pid = PIDGET (inferior_ptid);
508b725ae77Skettenis struct target_waitstatus last;
509b725ae77Skettenis ptid_t last_ptid;
510b725ae77Skettenis int ret;
511b725ae77Skettenis
512b725ae77Skettenis if (pid == 0)
513b725ae77Skettenis return;
514b725ae77Skettenis
515b725ae77Skettenis /* If we're stopped while forking and we haven't followed yet, kill the
516b725ae77Skettenis other task. We need to do this first because the parent will be
517b725ae77Skettenis sleeping if this is a vfork. */
518b725ae77Skettenis
519b725ae77Skettenis get_last_target_status (&last_ptid, &last);
520b725ae77Skettenis
521b725ae77Skettenis if (last.kind == TARGET_WAITKIND_FORKED
522b725ae77Skettenis || last.kind == TARGET_WAITKIND_VFORKED)
523b725ae77Skettenis {
524*11efff7fSkettenis ptrace (PT_KILL, last.value.related_pid, 0, 0);
525*11efff7fSkettenis wait (&status);
526b725ae77Skettenis }
527b725ae77Skettenis
528b725ae77Skettenis /* Kill the current process. */
529*11efff7fSkettenis ptrace (PT_KILL, pid, 0, 0);
530*11efff7fSkettenis ret = wait (&status);
531b725ae77Skettenis
532b725ae77Skettenis /* We might get a SIGCHLD instead of an exit status. This is
533b725ae77Skettenis aggravated by the first kill above - a child has just died. */
534b725ae77Skettenis
535b725ae77Skettenis while (ret == pid && WIFSTOPPED (status))
536b725ae77Skettenis {
537*11efff7fSkettenis ptrace (PT_KILL, pid, 0, 0);
538*11efff7fSkettenis ret = wait (&status);
539b725ae77Skettenis }
540b725ae77Skettenis
541b725ae77Skettenis target_mourn_inferior ();
542b725ae77Skettenis }
543*11efff7fSkettenis
544*11efff7fSkettenis /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
545*11efff7fSkettenis are processes sharing the same VM space. A multi-threaded process
546*11efff7fSkettenis is basically a group of such processes. However, such a grouping
547*11efff7fSkettenis is almost entirely a user-space issue; the kernel doesn't enforce
548*11efff7fSkettenis such a grouping at all (this might change in the future). In
549*11efff7fSkettenis general, we'll rely on the threads library (i.e. the GNU/Linux
550*11efff7fSkettenis Threads library) to provide such a grouping.
551*11efff7fSkettenis
552*11efff7fSkettenis It is perfectly well possible to write a multi-threaded application
553*11efff7fSkettenis without the assistance of a threads library, by using the clone
554*11efff7fSkettenis system call directly. This module should be able to give some
555*11efff7fSkettenis rudimentary support for debugging such applications if developers
556*11efff7fSkettenis specify the CLONE_PTRACE flag in the clone system call, and are
557*11efff7fSkettenis using the Linux kernel 2.4 or above.
558*11efff7fSkettenis
559*11efff7fSkettenis Note that there are some peculiarities in GNU/Linux that affect
560*11efff7fSkettenis this code:
561*11efff7fSkettenis
562*11efff7fSkettenis - In general one should specify the __WCLONE flag to waitpid in
563*11efff7fSkettenis order to make it report events for any of the cloned processes
564*11efff7fSkettenis (and leave it out for the initial process). However, if a cloned
565*11efff7fSkettenis process has exited the exit status is only reported if the
566*11efff7fSkettenis __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
567*11efff7fSkettenis we cannot use it since GDB must work on older systems too.
568*11efff7fSkettenis
569*11efff7fSkettenis - When a traced, cloned process exits and is waited for by the
570*11efff7fSkettenis debugger, the kernel reassigns it to the original parent and
571*11efff7fSkettenis keeps it around as a "zombie". Somehow, the GNU/Linux Threads
572*11efff7fSkettenis library doesn't notice this, which leads to the "zombie problem":
573*11efff7fSkettenis When debugged a multi-threaded process that spawns a lot of
574*11efff7fSkettenis threads will run out of processes, even if the threads exit,
575*11efff7fSkettenis because the "zombies" stay around. */
576*11efff7fSkettenis
577*11efff7fSkettenis /* List of known LWPs. */
578*11efff7fSkettenis static struct lwp_info *lwp_list;
579*11efff7fSkettenis
580*11efff7fSkettenis /* Number of LWPs in the list. */
581*11efff7fSkettenis static int num_lwps;
582*11efff7fSkettenis
583*11efff7fSkettenis /* Non-zero if we're running in "threaded" mode. */
584*11efff7fSkettenis static int threaded;
585*11efff7fSkettenis
586*11efff7fSkettenis
587*11efff7fSkettenis #define GET_LWP(ptid) ptid_get_lwp (ptid)
588*11efff7fSkettenis #define GET_PID(ptid) ptid_get_pid (ptid)
589*11efff7fSkettenis #define is_lwp(ptid) (GET_LWP (ptid) != 0)
590*11efff7fSkettenis #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
591*11efff7fSkettenis
592*11efff7fSkettenis /* If the last reported event was a SIGTRAP, this variable is set to
593*11efff7fSkettenis the process id of the LWP/thread that got it. */
594*11efff7fSkettenis ptid_t trap_ptid;
595*11efff7fSkettenis
596*11efff7fSkettenis
597*11efff7fSkettenis /* This module's target-specific operations. */
598*11efff7fSkettenis static struct target_ops linux_nat_ops;
599*11efff7fSkettenis
600*11efff7fSkettenis /* Since we cannot wait (in linux_nat_wait) for the initial process and
601*11efff7fSkettenis any cloned processes with a single call to waitpid, we have to use
602*11efff7fSkettenis the WNOHANG flag and call waitpid in a loop. To optimize
603*11efff7fSkettenis things a bit we use `sigsuspend' to wake us up when a process has
604*11efff7fSkettenis something to report (it will send us a SIGCHLD if it has). To make
605*11efff7fSkettenis this work we have to juggle with the signal mask. We save the
606*11efff7fSkettenis original signal mask such that we can restore it before creating a
607*11efff7fSkettenis new process in order to avoid blocking certain signals in the
608*11efff7fSkettenis inferior. We then block SIGCHLD during the waitpid/sigsuspend
609*11efff7fSkettenis loop. */
610*11efff7fSkettenis
611*11efff7fSkettenis /* Original signal mask. */
612*11efff7fSkettenis static sigset_t normal_mask;
613*11efff7fSkettenis
614*11efff7fSkettenis /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
615*11efff7fSkettenis _initialize_linux_nat. */
616*11efff7fSkettenis static sigset_t suspend_mask;
617*11efff7fSkettenis
618*11efff7fSkettenis /* Signals to block to make that sigsuspend work. */
619*11efff7fSkettenis static sigset_t blocked_mask;
620*11efff7fSkettenis
621*11efff7fSkettenis
622*11efff7fSkettenis /* Prototypes for local functions. */
623*11efff7fSkettenis static int stop_wait_callback (struct lwp_info *lp, void *data);
624*11efff7fSkettenis static int linux_nat_thread_alive (ptid_t ptid);
625*11efff7fSkettenis
626*11efff7fSkettenis /* Convert wait status STATUS to a string. Used for printing debug
627*11efff7fSkettenis messages only. */
628*11efff7fSkettenis
629*11efff7fSkettenis static char *
status_to_str(int status)630*11efff7fSkettenis status_to_str (int status)
631*11efff7fSkettenis {
632*11efff7fSkettenis static char buf[64];
633*11efff7fSkettenis
634*11efff7fSkettenis if (WIFSTOPPED (status))
635*11efff7fSkettenis snprintf (buf, sizeof (buf), "%s (stopped)",
636*11efff7fSkettenis strsignal (WSTOPSIG (status)));
637*11efff7fSkettenis else if (WIFSIGNALED (status))
638*11efff7fSkettenis snprintf (buf, sizeof (buf), "%s (terminated)",
639*11efff7fSkettenis strsignal (WSTOPSIG (status)));
640*11efff7fSkettenis else
641*11efff7fSkettenis snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
642*11efff7fSkettenis
643*11efff7fSkettenis return buf;
644*11efff7fSkettenis }
645*11efff7fSkettenis
646*11efff7fSkettenis /* Initialize the list of LWPs. Note that this module, contrary to
647*11efff7fSkettenis what GDB's generic threads layer does for its thread list,
648*11efff7fSkettenis re-initializes the LWP lists whenever we mourn or detach (which
649*11efff7fSkettenis doesn't involve mourning) the inferior. */
650*11efff7fSkettenis
651*11efff7fSkettenis static void
init_lwp_list(void)652*11efff7fSkettenis init_lwp_list (void)
653*11efff7fSkettenis {
654*11efff7fSkettenis struct lwp_info *lp, *lpnext;
655*11efff7fSkettenis
656*11efff7fSkettenis for (lp = lwp_list; lp; lp = lpnext)
657*11efff7fSkettenis {
658*11efff7fSkettenis lpnext = lp->next;
659*11efff7fSkettenis xfree (lp);
660*11efff7fSkettenis }
661*11efff7fSkettenis
662*11efff7fSkettenis lwp_list = NULL;
663*11efff7fSkettenis num_lwps = 0;
664*11efff7fSkettenis threaded = 0;
665*11efff7fSkettenis }
666*11efff7fSkettenis
667*11efff7fSkettenis /* Add the LWP specified by PID to the list. If this causes the
668*11efff7fSkettenis number of LWPs to become larger than one, go into "threaded" mode.
669*11efff7fSkettenis Return a pointer to the structure describing the new LWP. */
670*11efff7fSkettenis
671*11efff7fSkettenis static struct lwp_info *
add_lwp(ptid_t ptid)672*11efff7fSkettenis add_lwp (ptid_t ptid)
673*11efff7fSkettenis {
674*11efff7fSkettenis struct lwp_info *lp;
675*11efff7fSkettenis
676*11efff7fSkettenis gdb_assert (is_lwp (ptid));
677*11efff7fSkettenis
678*11efff7fSkettenis lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
679*11efff7fSkettenis
680*11efff7fSkettenis memset (lp, 0, sizeof (struct lwp_info));
681*11efff7fSkettenis
682*11efff7fSkettenis lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
683*11efff7fSkettenis
684*11efff7fSkettenis lp->ptid = ptid;
685*11efff7fSkettenis
686*11efff7fSkettenis lp->next = lwp_list;
687*11efff7fSkettenis lwp_list = lp;
688*11efff7fSkettenis if (++num_lwps > 1)
689*11efff7fSkettenis threaded = 1;
690*11efff7fSkettenis
691*11efff7fSkettenis return lp;
692*11efff7fSkettenis }
693*11efff7fSkettenis
694*11efff7fSkettenis /* Remove the LWP specified by PID from the list. */
695*11efff7fSkettenis
696*11efff7fSkettenis static void
delete_lwp(ptid_t ptid)697*11efff7fSkettenis delete_lwp (ptid_t ptid)
698*11efff7fSkettenis {
699*11efff7fSkettenis struct lwp_info *lp, *lpprev;
700*11efff7fSkettenis
701*11efff7fSkettenis lpprev = NULL;
702*11efff7fSkettenis
703*11efff7fSkettenis for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
704*11efff7fSkettenis if (ptid_equal (lp->ptid, ptid))
705*11efff7fSkettenis break;
706*11efff7fSkettenis
707*11efff7fSkettenis if (!lp)
708*11efff7fSkettenis return;
709*11efff7fSkettenis
710*11efff7fSkettenis /* We don't go back to "non-threaded" mode if the number of threads
711*11efff7fSkettenis becomes less than two. */
712*11efff7fSkettenis num_lwps--;
713*11efff7fSkettenis
714*11efff7fSkettenis if (lpprev)
715*11efff7fSkettenis lpprev->next = lp->next;
716*11efff7fSkettenis else
717*11efff7fSkettenis lwp_list = lp->next;
718*11efff7fSkettenis
719*11efff7fSkettenis xfree (lp);
720*11efff7fSkettenis }
721*11efff7fSkettenis
722*11efff7fSkettenis /* Return a pointer to the structure describing the LWP corresponding
723*11efff7fSkettenis to PID. If no corresponding LWP could be found, return NULL. */
724*11efff7fSkettenis
725*11efff7fSkettenis static struct lwp_info *
find_lwp_pid(ptid_t ptid)726*11efff7fSkettenis find_lwp_pid (ptid_t ptid)
727*11efff7fSkettenis {
728*11efff7fSkettenis struct lwp_info *lp;
729*11efff7fSkettenis int lwp;
730*11efff7fSkettenis
731*11efff7fSkettenis if (is_lwp (ptid))
732*11efff7fSkettenis lwp = GET_LWP (ptid);
733*11efff7fSkettenis else
734*11efff7fSkettenis lwp = GET_PID (ptid);
735*11efff7fSkettenis
736*11efff7fSkettenis for (lp = lwp_list; lp; lp = lp->next)
737*11efff7fSkettenis if (lwp == GET_LWP (lp->ptid))
738*11efff7fSkettenis return lp;
739*11efff7fSkettenis
740*11efff7fSkettenis return NULL;
741*11efff7fSkettenis }
742*11efff7fSkettenis
743*11efff7fSkettenis /* Call CALLBACK with its second argument set to DATA for every LWP in
744*11efff7fSkettenis the list. If CALLBACK returns 1 for a particular LWP, return a
745*11efff7fSkettenis pointer to the structure describing that LWP immediately.
746*11efff7fSkettenis Otherwise return NULL. */
747*11efff7fSkettenis
748*11efff7fSkettenis struct lwp_info *
iterate_over_lwps(int (* callback)(struct lwp_info *,void *),void * data)749*11efff7fSkettenis iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data)
750*11efff7fSkettenis {
751*11efff7fSkettenis struct lwp_info *lp, *lpnext;
752*11efff7fSkettenis
753*11efff7fSkettenis for (lp = lwp_list; lp; lp = lpnext)
754*11efff7fSkettenis {
755*11efff7fSkettenis lpnext = lp->next;
756*11efff7fSkettenis if ((*callback) (lp, data))
757*11efff7fSkettenis return lp;
758*11efff7fSkettenis }
759*11efff7fSkettenis
760*11efff7fSkettenis return NULL;
761*11efff7fSkettenis }
762*11efff7fSkettenis
763*11efff7fSkettenis /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
764*11efff7fSkettenis a message telling the user that a new LWP has been added to the
765*11efff7fSkettenis process. */
766*11efff7fSkettenis
767*11efff7fSkettenis void
lin_lwp_attach_lwp(ptid_t ptid,int verbose)768*11efff7fSkettenis lin_lwp_attach_lwp (ptid_t ptid, int verbose)
769*11efff7fSkettenis {
770*11efff7fSkettenis struct lwp_info *lp, *found_lp;
771*11efff7fSkettenis
772*11efff7fSkettenis gdb_assert (is_lwp (ptid));
773*11efff7fSkettenis
774*11efff7fSkettenis /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
775*11efff7fSkettenis to interrupt either the ptrace() or waitpid() calls below. */
776*11efff7fSkettenis if (!sigismember (&blocked_mask, SIGCHLD))
777*11efff7fSkettenis {
778*11efff7fSkettenis sigaddset (&blocked_mask, SIGCHLD);
779*11efff7fSkettenis sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
780*11efff7fSkettenis }
781*11efff7fSkettenis
782*11efff7fSkettenis if (verbose)
783*11efff7fSkettenis printf_filtered ("[New %s]\n", target_pid_to_str (ptid));
784*11efff7fSkettenis
785*11efff7fSkettenis found_lp = lp = find_lwp_pid (ptid);
786*11efff7fSkettenis if (lp == NULL)
787*11efff7fSkettenis lp = add_lwp (ptid);
788*11efff7fSkettenis
789*11efff7fSkettenis /* We assume that we're already attached to any LWP that has an id
790*11efff7fSkettenis equal to the overall process id, and to any LWP that is already
791*11efff7fSkettenis in our list of LWPs. If we're not seeing exit events from threads
792*11efff7fSkettenis and we've had PID wraparound since we last tried to stop all threads,
793*11efff7fSkettenis this assumption might be wrong; fortunately, this is very unlikely
794*11efff7fSkettenis to happen. */
795*11efff7fSkettenis if (GET_LWP (ptid) != GET_PID (ptid) && found_lp == NULL)
796*11efff7fSkettenis {
797*11efff7fSkettenis pid_t pid;
798*11efff7fSkettenis int status;
799*11efff7fSkettenis
800*11efff7fSkettenis if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
801*11efff7fSkettenis error ("Can't attach %s: %s", target_pid_to_str (ptid),
802*11efff7fSkettenis safe_strerror (errno));
803*11efff7fSkettenis
804*11efff7fSkettenis if (debug_linux_nat)
805*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
806*11efff7fSkettenis "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
807*11efff7fSkettenis target_pid_to_str (ptid));
808*11efff7fSkettenis
809*11efff7fSkettenis pid = waitpid (GET_LWP (ptid), &status, 0);
810*11efff7fSkettenis if (pid == -1 && errno == ECHILD)
811*11efff7fSkettenis {
812*11efff7fSkettenis /* Try again with __WCLONE to check cloned processes. */
813*11efff7fSkettenis pid = waitpid (GET_LWP (ptid), &status, __WCLONE);
814*11efff7fSkettenis lp->cloned = 1;
815*11efff7fSkettenis }
816*11efff7fSkettenis
817*11efff7fSkettenis gdb_assert (pid == GET_LWP (ptid)
818*11efff7fSkettenis && WIFSTOPPED (status) && WSTOPSIG (status));
819*11efff7fSkettenis
820*11efff7fSkettenis child_post_attach (pid);
821*11efff7fSkettenis
822*11efff7fSkettenis lp->stopped = 1;
823*11efff7fSkettenis
824*11efff7fSkettenis if (debug_linux_nat)
825*11efff7fSkettenis {
826*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
827*11efff7fSkettenis "LLAL: waitpid %s received %s\n",
828*11efff7fSkettenis target_pid_to_str (ptid),
829*11efff7fSkettenis status_to_str (status));
830*11efff7fSkettenis }
831*11efff7fSkettenis }
832*11efff7fSkettenis else
833*11efff7fSkettenis {
834*11efff7fSkettenis /* We assume that the LWP representing the original process is
835*11efff7fSkettenis already stopped. Mark it as stopped in the data structure
836*11efff7fSkettenis that the linux ptrace layer uses to keep track of threads.
837*11efff7fSkettenis Note that this won't have already been done since the main
838*11efff7fSkettenis thread will have, we assume, been stopped by an attach from a
839*11efff7fSkettenis different layer. */
840*11efff7fSkettenis lp->stopped = 1;
841*11efff7fSkettenis }
842*11efff7fSkettenis }
843*11efff7fSkettenis
844*11efff7fSkettenis static void
linux_nat_attach(char * args,int from_tty)845*11efff7fSkettenis linux_nat_attach (char *args, int from_tty)
846*11efff7fSkettenis {
847*11efff7fSkettenis struct lwp_info *lp;
848*11efff7fSkettenis pid_t pid;
849*11efff7fSkettenis int status;
850*11efff7fSkettenis
851*11efff7fSkettenis /* FIXME: We should probably accept a list of process id's, and
852*11efff7fSkettenis attach all of them. */
853*11efff7fSkettenis deprecated_child_ops.to_attach (args, from_tty);
854*11efff7fSkettenis
855*11efff7fSkettenis /* Add the initial process as the first LWP to the list. */
856*11efff7fSkettenis lp = add_lwp (BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid)));
857*11efff7fSkettenis
858*11efff7fSkettenis /* Make sure the initial process is stopped. The user-level threads
859*11efff7fSkettenis layer might want to poke around in the inferior, and that won't
860*11efff7fSkettenis work if things haven't stabilized yet. */
861*11efff7fSkettenis pid = waitpid (GET_PID (inferior_ptid), &status, 0);
862*11efff7fSkettenis if (pid == -1 && errno == ECHILD)
863*11efff7fSkettenis {
864*11efff7fSkettenis warning ("%s is a cloned process", target_pid_to_str (inferior_ptid));
865*11efff7fSkettenis
866*11efff7fSkettenis /* Try again with __WCLONE to check cloned processes. */
867*11efff7fSkettenis pid = waitpid (GET_PID (inferior_ptid), &status, __WCLONE);
868*11efff7fSkettenis lp->cloned = 1;
869*11efff7fSkettenis }
870*11efff7fSkettenis
871*11efff7fSkettenis gdb_assert (pid == GET_PID (inferior_ptid)
872*11efff7fSkettenis && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP);
873*11efff7fSkettenis
874*11efff7fSkettenis lp->stopped = 1;
875*11efff7fSkettenis
876*11efff7fSkettenis /* Fake the SIGSTOP that core GDB expects. */
877*11efff7fSkettenis lp->status = W_STOPCODE (SIGSTOP);
878*11efff7fSkettenis lp->resumed = 1;
879*11efff7fSkettenis if (debug_linux_nat)
880*11efff7fSkettenis {
881*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
882*11efff7fSkettenis "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid);
883*11efff7fSkettenis }
884*11efff7fSkettenis }
885*11efff7fSkettenis
886*11efff7fSkettenis static int
detach_callback(struct lwp_info * lp,void * data)887*11efff7fSkettenis detach_callback (struct lwp_info *lp, void *data)
888*11efff7fSkettenis {
889*11efff7fSkettenis gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
890*11efff7fSkettenis
891*11efff7fSkettenis if (debug_linux_nat && lp->status)
892*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
893*11efff7fSkettenis strsignal (WSTOPSIG (lp->status)),
894*11efff7fSkettenis target_pid_to_str (lp->ptid));
895*11efff7fSkettenis
896*11efff7fSkettenis while (lp->signalled && lp->stopped)
897*11efff7fSkettenis {
898*11efff7fSkettenis errno = 0;
899*11efff7fSkettenis if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0,
900*11efff7fSkettenis WSTOPSIG (lp->status)) < 0)
901*11efff7fSkettenis error ("Can't continue %s: %s", target_pid_to_str (lp->ptid),
902*11efff7fSkettenis safe_strerror (errno));
903*11efff7fSkettenis
904*11efff7fSkettenis if (debug_linux_nat)
905*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
906*11efff7fSkettenis "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
907*11efff7fSkettenis target_pid_to_str (lp->ptid),
908*11efff7fSkettenis status_to_str (lp->status));
909*11efff7fSkettenis
910*11efff7fSkettenis lp->stopped = 0;
911*11efff7fSkettenis lp->signalled = 0;
912*11efff7fSkettenis lp->status = 0;
913*11efff7fSkettenis /* FIXME drow/2003-08-26: There was a call to stop_wait_callback
914*11efff7fSkettenis here. But since lp->signalled was cleared above,
915*11efff7fSkettenis stop_wait_callback didn't do anything; the process was left
916*11efff7fSkettenis running. Shouldn't we be waiting for it to stop?
917*11efff7fSkettenis I've removed the call, since stop_wait_callback now does do
918*11efff7fSkettenis something when called with lp->signalled == 0. */
919*11efff7fSkettenis
920*11efff7fSkettenis gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
921*11efff7fSkettenis }
922*11efff7fSkettenis
923*11efff7fSkettenis /* We don't actually detach from the LWP that has an id equal to the
924*11efff7fSkettenis overall process id just yet. */
925*11efff7fSkettenis if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
926*11efff7fSkettenis {
927*11efff7fSkettenis errno = 0;
928*11efff7fSkettenis if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
929*11efff7fSkettenis WSTOPSIG (lp->status)) < 0)
930*11efff7fSkettenis error ("Can't detach %s: %s", target_pid_to_str (lp->ptid),
931*11efff7fSkettenis safe_strerror (errno));
932*11efff7fSkettenis
933*11efff7fSkettenis if (debug_linux_nat)
934*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
935*11efff7fSkettenis "PTRACE_DETACH (%s, %s, 0) (OK)\n",
936*11efff7fSkettenis target_pid_to_str (lp->ptid),
937*11efff7fSkettenis strsignal (WSTOPSIG (lp->status)));
938*11efff7fSkettenis
939*11efff7fSkettenis delete_lwp (lp->ptid);
940*11efff7fSkettenis }
941*11efff7fSkettenis
942*11efff7fSkettenis return 0;
943*11efff7fSkettenis }
944*11efff7fSkettenis
945*11efff7fSkettenis static void
linux_nat_detach(char * args,int from_tty)946*11efff7fSkettenis linux_nat_detach (char *args, int from_tty)
947*11efff7fSkettenis {
948*11efff7fSkettenis iterate_over_lwps (detach_callback, NULL);
949*11efff7fSkettenis
950*11efff7fSkettenis /* Only the initial process should be left right now. */
951*11efff7fSkettenis gdb_assert (num_lwps == 1);
952*11efff7fSkettenis
953*11efff7fSkettenis trap_ptid = null_ptid;
954*11efff7fSkettenis
955*11efff7fSkettenis /* Destroy LWP info; it's no longer valid. */
956*11efff7fSkettenis init_lwp_list ();
957*11efff7fSkettenis
958*11efff7fSkettenis /* Restore the original signal mask. */
959*11efff7fSkettenis sigprocmask (SIG_SETMASK, &normal_mask, NULL);
960*11efff7fSkettenis sigemptyset (&blocked_mask);
961*11efff7fSkettenis
962*11efff7fSkettenis inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
963*11efff7fSkettenis deprecated_child_ops.to_detach (args, from_tty);
964*11efff7fSkettenis }
965*11efff7fSkettenis
966*11efff7fSkettenis /* Resume LP. */
967*11efff7fSkettenis
968*11efff7fSkettenis static int
resume_callback(struct lwp_info * lp,void * data)969*11efff7fSkettenis resume_callback (struct lwp_info *lp, void *data)
970*11efff7fSkettenis {
971*11efff7fSkettenis if (lp->stopped && lp->status == 0)
972*11efff7fSkettenis {
973*11efff7fSkettenis struct thread_info *tp;
974*11efff7fSkettenis
975*11efff7fSkettenis child_resume (pid_to_ptid (GET_LWP (lp->ptid)), 0, TARGET_SIGNAL_0);
976*11efff7fSkettenis if (debug_linux_nat)
977*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
978*11efff7fSkettenis "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
979*11efff7fSkettenis target_pid_to_str (lp->ptid));
980*11efff7fSkettenis lp->stopped = 0;
981*11efff7fSkettenis lp->step = 0;
982*11efff7fSkettenis }
983*11efff7fSkettenis
984*11efff7fSkettenis return 0;
985*11efff7fSkettenis }
986*11efff7fSkettenis
987*11efff7fSkettenis static int
resume_clear_callback(struct lwp_info * lp,void * data)988*11efff7fSkettenis resume_clear_callback (struct lwp_info *lp, void *data)
989*11efff7fSkettenis {
990*11efff7fSkettenis lp->resumed = 0;
991*11efff7fSkettenis return 0;
992*11efff7fSkettenis }
993*11efff7fSkettenis
994*11efff7fSkettenis static int
resume_set_callback(struct lwp_info * lp,void * data)995*11efff7fSkettenis resume_set_callback (struct lwp_info *lp, void *data)
996*11efff7fSkettenis {
997*11efff7fSkettenis lp->resumed = 1;
998*11efff7fSkettenis return 0;
999*11efff7fSkettenis }
1000*11efff7fSkettenis
1001*11efff7fSkettenis static void
linux_nat_resume(ptid_t ptid,int step,enum target_signal signo)1002*11efff7fSkettenis linux_nat_resume (ptid_t ptid, int step, enum target_signal signo)
1003*11efff7fSkettenis {
1004*11efff7fSkettenis struct lwp_info *lp;
1005*11efff7fSkettenis int resume_all;
1006*11efff7fSkettenis
1007*11efff7fSkettenis /* A specific PTID means `step only this process id'. */
1008*11efff7fSkettenis resume_all = (PIDGET (ptid) == -1);
1009*11efff7fSkettenis
1010*11efff7fSkettenis if (resume_all)
1011*11efff7fSkettenis iterate_over_lwps (resume_set_callback, NULL);
1012*11efff7fSkettenis else
1013*11efff7fSkettenis iterate_over_lwps (resume_clear_callback, NULL);
1014*11efff7fSkettenis
1015*11efff7fSkettenis /* If PID is -1, it's the current inferior that should be
1016*11efff7fSkettenis handled specially. */
1017*11efff7fSkettenis if (PIDGET (ptid) == -1)
1018*11efff7fSkettenis ptid = inferior_ptid;
1019*11efff7fSkettenis
1020*11efff7fSkettenis lp = find_lwp_pid (ptid);
1021*11efff7fSkettenis if (lp)
1022*11efff7fSkettenis {
1023*11efff7fSkettenis ptid = pid_to_ptid (GET_LWP (lp->ptid));
1024*11efff7fSkettenis
1025*11efff7fSkettenis /* Remember if we're stepping. */
1026*11efff7fSkettenis lp->step = step;
1027*11efff7fSkettenis
1028*11efff7fSkettenis /* Mark this LWP as resumed. */
1029*11efff7fSkettenis lp->resumed = 1;
1030*11efff7fSkettenis
1031*11efff7fSkettenis /* If we have a pending wait status for this thread, there is no
1032*11efff7fSkettenis point in resuming the process. */
1033*11efff7fSkettenis if (lp->status)
1034*11efff7fSkettenis {
1035*11efff7fSkettenis /* FIXME: What should we do if we are supposed to continue
1036*11efff7fSkettenis this thread with a signal? */
1037*11efff7fSkettenis gdb_assert (signo == TARGET_SIGNAL_0);
1038*11efff7fSkettenis return;
1039*11efff7fSkettenis }
1040*11efff7fSkettenis
1041*11efff7fSkettenis /* Mark LWP as not stopped to prevent it from being continued by
1042*11efff7fSkettenis resume_callback. */
1043*11efff7fSkettenis lp->stopped = 0;
1044*11efff7fSkettenis }
1045*11efff7fSkettenis
1046*11efff7fSkettenis if (resume_all)
1047*11efff7fSkettenis iterate_over_lwps (resume_callback, NULL);
1048*11efff7fSkettenis
1049*11efff7fSkettenis child_resume (ptid, step, signo);
1050*11efff7fSkettenis if (debug_linux_nat)
1051*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1052*11efff7fSkettenis "LLR: %s %s, %s (resume event thread)\n",
1053*11efff7fSkettenis step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1054*11efff7fSkettenis target_pid_to_str (ptid),
1055*11efff7fSkettenis signo ? strsignal (signo) : "0");
1056*11efff7fSkettenis }
1057*11efff7fSkettenis
1058*11efff7fSkettenis /* Issue kill to specified lwp. */
1059*11efff7fSkettenis
1060*11efff7fSkettenis static int tkill_failed;
1061*11efff7fSkettenis
1062*11efff7fSkettenis static int
kill_lwp(int lwpid,int signo)1063*11efff7fSkettenis kill_lwp (int lwpid, int signo)
1064*11efff7fSkettenis {
1065*11efff7fSkettenis errno = 0;
1066*11efff7fSkettenis
1067*11efff7fSkettenis /* Use tkill, if possible, in case we are using nptl threads. If tkill
1068*11efff7fSkettenis fails, then we are not using nptl threads and we should be using kill. */
1069*11efff7fSkettenis
1070*11efff7fSkettenis #ifdef HAVE_TKILL_SYSCALL
1071*11efff7fSkettenis if (!tkill_failed)
1072*11efff7fSkettenis {
1073*11efff7fSkettenis int ret = syscall (__NR_tkill, lwpid, signo);
1074*11efff7fSkettenis if (errno != ENOSYS)
1075*11efff7fSkettenis return ret;
1076*11efff7fSkettenis errno = 0;
1077*11efff7fSkettenis tkill_failed = 1;
1078*11efff7fSkettenis }
1079*11efff7fSkettenis #endif
1080*11efff7fSkettenis
1081*11efff7fSkettenis return kill (lwpid, signo);
1082*11efff7fSkettenis }
1083*11efff7fSkettenis
1084*11efff7fSkettenis /* Handle a GNU/Linux extended wait response. Most of the work we
1085*11efff7fSkettenis just pass off to linux_handle_extended_wait, but if it reports a
1086*11efff7fSkettenis clone event we need to add the new LWP to our list (and not report
1087*11efff7fSkettenis the trap to higher layers). This function returns non-zero if
1088*11efff7fSkettenis the event should be ignored and we should wait again. */
1089*11efff7fSkettenis
1090*11efff7fSkettenis static int
linux_nat_handle_extended(struct lwp_info * lp,int status)1091*11efff7fSkettenis linux_nat_handle_extended (struct lwp_info *lp, int status)
1092*11efff7fSkettenis {
1093*11efff7fSkettenis linux_handle_extended_wait (GET_LWP (lp->ptid), status,
1094*11efff7fSkettenis &lp->waitstatus);
1095*11efff7fSkettenis
1096*11efff7fSkettenis /* TARGET_WAITKIND_SPURIOUS is used to indicate clone events. */
1097*11efff7fSkettenis if (lp->waitstatus.kind == TARGET_WAITKIND_SPURIOUS)
1098*11efff7fSkettenis {
1099*11efff7fSkettenis struct lwp_info *new_lp;
1100*11efff7fSkettenis new_lp = add_lwp (BUILD_LWP (lp->waitstatus.value.related_pid,
1101*11efff7fSkettenis GET_PID (inferior_ptid)));
1102*11efff7fSkettenis new_lp->cloned = 1;
1103*11efff7fSkettenis new_lp->stopped = 1;
1104*11efff7fSkettenis
1105*11efff7fSkettenis lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
1106*11efff7fSkettenis
1107*11efff7fSkettenis if (debug_linux_nat)
1108*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1109*11efff7fSkettenis "LLHE: Got clone event from LWP %ld, resuming\n",
1110*11efff7fSkettenis GET_LWP (lp->ptid));
1111*11efff7fSkettenis ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1112*11efff7fSkettenis
1113*11efff7fSkettenis return 1;
1114*11efff7fSkettenis }
1115*11efff7fSkettenis
1116*11efff7fSkettenis return 0;
1117*11efff7fSkettenis }
1118*11efff7fSkettenis
1119*11efff7fSkettenis /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1120*11efff7fSkettenis exited. */
1121*11efff7fSkettenis
1122*11efff7fSkettenis static int
wait_lwp(struct lwp_info * lp)1123*11efff7fSkettenis wait_lwp (struct lwp_info *lp)
1124*11efff7fSkettenis {
1125*11efff7fSkettenis pid_t pid;
1126*11efff7fSkettenis int status;
1127*11efff7fSkettenis int thread_dead = 0;
1128*11efff7fSkettenis
1129*11efff7fSkettenis gdb_assert (!lp->stopped);
1130*11efff7fSkettenis gdb_assert (lp->status == 0);
1131*11efff7fSkettenis
1132*11efff7fSkettenis pid = waitpid (GET_LWP (lp->ptid), &status, 0);
1133*11efff7fSkettenis if (pid == -1 && errno == ECHILD)
1134*11efff7fSkettenis {
1135*11efff7fSkettenis pid = waitpid (GET_LWP (lp->ptid), &status, __WCLONE);
1136*11efff7fSkettenis if (pid == -1 && errno == ECHILD)
1137*11efff7fSkettenis {
1138*11efff7fSkettenis /* The thread has previously exited. We need to delete it
1139*11efff7fSkettenis now because, for some vendor 2.4 kernels with NPTL
1140*11efff7fSkettenis support backported, there won't be an exit event unless
1141*11efff7fSkettenis it is the main thread. 2.6 kernels will report an exit
1142*11efff7fSkettenis event for each thread that exits, as expected. */
1143*11efff7fSkettenis thread_dead = 1;
1144*11efff7fSkettenis if (debug_linux_nat)
1145*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
1146*11efff7fSkettenis target_pid_to_str (lp->ptid));
1147*11efff7fSkettenis }
1148*11efff7fSkettenis }
1149*11efff7fSkettenis
1150*11efff7fSkettenis if (!thread_dead)
1151*11efff7fSkettenis {
1152*11efff7fSkettenis gdb_assert (pid == GET_LWP (lp->ptid));
1153*11efff7fSkettenis
1154*11efff7fSkettenis if (debug_linux_nat)
1155*11efff7fSkettenis {
1156*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1157*11efff7fSkettenis "WL: waitpid %s received %s\n",
1158*11efff7fSkettenis target_pid_to_str (lp->ptid),
1159*11efff7fSkettenis status_to_str (status));
1160*11efff7fSkettenis }
1161*11efff7fSkettenis }
1162*11efff7fSkettenis
1163*11efff7fSkettenis /* Check if the thread has exited. */
1164*11efff7fSkettenis if (WIFEXITED (status) || WIFSIGNALED (status))
1165*11efff7fSkettenis {
1166*11efff7fSkettenis thread_dead = 1;
1167*11efff7fSkettenis if (debug_linux_nat)
1168*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
1169*11efff7fSkettenis target_pid_to_str (lp->ptid));
1170*11efff7fSkettenis }
1171*11efff7fSkettenis
1172*11efff7fSkettenis if (thread_dead)
1173*11efff7fSkettenis {
1174*11efff7fSkettenis if (in_thread_list (lp->ptid))
1175*11efff7fSkettenis {
1176*11efff7fSkettenis /* Core GDB cannot deal with us deleting the current thread. */
1177*11efff7fSkettenis if (!ptid_equal (lp->ptid, inferior_ptid))
1178*11efff7fSkettenis delete_thread (lp->ptid);
1179*11efff7fSkettenis printf_unfiltered ("[%s exited]\n",
1180*11efff7fSkettenis target_pid_to_str (lp->ptid));
1181*11efff7fSkettenis }
1182*11efff7fSkettenis
1183*11efff7fSkettenis delete_lwp (lp->ptid);
1184*11efff7fSkettenis return 0;
1185*11efff7fSkettenis }
1186*11efff7fSkettenis
1187*11efff7fSkettenis gdb_assert (WIFSTOPPED (status));
1188*11efff7fSkettenis
1189*11efff7fSkettenis /* Handle GNU/Linux's extended waitstatus for trace events. */
1190*11efff7fSkettenis if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
1191*11efff7fSkettenis {
1192*11efff7fSkettenis if (debug_linux_nat)
1193*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1194*11efff7fSkettenis "WL: Handling extended status 0x%06x\n",
1195*11efff7fSkettenis status);
1196*11efff7fSkettenis if (linux_nat_handle_extended (lp, status))
1197*11efff7fSkettenis return wait_lwp (lp);
1198*11efff7fSkettenis }
1199*11efff7fSkettenis
1200*11efff7fSkettenis return status;
1201*11efff7fSkettenis }
1202*11efff7fSkettenis
1203*11efff7fSkettenis /* Send a SIGSTOP to LP. */
1204*11efff7fSkettenis
1205*11efff7fSkettenis static int
stop_callback(struct lwp_info * lp,void * data)1206*11efff7fSkettenis stop_callback (struct lwp_info *lp, void *data)
1207*11efff7fSkettenis {
1208*11efff7fSkettenis if (!lp->stopped && !lp->signalled)
1209*11efff7fSkettenis {
1210*11efff7fSkettenis int ret;
1211*11efff7fSkettenis
1212*11efff7fSkettenis if (debug_linux_nat)
1213*11efff7fSkettenis {
1214*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1215*11efff7fSkettenis "SC: kill %s **<SIGSTOP>**\n",
1216*11efff7fSkettenis target_pid_to_str (lp->ptid));
1217*11efff7fSkettenis }
1218*11efff7fSkettenis errno = 0;
1219*11efff7fSkettenis ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP);
1220*11efff7fSkettenis if (debug_linux_nat)
1221*11efff7fSkettenis {
1222*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1223*11efff7fSkettenis "SC: lwp kill %d %s\n",
1224*11efff7fSkettenis ret,
1225*11efff7fSkettenis errno ? safe_strerror (errno) : "ERRNO-OK");
1226*11efff7fSkettenis }
1227*11efff7fSkettenis
1228*11efff7fSkettenis lp->signalled = 1;
1229*11efff7fSkettenis gdb_assert (lp->status == 0);
1230*11efff7fSkettenis }
1231*11efff7fSkettenis
1232*11efff7fSkettenis return 0;
1233*11efff7fSkettenis }
1234*11efff7fSkettenis
1235*11efff7fSkettenis /* Wait until LP is stopped. If DATA is non-null it is interpreted as
1236*11efff7fSkettenis a pointer to a set of signals to be flushed immediately. */
1237*11efff7fSkettenis
1238*11efff7fSkettenis static int
stop_wait_callback(struct lwp_info * lp,void * data)1239*11efff7fSkettenis stop_wait_callback (struct lwp_info *lp, void *data)
1240*11efff7fSkettenis {
1241*11efff7fSkettenis sigset_t *flush_mask = data;
1242*11efff7fSkettenis
1243*11efff7fSkettenis if (!lp->stopped)
1244*11efff7fSkettenis {
1245*11efff7fSkettenis int status;
1246*11efff7fSkettenis
1247*11efff7fSkettenis status = wait_lwp (lp);
1248*11efff7fSkettenis if (status == 0)
1249*11efff7fSkettenis return 0;
1250*11efff7fSkettenis
1251*11efff7fSkettenis /* Ignore any signals in FLUSH_MASK. */
1252*11efff7fSkettenis if (flush_mask && sigismember (flush_mask, WSTOPSIG (status)))
1253*11efff7fSkettenis {
1254*11efff7fSkettenis if (!lp->signalled)
1255*11efff7fSkettenis {
1256*11efff7fSkettenis lp->stopped = 1;
1257*11efff7fSkettenis return 0;
1258*11efff7fSkettenis }
1259*11efff7fSkettenis
1260*11efff7fSkettenis errno = 0;
1261*11efff7fSkettenis ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1262*11efff7fSkettenis if (debug_linux_nat)
1263*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1264*11efff7fSkettenis "PTRACE_CONT %s, 0, 0 (%s)\n",
1265*11efff7fSkettenis target_pid_to_str (lp->ptid),
1266*11efff7fSkettenis errno ? safe_strerror (errno) : "OK");
1267*11efff7fSkettenis
1268*11efff7fSkettenis return stop_wait_callback (lp, flush_mask);
1269*11efff7fSkettenis }
1270*11efff7fSkettenis
1271*11efff7fSkettenis if (WSTOPSIG (status) != SIGSTOP)
1272*11efff7fSkettenis {
1273*11efff7fSkettenis if (WSTOPSIG (status) == SIGTRAP)
1274*11efff7fSkettenis {
1275*11efff7fSkettenis /* If a LWP other than the LWP that we're reporting an
1276*11efff7fSkettenis event for has hit a GDB breakpoint (as opposed to
1277*11efff7fSkettenis some random trap signal), then just arrange for it to
1278*11efff7fSkettenis hit it again later. We don't keep the SIGTRAP status
1279*11efff7fSkettenis and don't forward the SIGTRAP signal to the LWP. We
1280*11efff7fSkettenis will handle the current event, eventually we will
1281*11efff7fSkettenis resume all LWPs, and this one will get its breakpoint
1282*11efff7fSkettenis trap again.
1283*11efff7fSkettenis
1284*11efff7fSkettenis If we do not do this, then we run the risk that the
1285*11efff7fSkettenis user will delete or disable the breakpoint, but the
1286*11efff7fSkettenis thread will have already tripped on it. */
1287*11efff7fSkettenis
1288*11efff7fSkettenis /* Now resume this LWP and get the SIGSTOP event. */
1289*11efff7fSkettenis errno = 0;
1290*11efff7fSkettenis ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1291*11efff7fSkettenis if (debug_linux_nat)
1292*11efff7fSkettenis {
1293*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1294*11efff7fSkettenis "PTRACE_CONT %s, 0, 0 (%s)\n",
1295*11efff7fSkettenis target_pid_to_str (lp->ptid),
1296*11efff7fSkettenis errno ? safe_strerror (errno) : "OK");
1297*11efff7fSkettenis
1298*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1299*11efff7fSkettenis "SWC: Candidate SIGTRAP event in %s\n",
1300*11efff7fSkettenis target_pid_to_str (lp->ptid));
1301*11efff7fSkettenis }
1302*11efff7fSkettenis /* Hold the SIGTRAP for handling by linux_nat_wait. */
1303*11efff7fSkettenis stop_wait_callback (lp, data);
1304*11efff7fSkettenis /* If there's another event, throw it back into the queue. */
1305*11efff7fSkettenis if (lp->status)
1306*11efff7fSkettenis {
1307*11efff7fSkettenis if (debug_linux_nat)
1308*11efff7fSkettenis {
1309*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1310*11efff7fSkettenis "SWC: kill %s, %s\n",
1311*11efff7fSkettenis target_pid_to_str (lp->ptid),
1312*11efff7fSkettenis status_to_str ((int) status));
1313*11efff7fSkettenis }
1314*11efff7fSkettenis kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
1315*11efff7fSkettenis }
1316*11efff7fSkettenis /* Save the sigtrap event. */
1317*11efff7fSkettenis lp->status = status;
1318*11efff7fSkettenis return 0;
1319*11efff7fSkettenis }
1320*11efff7fSkettenis else
1321*11efff7fSkettenis {
1322*11efff7fSkettenis /* The thread was stopped with a signal other than
1323*11efff7fSkettenis SIGSTOP, and didn't accidentally trip a breakpoint. */
1324*11efff7fSkettenis
1325*11efff7fSkettenis if (debug_linux_nat)
1326*11efff7fSkettenis {
1327*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1328*11efff7fSkettenis "SWC: Pending event %s in %s\n",
1329*11efff7fSkettenis status_to_str ((int) status),
1330*11efff7fSkettenis target_pid_to_str (lp->ptid));
1331*11efff7fSkettenis }
1332*11efff7fSkettenis /* Now resume this LWP and get the SIGSTOP event. */
1333*11efff7fSkettenis errno = 0;
1334*11efff7fSkettenis ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1335*11efff7fSkettenis if (debug_linux_nat)
1336*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1337*11efff7fSkettenis "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
1338*11efff7fSkettenis target_pid_to_str (lp->ptid),
1339*11efff7fSkettenis errno ? safe_strerror (errno) : "OK");
1340*11efff7fSkettenis
1341*11efff7fSkettenis /* Hold this event/waitstatus while we check to see if
1342*11efff7fSkettenis there are any more (we still want to get that SIGSTOP). */
1343*11efff7fSkettenis stop_wait_callback (lp, data);
1344*11efff7fSkettenis /* If the lp->status field is still empty, use it to hold
1345*11efff7fSkettenis this event. If not, then this event must be returned
1346*11efff7fSkettenis to the event queue of the LWP. */
1347*11efff7fSkettenis if (lp->status == 0)
1348*11efff7fSkettenis lp->status = status;
1349*11efff7fSkettenis else
1350*11efff7fSkettenis {
1351*11efff7fSkettenis if (debug_linux_nat)
1352*11efff7fSkettenis {
1353*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1354*11efff7fSkettenis "SWC: kill %s, %s\n",
1355*11efff7fSkettenis target_pid_to_str (lp->ptid),
1356*11efff7fSkettenis status_to_str ((int) status));
1357*11efff7fSkettenis }
1358*11efff7fSkettenis kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
1359*11efff7fSkettenis }
1360*11efff7fSkettenis return 0;
1361*11efff7fSkettenis }
1362*11efff7fSkettenis }
1363*11efff7fSkettenis else
1364*11efff7fSkettenis {
1365*11efff7fSkettenis /* We caught the SIGSTOP that we intended to catch, so
1366*11efff7fSkettenis there's no SIGSTOP pending. */
1367*11efff7fSkettenis lp->stopped = 1;
1368*11efff7fSkettenis lp->signalled = 0;
1369*11efff7fSkettenis }
1370*11efff7fSkettenis }
1371*11efff7fSkettenis
1372*11efff7fSkettenis return 0;
1373*11efff7fSkettenis }
1374*11efff7fSkettenis
1375*11efff7fSkettenis /* Check whether PID has any pending signals in FLUSH_MASK. If so set
1376*11efff7fSkettenis the appropriate bits in PENDING, and return 1 - otherwise return 0. */
1377*11efff7fSkettenis
1378*11efff7fSkettenis static int
linux_nat_has_pending(int pid,sigset_t * pending,sigset_t * flush_mask)1379*11efff7fSkettenis linux_nat_has_pending (int pid, sigset_t *pending, sigset_t *flush_mask)
1380*11efff7fSkettenis {
1381*11efff7fSkettenis sigset_t blocked, ignored;
1382*11efff7fSkettenis int i;
1383*11efff7fSkettenis
1384*11efff7fSkettenis linux_proc_pending_signals (pid, pending, &blocked, &ignored);
1385*11efff7fSkettenis
1386*11efff7fSkettenis if (!flush_mask)
1387*11efff7fSkettenis return 0;
1388*11efff7fSkettenis
1389*11efff7fSkettenis for (i = 1; i < NSIG; i++)
1390*11efff7fSkettenis if (sigismember (pending, i))
1391*11efff7fSkettenis if (!sigismember (flush_mask, i)
1392*11efff7fSkettenis || sigismember (&blocked, i)
1393*11efff7fSkettenis || sigismember (&ignored, i))
1394*11efff7fSkettenis sigdelset (pending, i);
1395*11efff7fSkettenis
1396*11efff7fSkettenis if (sigisemptyset (pending))
1397*11efff7fSkettenis return 0;
1398*11efff7fSkettenis
1399*11efff7fSkettenis return 1;
1400*11efff7fSkettenis }
1401*11efff7fSkettenis
1402*11efff7fSkettenis /* DATA is interpreted as a mask of signals to flush. If LP has
1403*11efff7fSkettenis signals pending, and they are all in the flush mask, then arrange
1404*11efff7fSkettenis to flush them. LP should be stopped, as should all other threads
1405*11efff7fSkettenis it might share a signal queue with. */
1406*11efff7fSkettenis
1407*11efff7fSkettenis static int
flush_callback(struct lwp_info * lp,void * data)1408*11efff7fSkettenis flush_callback (struct lwp_info *lp, void *data)
1409*11efff7fSkettenis {
1410*11efff7fSkettenis sigset_t *flush_mask = data;
1411*11efff7fSkettenis sigset_t pending, intersection, blocked, ignored;
1412*11efff7fSkettenis int pid, status;
1413*11efff7fSkettenis
1414*11efff7fSkettenis /* Normally, when an LWP exits, it is removed from the LWP list. The
1415*11efff7fSkettenis last LWP isn't removed till later, however. So if there is only
1416*11efff7fSkettenis one LWP on the list, make sure it's alive. */
1417*11efff7fSkettenis if (lwp_list == lp && lp->next == NULL)
1418*11efff7fSkettenis if (!linux_nat_thread_alive (lp->ptid))
1419*11efff7fSkettenis return 0;
1420*11efff7fSkettenis
1421*11efff7fSkettenis /* Just because the LWP is stopped doesn't mean that new signals
1422*11efff7fSkettenis can't arrive from outside, so this function must be careful of
1423*11efff7fSkettenis race conditions. However, because all threads are stopped, we
1424*11efff7fSkettenis can assume that the pending mask will not shrink unless we resume
1425*11efff7fSkettenis the LWP, and that it will then get another signal. We can't
1426*11efff7fSkettenis control which one, however. */
1427*11efff7fSkettenis
1428*11efff7fSkettenis if (lp->status)
1429*11efff7fSkettenis {
1430*11efff7fSkettenis if (debug_linux_nat)
1431*11efff7fSkettenis printf_unfiltered ("FC: LP has pending status %06x\n", lp->status);
1432*11efff7fSkettenis if (WIFSTOPPED (lp->status) && sigismember (flush_mask, WSTOPSIG (lp->status)))
1433*11efff7fSkettenis lp->status = 0;
1434*11efff7fSkettenis }
1435*11efff7fSkettenis
1436*11efff7fSkettenis while (linux_nat_has_pending (GET_LWP (lp->ptid), &pending, flush_mask))
1437*11efff7fSkettenis {
1438*11efff7fSkettenis int ret;
1439*11efff7fSkettenis
1440*11efff7fSkettenis errno = 0;
1441*11efff7fSkettenis ret = ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1442*11efff7fSkettenis if (debug_linux_nat)
1443*11efff7fSkettenis fprintf_unfiltered (gdb_stderr,
1444*11efff7fSkettenis "FC: Sent PTRACE_CONT, ret %d %d\n", ret, errno);
1445*11efff7fSkettenis
1446*11efff7fSkettenis lp->stopped = 0;
1447*11efff7fSkettenis stop_wait_callback (lp, flush_mask);
1448*11efff7fSkettenis if (debug_linux_nat)
1449*11efff7fSkettenis fprintf_unfiltered (gdb_stderr,
1450*11efff7fSkettenis "FC: Wait finished; saved status is %d\n",
1451*11efff7fSkettenis lp->status);
1452*11efff7fSkettenis }
1453*11efff7fSkettenis
1454*11efff7fSkettenis return 0;
1455*11efff7fSkettenis }
1456*11efff7fSkettenis
1457*11efff7fSkettenis /* Return non-zero if LP has a wait status pending. */
1458*11efff7fSkettenis
1459*11efff7fSkettenis static int
status_callback(struct lwp_info * lp,void * data)1460*11efff7fSkettenis status_callback (struct lwp_info *lp, void *data)
1461*11efff7fSkettenis {
1462*11efff7fSkettenis /* Only report a pending wait status if we pretend that this has
1463*11efff7fSkettenis indeed been resumed. */
1464*11efff7fSkettenis return (lp->status != 0 && lp->resumed);
1465*11efff7fSkettenis }
1466*11efff7fSkettenis
1467*11efff7fSkettenis /* Return non-zero if LP isn't stopped. */
1468*11efff7fSkettenis
1469*11efff7fSkettenis static int
running_callback(struct lwp_info * lp,void * data)1470*11efff7fSkettenis running_callback (struct lwp_info *lp, void *data)
1471*11efff7fSkettenis {
1472*11efff7fSkettenis return (lp->stopped == 0 || (lp->status != 0 && lp->resumed));
1473*11efff7fSkettenis }
1474*11efff7fSkettenis
1475*11efff7fSkettenis /* Count the LWP's that have had events. */
1476*11efff7fSkettenis
1477*11efff7fSkettenis static int
count_events_callback(struct lwp_info * lp,void * data)1478*11efff7fSkettenis count_events_callback (struct lwp_info *lp, void *data)
1479*11efff7fSkettenis {
1480*11efff7fSkettenis int *count = data;
1481*11efff7fSkettenis
1482*11efff7fSkettenis gdb_assert (count != NULL);
1483*11efff7fSkettenis
1484*11efff7fSkettenis /* Count only LWPs that have a SIGTRAP event pending. */
1485*11efff7fSkettenis if (lp->status != 0
1486*11efff7fSkettenis && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
1487*11efff7fSkettenis (*count)++;
1488*11efff7fSkettenis
1489*11efff7fSkettenis return 0;
1490*11efff7fSkettenis }
1491*11efff7fSkettenis
1492*11efff7fSkettenis /* Select the LWP (if any) that is currently being single-stepped. */
1493*11efff7fSkettenis
1494*11efff7fSkettenis static int
select_singlestep_lwp_callback(struct lwp_info * lp,void * data)1495*11efff7fSkettenis select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
1496*11efff7fSkettenis {
1497*11efff7fSkettenis if (lp->step && lp->status != 0)
1498*11efff7fSkettenis return 1;
1499*11efff7fSkettenis else
1500*11efff7fSkettenis return 0;
1501*11efff7fSkettenis }
1502*11efff7fSkettenis
1503*11efff7fSkettenis /* Select the Nth LWP that has had a SIGTRAP event. */
1504*11efff7fSkettenis
1505*11efff7fSkettenis static int
select_event_lwp_callback(struct lwp_info * lp,void * data)1506*11efff7fSkettenis select_event_lwp_callback (struct lwp_info *lp, void *data)
1507*11efff7fSkettenis {
1508*11efff7fSkettenis int *selector = data;
1509*11efff7fSkettenis
1510*11efff7fSkettenis gdb_assert (selector != NULL);
1511*11efff7fSkettenis
1512*11efff7fSkettenis /* Select only LWPs that have a SIGTRAP event pending. */
1513*11efff7fSkettenis if (lp->status != 0
1514*11efff7fSkettenis && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
1515*11efff7fSkettenis if ((*selector)-- == 0)
1516*11efff7fSkettenis return 1;
1517*11efff7fSkettenis
1518*11efff7fSkettenis return 0;
1519*11efff7fSkettenis }
1520*11efff7fSkettenis
1521*11efff7fSkettenis static int
cancel_breakpoints_callback(struct lwp_info * lp,void * data)1522*11efff7fSkettenis cancel_breakpoints_callback (struct lwp_info *lp, void *data)
1523*11efff7fSkettenis {
1524*11efff7fSkettenis struct lwp_info *event_lp = data;
1525*11efff7fSkettenis
1526*11efff7fSkettenis /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
1527*11efff7fSkettenis if (lp == event_lp)
1528*11efff7fSkettenis return 0;
1529*11efff7fSkettenis
1530*11efff7fSkettenis /* If a LWP other than the LWP that we're reporting an event for has
1531*11efff7fSkettenis hit a GDB breakpoint (as opposed to some random trap signal),
1532*11efff7fSkettenis then just arrange for it to hit it again later. We don't keep
1533*11efff7fSkettenis the SIGTRAP status and don't forward the SIGTRAP signal to the
1534*11efff7fSkettenis LWP. We will handle the current event, eventually we will resume
1535*11efff7fSkettenis all LWPs, and this one will get its breakpoint trap again.
1536*11efff7fSkettenis
1537*11efff7fSkettenis If we do not do this, then we run the risk that the user will
1538*11efff7fSkettenis delete or disable the breakpoint, but the LWP will have already
1539*11efff7fSkettenis tripped on it. */
1540*11efff7fSkettenis
1541*11efff7fSkettenis if (lp->status != 0
1542*11efff7fSkettenis && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
1543*11efff7fSkettenis && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) -
1544*11efff7fSkettenis DECR_PC_AFTER_BREAK))
1545*11efff7fSkettenis {
1546*11efff7fSkettenis if (debug_linux_nat)
1547*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1548*11efff7fSkettenis "CBC: Push back breakpoint for %s\n",
1549*11efff7fSkettenis target_pid_to_str (lp->ptid));
1550*11efff7fSkettenis
1551*11efff7fSkettenis /* Back up the PC if necessary. */
1552*11efff7fSkettenis if (DECR_PC_AFTER_BREAK)
1553*11efff7fSkettenis write_pc_pid (read_pc_pid (lp->ptid) - DECR_PC_AFTER_BREAK, lp->ptid);
1554*11efff7fSkettenis
1555*11efff7fSkettenis /* Throw away the SIGTRAP. */
1556*11efff7fSkettenis lp->status = 0;
1557*11efff7fSkettenis }
1558*11efff7fSkettenis
1559*11efff7fSkettenis return 0;
1560*11efff7fSkettenis }
1561*11efff7fSkettenis
1562*11efff7fSkettenis /* Select one LWP out of those that have events pending. */
1563*11efff7fSkettenis
1564*11efff7fSkettenis static void
select_event_lwp(struct lwp_info ** orig_lp,int * status)1565*11efff7fSkettenis select_event_lwp (struct lwp_info **orig_lp, int *status)
1566*11efff7fSkettenis {
1567*11efff7fSkettenis int num_events = 0;
1568*11efff7fSkettenis int random_selector;
1569*11efff7fSkettenis struct lwp_info *event_lp;
1570*11efff7fSkettenis
1571*11efff7fSkettenis /* Record the wait status for the origional LWP. */
1572*11efff7fSkettenis (*orig_lp)->status = *status;
1573*11efff7fSkettenis
1574*11efff7fSkettenis /* Give preference to any LWP that is being single-stepped. */
1575*11efff7fSkettenis event_lp = iterate_over_lwps (select_singlestep_lwp_callback, NULL);
1576*11efff7fSkettenis if (event_lp != NULL)
1577*11efff7fSkettenis {
1578*11efff7fSkettenis if (debug_linux_nat)
1579*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1580*11efff7fSkettenis "SEL: Select single-step %s\n",
1581*11efff7fSkettenis target_pid_to_str (event_lp->ptid));
1582*11efff7fSkettenis }
1583*11efff7fSkettenis else
1584*11efff7fSkettenis {
1585*11efff7fSkettenis /* No single-stepping LWP. Select one at random, out of those
1586*11efff7fSkettenis which have had SIGTRAP events. */
1587*11efff7fSkettenis
1588*11efff7fSkettenis /* First see how many SIGTRAP events we have. */
1589*11efff7fSkettenis iterate_over_lwps (count_events_callback, &num_events);
1590*11efff7fSkettenis
1591*11efff7fSkettenis /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
1592*11efff7fSkettenis random_selector = (int)
1593*11efff7fSkettenis ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
1594*11efff7fSkettenis
1595*11efff7fSkettenis if (debug_linux_nat && num_events > 1)
1596*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1597*11efff7fSkettenis "SEL: Found %d SIGTRAP events, selecting #%d\n",
1598*11efff7fSkettenis num_events, random_selector);
1599*11efff7fSkettenis
1600*11efff7fSkettenis event_lp = iterate_over_lwps (select_event_lwp_callback,
1601*11efff7fSkettenis &random_selector);
1602*11efff7fSkettenis }
1603*11efff7fSkettenis
1604*11efff7fSkettenis if (event_lp != NULL)
1605*11efff7fSkettenis {
1606*11efff7fSkettenis /* Switch the event LWP. */
1607*11efff7fSkettenis *orig_lp = event_lp;
1608*11efff7fSkettenis *status = event_lp->status;
1609*11efff7fSkettenis }
1610*11efff7fSkettenis
1611*11efff7fSkettenis /* Flush the wait status for the event LWP. */
1612*11efff7fSkettenis (*orig_lp)->status = 0;
1613*11efff7fSkettenis }
1614*11efff7fSkettenis
1615*11efff7fSkettenis /* Return non-zero if LP has been resumed. */
1616*11efff7fSkettenis
1617*11efff7fSkettenis static int
resumed_callback(struct lwp_info * lp,void * data)1618*11efff7fSkettenis resumed_callback (struct lwp_info *lp, void *data)
1619*11efff7fSkettenis {
1620*11efff7fSkettenis return lp->resumed;
1621*11efff7fSkettenis }
1622*11efff7fSkettenis
1623*11efff7fSkettenis #ifdef CHILD_WAIT
1624*11efff7fSkettenis
1625*11efff7fSkettenis /* We need to override child_wait to support attaching to cloned
1626*11efff7fSkettenis processes, since a normal wait (as done by the default version)
1627*11efff7fSkettenis ignores those processes. */
1628*11efff7fSkettenis
1629*11efff7fSkettenis /* Wait for child PTID to do something. Return id of the child,
1630*11efff7fSkettenis minus_one_ptid in case of error; store status into *OURSTATUS. */
1631*11efff7fSkettenis
1632*11efff7fSkettenis ptid_t
child_wait(ptid_t ptid,struct target_waitstatus * ourstatus)1633*11efff7fSkettenis child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1634*11efff7fSkettenis {
1635*11efff7fSkettenis int save_errno;
1636*11efff7fSkettenis int status;
1637*11efff7fSkettenis pid_t pid;
1638*11efff7fSkettenis
1639*11efff7fSkettenis ourstatus->kind = TARGET_WAITKIND_IGNORE;
1640*11efff7fSkettenis
1641*11efff7fSkettenis do
1642*11efff7fSkettenis {
1643*11efff7fSkettenis set_sigint_trap (); /* Causes SIGINT to be passed on to the
1644*11efff7fSkettenis attached process. */
1645*11efff7fSkettenis set_sigio_trap ();
1646*11efff7fSkettenis
1647*11efff7fSkettenis pid = waitpid (GET_PID (ptid), &status, 0);
1648*11efff7fSkettenis if (pid == -1 && errno == ECHILD)
1649*11efff7fSkettenis /* Try again with __WCLONE to check cloned processes. */
1650*11efff7fSkettenis pid = waitpid (GET_PID (ptid), &status, __WCLONE);
1651*11efff7fSkettenis
1652*11efff7fSkettenis if (debug_linux_nat)
1653*11efff7fSkettenis {
1654*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1655*11efff7fSkettenis "CW: waitpid %ld received %s\n",
1656*11efff7fSkettenis (long) pid, status_to_str (status));
1657*11efff7fSkettenis }
1658*11efff7fSkettenis
1659*11efff7fSkettenis save_errno = errno;
1660*11efff7fSkettenis
1661*11efff7fSkettenis /* Make sure we don't report an event for the exit of the
1662*11efff7fSkettenis original program, if we've detached from it. */
1663*11efff7fSkettenis if (pid != -1 && !WIFSTOPPED (status) && pid != GET_PID (inferior_ptid))
1664*11efff7fSkettenis {
1665*11efff7fSkettenis pid = -1;
1666*11efff7fSkettenis save_errno = EINTR;
1667*11efff7fSkettenis }
1668*11efff7fSkettenis
1669*11efff7fSkettenis /* Check for stop events reported by a process we didn't already
1670*11efff7fSkettenis know about - in this case, anything other than inferior_ptid.
1671*11efff7fSkettenis
1672*11efff7fSkettenis If we're expecting to receive stopped processes after fork,
1673*11efff7fSkettenis vfork, and clone events, then we'll just add the new one to
1674*11efff7fSkettenis our list and go back to waiting for the event to be reported
1675*11efff7fSkettenis - the stopped process might be returned from waitpid before
1676*11efff7fSkettenis or after the event is. If we want to handle debugging of
1677*11efff7fSkettenis CLONE_PTRACE processes we need to do more here, i.e. switch
1678*11efff7fSkettenis to multi-threaded mode. */
1679*11efff7fSkettenis if (pid != -1 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP
1680*11efff7fSkettenis && pid != GET_PID (inferior_ptid))
1681*11efff7fSkettenis {
1682*11efff7fSkettenis linux_record_stopped_pid (pid);
1683*11efff7fSkettenis pid = -1;
1684*11efff7fSkettenis save_errno = EINTR;
1685*11efff7fSkettenis }
1686*11efff7fSkettenis
1687*11efff7fSkettenis /* Handle GNU/Linux's extended waitstatus for trace events. */
1688*11efff7fSkettenis if (pid != -1 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
1689*11efff7fSkettenis && status >> 16 != 0)
1690*11efff7fSkettenis {
1691*11efff7fSkettenis linux_handle_extended_wait (pid, status, ourstatus);
1692*11efff7fSkettenis
1693*11efff7fSkettenis /* If we see a clone event, detach the child, and don't
1694*11efff7fSkettenis report the event. It would be nice to offer some way to
1695*11efff7fSkettenis switch into a non-thread-db based threaded mode at this
1696*11efff7fSkettenis point. */
1697*11efff7fSkettenis if (ourstatus->kind == TARGET_WAITKIND_SPURIOUS)
1698*11efff7fSkettenis {
1699*11efff7fSkettenis ptrace (PTRACE_DETACH, ourstatus->value.related_pid, 0, 0);
1700*11efff7fSkettenis ourstatus->kind = TARGET_WAITKIND_IGNORE;
1701*11efff7fSkettenis ptrace (PTRACE_CONT, pid, 0, 0);
1702*11efff7fSkettenis pid = -1;
1703*11efff7fSkettenis save_errno = EINTR;
1704*11efff7fSkettenis }
1705*11efff7fSkettenis }
1706*11efff7fSkettenis
1707*11efff7fSkettenis clear_sigio_trap ();
1708*11efff7fSkettenis clear_sigint_trap ();
1709*11efff7fSkettenis }
1710*11efff7fSkettenis while (pid == -1 && save_errno == EINTR);
1711*11efff7fSkettenis
1712*11efff7fSkettenis if (pid == -1)
1713*11efff7fSkettenis {
1714*11efff7fSkettenis warning ("Child process unexpectedly missing: %s",
1715*11efff7fSkettenis safe_strerror (errno));
1716*11efff7fSkettenis
1717*11efff7fSkettenis /* Claim it exited with unknown signal. */
1718*11efff7fSkettenis ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1719*11efff7fSkettenis ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1720*11efff7fSkettenis return minus_one_ptid;
1721*11efff7fSkettenis }
1722*11efff7fSkettenis
1723*11efff7fSkettenis if (ourstatus->kind == TARGET_WAITKIND_IGNORE)
1724*11efff7fSkettenis store_waitstatus (ourstatus, status);
1725*11efff7fSkettenis
1726*11efff7fSkettenis return pid_to_ptid (pid);
1727*11efff7fSkettenis }
1728*11efff7fSkettenis
1729*11efff7fSkettenis #endif
1730*11efff7fSkettenis
1731*11efff7fSkettenis /* Stop an active thread, verify it still exists, then resume it. */
1732*11efff7fSkettenis
1733*11efff7fSkettenis static int
stop_and_resume_callback(struct lwp_info * lp,void * data)1734*11efff7fSkettenis stop_and_resume_callback (struct lwp_info *lp, void *data)
1735*11efff7fSkettenis {
1736*11efff7fSkettenis struct lwp_info *ptr;
1737*11efff7fSkettenis
1738*11efff7fSkettenis if (!lp->stopped && !lp->signalled)
1739*11efff7fSkettenis {
1740*11efff7fSkettenis stop_callback (lp, NULL);
1741*11efff7fSkettenis stop_wait_callback (lp, NULL);
1742*11efff7fSkettenis /* Resume if the lwp still exists. */
1743*11efff7fSkettenis for (ptr = lwp_list; ptr; ptr = ptr->next)
1744*11efff7fSkettenis if (lp == ptr)
1745*11efff7fSkettenis {
1746*11efff7fSkettenis resume_callback (lp, NULL);
1747*11efff7fSkettenis resume_set_callback (lp, NULL);
1748*11efff7fSkettenis }
1749*11efff7fSkettenis }
1750*11efff7fSkettenis return 0;
1751*11efff7fSkettenis }
1752*11efff7fSkettenis
1753*11efff7fSkettenis static ptid_t
linux_nat_wait(ptid_t ptid,struct target_waitstatus * ourstatus)1754*11efff7fSkettenis linux_nat_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1755*11efff7fSkettenis {
1756*11efff7fSkettenis struct lwp_info *lp = NULL;
1757*11efff7fSkettenis int options = 0;
1758*11efff7fSkettenis int status = 0;
1759*11efff7fSkettenis pid_t pid = PIDGET (ptid);
1760*11efff7fSkettenis sigset_t flush_mask;
1761*11efff7fSkettenis
1762*11efff7fSkettenis sigemptyset (&flush_mask);
1763*11efff7fSkettenis
1764*11efff7fSkettenis /* Make sure SIGCHLD is blocked. */
1765*11efff7fSkettenis if (!sigismember (&blocked_mask, SIGCHLD))
1766*11efff7fSkettenis {
1767*11efff7fSkettenis sigaddset (&blocked_mask, SIGCHLD);
1768*11efff7fSkettenis sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
1769*11efff7fSkettenis }
1770*11efff7fSkettenis
1771*11efff7fSkettenis retry:
1772*11efff7fSkettenis
1773*11efff7fSkettenis /* Make sure there is at least one LWP that has been resumed, at
1774*11efff7fSkettenis least if there are any LWPs at all. */
1775*11efff7fSkettenis gdb_assert (num_lwps == 0 || iterate_over_lwps (resumed_callback, NULL));
1776*11efff7fSkettenis
1777*11efff7fSkettenis /* First check if there is a LWP with a wait status pending. */
1778*11efff7fSkettenis if (pid == -1)
1779*11efff7fSkettenis {
1780*11efff7fSkettenis /* Any LWP that's been resumed will do. */
1781*11efff7fSkettenis lp = iterate_over_lwps (status_callback, NULL);
1782*11efff7fSkettenis if (lp)
1783*11efff7fSkettenis {
1784*11efff7fSkettenis status = lp->status;
1785*11efff7fSkettenis lp->status = 0;
1786*11efff7fSkettenis
1787*11efff7fSkettenis if (debug_linux_nat && status)
1788*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1789*11efff7fSkettenis "LLW: Using pending wait status %s for %s.\n",
1790*11efff7fSkettenis status_to_str (status),
1791*11efff7fSkettenis target_pid_to_str (lp->ptid));
1792*11efff7fSkettenis }
1793*11efff7fSkettenis
1794*11efff7fSkettenis /* But if we don't fine one, we'll have to wait, and check both
1795*11efff7fSkettenis cloned and uncloned processes. We start with the cloned
1796*11efff7fSkettenis processes. */
1797*11efff7fSkettenis options = __WCLONE | WNOHANG;
1798*11efff7fSkettenis }
1799*11efff7fSkettenis else if (is_lwp (ptid))
1800*11efff7fSkettenis {
1801*11efff7fSkettenis if (debug_linux_nat)
1802*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1803*11efff7fSkettenis "LLW: Waiting for specific LWP %s.\n",
1804*11efff7fSkettenis target_pid_to_str (ptid));
1805*11efff7fSkettenis
1806*11efff7fSkettenis /* We have a specific LWP to check. */
1807*11efff7fSkettenis lp = find_lwp_pid (ptid);
1808*11efff7fSkettenis gdb_assert (lp);
1809*11efff7fSkettenis status = lp->status;
1810*11efff7fSkettenis lp->status = 0;
1811*11efff7fSkettenis
1812*11efff7fSkettenis if (debug_linux_nat && status)
1813*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1814*11efff7fSkettenis "LLW: Using pending wait status %s for %s.\n",
1815*11efff7fSkettenis status_to_str (status),
1816*11efff7fSkettenis target_pid_to_str (lp->ptid));
1817*11efff7fSkettenis
1818*11efff7fSkettenis /* If we have to wait, take into account whether PID is a cloned
1819*11efff7fSkettenis process or not. And we have to convert it to something that
1820*11efff7fSkettenis the layer beneath us can understand. */
1821*11efff7fSkettenis options = lp->cloned ? __WCLONE : 0;
1822*11efff7fSkettenis pid = GET_LWP (ptid);
1823*11efff7fSkettenis }
1824*11efff7fSkettenis
1825*11efff7fSkettenis if (status && lp->signalled)
1826*11efff7fSkettenis {
1827*11efff7fSkettenis /* A pending SIGSTOP may interfere with the normal stream of
1828*11efff7fSkettenis events. In a typical case where interference is a problem,
1829*11efff7fSkettenis we have a SIGSTOP signal pending for LWP A while
1830*11efff7fSkettenis single-stepping it, encounter an event in LWP B, and take the
1831*11efff7fSkettenis pending SIGSTOP while trying to stop LWP A. After processing
1832*11efff7fSkettenis the event in LWP B, LWP A is continued, and we'll never see
1833*11efff7fSkettenis the SIGTRAP associated with the last time we were
1834*11efff7fSkettenis single-stepping LWP A. */
1835*11efff7fSkettenis
1836*11efff7fSkettenis /* Resume the thread. It should halt immediately returning the
1837*11efff7fSkettenis pending SIGSTOP. */
1838*11efff7fSkettenis registers_changed ();
1839*11efff7fSkettenis child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
1840*11efff7fSkettenis TARGET_SIGNAL_0);
1841*11efff7fSkettenis if (debug_linux_nat)
1842*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1843*11efff7fSkettenis "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
1844*11efff7fSkettenis lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1845*11efff7fSkettenis target_pid_to_str (lp->ptid));
1846*11efff7fSkettenis lp->stopped = 0;
1847*11efff7fSkettenis gdb_assert (lp->resumed);
1848*11efff7fSkettenis
1849*11efff7fSkettenis /* This should catch the pending SIGSTOP. */
1850*11efff7fSkettenis stop_wait_callback (lp, NULL);
1851*11efff7fSkettenis }
1852*11efff7fSkettenis
1853*11efff7fSkettenis set_sigint_trap (); /* Causes SIGINT to be passed on to the
1854*11efff7fSkettenis attached process. */
1855*11efff7fSkettenis set_sigio_trap ();
1856*11efff7fSkettenis
1857*11efff7fSkettenis while (status == 0)
1858*11efff7fSkettenis {
1859*11efff7fSkettenis pid_t lwpid;
1860*11efff7fSkettenis
1861*11efff7fSkettenis lwpid = waitpid (pid, &status, options);
1862*11efff7fSkettenis if (lwpid > 0)
1863*11efff7fSkettenis {
1864*11efff7fSkettenis gdb_assert (pid == -1 || lwpid == pid);
1865*11efff7fSkettenis
1866*11efff7fSkettenis if (debug_linux_nat)
1867*11efff7fSkettenis {
1868*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1869*11efff7fSkettenis "LLW: waitpid %ld received %s\n",
1870*11efff7fSkettenis (long) lwpid, status_to_str (status));
1871*11efff7fSkettenis }
1872*11efff7fSkettenis
1873*11efff7fSkettenis lp = find_lwp_pid (pid_to_ptid (lwpid));
1874*11efff7fSkettenis
1875*11efff7fSkettenis /* Check for stop events reported by a process we didn't
1876*11efff7fSkettenis already know about - anything not already in our LWP
1877*11efff7fSkettenis list.
1878*11efff7fSkettenis
1879*11efff7fSkettenis If we're expecting to receive stopped processes after
1880*11efff7fSkettenis fork, vfork, and clone events, then we'll just add the
1881*11efff7fSkettenis new one to our list and go back to waiting for the event
1882*11efff7fSkettenis to be reported - the stopped process might be returned
1883*11efff7fSkettenis from waitpid before or after the event is. */
1884*11efff7fSkettenis if (WIFSTOPPED (status) && !lp)
1885*11efff7fSkettenis {
1886*11efff7fSkettenis linux_record_stopped_pid (lwpid);
1887*11efff7fSkettenis status = 0;
1888*11efff7fSkettenis continue;
1889*11efff7fSkettenis }
1890*11efff7fSkettenis
1891*11efff7fSkettenis /* Make sure we don't report an event for the exit of an LWP not in
1892*11efff7fSkettenis our list, i.e. not part of the current process. This can happen
1893*11efff7fSkettenis if we detach from a program we original forked and then it
1894*11efff7fSkettenis exits. */
1895*11efff7fSkettenis if (!WIFSTOPPED (status) && !lp)
1896*11efff7fSkettenis {
1897*11efff7fSkettenis status = 0;
1898*11efff7fSkettenis continue;
1899*11efff7fSkettenis }
1900*11efff7fSkettenis
1901*11efff7fSkettenis /* NOTE drow/2003-06-17: This code seems to be meant for debugging
1902*11efff7fSkettenis CLONE_PTRACE processes which do not use the thread library -
1903*11efff7fSkettenis otherwise we wouldn't find the new LWP this way. That doesn't
1904*11efff7fSkettenis currently work, and the following code is currently unreachable
1905*11efff7fSkettenis due to the two blocks above. If it's fixed some day, this code
1906*11efff7fSkettenis should be broken out into a function so that we can also pick up
1907*11efff7fSkettenis LWPs from the new interface. */
1908*11efff7fSkettenis if (!lp)
1909*11efff7fSkettenis {
1910*11efff7fSkettenis lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
1911*11efff7fSkettenis if (options & __WCLONE)
1912*11efff7fSkettenis lp->cloned = 1;
1913*11efff7fSkettenis
1914*11efff7fSkettenis if (threaded)
1915*11efff7fSkettenis {
1916*11efff7fSkettenis gdb_assert (WIFSTOPPED (status)
1917*11efff7fSkettenis && WSTOPSIG (status) == SIGSTOP);
1918*11efff7fSkettenis lp->signalled = 1;
1919*11efff7fSkettenis
1920*11efff7fSkettenis if (!in_thread_list (inferior_ptid))
1921*11efff7fSkettenis {
1922*11efff7fSkettenis inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
1923*11efff7fSkettenis GET_PID (inferior_ptid));
1924*11efff7fSkettenis add_thread (inferior_ptid);
1925*11efff7fSkettenis }
1926*11efff7fSkettenis
1927*11efff7fSkettenis add_thread (lp->ptid);
1928*11efff7fSkettenis printf_unfiltered ("[New %s]\n",
1929*11efff7fSkettenis target_pid_to_str (lp->ptid));
1930*11efff7fSkettenis }
1931*11efff7fSkettenis }
1932*11efff7fSkettenis
1933*11efff7fSkettenis /* Handle GNU/Linux's extended waitstatus for trace events. */
1934*11efff7fSkettenis if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
1935*11efff7fSkettenis {
1936*11efff7fSkettenis if (debug_linux_nat)
1937*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1938*11efff7fSkettenis "LLW: Handling extended status 0x%06x\n",
1939*11efff7fSkettenis status);
1940*11efff7fSkettenis if (linux_nat_handle_extended (lp, status))
1941*11efff7fSkettenis {
1942*11efff7fSkettenis status = 0;
1943*11efff7fSkettenis continue;
1944*11efff7fSkettenis }
1945*11efff7fSkettenis }
1946*11efff7fSkettenis
1947*11efff7fSkettenis /* Check if the thread has exited. */
1948*11efff7fSkettenis if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1)
1949*11efff7fSkettenis {
1950*11efff7fSkettenis if (in_thread_list (lp->ptid))
1951*11efff7fSkettenis {
1952*11efff7fSkettenis /* Core GDB cannot deal with us deleting the current
1953*11efff7fSkettenis thread. */
1954*11efff7fSkettenis if (!ptid_equal (lp->ptid, inferior_ptid))
1955*11efff7fSkettenis delete_thread (lp->ptid);
1956*11efff7fSkettenis printf_unfiltered ("[%s exited]\n",
1957*11efff7fSkettenis target_pid_to_str (lp->ptid));
1958*11efff7fSkettenis }
1959*11efff7fSkettenis
1960*11efff7fSkettenis /* If this is the main thread, we must stop all threads and
1961*11efff7fSkettenis verify if they are still alive. This is because in the nptl
1962*11efff7fSkettenis thread model, there is no signal issued for exiting LWPs
1963*11efff7fSkettenis other than the main thread. We only get the main thread
1964*11efff7fSkettenis exit signal once all child threads have already exited.
1965*11efff7fSkettenis If we stop all the threads and use the stop_wait_callback
1966*11efff7fSkettenis to check if they have exited we can determine whether this
1967*11efff7fSkettenis signal should be ignored or whether it means the end of the
1968*11efff7fSkettenis debugged application, regardless of which threading model
1969*11efff7fSkettenis is being used. */
1970*11efff7fSkettenis if (GET_PID (lp->ptid) == GET_LWP (lp->ptid))
1971*11efff7fSkettenis {
1972*11efff7fSkettenis lp->stopped = 1;
1973*11efff7fSkettenis iterate_over_lwps (stop_and_resume_callback, NULL);
1974*11efff7fSkettenis }
1975*11efff7fSkettenis
1976*11efff7fSkettenis if (debug_linux_nat)
1977*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
1978*11efff7fSkettenis "LLW: %s exited.\n",
1979*11efff7fSkettenis target_pid_to_str (lp->ptid));
1980*11efff7fSkettenis
1981*11efff7fSkettenis delete_lwp (lp->ptid);
1982*11efff7fSkettenis
1983*11efff7fSkettenis /* If there is at least one more LWP, then the exit signal
1984*11efff7fSkettenis was not the end of the debugged application and should be
1985*11efff7fSkettenis ignored. */
1986*11efff7fSkettenis if (num_lwps > 0)
1987*11efff7fSkettenis {
1988*11efff7fSkettenis /* Make sure there is at least one thread running. */
1989*11efff7fSkettenis gdb_assert (iterate_over_lwps (running_callback, NULL));
1990*11efff7fSkettenis
1991*11efff7fSkettenis /* Discard the event. */
1992*11efff7fSkettenis status = 0;
1993*11efff7fSkettenis continue;
1994*11efff7fSkettenis }
1995*11efff7fSkettenis }
1996*11efff7fSkettenis
1997*11efff7fSkettenis /* Check if the current LWP has previously exited. In the nptl
1998*11efff7fSkettenis thread model, LWPs other than the main thread do not issue
1999*11efff7fSkettenis signals when they exit so we must check whenever the thread
2000*11efff7fSkettenis has stopped. A similar check is made in stop_wait_callback(). */
2001*11efff7fSkettenis if (num_lwps > 1 && !linux_nat_thread_alive (lp->ptid))
2002*11efff7fSkettenis {
2003*11efff7fSkettenis if (in_thread_list (lp->ptid))
2004*11efff7fSkettenis {
2005*11efff7fSkettenis /* Core GDB cannot deal with us deleting the current
2006*11efff7fSkettenis thread. */
2007*11efff7fSkettenis if (!ptid_equal (lp->ptid, inferior_ptid))
2008*11efff7fSkettenis delete_thread (lp->ptid);
2009*11efff7fSkettenis printf_unfiltered ("[%s exited]\n",
2010*11efff7fSkettenis target_pid_to_str (lp->ptid));
2011*11efff7fSkettenis }
2012*11efff7fSkettenis if (debug_linux_nat)
2013*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2014*11efff7fSkettenis "LLW: %s exited.\n",
2015*11efff7fSkettenis target_pid_to_str (lp->ptid));
2016*11efff7fSkettenis
2017*11efff7fSkettenis delete_lwp (lp->ptid);
2018*11efff7fSkettenis
2019*11efff7fSkettenis /* Make sure there is at least one thread running. */
2020*11efff7fSkettenis gdb_assert (iterate_over_lwps (running_callback, NULL));
2021*11efff7fSkettenis
2022*11efff7fSkettenis /* Discard the event. */
2023*11efff7fSkettenis status = 0;
2024*11efff7fSkettenis continue;
2025*11efff7fSkettenis }
2026*11efff7fSkettenis
2027*11efff7fSkettenis /* Make sure we don't report a SIGSTOP that we sent
2028*11efff7fSkettenis ourselves in an attempt to stop an LWP. */
2029*11efff7fSkettenis if (lp->signalled
2030*11efff7fSkettenis && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
2031*11efff7fSkettenis {
2032*11efff7fSkettenis if (debug_linux_nat)
2033*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2034*11efff7fSkettenis "LLW: Delayed SIGSTOP caught for %s.\n",
2035*11efff7fSkettenis target_pid_to_str (lp->ptid));
2036*11efff7fSkettenis
2037*11efff7fSkettenis /* This is a delayed SIGSTOP. */
2038*11efff7fSkettenis lp->signalled = 0;
2039*11efff7fSkettenis
2040*11efff7fSkettenis registers_changed ();
2041*11efff7fSkettenis child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
2042*11efff7fSkettenis TARGET_SIGNAL_0);
2043*11efff7fSkettenis if (debug_linux_nat)
2044*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2045*11efff7fSkettenis "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2046*11efff7fSkettenis lp->step ?
2047*11efff7fSkettenis "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2048*11efff7fSkettenis target_pid_to_str (lp->ptid));
2049*11efff7fSkettenis
2050*11efff7fSkettenis lp->stopped = 0;
2051*11efff7fSkettenis gdb_assert (lp->resumed);
2052*11efff7fSkettenis
2053*11efff7fSkettenis /* Discard the event. */
2054*11efff7fSkettenis status = 0;
2055*11efff7fSkettenis continue;
2056*11efff7fSkettenis }
2057*11efff7fSkettenis
2058*11efff7fSkettenis break;
2059*11efff7fSkettenis }
2060*11efff7fSkettenis
2061*11efff7fSkettenis if (pid == -1)
2062*11efff7fSkettenis {
2063*11efff7fSkettenis /* Alternate between checking cloned and uncloned processes. */
2064*11efff7fSkettenis options ^= __WCLONE;
2065*11efff7fSkettenis
2066*11efff7fSkettenis /* And suspend every time we have checked both. */
2067*11efff7fSkettenis if (options & __WCLONE)
2068*11efff7fSkettenis sigsuspend (&suspend_mask);
2069*11efff7fSkettenis }
2070*11efff7fSkettenis
2071*11efff7fSkettenis /* We shouldn't end up here unless we want to try again. */
2072*11efff7fSkettenis gdb_assert (status == 0);
2073*11efff7fSkettenis }
2074*11efff7fSkettenis
2075*11efff7fSkettenis clear_sigio_trap ();
2076*11efff7fSkettenis clear_sigint_trap ();
2077*11efff7fSkettenis
2078*11efff7fSkettenis gdb_assert (lp);
2079*11efff7fSkettenis
2080*11efff7fSkettenis /* Don't report signals that GDB isn't interested in, such as
2081*11efff7fSkettenis signals that are neither printed nor stopped upon. Stopping all
2082*11efff7fSkettenis threads can be a bit time-consuming so if we want decent
2083*11efff7fSkettenis performance with heavily multi-threaded programs, especially when
2084*11efff7fSkettenis they're using a high frequency timer, we'd better avoid it if we
2085*11efff7fSkettenis can. */
2086*11efff7fSkettenis
2087*11efff7fSkettenis if (WIFSTOPPED (status))
2088*11efff7fSkettenis {
2089*11efff7fSkettenis int signo = target_signal_from_host (WSTOPSIG (status));
2090*11efff7fSkettenis
2091*11efff7fSkettenis if (signal_stop_state (signo) == 0
2092*11efff7fSkettenis && signal_print_state (signo) == 0
2093*11efff7fSkettenis && signal_pass_state (signo) == 1)
2094*11efff7fSkettenis {
2095*11efff7fSkettenis /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2096*11efff7fSkettenis here? It is not clear we should. GDB may not expect
2097*11efff7fSkettenis other threads to run. On the other hand, not resuming
2098*11efff7fSkettenis newly attached threads may cause an unwanted delay in
2099*11efff7fSkettenis getting them running. */
2100*11efff7fSkettenis registers_changed ();
2101*11efff7fSkettenis child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, signo);
2102*11efff7fSkettenis if (debug_linux_nat)
2103*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2104*11efff7fSkettenis "LLW: %s %s, %s (preempt 'handle')\n",
2105*11efff7fSkettenis lp->step ?
2106*11efff7fSkettenis "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2107*11efff7fSkettenis target_pid_to_str (lp->ptid),
2108*11efff7fSkettenis signo ? strsignal (signo) : "0");
2109*11efff7fSkettenis lp->stopped = 0;
2110*11efff7fSkettenis status = 0;
2111*11efff7fSkettenis goto retry;
2112*11efff7fSkettenis }
2113*11efff7fSkettenis
2114*11efff7fSkettenis if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
2115*11efff7fSkettenis {
2116*11efff7fSkettenis /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2117*11efff7fSkettenis forwarded to the entire process group, that is, all LWP's
2118*11efff7fSkettenis will receive it. Since we only want to report it once,
2119*11efff7fSkettenis we try to flush it from all LWPs except this one. */
2120*11efff7fSkettenis sigaddset (&flush_mask, SIGINT);
2121*11efff7fSkettenis }
2122*11efff7fSkettenis }
2123*11efff7fSkettenis
2124*11efff7fSkettenis /* This LWP is stopped now. */
2125*11efff7fSkettenis lp->stopped = 1;
2126*11efff7fSkettenis
2127*11efff7fSkettenis if (debug_linux_nat)
2128*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
2129*11efff7fSkettenis status_to_str (status), target_pid_to_str (lp->ptid));
2130*11efff7fSkettenis
2131*11efff7fSkettenis /* Now stop all other LWP's ... */
2132*11efff7fSkettenis iterate_over_lwps (stop_callback, NULL);
2133*11efff7fSkettenis
2134*11efff7fSkettenis /* ... and wait until all of them have reported back that they're no
2135*11efff7fSkettenis longer running. */
2136*11efff7fSkettenis iterate_over_lwps (stop_wait_callback, &flush_mask);
2137*11efff7fSkettenis iterate_over_lwps (flush_callback, &flush_mask);
2138*11efff7fSkettenis
2139*11efff7fSkettenis /* If we're not waiting for a specific LWP, choose an event LWP from
2140*11efff7fSkettenis among those that have had events. Giving equal priority to all
2141*11efff7fSkettenis LWPs that have had events helps prevent starvation. */
2142*11efff7fSkettenis if (pid == -1)
2143*11efff7fSkettenis select_event_lwp (&lp, &status);
2144*11efff7fSkettenis
2145*11efff7fSkettenis /* Now that we've selected our final event LWP, cancel any
2146*11efff7fSkettenis breakpoints in other LWPs that have hit a GDB breakpoint. See
2147*11efff7fSkettenis the comment in cancel_breakpoints_callback to find out why. */
2148*11efff7fSkettenis iterate_over_lwps (cancel_breakpoints_callback, lp);
2149*11efff7fSkettenis
2150*11efff7fSkettenis /* If we're not running in "threaded" mode, we'll report the bare
2151*11efff7fSkettenis process id. */
2152*11efff7fSkettenis
2153*11efff7fSkettenis if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
2154*11efff7fSkettenis {
2155*11efff7fSkettenis trap_ptid = (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid)));
2156*11efff7fSkettenis if (debug_linux_nat)
2157*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2158*11efff7fSkettenis "LLW: trap_ptid is %s.\n",
2159*11efff7fSkettenis target_pid_to_str (trap_ptid));
2160*11efff7fSkettenis }
2161*11efff7fSkettenis else
2162*11efff7fSkettenis trap_ptid = null_ptid;
2163*11efff7fSkettenis
2164*11efff7fSkettenis if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2165*11efff7fSkettenis {
2166*11efff7fSkettenis *ourstatus = lp->waitstatus;
2167*11efff7fSkettenis lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
2168*11efff7fSkettenis }
2169*11efff7fSkettenis else
2170*11efff7fSkettenis store_waitstatus (ourstatus, status);
2171*11efff7fSkettenis
2172*11efff7fSkettenis return (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid)));
2173*11efff7fSkettenis }
2174*11efff7fSkettenis
2175*11efff7fSkettenis static int
kill_callback(struct lwp_info * lp,void * data)2176*11efff7fSkettenis kill_callback (struct lwp_info *lp, void *data)
2177*11efff7fSkettenis {
2178*11efff7fSkettenis errno = 0;
2179*11efff7fSkettenis ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
2180*11efff7fSkettenis if (debug_linux_nat)
2181*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2182*11efff7fSkettenis "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
2183*11efff7fSkettenis target_pid_to_str (lp->ptid),
2184*11efff7fSkettenis errno ? safe_strerror (errno) : "OK");
2185*11efff7fSkettenis
2186*11efff7fSkettenis return 0;
2187*11efff7fSkettenis }
2188*11efff7fSkettenis
2189*11efff7fSkettenis static int
kill_wait_callback(struct lwp_info * lp,void * data)2190*11efff7fSkettenis kill_wait_callback (struct lwp_info *lp, void *data)
2191*11efff7fSkettenis {
2192*11efff7fSkettenis pid_t pid;
2193*11efff7fSkettenis
2194*11efff7fSkettenis /* We must make sure that there are no pending events (delayed
2195*11efff7fSkettenis SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
2196*11efff7fSkettenis program doesn't interfere with any following debugging session. */
2197*11efff7fSkettenis
2198*11efff7fSkettenis /* For cloned processes we must check both with __WCLONE and
2199*11efff7fSkettenis without, since the exit status of a cloned process isn't reported
2200*11efff7fSkettenis with __WCLONE. */
2201*11efff7fSkettenis if (lp->cloned)
2202*11efff7fSkettenis {
2203*11efff7fSkettenis do
2204*11efff7fSkettenis {
2205*11efff7fSkettenis pid = waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
2206*11efff7fSkettenis if (pid != (pid_t) -1 && debug_linux_nat)
2207*11efff7fSkettenis {
2208*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2209*11efff7fSkettenis "KWC: wait %s received unknown.\n",
2210*11efff7fSkettenis target_pid_to_str (lp->ptid));
2211*11efff7fSkettenis }
2212*11efff7fSkettenis }
2213*11efff7fSkettenis while (pid == GET_LWP (lp->ptid));
2214*11efff7fSkettenis
2215*11efff7fSkettenis gdb_assert (pid == -1 && errno == ECHILD);
2216*11efff7fSkettenis }
2217*11efff7fSkettenis
2218*11efff7fSkettenis do
2219*11efff7fSkettenis {
2220*11efff7fSkettenis pid = waitpid (GET_LWP (lp->ptid), NULL, 0);
2221*11efff7fSkettenis if (pid != (pid_t) -1 && debug_linux_nat)
2222*11efff7fSkettenis {
2223*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2224*11efff7fSkettenis "KWC: wait %s received unk.\n",
2225*11efff7fSkettenis target_pid_to_str (lp->ptid));
2226*11efff7fSkettenis }
2227*11efff7fSkettenis }
2228*11efff7fSkettenis while (pid == GET_LWP (lp->ptid));
2229*11efff7fSkettenis
2230*11efff7fSkettenis gdb_assert (pid == -1 && errno == ECHILD);
2231*11efff7fSkettenis return 0;
2232*11efff7fSkettenis }
2233*11efff7fSkettenis
2234*11efff7fSkettenis static void
linux_nat_kill(void)2235*11efff7fSkettenis linux_nat_kill (void)
2236*11efff7fSkettenis {
2237*11efff7fSkettenis /* Kill all LWP's ... */
2238*11efff7fSkettenis iterate_over_lwps (kill_callback, NULL);
2239*11efff7fSkettenis
2240*11efff7fSkettenis /* ... and wait until we've flushed all events. */
2241*11efff7fSkettenis iterate_over_lwps (kill_wait_callback, NULL);
2242*11efff7fSkettenis
2243*11efff7fSkettenis target_mourn_inferior ();
2244*11efff7fSkettenis }
2245*11efff7fSkettenis
2246*11efff7fSkettenis static void
linux_nat_create_inferior(char * exec_file,char * allargs,char ** env,int from_tty)2247*11efff7fSkettenis linux_nat_create_inferior (char *exec_file, char *allargs, char **env,
2248*11efff7fSkettenis int from_tty)
2249*11efff7fSkettenis {
2250*11efff7fSkettenis deprecated_child_ops.to_create_inferior (exec_file, allargs, env, from_tty);
2251*11efff7fSkettenis }
2252*11efff7fSkettenis
2253*11efff7fSkettenis static void
linux_nat_mourn_inferior(void)2254*11efff7fSkettenis linux_nat_mourn_inferior (void)
2255*11efff7fSkettenis {
2256*11efff7fSkettenis trap_ptid = null_ptid;
2257*11efff7fSkettenis
2258*11efff7fSkettenis /* Destroy LWP info; it's no longer valid. */
2259*11efff7fSkettenis init_lwp_list ();
2260*11efff7fSkettenis
2261*11efff7fSkettenis /* Restore the original signal mask. */
2262*11efff7fSkettenis sigprocmask (SIG_SETMASK, &normal_mask, NULL);
2263*11efff7fSkettenis sigemptyset (&blocked_mask);
2264*11efff7fSkettenis
2265*11efff7fSkettenis deprecated_child_ops.to_mourn_inferior ();
2266*11efff7fSkettenis }
2267*11efff7fSkettenis
2268*11efff7fSkettenis static int
linux_nat_xfer_memory(CORE_ADDR memaddr,char * myaddr,int len,int write,struct mem_attrib * attrib,struct target_ops * target)2269*11efff7fSkettenis linux_nat_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
2270*11efff7fSkettenis struct mem_attrib *attrib, struct target_ops *target)
2271*11efff7fSkettenis {
2272*11efff7fSkettenis struct cleanup *old_chain = save_inferior_ptid ();
2273*11efff7fSkettenis int xfer;
2274*11efff7fSkettenis
2275*11efff7fSkettenis if (is_lwp (inferior_ptid))
2276*11efff7fSkettenis inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
2277*11efff7fSkettenis
2278*11efff7fSkettenis xfer = linux_proc_xfer_memory (memaddr, myaddr, len, write, attrib, target);
2279*11efff7fSkettenis if (xfer == 0)
2280*11efff7fSkettenis xfer = child_xfer_memory (memaddr, myaddr, len, write, attrib, target);
2281*11efff7fSkettenis
2282*11efff7fSkettenis do_cleanups (old_chain);
2283*11efff7fSkettenis return xfer;
2284*11efff7fSkettenis }
2285*11efff7fSkettenis
2286*11efff7fSkettenis static int
linux_nat_thread_alive(ptid_t ptid)2287*11efff7fSkettenis linux_nat_thread_alive (ptid_t ptid)
2288*11efff7fSkettenis {
2289*11efff7fSkettenis gdb_assert (is_lwp (ptid));
2290*11efff7fSkettenis
2291*11efff7fSkettenis errno = 0;
2292*11efff7fSkettenis ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0);
2293*11efff7fSkettenis if (debug_linux_nat)
2294*11efff7fSkettenis fprintf_unfiltered (gdb_stdlog,
2295*11efff7fSkettenis "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
2296*11efff7fSkettenis target_pid_to_str (ptid),
2297*11efff7fSkettenis errno ? safe_strerror (errno) : "OK");
2298*11efff7fSkettenis if (errno)
2299*11efff7fSkettenis return 0;
2300*11efff7fSkettenis
2301*11efff7fSkettenis return 1;
2302*11efff7fSkettenis }
2303*11efff7fSkettenis
2304*11efff7fSkettenis static char *
linux_nat_pid_to_str(ptid_t ptid)2305*11efff7fSkettenis linux_nat_pid_to_str (ptid_t ptid)
2306*11efff7fSkettenis {
2307*11efff7fSkettenis static char buf[64];
2308*11efff7fSkettenis
2309*11efff7fSkettenis if (is_lwp (ptid))
2310*11efff7fSkettenis {
2311*11efff7fSkettenis snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
2312*11efff7fSkettenis return buf;
2313*11efff7fSkettenis }
2314*11efff7fSkettenis
2315*11efff7fSkettenis return normal_pid_to_str (ptid);
2316*11efff7fSkettenis }
2317*11efff7fSkettenis
2318*11efff7fSkettenis static void
init_linux_nat_ops(void)2319*11efff7fSkettenis init_linux_nat_ops (void)
2320*11efff7fSkettenis {
2321*11efff7fSkettenis #if 0
2322*11efff7fSkettenis linux_nat_ops.to_open = linux_nat_open;
2323*11efff7fSkettenis #endif
2324*11efff7fSkettenis linux_nat_ops.to_shortname = "lwp-layer";
2325*11efff7fSkettenis linux_nat_ops.to_longname = "lwp-layer";
2326*11efff7fSkettenis linux_nat_ops.to_doc = "Low level threads support (LWP layer)";
2327*11efff7fSkettenis linux_nat_ops.to_attach = linux_nat_attach;
2328*11efff7fSkettenis linux_nat_ops.to_detach = linux_nat_detach;
2329*11efff7fSkettenis linux_nat_ops.to_resume = linux_nat_resume;
2330*11efff7fSkettenis linux_nat_ops.to_wait = linux_nat_wait;
2331*11efff7fSkettenis /* fetch_inferior_registers and store_inferior_registers will
2332*11efff7fSkettenis honor the LWP id, so we can use them directly. */
2333*11efff7fSkettenis linux_nat_ops.to_fetch_registers = fetch_inferior_registers;
2334*11efff7fSkettenis linux_nat_ops.to_store_registers = store_inferior_registers;
2335*11efff7fSkettenis linux_nat_ops.deprecated_xfer_memory = linux_nat_xfer_memory;
2336*11efff7fSkettenis linux_nat_ops.to_kill = linux_nat_kill;
2337*11efff7fSkettenis linux_nat_ops.to_create_inferior = linux_nat_create_inferior;
2338*11efff7fSkettenis linux_nat_ops.to_mourn_inferior = linux_nat_mourn_inferior;
2339*11efff7fSkettenis linux_nat_ops.to_thread_alive = linux_nat_thread_alive;
2340*11efff7fSkettenis linux_nat_ops.to_pid_to_str = linux_nat_pid_to_str;
2341*11efff7fSkettenis linux_nat_ops.to_post_startup_inferior = child_post_startup_inferior;
2342*11efff7fSkettenis linux_nat_ops.to_post_attach = child_post_attach;
2343*11efff7fSkettenis linux_nat_ops.to_insert_fork_catchpoint = child_insert_fork_catchpoint;
2344*11efff7fSkettenis linux_nat_ops.to_insert_vfork_catchpoint = child_insert_vfork_catchpoint;
2345*11efff7fSkettenis linux_nat_ops.to_insert_exec_catchpoint = child_insert_exec_catchpoint;
2346*11efff7fSkettenis
2347*11efff7fSkettenis linux_nat_ops.to_stratum = thread_stratum;
2348*11efff7fSkettenis linux_nat_ops.to_has_thread_control = tc_schedlock;
2349*11efff7fSkettenis linux_nat_ops.to_magic = OPS_MAGIC;
2350*11efff7fSkettenis }
2351*11efff7fSkettenis
2352*11efff7fSkettenis static void
sigchld_handler(int signo)2353*11efff7fSkettenis sigchld_handler (int signo)
2354*11efff7fSkettenis {
2355*11efff7fSkettenis /* Do nothing. The only reason for this handler is that it allows
2356*11efff7fSkettenis us to use sigsuspend in linux_nat_wait above to wait for the
2357*11efff7fSkettenis arrival of a SIGCHLD. */
2358*11efff7fSkettenis }
2359*11efff7fSkettenis
2360*11efff7fSkettenis /* Accepts an integer PID; Returns a string representing a file that
2361*11efff7fSkettenis can be opened to get the symbols for the child process. */
2362*11efff7fSkettenis
2363*11efff7fSkettenis char *
child_pid_to_exec_file(int pid)2364*11efff7fSkettenis child_pid_to_exec_file (int pid)
2365*11efff7fSkettenis {
2366*11efff7fSkettenis char *name1, *name2;
2367*11efff7fSkettenis
2368*11efff7fSkettenis name1 = xmalloc (MAXPATHLEN);
2369*11efff7fSkettenis name2 = xmalloc (MAXPATHLEN);
2370*11efff7fSkettenis make_cleanup (xfree, name1);
2371*11efff7fSkettenis make_cleanup (xfree, name2);
2372*11efff7fSkettenis memset (name2, 0, MAXPATHLEN);
2373*11efff7fSkettenis
2374*11efff7fSkettenis sprintf (name1, "/proc/%d/exe", pid);
2375*11efff7fSkettenis if (readlink (name1, name2, MAXPATHLEN) > 0)
2376*11efff7fSkettenis return name2;
2377*11efff7fSkettenis else
2378*11efff7fSkettenis return name1;
2379*11efff7fSkettenis }
2380*11efff7fSkettenis
2381*11efff7fSkettenis /* Service function for corefiles and info proc. */
2382*11efff7fSkettenis
2383*11efff7fSkettenis static int
read_mapping(FILE * mapfile,long long * addr,long long * endaddr,char * permissions,long long * offset,char * device,long long * inode,char * filename)2384*11efff7fSkettenis read_mapping (FILE *mapfile,
2385*11efff7fSkettenis long long *addr,
2386*11efff7fSkettenis long long *endaddr,
2387*11efff7fSkettenis char *permissions,
2388*11efff7fSkettenis long long *offset,
2389*11efff7fSkettenis char *device, long long *inode, char *filename)
2390*11efff7fSkettenis {
2391*11efff7fSkettenis int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
2392*11efff7fSkettenis addr, endaddr, permissions, offset, device, inode);
2393*11efff7fSkettenis
2394*11efff7fSkettenis if (ret > 0 && ret != EOF && *inode != 0)
2395*11efff7fSkettenis {
2396*11efff7fSkettenis /* Eat everything up to EOL for the filename. This will prevent
2397*11efff7fSkettenis weird filenames (such as one with embedded whitespace) from
2398*11efff7fSkettenis confusing this code. It also makes this code more robust in
2399*11efff7fSkettenis respect to annotations the kernel may add after the filename.
2400*11efff7fSkettenis
2401*11efff7fSkettenis Note the filename is used for informational purposes
2402*11efff7fSkettenis only. */
2403*11efff7fSkettenis ret += fscanf (mapfile, "%[^\n]\n", filename);
2404*11efff7fSkettenis }
2405*11efff7fSkettenis else
2406*11efff7fSkettenis {
2407*11efff7fSkettenis filename[0] = '\0'; /* no filename */
2408*11efff7fSkettenis fscanf (mapfile, "\n");
2409*11efff7fSkettenis }
2410*11efff7fSkettenis return (ret != 0 && ret != EOF);
2411*11efff7fSkettenis }
2412*11efff7fSkettenis
2413*11efff7fSkettenis /* Fills the "to_find_memory_regions" target vector. Lists the memory
2414*11efff7fSkettenis regions in the inferior for a corefile. */
2415*11efff7fSkettenis
2416*11efff7fSkettenis static int
linux_nat_find_memory_regions(int (* func)(CORE_ADDR,unsigned long,int,int,int,void *),void * obfd)2417*11efff7fSkettenis linux_nat_find_memory_regions (int (*func) (CORE_ADDR,
2418*11efff7fSkettenis unsigned long,
2419*11efff7fSkettenis int, int, int, void *), void *obfd)
2420*11efff7fSkettenis {
2421*11efff7fSkettenis long long pid = PIDGET (inferior_ptid);
2422*11efff7fSkettenis char mapsfilename[MAXPATHLEN];
2423*11efff7fSkettenis FILE *mapsfile;
2424*11efff7fSkettenis long long addr, endaddr, size, offset, inode;
2425*11efff7fSkettenis char permissions[8], device[8], filename[MAXPATHLEN];
2426*11efff7fSkettenis int read, write, exec;
2427*11efff7fSkettenis int ret;
2428*11efff7fSkettenis
2429*11efff7fSkettenis /* Compose the filename for the /proc memory map, and open it. */
2430*11efff7fSkettenis sprintf (mapsfilename, "/proc/%lld/maps", pid);
2431*11efff7fSkettenis if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
2432*11efff7fSkettenis error ("Could not open %s\n", mapsfilename);
2433*11efff7fSkettenis
2434*11efff7fSkettenis if (info_verbose)
2435*11efff7fSkettenis fprintf_filtered (gdb_stdout,
2436*11efff7fSkettenis "Reading memory regions from %s\n", mapsfilename);
2437*11efff7fSkettenis
2438*11efff7fSkettenis /* Now iterate until end-of-file. */
2439*11efff7fSkettenis while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
2440*11efff7fSkettenis &offset, &device[0], &inode, &filename[0]))
2441*11efff7fSkettenis {
2442*11efff7fSkettenis size = endaddr - addr;
2443*11efff7fSkettenis
2444*11efff7fSkettenis /* Get the segment's permissions. */
2445*11efff7fSkettenis read = (strchr (permissions, 'r') != 0);
2446*11efff7fSkettenis write = (strchr (permissions, 'w') != 0);
2447*11efff7fSkettenis exec = (strchr (permissions, 'x') != 0);
2448*11efff7fSkettenis
2449*11efff7fSkettenis if (info_verbose)
2450*11efff7fSkettenis {
2451*11efff7fSkettenis fprintf_filtered (gdb_stdout,
2452*11efff7fSkettenis "Save segment, %lld bytes at 0x%s (%c%c%c)",
2453*11efff7fSkettenis size, paddr_nz (addr),
2454*11efff7fSkettenis read ? 'r' : ' ',
2455*11efff7fSkettenis write ? 'w' : ' ', exec ? 'x' : ' ');
2456*11efff7fSkettenis if (filename && filename[0])
2457*11efff7fSkettenis fprintf_filtered (gdb_stdout, " for %s", filename);
2458*11efff7fSkettenis fprintf_filtered (gdb_stdout, "\n");
2459*11efff7fSkettenis }
2460*11efff7fSkettenis
2461*11efff7fSkettenis /* Invoke the callback function to create the corefile
2462*11efff7fSkettenis segment. */
2463*11efff7fSkettenis func (addr, size, read, write, exec, obfd);
2464*11efff7fSkettenis }
2465*11efff7fSkettenis fclose (mapsfile);
2466*11efff7fSkettenis return 0;
2467*11efff7fSkettenis }
2468*11efff7fSkettenis
2469*11efff7fSkettenis /* Records the thread's register state for the corefile note
2470*11efff7fSkettenis section. */
2471*11efff7fSkettenis
2472*11efff7fSkettenis static char *
linux_nat_do_thread_registers(bfd * obfd,ptid_t ptid,char * note_data,int * note_size)2473*11efff7fSkettenis linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
2474*11efff7fSkettenis char *note_data, int *note_size)
2475*11efff7fSkettenis {
2476*11efff7fSkettenis gdb_gregset_t gregs;
2477*11efff7fSkettenis gdb_fpregset_t fpregs;
2478*11efff7fSkettenis #ifdef FILL_FPXREGSET
2479*11efff7fSkettenis gdb_fpxregset_t fpxregs;
2480*11efff7fSkettenis #endif
2481*11efff7fSkettenis unsigned long lwp = ptid_get_lwp (ptid);
2482*11efff7fSkettenis
2483*11efff7fSkettenis fill_gregset (&gregs, -1);
2484*11efff7fSkettenis note_data = (char *) elfcore_write_prstatus (obfd,
2485*11efff7fSkettenis note_data,
2486*11efff7fSkettenis note_size,
2487*11efff7fSkettenis lwp,
2488*11efff7fSkettenis stop_signal, &gregs);
2489*11efff7fSkettenis
2490*11efff7fSkettenis fill_fpregset (&fpregs, -1);
2491*11efff7fSkettenis note_data = (char *) elfcore_write_prfpreg (obfd,
2492*11efff7fSkettenis note_data,
2493*11efff7fSkettenis note_size,
2494*11efff7fSkettenis &fpregs, sizeof (fpregs));
2495*11efff7fSkettenis #ifdef FILL_FPXREGSET
2496*11efff7fSkettenis fill_fpxregset (&fpxregs, -1);
2497*11efff7fSkettenis note_data = (char *) elfcore_write_prxfpreg (obfd,
2498*11efff7fSkettenis note_data,
2499*11efff7fSkettenis note_size,
2500*11efff7fSkettenis &fpxregs, sizeof (fpxregs));
2501*11efff7fSkettenis #endif
2502*11efff7fSkettenis return note_data;
2503*11efff7fSkettenis }
2504*11efff7fSkettenis
2505*11efff7fSkettenis struct linux_nat_corefile_thread_data
2506*11efff7fSkettenis {
2507*11efff7fSkettenis bfd *obfd;
2508*11efff7fSkettenis char *note_data;
2509*11efff7fSkettenis int *note_size;
2510*11efff7fSkettenis int num_notes;
2511*11efff7fSkettenis };
2512*11efff7fSkettenis
2513*11efff7fSkettenis /* Called by gdbthread.c once per thread. Records the thread's
2514*11efff7fSkettenis register state for the corefile note section. */
2515*11efff7fSkettenis
2516*11efff7fSkettenis static int
linux_nat_corefile_thread_callback(struct lwp_info * ti,void * data)2517*11efff7fSkettenis linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
2518*11efff7fSkettenis {
2519*11efff7fSkettenis struct linux_nat_corefile_thread_data *args = data;
2520*11efff7fSkettenis ptid_t saved_ptid = inferior_ptid;
2521*11efff7fSkettenis
2522*11efff7fSkettenis inferior_ptid = ti->ptid;
2523*11efff7fSkettenis registers_changed ();
2524*11efff7fSkettenis target_fetch_registers (-1); /* FIXME should not be necessary;
2525*11efff7fSkettenis fill_gregset should do it automatically. */
2526*11efff7fSkettenis args->note_data = linux_nat_do_thread_registers (args->obfd,
2527*11efff7fSkettenis ti->ptid,
2528*11efff7fSkettenis args->note_data,
2529*11efff7fSkettenis args->note_size);
2530*11efff7fSkettenis args->num_notes++;
2531*11efff7fSkettenis inferior_ptid = saved_ptid;
2532*11efff7fSkettenis registers_changed ();
2533*11efff7fSkettenis target_fetch_registers (-1); /* FIXME should not be necessary;
2534*11efff7fSkettenis fill_gregset should do it automatically. */
2535*11efff7fSkettenis return 0;
2536*11efff7fSkettenis }
2537*11efff7fSkettenis
2538*11efff7fSkettenis /* Records the register state for the corefile note section. */
2539*11efff7fSkettenis
2540*11efff7fSkettenis static char *
linux_nat_do_registers(bfd * obfd,ptid_t ptid,char * note_data,int * note_size)2541*11efff7fSkettenis linux_nat_do_registers (bfd *obfd, ptid_t ptid,
2542*11efff7fSkettenis char *note_data, int *note_size)
2543*11efff7fSkettenis {
2544*11efff7fSkettenis registers_changed ();
2545*11efff7fSkettenis target_fetch_registers (-1); /* FIXME should not be necessary;
2546*11efff7fSkettenis fill_gregset should do it automatically. */
2547*11efff7fSkettenis return linux_nat_do_thread_registers (obfd,
2548*11efff7fSkettenis ptid_build (ptid_get_pid (inferior_ptid),
2549*11efff7fSkettenis ptid_get_pid (inferior_ptid),
2550*11efff7fSkettenis 0),
2551*11efff7fSkettenis note_data, note_size);
2552*11efff7fSkettenis return note_data;
2553*11efff7fSkettenis }
2554*11efff7fSkettenis
2555*11efff7fSkettenis /* Fills the "to_make_corefile_note" target vector. Builds the note
2556*11efff7fSkettenis section for a corefile, and returns it in a malloc buffer. */
2557*11efff7fSkettenis
2558*11efff7fSkettenis static char *
linux_nat_make_corefile_notes(bfd * obfd,int * note_size)2559*11efff7fSkettenis linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
2560*11efff7fSkettenis {
2561*11efff7fSkettenis struct linux_nat_corefile_thread_data thread_args;
2562*11efff7fSkettenis struct cleanup *old_chain;
2563*11efff7fSkettenis char fname[16] = { '\0' };
2564*11efff7fSkettenis char psargs[80] = { '\0' };
2565*11efff7fSkettenis char *note_data = NULL;
2566*11efff7fSkettenis ptid_t current_ptid = inferior_ptid;
2567*11efff7fSkettenis char *auxv;
2568*11efff7fSkettenis int auxv_len;
2569*11efff7fSkettenis
2570*11efff7fSkettenis if (get_exec_file (0))
2571*11efff7fSkettenis {
2572*11efff7fSkettenis strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
2573*11efff7fSkettenis strncpy (psargs, get_exec_file (0), sizeof (psargs));
2574*11efff7fSkettenis if (get_inferior_args ())
2575*11efff7fSkettenis {
2576*11efff7fSkettenis strncat (psargs, " ", sizeof (psargs) - strlen (psargs));
2577*11efff7fSkettenis strncat (psargs, get_inferior_args (),
2578*11efff7fSkettenis sizeof (psargs) - strlen (psargs));
2579*11efff7fSkettenis }
2580*11efff7fSkettenis note_data = (char *) elfcore_write_prpsinfo (obfd,
2581*11efff7fSkettenis note_data,
2582*11efff7fSkettenis note_size, fname, psargs);
2583*11efff7fSkettenis }
2584*11efff7fSkettenis
2585*11efff7fSkettenis /* Dump information for threads. */
2586*11efff7fSkettenis thread_args.obfd = obfd;
2587*11efff7fSkettenis thread_args.note_data = note_data;
2588*11efff7fSkettenis thread_args.note_size = note_size;
2589*11efff7fSkettenis thread_args.num_notes = 0;
2590*11efff7fSkettenis iterate_over_lwps (linux_nat_corefile_thread_callback, &thread_args);
2591*11efff7fSkettenis if (thread_args.num_notes == 0)
2592*11efff7fSkettenis {
2593*11efff7fSkettenis /* iterate_over_threads didn't come up with any threads; just
2594*11efff7fSkettenis use inferior_ptid. */
2595*11efff7fSkettenis note_data = linux_nat_do_registers (obfd, inferior_ptid,
2596*11efff7fSkettenis note_data, note_size);
2597*11efff7fSkettenis }
2598*11efff7fSkettenis else
2599*11efff7fSkettenis {
2600*11efff7fSkettenis note_data = thread_args.note_data;
2601*11efff7fSkettenis }
2602*11efff7fSkettenis
2603*11efff7fSkettenis auxv_len = target_auxv_read (¤t_target, &auxv);
2604*11efff7fSkettenis if (auxv_len > 0)
2605*11efff7fSkettenis {
2606*11efff7fSkettenis note_data = elfcore_write_note (obfd, note_data, note_size,
2607*11efff7fSkettenis "CORE", NT_AUXV, auxv, auxv_len);
2608*11efff7fSkettenis xfree (auxv);
2609*11efff7fSkettenis }
2610*11efff7fSkettenis
2611*11efff7fSkettenis make_cleanup (xfree, note_data);
2612*11efff7fSkettenis return note_data;
2613*11efff7fSkettenis }
2614*11efff7fSkettenis
2615*11efff7fSkettenis /* Implement the "info proc" command. */
2616*11efff7fSkettenis
2617*11efff7fSkettenis static void
linux_nat_info_proc_cmd(char * args,int from_tty)2618*11efff7fSkettenis linux_nat_info_proc_cmd (char *args, int from_tty)
2619*11efff7fSkettenis {
2620*11efff7fSkettenis long long pid = PIDGET (inferior_ptid);
2621*11efff7fSkettenis FILE *procfile;
2622*11efff7fSkettenis char **argv = NULL;
2623*11efff7fSkettenis char buffer[MAXPATHLEN];
2624*11efff7fSkettenis char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
2625*11efff7fSkettenis int cmdline_f = 1;
2626*11efff7fSkettenis int cwd_f = 1;
2627*11efff7fSkettenis int exe_f = 1;
2628*11efff7fSkettenis int mappings_f = 0;
2629*11efff7fSkettenis int environ_f = 0;
2630*11efff7fSkettenis int status_f = 0;
2631*11efff7fSkettenis int stat_f = 0;
2632*11efff7fSkettenis int all = 0;
2633*11efff7fSkettenis struct stat dummy;
2634*11efff7fSkettenis
2635*11efff7fSkettenis if (args)
2636*11efff7fSkettenis {
2637*11efff7fSkettenis /* Break up 'args' into an argv array. */
2638*11efff7fSkettenis if ((argv = buildargv (args)) == NULL)
2639*11efff7fSkettenis nomem (0);
2640*11efff7fSkettenis else
2641*11efff7fSkettenis make_cleanup_freeargv (argv);
2642*11efff7fSkettenis }
2643*11efff7fSkettenis while (argv != NULL && *argv != NULL)
2644*11efff7fSkettenis {
2645*11efff7fSkettenis if (isdigit (argv[0][0]))
2646*11efff7fSkettenis {
2647*11efff7fSkettenis pid = strtoul (argv[0], NULL, 10);
2648*11efff7fSkettenis }
2649*11efff7fSkettenis else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
2650*11efff7fSkettenis {
2651*11efff7fSkettenis mappings_f = 1;
2652*11efff7fSkettenis }
2653*11efff7fSkettenis else if (strcmp (argv[0], "status") == 0)
2654*11efff7fSkettenis {
2655*11efff7fSkettenis status_f = 1;
2656*11efff7fSkettenis }
2657*11efff7fSkettenis else if (strcmp (argv[0], "stat") == 0)
2658*11efff7fSkettenis {
2659*11efff7fSkettenis stat_f = 1;
2660*11efff7fSkettenis }
2661*11efff7fSkettenis else if (strcmp (argv[0], "cmd") == 0)
2662*11efff7fSkettenis {
2663*11efff7fSkettenis cmdline_f = 1;
2664*11efff7fSkettenis }
2665*11efff7fSkettenis else if (strncmp (argv[0], "exe", strlen (argv[0])) == 0)
2666*11efff7fSkettenis {
2667*11efff7fSkettenis exe_f = 1;
2668*11efff7fSkettenis }
2669*11efff7fSkettenis else if (strcmp (argv[0], "cwd") == 0)
2670*11efff7fSkettenis {
2671*11efff7fSkettenis cwd_f = 1;
2672*11efff7fSkettenis }
2673*11efff7fSkettenis else if (strncmp (argv[0], "all", strlen (argv[0])) == 0)
2674*11efff7fSkettenis {
2675*11efff7fSkettenis all = 1;
2676*11efff7fSkettenis }
2677*11efff7fSkettenis else
2678*11efff7fSkettenis {
2679*11efff7fSkettenis /* [...] (future options here) */
2680*11efff7fSkettenis }
2681*11efff7fSkettenis argv++;
2682*11efff7fSkettenis }
2683*11efff7fSkettenis if (pid == 0)
2684*11efff7fSkettenis error ("No current process: you must name one.");
2685*11efff7fSkettenis
2686*11efff7fSkettenis sprintf (fname1, "/proc/%lld", pid);
2687*11efff7fSkettenis if (stat (fname1, &dummy) != 0)
2688*11efff7fSkettenis error ("No /proc directory: '%s'", fname1);
2689*11efff7fSkettenis
2690*11efff7fSkettenis printf_filtered ("process %lld\n", pid);
2691*11efff7fSkettenis if (cmdline_f || all)
2692*11efff7fSkettenis {
2693*11efff7fSkettenis sprintf (fname1, "/proc/%lld/cmdline", pid);
2694*11efff7fSkettenis if ((procfile = fopen (fname1, "r")) > 0)
2695*11efff7fSkettenis {
2696*11efff7fSkettenis fgets (buffer, sizeof (buffer), procfile);
2697*11efff7fSkettenis printf_filtered ("cmdline = '%s'\n", buffer);
2698*11efff7fSkettenis fclose (procfile);
2699*11efff7fSkettenis }
2700*11efff7fSkettenis else
2701*11efff7fSkettenis warning ("unable to open /proc file '%s'", fname1);
2702*11efff7fSkettenis }
2703*11efff7fSkettenis if (cwd_f || all)
2704*11efff7fSkettenis {
2705*11efff7fSkettenis sprintf (fname1, "/proc/%lld/cwd", pid);
2706*11efff7fSkettenis memset (fname2, 0, sizeof (fname2));
2707*11efff7fSkettenis if (readlink (fname1, fname2, sizeof (fname2)) > 0)
2708*11efff7fSkettenis printf_filtered ("cwd = '%s'\n", fname2);
2709*11efff7fSkettenis else
2710*11efff7fSkettenis warning ("unable to read link '%s'", fname1);
2711*11efff7fSkettenis }
2712*11efff7fSkettenis if (exe_f || all)
2713*11efff7fSkettenis {
2714*11efff7fSkettenis sprintf (fname1, "/proc/%lld/exe", pid);
2715*11efff7fSkettenis memset (fname2, 0, sizeof (fname2));
2716*11efff7fSkettenis if (readlink (fname1, fname2, sizeof (fname2)) > 0)
2717*11efff7fSkettenis printf_filtered ("exe = '%s'\n", fname2);
2718*11efff7fSkettenis else
2719*11efff7fSkettenis warning ("unable to read link '%s'", fname1);
2720*11efff7fSkettenis }
2721*11efff7fSkettenis if (mappings_f || all)
2722*11efff7fSkettenis {
2723*11efff7fSkettenis sprintf (fname1, "/proc/%lld/maps", pid);
2724*11efff7fSkettenis if ((procfile = fopen (fname1, "r")) > 0)
2725*11efff7fSkettenis {
2726*11efff7fSkettenis long long addr, endaddr, size, offset, inode;
2727*11efff7fSkettenis char permissions[8], device[8], filename[MAXPATHLEN];
2728*11efff7fSkettenis
2729*11efff7fSkettenis printf_filtered ("Mapped address spaces:\n\n");
2730*11efff7fSkettenis if (TARGET_ADDR_BIT == 32)
2731*11efff7fSkettenis {
2732*11efff7fSkettenis printf_filtered ("\t%10s %10s %10s %10s %7s\n",
2733*11efff7fSkettenis "Start Addr",
2734*11efff7fSkettenis " End Addr",
2735*11efff7fSkettenis " Size", " Offset", "objfile");
2736*11efff7fSkettenis }
2737*11efff7fSkettenis else
2738*11efff7fSkettenis {
2739*11efff7fSkettenis printf_filtered (" %18s %18s %10s %10s %7s\n",
2740*11efff7fSkettenis "Start Addr",
2741*11efff7fSkettenis " End Addr",
2742*11efff7fSkettenis " Size", " Offset", "objfile");
2743*11efff7fSkettenis }
2744*11efff7fSkettenis
2745*11efff7fSkettenis while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
2746*11efff7fSkettenis &offset, &device[0], &inode, &filename[0]))
2747*11efff7fSkettenis {
2748*11efff7fSkettenis size = endaddr - addr;
2749*11efff7fSkettenis
2750*11efff7fSkettenis /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
2751*11efff7fSkettenis calls here (and possibly above) should be abstracted
2752*11efff7fSkettenis out into their own functions? Andrew suggests using
2753*11efff7fSkettenis a generic local_address_string instead to print out
2754*11efff7fSkettenis the addresses; that makes sense to me, too. */
2755*11efff7fSkettenis
2756*11efff7fSkettenis if (TARGET_ADDR_BIT == 32)
2757*11efff7fSkettenis {
2758*11efff7fSkettenis printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
2759*11efff7fSkettenis (unsigned long) addr, /* FIXME: pr_addr */
2760*11efff7fSkettenis (unsigned long) endaddr,
2761*11efff7fSkettenis (int) size,
2762*11efff7fSkettenis (unsigned int) offset,
2763*11efff7fSkettenis filename[0] ? filename : "");
2764*11efff7fSkettenis }
2765*11efff7fSkettenis else
2766*11efff7fSkettenis {
2767*11efff7fSkettenis printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
2768*11efff7fSkettenis (unsigned long) addr, /* FIXME: pr_addr */
2769*11efff7fSkettenis (unsigned long) endaddr,
2770*11efff7fSkettenis (int) size,
2771*11efff7fSkettenis (unsigned int) offset,
2772*11efff7fSkettenis filename[0] ? filename : "");
2773*11efff7fSkettenis }
2774*11efff7fSkettenis }
2775*11efff7fSkettenis
2776*11efff7fSkettenis fclose (procfile);
2777*11efff7fSkettenis }
2778*11efff7fSkettenis else
2779*11efff7fSkettenis warning ("unable to open /proc file '%s'", fname1);
2780*11efff7fSkettenis }
2781*11efff7fSkettenis if (status_f || all)
2782*11efff7fSkettenis {
2783*11efff7fSkettenis sprintf (fname1, "/proc/%lld/status", pid);
2784*11efff7fSkettenis if ((procfile = fopen (fname1, "r")) > 0)
2785*11efff7fSkettenis {
2786*11efff7fSkettenis while (fgets (buffer, sizeof (buffer), procfile) != NULL)
2787*11efff7fSkettenis puts_filtered (buffer);
2788*11efff7fSkettenis fclose (procfile);
2789*11efff7fSkettenis }
2790*11efff7fSkettenis else
2791*11efff7fSkettenis warning ("unable to open /proc file '%s'", fname1);
2792*11efff7fSkettenis }
2793*11efff7fSkettenis if (stat_f || all)
2794*11efff7fSkettenis {
2795*11efff7fSkettenis sprintf (fname1, "/proc/%lld/stat", pid);
2796*11efff7fSkettenis if ((procfile = fopen (fname1, "r")) > 0)
2797*11efff7fSkettenis {
2798*11efff7fSkettenis int itmp;
2799*11efff7fSkettenis char ctmp;
2800*11efff7fSkettenis
2801*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2802*11efff7fSkettenis printf_filtered ("Process: %d\n", itmp);
2803*11efff7fSkettenis if (fscanf (procfile, "%s ", &buffer[0]) > 0)
2804*11efff7fSkettenis printf_filtered ("Exec file: %s\n", buffer);
2805*11efff7fSkettenis if (fscanf (procfile, "%c ", &ctmp) > 0)
2806*11efff7fSkettenis printf_filtered ("State: %c\n", ctmp);
2807*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2808*11efff7fSkettenis printf_filtered ("Parent process: %d\n", itmp);
2809*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2810*11efff7fSkettenis printf_filtered ("Process group: %d\n", itmp);
2811*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2812*11efff7fSkettenis printf_filtered ("Session id: %d\n", itmp);
2813*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2814*11efff7fSkettenis printf_filtered ("TTY: %d\n", itmp);
2815*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2816*11efff7fSkettenis printf_filtered ("TTY owner process group: %d\n", itmp);
2817*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2818*11efff7fSkettenis printf_filtered ("Flags: 0x%x\n", itmp);
2819*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2820*11efff7fSkettenis printf_filtered ("Minor faults (no memory page): %u\n",
2821*11efff7fSkettenis (unsigned int) itmp);
2822*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2823*11efff7fSkettenis printf_filtered ("Minor faults, children: %u\n",
2824*11efff7fSkettenis (unsigned int) itmp);
2825*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2826*11efff7fSkettenis printf_filtered ("Major faults (memory page faults): %u\n",
2827*11efff7fSkettenis (unsigned int) itmp);
2828*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2829*11efff7fSkettenis printf_filtered ("Major faults, children: %u\n",
2830*11efff7fSkettenis (unsigned int) itmp);
2831*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2832*11efff7fSkettenis printf_filtered ("utime: %d\n", itmp);
2833*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2834*11efff7fSkettenis printf_filtered ("stime: %d\n", itmp);
2835*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2836*11efff7fSkettenis printf_filtered ("utime, children: %d\n", itmp);
2837*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2838*11efff7fSkettenis printf_filtered ("stime, children: %d\n", itmp);
2839*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2840*11efff7fSkettenis printf_filtered ("jiffies remaining in current time slice: %d\n",
2841*11efff7fSkettenis itmp);
2842*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2843*11efff7fSkettenis printf_filtered ("'nice' value: %d\n", itmp);
2844*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2845*11efff7fSkettenis printf_filtered ("jiffies until next timeout: %u\n",
2846*11efff7fSkettenis (unsigned int) itmp);
2847*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2848*11efff7fSkettenis printf_filtered ("jiffies until next SIGALRM: %u\n",
2849*11efff7fSkettenis (unsigned int) itmp);
2850*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2851*11efff7fSkettenis printf_filtered ("start time (jiffies since system boot): %d\n",
2852*11efff7fSkettenis itmp);
2853*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2854*11efff7fSkettenis printf_filtered ("Virtual memory size: %u\n",
2855*11efff7fSkettenis (unsigned int) itmp);
2856*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2857*11efff7fSkettenis printf_filtered ("Resident set size: %u\n", (unsigned int) itmp);
2858*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2859*11efff7fSkettenis printf_filtered ("rlim: %u\n", (unsigned int) itmp);
2860*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2861*11efff7fSkettenis printf_filtered ("Start of text: 0x%x\n", itmp);
2862*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2863*11efff7fSkettenis printf_filtered ("End of text: 0x%x\n", itmp);
2864*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0)
2865*11efff7fSkettenis printf_filtered ("Start of stack: 0x%x\n", itmp);
2866*11efff7fSkettenis #if 0 /* Don't know how architecture-dependent the rest is...
2867*11efff7fSkettenis Anyway the signal bitmap info is available from "status". */
2868*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
2869*11efff7fSkettenis printf_filtered ("Kernel stack pointer: 0x%x\n", itmp);
2870*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
2871*11efff7fSkettenis printf_filtered ("Kernel instr pointer: 0x%x\n", itmp);
2872*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2873*11efff7fSkettenis printf_filtered ("Pending signals bitmap: 0x%x\n", itmp);
2874*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2875*11efff7fSkettenis printf_filtered ("Blocked signals bitmap: 0x%x\n", itmp);
2876*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2877*11efff7fSkettenis printf_filtered ("Ignored signals bitmap: 0x%x\n", itmp);
2878*11efff7fSkettenis if (fscanf (procfile, "%d ", &itmp) > 0)
2879*11efff7fSkettenis printf_filtered ("Catched signals bitmap: 0x%x\n", itmp);
2880*11efff7fSkettenis if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
2881*11efff7fSkettenis printf_filtered ("wchan (system call): 0x%x\n", itmp);
2882*11efff7fSkettenis #endif
2883*11efff7fSkettenis fclose (procfile);
2884*11efff7fSkettenis }
2885*11efff7fSkettenis else
2886*11efff7fSkettenis warning ("unable to open /proc file '%s'", fname1);
2887*11efff7fSkettenis }
2888*11efff7fSkettenis }
2889*11efff7fSkettenis
2890*11efff7fSkettenis int
linux_proc_xfer_memory(CORE_ADDR addr,char * myaddr,int len,int write,struct mem_attrib * attrib,struct target_ops * target)2891*11efff7fSkettenis linux_proc_xfer_memory (CORE_ADDR addr, char *myaddr, int len, int write,
2892*11efff7fSkettenis struct mem_attrib *attrib, struct target_ops *target)
2893*11efff7fSkettenis {
2894*11efff7fSkettenis int fd, ret;
2895*11efff7fSkettenis char filename[64];
2896*11efff7fSkettenis
2897*11efff7fSkettenis if (write)
2898*11efff7fSkettenis return 0;
2899*11efff7fSkettenis
2900*11efff7fSkettenis /* Don't bother for one word. */
2901*11efff7fSkettenis if (len < 3 * sizeof (long))
2902*11efff7fSkettenis return 0;
2903*11efff7fSkettenis
2904*11efff7fSkettenis /* We could keep this file open and cache it - possibly one per
2905*11efff7fSkettenis thread. That requires some juggling, but is even faster. */
2906*11efff7fSkettenis sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
2907*11efff7fSkettenis fd = open (filename, O_RDONLY | O_LARGEFILE);
2908*11efff7fSkettenis if (fd == -1)
2909*11efff7fSkettenis return 0;
2910*11efff7fSkettenis
2911*11efff7fSkettenis /* If pread64 is available, use it. It's faster if the kernel
2912*11efff7fSkettenis supports it (only one syscall), and it's 64-bit safe even on
2913*11efff7fSkettenis 32-bit platforms (for instance, SPARC debugging a SPARC64
2914*11efff7fSkettenis application). */
2915*11efff7fSkettenis #ifdef HAVE_PREAD64
2916*11efff7fSkettenis if (pread64 (fd, myaddr, len, addr) != len)
2917*11efff7fSkettenis #else
2918*11efff7fSkettenis if (lseek (fd, addr, SEEK_SET) == -1 || read (fd, myaddr, len) != len)
2919*11efff7fSkettenis #endif
2920*11efff7fSkettenis ret = 0;
2921*11efff7fSkettenis else
2922*11efff7fSkettenis ret = len;
2923*11efff7fSkettenis
2924*11efff7fSkettenis close (fd);
2925*11efff7fSkettenis return ret;
2926*11efff7fSkettenis }
2927*11efff7fSkettenis
2928*11efff7fSkettenis /* Parse LINE as a signal set and add its set bits to SIGS. */
2929*11efff7fSkettenis
2930*11efff7fSkettenis static void
add_line_to_sigset(const char * line,sigset_t * sigs)2931*11efff7fSkettenis add_line_to_sigset (const char *line, sigset_t *sigs)
2932*11efff7fSkettenis {
2933*11efff7fSkettenis int len = strlen (line) - 1;
2934*11efff7fSkettenis const char *p;
2935*11efff7fSkettenis int signum;
2936*11efff7fSkettenis
2937*11efff7fSkettenis if (line[len] != '\n')
2938*11efff7fSkettenis error ("Could not parse signal set: %s", line);
2939*11efff7fSkettenis
2940*11efff7fSkettenis p = line;
2941*11efff7fSkettenis signum = len * 4;
2942*11efff7fSkettenis while (len-- > 0)
2943*11efff7fSkettenis {
2944*11efff7fSkettenis int digit;
2945*11efff7fSkettenis
2946*11efff7fSkettenis if (*p >= '0' && *p <= '9')
2947*11efff7fSkettenis digit = *p - '0';
2948*11efff7fSkettenis else if (*p >= 'a' && *p <= 'f')
2949*11efff7fSkettenis digit = *p - 'a' + 10;
2950*11efff7fSkettenis else
2951*11efff7fSkettenis error ("Could not parse signal set: %s", line);
2952*11efff7fSkettenis
2953*11efff7fSkettenis signum -= 4;
2954*11efff7fSkettenis
2955*11efff7fSkettenis if (digit & 1)
2956*11efff7fSkettenis sigaddset (sigs, signum + 1);
2957*11efff7fSkettenis if (digit & 2)
2958*11efff7fSkettenis sigaddset (sigs, signum + 2);
2959*11efff7fSkettenis if (digit & 4)
2960*11efff7fSkettenis sigaddset (sigs, signum + 3);
2961*11efff7fSkettenis if (digit & 8)
2962*11efff7fSkettenis sigaddset (sigs, signum + 4);
2963*11efff7fSkettenis
2964*11efff7fSkettenis p++;
2965*11efff7fSkettenis }
2966*11efff7fSkettenis }
2967*11efff7fSkettenis
2968*11efff7fSkettenis /* Find process PID's pending signals from /proc/pid/status and set
2969*11efff7fSkettenis SIGS to match. */
2970*11efff7fSkettenis
2971*11efff7fSkettenis void
linux_proc_pending_signals(int pid,sigset_t * pending,sigset_t * blocked,sigset_t * ignored)2972*11efff7fSkettenis linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored)
2973*11efff7fSkettenis {
2974*11efff7fSkettenis FILE *procfile;
2975*11efff7fSkettenis char buffer[MAXPATHLEN], fname[MAXPATHLEN];
2976*11efff7fSkettenis int signum;
2977*11efff7fSkettenis
2978*11efff7fSkettenis sigemptyset (pending);
2979*11efff7fSkettenis sigemptyset (blocked);
2980*11efff7fSkettenis sigemptyset (ignored);
2981*11efff7fSkettenis sprintf (fname, "/proc/%d/status", pid);
2982*11efff7fSkettenis procfile = fopen (fname, "r");
2983*11efff7fSkettenis if (procfile == NULL)
2984*11efff7fSkettenis error ("Could not open %s", fname);
2985*11efff7fSkettenis
2986*11efff7fSkettenis while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
2987*11efff7fSkettenis {
2988*11efff7fSkettenis /* Normal queued signals are on the SigPnd line in the status
2989*11efff7fSkettenis file. However, 2.6 kernels also have a "shared" pending
2990*11efff7fSkettenis queue for delivering signals to a thread group, so check for
2991*11efff7fSkettenis a ShdPnd line also.
2992*11efff7fSkettenis
2993*11efff7fSkettenis Unfortunately some Red Hat kernels include the shared pending
2994*11efff7fSkettenis queue but not the ShdPnd status field. */
2995*11efff7fSkettenis
2996*11efff7fSkettenis if (strncmp (buffer, "SigPnd:\t", 8) == 0)
2997*11efff7fSkettenis add_line_to_sigset (buffer + 8, pending);
2998*11efff7fSkettenis else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
2999*11efff7fSkettenis add_line_to_sigset (buffer + 8, pending);
3000*11efff7fSkettenis else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
3001*11efff7fSkettenis add_line_to_sigset (buffer + 8, blocked);
3002*11efff7fSkettenis else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
3003*11efff7fSkettenis add_line_to_sigset (buffer + 8, ignored);
3004*11efff7fSkettenis }
3005*11efff7fSkettenis
3006*11efff7fSkettenis fclose (procfile);
3007*11efff7fSkettenis }
3008*11efff7fSkettenis
3009*11efff7fSkettenis void
_initialize_linux_nat(void)3010*11efff7fSkettenis _initialize_linux_nat (void)
3011*11efff7fSkettenis {
3012*11efff7fSkettenis struct sigaction action;
3013*11efff7fSkettenis extern void thread_db_init (struct target_ops *);
3014*11efff7fSkettenis
3015*11efff7fSkettenis deprecated_child_ops.to_find_memory_regions = linux_nat_find_memory_regions;
3016*11efff7fSkettenis deprecated_child_ops.to_make_corefile_notes = linux_nat_make_corefile_notes;
3017*11efff7fSkettenis
3018*11efff7fSkettenis add_info ("proc", linux_nat_info_proc_cmd,
3019*11efff7fSkettenis "Show /proc process information about any running process.\n\
3020*11efff7fSkettenis Specify any process id, or use the program being debugged by default.\n\
3021*11efff7fSkettenis Specify any of the following keywords for detailed info:\n\
3022*11efff7fSkettenis mappings -- list of mapped memory regions.\n\
3023*11efff7fSkettenis stat -- list a bunch of random process info.\n\
3024*11efff7fSkettenis status -- list a different bunch of random process info.\n\
3025*11efff7fSkettenis all -- list all available /proc info.");
3026*11efff7fSkettenis
3027*11efff7fSkettenis init_linux_nat_ops ();
3028*11efff7fSkettenis add_target (&linux_nat_ops);
3029*11efff7fSkettenis thread_db_init (&linux_nat_ops);
3030*11efff7fSkettenis
3031*11efff7fSkettenis /* Save the original signal mask. */
3032*11efff7fSkettenis sigprocmask (SIG_SETMASK, NULL, &normal_mask);
3033*11efff7fSkettenis
3034*11efff7fSkettenis action.sa_handler = sigchld_handler;
3035*11efff7fSkettenis sigemptyset (&action.sa_mask);
3036*11efff7fSkettenis action.sa_flags = 0;
3037*11efff7fSkettenis sigaction (SIGCHLD, &action, NULL);
3038*11efff7fSkettenis
3039*11efff7fSkettenis /* Make sure we don't block SIGCHLD during a sigsuspend. */
3040*11efff7fSkettenis sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
3041*11efff7fSkettenis sigdelset (&suspend_mask, SIGCHLD);
3042*11efff7fSkettenis
3043*11efff7fSkettenis sigemptyset (&blocked_mask);
3044*11efff7fSkettenis
3045*11efff7fSkettenis deprecated_add_show_from_set
3046*11efff7fSkettenis (add_set_cmd ("lin-lwp", no_class, var_zinteger,
3047*11efff7fSkettenis (char *) &debug_linux_nat,
3048*11efff7fSkettenis "Set debugging of GNU/Linux lwp module.\n\
3049*11efff7fSkettenis Enables printf debugging output.\n", &setdebuglist), &showdebuglist);
3050*11efff7fSkettenis }
3051*11efff7fSkettenis
3052*11efff7fSkettenis
3053*11efff7fSkettenis /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
3054*11efff7fSkettenis the GNU/Linux Threads library and therefore doesn't really belong
3055*11efff7fSkettenis here. */
3056*11efff7fSkettenis
3057*11efff7fSkettenis /* Read variable NAME in the target and return its value if found.
3058*11efff7fSkettenis Otherwise return zero. It is assumed that the type of the variable
3059*11efff7fSkettenis is `int'. */
3060*11efff7fSkettenis
3061*11efff7fSkettenis static int
get_signo(const char * name)3062*11efff7fSkettenis get_signo (const char *name)
3063*11efff7fSkettenis {
3064*11efff7fSkettenis struct minimal_symbol *ms;
3065*11efff7fSkettenis int signo;
3066*11efff7fSkettenis
3067*11efff7fSkettenis ms = lookup_minimal_symbol (name, NULL, NULL);
3068*11efff7fSkettenis if (ms == NULL)
3069*11efff7fSkettenis return 0;
3070*11efff7fSkettenis
3071*11efff7fSkettenis if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (char *) &signo,
3072*11efff7fSkettenis sizeof (signo)) != 0)
3073*11efff7fSkettenis return 0;
3074*11efff7fSkettenis
3075*11efff7fSkettenis return signo;
3076*11efff7fSkettenis }
3077*11efff7fSkettenis
3078*11efff7fSkettenis /* Return the set of signals used by the threads library in *SET. */
3079*11efff7fSkettenis
3080*11efff7fSkettenis void
lin_thread_get_thread_signals(sigset_t * set)3081*11efff7fSkettenis lin_thread_get_thread_signals (sigset_t *set)
3082*11efff7fSkettenis {
3083*11efff7fSkettenis struct sigaction action;
3084*11efff7fSkettenis int restart, cancel;
3085*11efff7fSkettenis
3086*11efff7fSkettenis sigemptyset (set);
3087*11efff7fSkettenis
3088*11efff7fSkettenis restart = get_signo ("__pthread_sig_restart");
3089*11efff7fSkettenis if (restart == 0)
3090*11efff7fSkettenis return;
3091*11efff7fSkettenis
3092*11efff7fSkettenis cancel = get_signo ("__pthread_sig_cancel");
3093*11efff7fSkettenis if (cancel == 0)
3094*11efff7fSkettenis return;
3095*11efff7fSkettenis
3096*11efff7fSkettenis sigaddset (set, restart);
3097*11efff7fSkettenis sigaddset (set, cancel);
3098*11efff7fSkettenis
3099*11efff7fSkettenis /* The GNU/Linux Threads library makes terminating threads send a
3100*11efff7fSkettenis special "cancel" signal instead of SIGCHLD. Make sure we catch
3101*11efff7fSkettenis those (to prevent them from terminating GDB itself, which is
3102*11efff7fSkettenis likely to be their default action) and treat them the same way as
3103*11efff7fSkettenis SIGCHLD. */
3104*11efff7fSkettenis
3105*11efff7fSkettenis action.sa_handler = sigchld_handler;
3106*11efff7fSkettenis sigemptyset (&action.sa_mask);
3107*11efff7fSkettenis action.sa_flags = 0;
3108*11efff7fSkettenis sigaction (cancel, &action, NULL);
3109*11efff7fSkettenis
3110*11efff7fSkettenis /* We block the "cancel" signal throughout this code ... */
3111*11efff7fSkettenis sigaddset (&blocked_mask, cancel);
3112*11efff7fSkettenis sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
3113*11efff7fSkettenis
3114*11efff7fSkettenis /* ... except during a sigsuspend. */
3115*11efff7fSkettenis sigdelset (&suspend_mask, cancel);
3116*11efff7fSkettenis }
3117