xref: /openbsd-src/gnu/usr.bin/binutils/gdb/linux-nat.c (revision 11efff7f3ac2b3cfeff0c0cddc14294d9b3aca4f)
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 (&current_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