]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/gdbserver/linux-low.c
ChangeLog:
[thirdparty/binutils-gdb.git] / gdb / gdbserver / linux-low.c
CommitLineData
da6d8c04 1/* Low level interface to ptrace, for the remote server for GDB.
545587ee 2 Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
0fb0cc75 3 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
da6d8c04
DJ
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
da6d8c04
DJ
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
da6d8c04
DJ
19
20#include "server.h"
58caa3dc 21#include "linux-low.h"
d0722149
DE
22#include "ansidecl.h" /* For ATTRIBUTE_PACKED, must be bug in external.h. */
23#include "elf/common.h"
24#include "elf/external.h"
da6d8c04 25
58caa3dc 26#include <sys/wait.h>
da6d8c04
DJ
27#include <stdio.h>
28#include <sys/param.h>
da6d8c04 29#include <sys/ptrace.h>
da6d8c04
DJ
30#include <signal.h>
31#include <sys/ioctl.h>
32#include <fcntl.h>
d07c63e7 33#include <string.h>
0a30fbc4
DJ
34#include <stdlib.h>
35#include <unistd.h>
fa6a77dc 36#include <errno.h>
fd500816 37#include <sys/syscall.h>
f9387fc3 38#include <sched.h>
07e059b5
VP
39#include <ctype.h>
40#include <pwd.h>
41#include <sys/types.h>
42#include <dirent.h>
da6d8c04 43
32ca6d61
DJ
44#ifndef PTRACE_GETSIGINFO
45# define PTRACE_GETSIGINFO 0x4202
46# define PTRACE_SETSIGINFO 0x4203
47#endif
48
fd462a61
DJ
49#ifndef O_LARGEFILE
50#define O_LARGEFILE 0
51#endif
52
24a09b5f
DJ
53/* If the system headers did not provide the constants, hard-code the normal
54 values. */
55#ifndef PTRACE_EVENT_FORK
56
57#define PTRACE_SETOPTIONS 0x4200
58#define PTRACE_GETEVENTMSG 0x4201
59
60/* options set using PTRACE_SETOPTIONS */
61#define PTRACE_O_TRACESYSGOOD 0x00000001
62#define PTRACE_O_TRACEFORK 0x00000002
63#define PTRACE_O_TRACEVFORK 0x00000004
64#define PTRACE_O_TRACECLONE 0x00000008
65#define PTRACE_O_TRACEEXEC 0x00000010
66#define PTRACE_O_TRACEVFORKDONE 0x00000020
67#define PTRACE_O_TRACEEXIT 0x00000040
68
69/* Wait extended result codes for the above trace options. */
70#define PTRACE_EVENT_FORK 1
71#define PTRACE_EVENT_VFORK 2
72#define PTRACE_EVENT_CLONE 3
73#define PTRACE_EVENT_EXEC 4
74#define PTRACE_EVENT_VFORK_DONE 5
75#define PTRACE_EVENT_EXIT 6
76
77#endif /* PTRACE_EVENT_FORK */
78
79/* We can't always assume that this flag is available, but all systems
80 with the ptrace event handlers also have __WALL, so it's safe to use
81 in some contexts. */
82#ifndef __WALL
83#define __WALL 0x40000000 /* Wait for any child. */
84#endif
85
42c81e2a
DJ
86#ifdef __UCLIBC__
87#if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
88#define HAS_NOMMU
89#endif
90#endif
91
24a09b5f
DJ
92/* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
93 representation of the thread ID.
611cb4a5 94
54a0b537 95 ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
95954743
PA
96 the same as the LWP ID.
97
98 ``all_processes'' is keyed by the "overall process ID", which
99 GNU/Linux calls tgid, "thread group ID". */
0d62e5e8 100
54a0b537 101struct inferior_list all_lwps;
0d62e5e8 102
24a09b5f
DJ
103/* A list of all unknown processes which receive stop signals. Some other
104 process will presumably claim each of these as forked children
105 momentarily. */
106
107struct inferior_list stopped_pids;
108
0d62e5e8
DJ
109/* FIXME this is a bit of a hack, and could be removed. */
110int stopping_threads;
111
112/* FIXME make into a target method? */
24a09b5f 113int using_threads = 1;
24a09b5f 114
95954743
PA
115/* This flag is true iff we've just created or attached to our first
116 inferior but it has not stopped yet. As soon as it does, we need
117 to call the low target's arch_setup callback. Doing this only on
118 the first inferior avoids reinializing the architecture on every
119 inferior, and avoids messing with the register caches of the
120 already running inferiors. NOTE: this assumes all inferiors under
121 control of gdbserver have the same architecture. */
d61ddec4
UW
122static int new_inferior;
123
2acc282a 124static void linux_resume_one_lwp (struct lwp_info *lwp,
54a0b537 125 int step, int signal, siginfo_t *info);
2bd7c093 126static void linux_resume (struct thread_resume *resume_info, size_t n);
54a0b537 127static void stop_all_lwps (void);
95954743 128static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
54a0b537 129static int check_removed_breakpoint (struct lwp_info *event_child);
95954743 130static void *add_lwp (ptid_t ptid);
97438e3f 131static int my_waitpid (int pid, int *status, int flags);
c35fafde 132static int linux_stopped_by_watchpoint (void);
95954743 133static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
0d62e5e8
DJ
134
135struct pending_signals
136{
137 int signal;
32ca6d61 138 siginfo_t info;
0d62e5e8
DJ
139 struct pending_signals *prev;
140};
611cb4a5 141
d844cde6 142#define PTRACE_ARG3_TYPE long
c6ecbae5 143#define PTRACE_XFER_TYPE long
da6d8c04 144
58caa3dc 145#ifdef HAVE_LINUX_REGSETS
52fa2412
UW
146static char *disabled_regsets;
147static int num_regsets;
58caa3dc
DJ
148#endif
149
bd99dc85
PA
150/* The read/write ends of the pipe registered as waitable file in the
151 event loop. */
152static int linux_event_pipe[2] = { -1, -1 };
153
154/* True if we're currently in async mode. */
155#define target_is_async_p() (linux_event_pipe[0] != -1)
156
157static void send_sigstop (struct inferior_list_entry *entry);
158static void wait_for_sigstop (struct inferior_list_entry *entry);
159
d0722149
DE
160/* Accepts an integer PID; Returns a string representing a file that
161 can be opened to get info for the child process.
162 Space for the result is malloc'd, caller must free. */
163
164char *
165linux_child_pid_to_exec_file (int pid)
166{
167 char *name1, *name2;
168
169 name1 = xmalloc (MAXPATHLEN);
170 name2 = xmalloc (MAXPATHLEN);
171 memset (name2, 0, MAXPATHLEN);
172
173 sprintf (name1, "/proc/%d/exe", pid);
174 if (readlink (name1, name2, MAXPATHLEN) > 0)
175 {
176 free (name1);
177 return name2;
178 }
179 else
180 {
181 free (name2);
182 return name1;
183 }
184}
185
186/* Return non-zero if HEADER is a 64-bit ELF file. */
187
188static int
189elf_64_header_p (const Elf64_External_Ehdr *header)
190{
191 return (header->e_ident[EI_MAG0] == ELFMAG0
192 && header->e_ident[EI_MAG1] == ELFMAG1
193 && header->e_ident[EI_MAG2] == ELFMAG2
194 && header->e_ident[EI_MAG3] == ELFMAG3
195 && header->e_ident[EI_CLASS] == ELFCLASS64);
196}
197
198/* Return non-zero if FILE is a 64-bit ELF file,
199 zero if the file is not a 64-bit ELF file,
200 and -1 if the file is not accessible or doesn't exist. */
201
202int
203elf_64_file_p (const char *file)
204{
205 Elf64_External_Ehdr header;
206 int fd;
207
208 fd = open (file, O_RDONLY);
209 if (fd < 0)
210 return -1;
211
212 if (read (fd, &header, sizeof (header)) != sizeof (header))
213 {
214 close (fd);
215 return 0;
216 }
217 close (fd);
218
219 return elf_64_header_p (&header);
220}
221
bd99dc85
PA
222static void
223delete_lwp (struct lwp_info *lwp)
224{
225 remove_thread (get_lwp_thread (lwp));
226 remove_inferior (&all_lwps, &lwp->head);
aa5ca48f 227 free (lwp->arch_private);
bd99dc85
PA
228 free (lwp);
229}
230
95954743
PA
231/* Add a process to the common process list, and set its private
232 data. */
233
234static struct process_info *
235linux_add_process (int pid, int attached)
236{
237 struct process_info *proc;
238
239 /* Is this the first process? If so, then set the arch. */
240 if (all_processes.head == NULL)
241 new_inferior = 1;
242
243 proc = add_process (pid, attached);
244 proc->private = xcalloc (1, sizeof (*proc->private));
245
aa5ca48f
DE
246 if (the_low_target.new_process != NULL)
247 proc->private->arch_private = the_low_target.new_process ();
248
95954743
PA
249 return proc;
250}
251
5091eb23
DE
252/* Remove a process from the common process list,
253 also freeing all private data. */
254
255static void
256linux_remove_process (struct process_info *process)
257{
aa5ca48f 258 free (process->private->arch_private);
5091eb23
DE
259 free (process->private);
260 remove_process (process);
261}
262
bd99dc85
PA
263/* Handle a GNU/Linux extended wait response. If we see a clone
264 event, we need to add the new LWP to our list (and not report the
265 trap to higher layers). */
0d62e5e8 266
24a09b5f 267static void
54a0b537 268handle_extended_wait (struct lwp_info *event_child, int wstat)
24a09b5f
DJ
269{
270 int event = wstat >> 16;
54a0b537 271 struct lwp_info *new_lwp;
24a09b5f
DJ
272
273 if (event == PTRACE_EVENT_CLONE)
274 {
95954743 275 ptid_t ptid;
24a09b5f 276 unsigned long new_pid;
836acd6d 277 int ret, status = W_STOPCODE (SIGSTOP);
24a09b5f 278
bd99dc85 279 ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), 0, &new_pid);
24a09b5f
DJ
280
281 /* If we haven't already seen the new PID stop, wait for it now. */
282 if (! pull_pid_from_list (&stopped_pids, new_pid))
283 {
284 /* The new child has a pending SIGSTOP. We can't affect it until it
285 hits the SIGSTOP, but we're already attached. */
286
97438e3f 287 ret = my_waitpid (new_pid, &status, __WALL);
24a09b5f
DJ
288
289 if (ret == -1)
290 perror_with_name ("waiting for new child");
291 else if (ret != new_pid)
292 warning ("wait returned unexpected PID %d", ret);
da5898ce 293 else if (!WIFSTOPPED (status))
24a09b5f
DJ
294 warning ("wait returned unexpected status 0x%x", status);
295 }
296
297 ptrace (PTRACE_SETOPTIONS, new_pid, 0, PTRACE_O_TRACECLONE);
298
95954743
PA
299 ptid = ptid_build (pid_of (event_child), new_pid, 0);
300 new_lwp = (struct lwp_info *) add_lwp (ptid);
301 add_thread (ptid, new_lwp);
24a09b5f 302
e27d73f6
DE
303 /* Either we're going to immediately resume the new thread
304 or leave it stopped. linux_resume_one_lwp is a nop if it
305 thinks the thread is currently running, so set this first
306 before calling linux_resume_one_lwp. */
307 new_lwp->stopped = 1;
308
da5898ce
DJ
309 /* Normally we will get the pending SIGSTOP. But in some cases
310 we might get another signal delivered to the group first.
f21cc1a2 311 If we do get another signal, be sure not to lose it. */
da5898ce
DJ
312 if (WSTOPSIG (status) == SIGSTOP)
313 {
e27d73f6
DE
314 if (! stopping_threads)
315 linux_resume_one_lwp (new_lwp, 0, 0, NULL);
da5898ce 316 }
24a09b5f 317 else
da5898ce 318 {
54a0b537 319 new_lwp->stop_expected = 1;
da5898ce
DJ
320 if (stopping_threads)
321 {
54a0b537
PA
322 new_lwp->status_pending_p = 1;
323 new_lwp->status_pending = status;
da5898ce
DJ
324 }
325 else
326 /* Pass the signal on. This is what GDB does - except
327 shouldn't we really report it instead? */
e27d73f6 328 linux_resume_one_lwp (new_lwp, 0, WSTOPSIG (status), NULL);
da5898ce 329 }
24a09b5f
DJ
330
331 /* Always resume the current thread. If we are stopping
332 threads, it will have a pending SIGSTOP; we may as well
333 collect it now. */
2acc282a 334 linux_resume_one_lwp (event_child, event_child->stepping, 0, NULL);
24a09b5f
DJ
335 }
336}
337
0d62e5e8
DJ
338/* This function should only be called if the process got a SIGTRAP.
339 The SIGTRAP could mean several things.
340
341 On i386, where decr_pc_after_break is non-zero:
342 If we were single-stepping this process using PTRACE_SINGLESTEP,
343 we will get only the one SIGTRAP (even if the instruction we
344 stepped over was a breakpoint). The value of $eip will be the
345 next instruction.
346 If we continue the process using PTRACE_CONT, we will get a
347 SIGTRAP when we hit a breakpoint. The value of $eip will be
348 the instruction after the breakpoint (i.e. needs to be
349 decremented). If we report the SIGTRAP to GDB, we must also
350 report the undecremented PC. If we cancel the SIGTRAP, we
351 must resume at the decremented PC.
352
353 (Presumably, not yet tested) On a non-decr_pc_after_break machine
354 with hardware or kernel single-step:
355 If we single-step over a breakpoint instruction, our PC will
356 point at the following instruction. If we continue and hit a
357 breakpoint instruction, our PC will point at the breakpoint
358 instruction. */
359
360static CORE_ADDR
361get_stop_pc (void)
362{
363 CORE_ADDR stop_pc = (*the_low_target.get_pc) ();
364
47c0c975
DE
365 if (! get_thread_lwp (current_inferior)->stepping)
366 stop_pc -= the_low_target.decr_pc_after_break;
367
368 if (debug_threads)
369 fprintf (stderr, "stop pc is 0x%lx\n", (long) stop_pc);
370
371 return stop_pc;
0d62e5e8 372}
ce3a066d 373
0d62e5e8 374static void *
95954743 375add_lwp (ptid_t ptid)
611cb4a5 376{
54a0b537 377 struct lwp_info *lwp;
0d62e5e8 378
54a0b537
PA
379 lwp = (struct lwp_info *) xmalloc (sizeof (*lwp));
380 memset (lwp, 0, sizeof (*lwp));
0d62e5e8 381
95954743 382 lwp->head.id = ptid;
0d62e5e8 383
aa5ca48f
DE
384 if (the_low_target.new_thread != NULL)
385 lwp->arch_private = the_low_target.new_thread ();
386
54a0b537 387 add_inferior_to_list (&all_lwps, &lwp->head);
0d62e5e8 388
54a0b537 389 return lwp;
0d62e5e8 390}
611cb4a5 391
da6d8c04
DJ
392/* Start an inferior process and returns its pid.
393 ALLARGS is a vector of program-name and args. */
394
ce3a066d
DJ
395static int
396linux_create_inferior (char *program, char **allargs)
da6d8c04 397{
a6dbe5df 398 struct lwp_info *new_lwp;
da6d8c04 399 int pid;
95954743 400 ptid_t ptid;
da6d8c04 401
42c81e2a 402#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437
NS
403 pid = vfork ();
404#else
da6d8c04 405 pid = fork ();
52fb6437 406#endif
da6d8c04
DJ
407 if (pid < 0)
408 perror_with_name ("fork");
409
410 if (pid == 0)
411 {
412 ptrace (PTRACE_TRACEME, 0, 0, 0);
413
254787d4 414 signal (__SIGRTMIN + 1, SIG_DFL);
0d62e5e8 415
a9fa9f7d
DJ
416 setpgid (0, 0);
417
2b876972
DJ
418 execv (program, allargs);
419 if (errno == ENOENT)
420 execvp (program, allargs);
da6d8c04
DJ
421
422 fprintf (stderr, "Cannot exec %s: %s.\n", program,
d07c63e7 423 strerror (errno));
da6d8c04
DJ
424 fflush (stderr);
425 _exit (0177);
426 }
427
95954743
PA
428 linux_add_process (pid, 0);
429
430 ptid = ptid_build (pid, pid, 0);
431 new_lwp = add_lwp (ptid);
432 add_thread (ptid, new_lwp);
a6dbe5df 433 new_lwp->must_set_ptrace_flags = 1;
611cb4a5 434
a9fa9f7d 435 return pid;
da6d8c04
DJ
436}
437
438/* Attach to an inferior process. */
439
95954743
PA
440static void
441linux_attach_lwp_1 (unsigned long lwpid, int initial)
da6d8c04 442{
95954743 443 ptid_t ptid;
54a0b537 444 struct lwp_info *new_lwp;
611cb4a5 445
95954743 446 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) != 0)
da6d8c04 447 {
95954743 448 if (!initial)
2d717e4f
DJ
449 {
450 /* If we fail to attach to an LWP, just warn. */
95954743 451 fprintf (stderr, "Cannot attach to lwp %ld: %s (%d)\n", lwpid,
2d717e4f
DJ
452 strerror (errno), errno);
453 fflush (stderr);
454 return;
455 }
456 else
457 /* If we fail to attach to a process, report an error. */
95954743 458 error ("Cannot attach to lwp %ld: %s (%d)\n", lwpid,
43d5792c 459 strerror (errno), errno);
da6d8c04
DJ
460 }
461
95954743
PA
462 if (initial)
463 /* NOTE/FIXME: This lwp might have not been the tgid. */
464 ptid = ptid_build (lwpid, lwpid, 0);
465 else
466 {
467 /* Note that extracting the pid from the current inferior is
468 safe, since we're always called in the context of the same
469 process as this new thread. */
470 int pid = pid_of (get_thread_lwp (current_inferior));
471 ptid = ptid_build (pid, lwpid, 0);
472 }
24a09b5f 473
95954743
PA
474 new_lwp = (struct lwp_info *) add_lwp (ptid);
475 add_thread (ptid, new_lwp);
0d62e5e8 476
a6dbe5df
PA
477 /* We need to wait for SIGSTOP before being able to make the next
478 ptrace call on this LWP. */
479 new_lwp->must_set_ptrace_flags = 1;
480
0d62e5e8 481 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
0e21c1ec
DE
482 brings it to a halt.
483
484 There are several cases to consider here:
485
486 1) gdbserver has already attached to the process and is being notified
1b3f6016
PA
487 of a new thread that is being created.
488 In this case we should ignore that SIGSTOP and resume the process.
489 This is handled below by setting stop_expected = 1.
0e21c1ec
DE
490
491 2) This is the first thread (the process thread), and we're attaching
1b3f6016
PA
492 to it via attach_inferior.
493 In this case we want the process thread to stop.
494 This is handled by having linux_attach clear stop_expected after
495 we return.
496 ??? If the process already has several threads we leave the other
497 threads running.
0e21c1ec
DE
498
499 3) GDB is connecting to gdbserver and is requesting an enumeration of all
1b3f6016
PA
500 existing threads.
501 In this case we want the thread to stop.
502 FIXME: This case is currently not properly handled.
503 We should wait for the SIGSTOP but don't. Things work apparently
504 because enough time passes between when we ptrace (ATTACH) and when
505 gdb makes the next ptrace call on the thread.
0d62e5e8
DJ
506
507 On the other hand, if we are currently trying to stop all threads, we
508 should treat the new thread as if we had sent it a SIGSTOP. This works
54a0b537 509 because we are guaranteed that the add_lwp call above added us to the
0e21c1ec
DE
510 end of the list, and so the new thread has not yet reached
511 wait_for_sigstop (but will). */
0d62e5e8 512 if (! stopping_threads)
54a0b537 513 new_lwp->stop_expected = 1;
0d62e5e8
DJ
514}
515
95954743
PA
516void
517linux_attach_lwp (unsigned long lwpid)
518{
519 linux_attach_lwp_1 (lwpid, 0);
520}
521
0d62e5e8 522int
a1928bad 523linux_attach (unsigned long pid)
0d62e5e8 524{
54a0b537 525 struct lwp_info *lwp;
0d62e5e8 526
95954743
PA
527 linux_attach_lwp_1 (pid, 1);
528
529 linux_add_process (pid, 1);
0d62e5e8 530
bd99dc85
PA
531 if (!non_stop)
532 {
533 /* Don't ignore the initial SIGSTOP if we just attached to this
534 process. It will be collected by wait shortly. */
95954743
PA
535 lwp = (struct lwp_info *) find_inferior_id (&all_lwps,
536 ptid_build (pid, pid, 0));
bd99dc85
PA
537 lwp->stop_expected = 0;
538 }
0d62e5e8 539
95954743
PA
540 return 0;
541}
542
543struct counter
544{
545 int pid;
546 int count;
547};
548
549static int
550second_thread_of_pid_p (struct inferior_list_entry *entry, void *args)
551{
552 struct counter *counter = args;
553
554 if (ptid_get_pid (entry->id) == counter->pid)
555 {
556 if (++counter->count > 1)
557 return 1;
558 }
d61ddec4 559
da6d8c04
DJ
560 return 0;
561}
562
95954743
PA
563static int
564last_thread_of_process_p (struct thread_info *thread)
565{
566 ptid_t ptid = ((struct inferior_list_entry *)thread)->id;
567 int pid = ptid_get_pid (ptid);
568 struct counter counter = { pid , 0 };
da6d8c04 569
95954743
PA
570 return (find_inferior (&all_threads,
571 second_thread_of_pid_p, &counter) == NULL);
572}
573
574/* Kill the inferior lwp. */
575
576static int
577linux_kill_one_lwp (struct inferior_list_entry *entry, void *args)
da6d8c04 578{
0d62e5e8 579 struct thread_info *thread = (struct thread_info *) entry;
54a0b537 580 struct lwp_info *lwp = get_thread_lwp (thread);
0d62e5e8 581 int wstat;
95954743
PA
582 int pid = * (int *) args;
583
584 if (ptid_get_pid (entry->id) != pid)
585 return 0;
0d62e5e8 586
fd500816
DJ
587 /* We avoid killing the first thread here, because of a Linux kernel (at
588 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
589 the children get a chance to be reaped, it will remain a zombie
590 forever. */
95954743 591
12b42a12 592 if (lwpid_of (lwp) == pid)
95954743
PA
593 {
594 if (debug_threads)
595 fprintf (stderr, "lkop: is last of process %s\n",
596 target_pid_to_str (entry->id));
597 return 0;
598 }
fd500816 599
bd99dc85
PA
600 /* If we're killing a running inferior, make sure it is stopped
601 first, as PTRACE_KILL will not work otherwise. */
602 if (!lwp->stopped)
603 send_sigstop (&lwp->head);
604
0d62e5e8
DJ
605 do
606 {
bd99dc85 607 ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
0d62e5e8
DJ
608
609 /* Make sure it died. The loop is most likely unnecessary. */
95954743 610 pid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
bd99dc85 611 } while (pid > 0 && WIFSTOPPED (wstat));
95954743
PA
612
613 return 0;
da6d8c04
DJ
614}
615
95954743
PA
616static int
617linux_kill (int pid)
0d62e5e8 618{
95954743 619 struct process_info *process;
54a0b537 620 struct lwp_info *lwp;
95954743 621 struct thread_info *thread;
fd500816 622 int wstat;
95954743 623 int lwpid;
fd500816 624
95954743
PA
625 process = find_process_pid (pid);
626 if (process == NULL)
627 return -1;
9d606399 628
95954743 629 find_inferior (&all_threads, linux_kill_one_lwp, &pid);
fd500816 630
54a0b537 631 /* See the comment in linux_kill_one_lwp. We did not kill the first
fd500816 632 thread in the list, so do so now. */
95954743
PA
633 lwp = find_lwp_pid (pid_to_ptid (pid));
634 thread = get_lwp_thread (lwp);
bd99dc85
PA
635
636 if (debug_threads)
95954743
PA
637 fprintf (stderr, "lk_1: killing lwp %ld, for pid: %d\n",
638 lwpid_of (lwp), pid);
bd99dc85
PA
639
640 /* If we're killing a running inferior, make sure it is stopped
641 first, as PTRACE_KILL will not work otherwise. */
642 if (!lwp->stopped)
643 send_sigstop (&lwp->head);
644
fd500816
DJ
645 do
646 {
bd99dc85 647 ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
fd500816
DJ
648
649 /* Make sure it died. The loop is most likely unnecessary. */
95954743
PA
650 lwpid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
651 } while (lwpid > 0 && WIFSTOPPED (wstat));
2d717e4f 652
bd99dc85 653 delete_lwp (lwp);
5091eb23 654 linux_remove_process (process);
95954743 655 return 0;
0d62e5e8
DJ
656}
657
95954743
PA
658static int
659linux_detach_one_lwp (struct inferior_list_entry *entry, void *args)
6ad8ae5c
DJ
660{
661 struct thread_info *thread = (struct thread_info *) entry;
54a0b537 662 struct lwp_info *lwp = get_thread_lwp (thread);
95954743
PA
663 int pid = * (int *) args;
664
665 if (ptid_get_pid (entry->id) != pid)
666 return 0;
6ad8ae5c 667
bd99dc85
PA
668 /* If we're detaching from a running inferior, make sure it is
669 stopped first, as PTRACE_DETACH will not work otherwise. */
670 if (!lwp->stopped)
671 {
95954743 672 int lwpid = lwpid_of (lwp);
bd99dc85
PA
673
674 stopping_threads = 1;
675 send_sigstop (&lwp->head);
676
677 /* If this detects a new thread through a clone event, the new
678 thread is appended to the end of the lwp list, so we'll
679 eventually detach from it. */
680 wait_for_sigstop (&lwp->head);
681 stopping_threads = 0;
682
683 /* If LWP exits while we're trying to stop it, there's nothing
684 left to do. */
95954743 685 lwp = find_lwp_pid (pid_to_ptid (lwpid));
bd99dc85 686 if (lwp == NULL)
95954743 687 return 0;
bd99dc85
PA
688 }
689
ae13219e
DJ
690 /* Make sure the process isn't stopped at a breakpoint that's
691 no longer there. */
54a0b537 692 check_removed_breakpoint (lwp);
ae13219e
DJ
693
694 /* If this process is stopped but is expecting a SIGSTOP, then make
695 sure we take care of that now. This isn't absolutely guaranteed
696 to collect the SIGSTOP, but is fairly likely to. */
54a0b537 697 if (lwp->stop_expected)
ae13219e 698 {
bd99dc85 699 int wstat;
ae13219e 700 /* Clear stop_expected, so that the SIGSTOP will be reported. */
54a0b537
PA
701 lwp->stop_expected = 0;
702 if (lwp->stopped)
2acc282a 703 linux_resume_one_lwp (lwp, 0, 0, NULL);
95954743 704 linux_wait_for_event (lwp->head.id, &wstat, __WALL);
ae13219e
DJ
705 }
706
707 /* Flush any pending changes to the process's registers. */
708 regcache_invalidate_one ((struct inferior_list_entry *)
54a0b537 709 get_lwp_thread (lwp));
ae13219e
DJ
710
711 /* Finally, let it resume. */
bd99dc85
PA
712 ptrace (PTRACE_DETACH, lwpid_of (lwp), 0, 0);
713
714 delete_lwp (lwp);
95954743 715 return 0;
6ad8ae5c
DJ
716}
717
dd6953e1 718static int
95954743 719any_thread_of (struct inferior_list_entry *entry, void *args)
6ad8ae5c 720{
95954743
PA
721 int *pid_p = args;
722
723 if (ptid_get_pid (entry->id) == *pid_p)
724 return 1;
725
726 return 0;
727}
728
729static int
730linux_detach (int pid)
731{
732 struct process_info *process;
733
734 process = find_process_pid (pid);
735 if (process == NULL)
736 return -1;
737
738 current_inferior =
739 (struct thread_info *) find_inferior (&all_threads, any_thread_of, &pid);
740
ae13219e 741 delete_all_breakpoints ();
95954743 742 find_inferior (&all_threads, linux_detach_one_lwp, &pid);
5091eb23 743 linux_remove_process (process);
dd6953e1 744 return 0;
6ad8ae5c
DJ
745}
746
444d6139 747static void
95954743 748linux_join (int pid)
444d6139 749{
444d6139 750 int status, ret;
95954743 751 struct process_info *process;
bd99dc85 752
95954743
PA
753 process = find_process_pid (pid);
754 if (process == NULL)
755 return;
444d6139
PA
756
757 do {
95954743 758 ret = my_waitpid (pid, &status, 0);
444d6139
PA
759 if (WIFEXITED (status) || WIFSIGNALED (status))
760 break;
761 } while (ret != -1 || errno != ECHILD);
762}
763
6ad8ae5c 764/* Return nonzero if the given thread is still alive. */
0d62e5e8 765static int
95954743 766linux_thread_alive (ptid_t ptid)
0d62e5e8 767{
95954743
PA
768 struct lwp_info *lwp = find_lwp_pid (ptid);
769
770 /* We assume we always know if a thread exits. If a whole process
771 exited but we still haven't been able to report it to GDB, we'll
772 hold on to the last lwp of the dead process. */
773 if (lwp != NULL)
774 return !lwp->dead;
0d62e5e8
DJ
775 else
776 return 0;
777}
778
779/* Return nonzero if this process stopped at a breakpoint which
780 no longer appears to be inserted. Also adjust the PC
781 appropriately to resume where the breakpoint used to be. */
ce3a066d 782static int
54a0b537 783check_removed_breakpoint (struct lwp_info *event_child)
da6d8c04 784{
0d62e5e8
DJ
785 CORE_ADDR stop_pc;
786 struct thread_info *saved_inferior;
787
788 if (event_child->pending_is_breakpoint == 0)
789 return 0;
790
791 if (debug_threads)
54a0b537 792 fprintf (stderr, "Checking for breakpoint in lwp %ld.\n",
bd99dc85 793 lwpid_of (event_child));
0d62e5e8
DJ
794
795 saved_inferior = current_inferior;
54a0b537 796 current_inferior = get_lwp_thread (event_child);
0d62e5e8
DJ
797
798 stop_pc = get_stop_pc ();
799
800 /* If the PC has changed since we stopped, then we shouldn't do
801 anything. This happens if, for instance, GDB handled the
802 decr_pc_after_break subtraction itself. */
803 if (stop_pc != event_child->pending_stop_pc)
804 {
805 if (debug_threads)
ae13219e
DJ
806 fprintf (stderr, "Ignoring, PC was changed. Old PC was 0x%08llx\n",
807 event_child->pending_stop_pc);
0d62e5e8
DJ
808
809 event_child->pending_is_breakpoint = 0;
810 current_inferior = saved_inferior;
811 return 0;
812 }
813
814 /* If the breakpoint is still there, we will report hitting it. */
815 if ((*the_low_target.breakpoint_at) (stop_pc))
816 {
817 if (debug_threads)
818 fprintf (stderr, "Ignoring, breakpoint is still present.\n");
819 current_inferior = saved_inferior;
820 return 0;
821 }
822
823 if (debug_threads)
824 fprintf (stderr, "Removed breakpoint.\n");
825
826 /* For decr_pc_after_break targets, here is where we perform the
827 decrement. We go immediately from this function to resuming,
828 and can not safely call get_stop_pc () again. */
829 if (the_low_target.set_pc != NULL)
47c0c975
DE
830 {
831 if (debug_threads)
832 fprintf (stderr, "Set pc to 0x%lx\n", (long) stop_pc);
833 (*the_low_target.set_pc) (stop_pc);
834 }
0d62e5e8
DJ
835
836 /* We consumed the pending SIGTRAP. */
5544ad89 837 event_child->pending_is_breakpoint = 0;
0d62e5e8
DJ
838 event_child->status_pending_p = 0;
839 event_child->status_pending = 0;
840
841 current_inferior = saved_inferior;
da6d8c04
DJ
842 return 1;
843}
844
54a0b537
PA
845/* Return 1 if this lwp has an interesting status pending. This
846 function may silently resume an inferior lwp. */
611cb4a5 847static int
95954743 848status_pending_p (struct inferior_list_entry *entry, void *arg)
0d62e5e8 849{
54a0b537 850 struct lwp_info *lwp = (struct lwp_info *) entry;
95954743
PA
851 ptid_t ptid = * (ptid_t *) arg;
852
853 /* Check if we're only interested in events from a specific process
854 or its lwps. */
855 if (!ptid_equal (minus_one_ptid, ptid)
856 && ptid_get_pid (ptid) != ptid_get_pid (lwp->head.id))
857 return 0;
0d62e5e8 858
bd99dc85 859 if (lwp->status_pending_p && !lwp->suspended)
54a0b537 860 if (check_removed_breakpoint (lwp))
0d62e5e8
DJ
861 {
862 /* This thread was stopped at a breakpoint, and the breakpoint
863 is now gone. We were told to continue (or step...) all threads,
864 so GDB isn't trying to single-step past this breakpoint.
865 So instead of reporting the old SIGTRAP, pretend we got to
866 the breakpoint just after it was removed instead of just
867 before; resume the process. */
2acc282a 868 linux_resume_one_lwp (lwp, 0, 0, NULL);
0d62e5e8
DJ
869 return 0;
870 }
871
bd99dc85 872 return (lwp->status_pending_p && !lwp->suspended);
0d62e5e8
DJ
873}
874
95954743
PA
875static int
876same_lwp (struct inferior_list_entry *entry, void *data)
877{
878 ptid_t ptid = *(ptid_t *) data;
879 int lwp;
880
881 if (ptid_get_lwp (ptid) != 0)
882 lwp = ptid_get_lwp (ptid);
883 else
884 lwp = ptid_get_pid (ptid);
885
886 if (ptid_get_lwp (entry->id) == lwp)
887 return 1;
888
889 return 0;
890}
891
892struct lwp_info *
893find_lwp_pid (ptid_t ptid)
894{
895 return (struct lwp_info*) find_inferior (&all_lwps, same_lwp, &ptid);
896}
897
bd99dc85 898static struct lwp_info *
95954743 899linux_wait_for_lwp (ptid_t ptid, int *wstatp, int options)
611cb4a5 900{
0d62e5e8 901 int ret;
95954743 902 int to_wait_for = -1;
bd99dc85 903 struct lwp_info *child = NULL;
0d62e5e8 904
bd99dc85 905 if (debug_threads)
95954743
PA
906 fprintf (stderr, "linux_wait_for_lwp: %s\n", target_pid_to_str (ptid));
907
908 if (ptid_equal (ptid, minus_one_ptid))
909 to_wait_for = -1; /* any child */
910 else
911 to_wait_for = ptid_get_lwp (ptid); /* this lwp only */
0d62e5e8 912
bd99dc85 913 options |= __WALL;
0d62e5e8 914
bd99dc85 915retry:
0d62e5e8 916
bd99dc85
PA
917 ret = my_waitpid (to_wait_for, wstatp, options);
918 if (ret == 0 || (ret == -1 && errno == ECHILD && (options & WNOHANG)))
919 return NULL;
920 else if (ret == -1)
921 perror_with_name ("waitpid");
0d62e5e8
DJ
922
923 if (debug_threads
924 && (!WIFSTOPPED (*wstatp)
925 || (WSTOPSIG (*wstatp) != 32
926 && WSTOPSIG (*wstatp) != 33)))
927 fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
928
95954743 929 child = find_lwp_pid (pid_to_ptid (ret));
0d62e5e8 930
24a09b5f
DJ
931 /* If we didn't find a process, one of two things presumably happened:
932 - A process we started and then detached from has exited. Ignore it.
933 - A process we are controlling has forked and the new child's stop
934 was reported to us by the kernel. Save its PID. */
bd99dc85 935 if (child == NULL && WIFSTOPPED (*wstatp))
24a09b5f
DJ
936 {
937 add_pid_to_list (&stopped_pids, ret);
938 goto retry;
939 }
bd99dc85 940 else if (child == NULL)
24a09b5f
DJ
941 goto retry;
942
bd99dc85
PA
943 child->stopped = 1;
944 child->pending_is_breakpoint = 0;
0d62e5e8 945
bd99dc85 946 child->last_status = *wstatp;
32ca6d61 947
d61ddec4
UW
948 /* Architecture-specific setup after inferior is running.
949 This needs to happen after we have attached to the inferior
950 and it is stopped for the first time, but before we access
951 any inferior registers. */
952 if (new_inferior)
953 {
954 the_low_target.arch_setup ();
52fa2412
UW
955#ifdef HAVE_LINUX_REGSETS
956 memset (disabled_regsets, 0, num_regsets);
957#endif
d61ddec4
UW
958 new_inferior = 0;
959 }
960
0d62e5e8 961 if (debug_threads
47c0c975
DE
962 && WIFSTOPPED (*wstatp)
963 && the_low_target.get_pc != NULL)
0d62e5e8 964 {
896c7fbb 965 struct thread_info *saved_inferior = current_inferior;
47c0c975
DE
966 CORE_ADDR pc;
967
0d62e5e8 968 current_inferior = (struct thread_info *)
95954743 969 find_inferior_id (&all_threads, child->head.id);
47c0c975
DE
970 pc = (*the_low_target.get_pc) ();
971 fprintf (stderr, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc);
896c7fbb 972 current_inferior = saved_inferior;
0d62e5e8 973 }
bd99dc85
PA
974
975 return child;
0d62e5e8 976}
611cb4a5 977
bd99dc85
PA
978/* Wait for an event from child PID. If PID is -1, wait for any
979 child. Store the stop status through the status pointer WSTAT.
980 OPTIONS is passed to the waitpid call. Return 0 if no child stop
981 event was found and OPTIONS contains WNOHANG. Return the PID of
982 the stopped child otherwise. */
983
0d62e5e8 984static int
95954743 985linux_wait_for_event_1 (ptid_t ptid, int *wstat, int options)
0d62e5e8
DJ
986{
987 CORE_ADDR stop_pc;
bd99dc85 988 struct lwp_info *event_child = NULL;
b65d95c5 989 int bp_status;
bd99dc85 990 struct lwp_info *requested_child = NULL;
0d62e5e8 991
95954743 992 /* Check for a lwp with a pending status. */
0d62e5e8
DJ
993 /* It is possible that the user changed the pending task's registers since
994 it stopped. We correctly handle the change of PC if we hit a breakpoint
e5379b03 995 (in check_removed_breakpoint); signals should be reported anyway. */
bd99dc85 996
95954743
PA
997 if (ptid_equal (ptid, minus_one_ptid)
998 || ptid_equal (pid_to_ptid (ptid_get_pid (ptid)), ptid))
0d62e5e8 999 {
54a0b537 1000 event_child = (struct lwp_info *)
95954743 1001 find_inferior (&all_lwps, status_pending_p, &ptid);
0d62e5e8 1002 if (debug_threads && event_child)
bd99dc85 1003 fprintf (stderr, "Got a pending child %ld\n", lwpid_of (event_child));
0d62e5e8
DJ
1004 }
1005 else
1006 {
95954743 1007 requested_child = find_lwp_pid (ptid);
bd99dc85
PA
1008 if (requested_child->status_pending_p
1009 && !check_removed_breakpoint (requested_child))
1010 event_child = requested_child;
0d62e5e8 1011 }
611cb4a5 1012
0d62e5e8
DJ
1013 if (event_child != NULL)
1014 {
bd99dc85
PA
1015 if (debug_threads)
1016 fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
1017 lwpid_of (event_child), event_child->status_pending);
1018 *wstat = event_child->status_pending;
1019 event_child->status_pending_p = 0;
1020 event_child->status_pending = 0;
1021 current_inferior = get_lwp_thread (event_child);
1022 return lwpid_of (event_child);
0d62e5e8
DJ
1023 }
1024
1025 /* We only enter this loop if no process has a pending wait status. Thus
1026 any action taken in response to a wait status inside this loop is
1027 responding as soon as we detect the status, not after any pending
1028 events. */
1029 while (1)
1030 {
95954743 1031 event_child = linux_wait_for_lwp (ptid, wstat, options);
0d62e5e8 1032
bd99dc85
PA
1033 if ((options & WNOHANG) && event_child == NULL)
1034 return 0;
0d62e5e8
DJ
1035
1036 if (event_child == NULL)
1037 error ("event from unknown child");
611cb4a5 1038
bd99dc85 1039 current_inferior = get_lwp_thread (event_child);
0d62e5e8 1040
89be2091 1041 /* Check for thread exit. */
bd99dc85 1042 if (! WIFSTOPPED (*wstat))
0d62e5e8 1043 {
89be2091 1044 if (debug_threads)
95954743 1045 fprintf (stderr, "LWP %ld exiting\n", lwpid_of (event_child));
89be2091
DJ
1046
1047 /* If the last thread is exiting, just return. */
95954743 1048 if (last_thread_of_process_p (current_inferior))
bd99dc85
PA
1049 {
1050 if (debug_threads)
95954743
PA
1051 fprintf (stderr, "LWP %ld is last lwp of process\n",
1052 lwpid_of (event_child));
bd99dc85
PA
1053 return lwpid_of (event_child);
1054 }
89be2091 1055
bd99dc85 1056 delete_lwp (event_child);
89be2091 1057
bd99dc85
PA
1058 if (!non_stop)
1059 {
1060 current_inferior = (struct thread_info *) all_threads.head;
1061 if (debug_threads)
1062 fprintf (stderr, "Current inferior is now %ld\n",
1063 lwpid_of (get_thread_lwp (current_inferior)));
1064 }
1065 else
1066 {
1067 current_inferior = NULL;
1068 if (debug_threads)
1069 fprintf (stderr, "Current inferior is now <NULL>\n");
1070 }
89be2091
DJ
1071
1072 /* If we were waiting for this particular child to do something...
1073 well, it did something. */
bd99dc85 1074 if (requested_child != NULL)
95954743 1075 return lwpid_of (event_child);
89be2091
DJ
1076
1077 /* Wait for a more interesting event. */
1078 continue;
1079 }
1080
a6dbe5df
PA
1081 if (event_child->must_set_ptrace_flags)
1082 {
1083 ptrace (PTRACE_SETOPTIONS, lwpid_of (event_child),
1084 0, PTRACE_O_TRACECLONE);
1085 event_child->must_set_ptrace_flags = 0;
1086 }
1087
bd99dc85
PA
1088 if (WIFSTOPPED (*wstat)
1089 && WSTOPSIG (*wstat) == SIGSTOP
89be2091
DJ
1090 && event_child->stop_expected)
1091 {
1092 if (debug_threads)
1093 fprintf (stderr, "Expected stop.\n");
1094 event_child->stop_expected = 0;
2acc282a 1095 linux_resume_one_lwp (event_child, event_child->stepping, 0, NULL);
89be2091
DJ
1096 continue;
1097 }
1098
bd99dc85
PA
1099 if (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) == SIGTRAP
1100 && *wstat >> 16 != 0)
24a09b5f 1101 {
bd99dc85 1102 handle_extended_wait (event_child, *wstat);
24a09b5f
DJ
1103 continue;
1104 }
1105
89be2091
DJ
1106 /* If GDB is not interested in this signal, don't stop other
1107 threads, and don't report it to GDB. Just resume the
1108 inferior right away. We do this for threading-related
69f223ed
DJ
1109 signals as well as any that GDB specifically requested we
1110 ignore. But never ignore SIGSTOP if we sent it ourselves,
1111 and do not ignore signals when stepping - they may require
1112 special handling to skip the signal handler. */
89be2091
DJ
1113 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
1114 thread library? */
bd99dc85 1115 if (WIFSTOPPED (*wstat)
69f223ed 1116 && !event_child->stepping
24a09b5f
DJ
1117 && (
1118#ifdef USE_THREAD_DB
95954743 1119 (current_process ()->private->thread_db_active
bd99dc85
PA
1120 && (WSTOPSIG (*wstat) == __SIGRTMIN
1121 || WSTOPSIG (*wstat) == __SIGRTMIN + 1))
24a09b5f
DJ
1122 ||
1123#endif
bd99dc85
PA
1124 (pass_signals[target_signal_from_host (WSTOPSIG (*wstat))]
1125 && (WSTOPSIG (*wstat) != SIGSTOP || !stopping_threads))))
89be2091
DJ
1126 {
1127 siginfo_t info, *info_p;
1128
1129 if (debug_threads)
24a09b5f 1130 fprintf (stderr, "Ignored signal %d for LWP %ld.\n",
bd99dc85 1131 WSTOPSIG (*wstat), lwpid_of (event_child));
89be2091 1132
bd99dc85 1133 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child), 0, &info) == 0)
89be2091
DJ
1134 info_p = &info;
1135 else
1136 info_p = NULL;
2acc282a 1137 linux_resume_one_lwp (event_child,
54a0b537 1138 event_child->stepping,
bd99dc85 1139 WSTOPSIG (*wstat), info_p);
89be2091 1140 continue;
0d62e5e8 1141 }
611cb4a5 1142
0d62e5e8
DJ
1143 /* If this event was not handled above, and is not a SIGTRAP, report
1144 it. */
bd99dc85
PA
1145 if (!WIFSTOPPED (*wstat) || WSTOPSIG (*wstat) != SIGTRAP)
1146 return lwpid_of (event_child);
611cb4a5 1147
0d62e5e8
DJ
1148 /* If this target does not support breakpoints, we simply report the
1149 SIGTRAP; it's of no concern to us. */
1150 if (the_low_target.get_pc == NULL)
bd99dc85 1151 return lwpid_of (event_child);
0d62e5e8
DJ
1152
1153 stop_pc = get_stop_pc ();
1154
1155 /* bp_reinsert will only be set if we were single-stepping.
1156 Notice that we will resume the process after hitting
1157 a gdbserver breakpoint; single-stepping to/over one
1158 is not supported (yet). */
1159 if (event_child->bp_reinsert != 0)
1160 {
1161 if (debug_threads)
1162 fprintf (stderr, "Reinserted breakpoint.\n");
1163 reinsert_breakpoint (event_child->bp_reinsert);
1164 event_child->bp_reinsert = 0;
1165
1166 /* Clear the single-stepping flag and SIGTRAP as we resume. */
2acc282a 1167 linux_resume_one_lwp (event_child, 0, 0, NULL);
0d62e5e8
DJ
1168 continue;
1169 }
1170
b65d95c5 1171 bp_status = check_breakpoints (stop_pc);
0d62e5e8 1172
b65d95c5 1173 if (bp_status != 0)
0d62e5e8 1174 {
b65d95c5
DJ
1175 if (debug_threads)
1176 fprintf (stderr, "Hit a gdbserver breakpoint.\n");
1177
0d62e5e8 1178 /* We hit one of our own breakpoints. We mark it as a pending
e5379b03 1179 breakpoint, so that check_removed_breakpoint () will do the PC
0d62e5e8
DJ
1180 adjustment for us at the appropriate time. */
1181 event_child->pending_is_breakpoint = 1;
1182 event_child->pending_stop_pc = stop_pc;
1183
b65d95c5 1184 /* We may need to put the breakpoint back. We continue in the event
0d62e5e8
DJ
1185 loop instead of simply replacing the breakpoint right away,
1186 in order to not lose signals sent to the thread that hit the
1187 breakpoint. Unfortunately this increases the window where another
1188 thread could sneak past the removed breakpoint. For the current
1189 use of server-side breakpoints (thread creation) this is
1190 acceptable; but it needs to be considered before this breakpoint
1191 mechanism can be used in more general ways. For some breakpoints
1192 it may be necessary to stop all other threads, but that should
1193 be avoided where possible.
1194
1195 If breakpoint_reinsert_addr is NULL, that means that we can
1196 use PTRACE_SINGLESTEP on this platform. Uninsert the breakpoint,
1197 mark it for reinsertion, and single-step.
1198
1199 Otherwise, call the target function to figure out where we need
1200 our temporary breakpoint, create it, and continue executing this
1201 process. */
bd99dc85
PA
1202
1203 /* NOTE: we're lifting breakpoints in non-stop mode. This
1204 is currently only used for thread event breakpoints, so
1205 it isn't that bad as long as we have PTRACE_EVENT_CLONE
1206 events. */
b65d95c5
DJ
1207 if (bp_status == 2)
1208 /* No need to reinsert. */
2acc282a 1209 linux_resume_one_lwp (event_child, 0, 0, NULL);
b65d95c5 1210 else if (the_low_target.breakpoint_reinsert_addr == NULL)
0d62e5e8
DJ
1211 {
1212 event_child->bp_reinsert = stop_pc;
1213 uninsert_breakpoint (stop_pc);
2acc282a 1214 linux_resume_one_lwp (event_child, 1, 0, NULL);
0d62e5e8
DJ
1215 }
1216 else
1217 {
1218 reinsert_breakpoint_by_bp
1219 (stop_pc, (*the_low_target.breakpoint_reinsert_addr) ());
2acc282a 1220 linux_resume_one_lwp (event_child, 0, 0, NULL);
611cb4a5 1221 }
0d62e5e8
DJ
1222
1223 continue;
1224 }
1225
b65d95c5
DJ
1226 if (debug_threads)
1227 fprintf (stderr, "Hit a non-gdbserver breakpoint.\n");
1228
0d62e5e8 1229 /* If we were single-stepping, we definitely want to report the
c35fafde
PA
1230 SIGTRAP. Although the single-step operation has completed,
1231 do not clear clear the stepping flag yet; we need to check it
1232 in wait_for_sigstop. */
0d62e5e8 1233 if (event_child->stepping)
bd99dc85 1234 return lwpid_of (event_child);
0d62e5e8
DJ
1235
1236 /* A SIGTRAP that we can't explain. It may have been a breakpoint.
1237 Check if it is a breakpoint, and if so mark the process information
1238 accordingly. This will handle both the necessary fiddling with the
1239 PC on decr_pc_after_break targets and suppressing extra threads
1240 hitting a breakpoint if two hit it at once and then GDB removes it
1241 after the first is reported. Arguably it would be better to report
1242 multiple threads hitting breakpoints simultaneously, but the current
1243 remote protocol does not allow this. */
1244 if ((*the_low_target.breakpoint_at) (stop_pc))
1245 {
1246 event_child->pending_is_breakpoint = 1;
1247 event_child->pending_stop_pc = stop_pc;
611cb4a5
DJ
1248 }
1249
bd99dc85 1250 return lwpid_of (event_child);
611cb4a5 1251 }
0d62e5e8 1252
611cb4a5
DJ
1253 /* NOTREACHED */
1254 return 0;
1255}
1256
95954743
PA
1257static int
1258linux_wait_for_event (ptid_t ptid, int *wstat, int options)
1259{
1260 ptid_t wait_ptid;
1261
1262 if (ptid_is_pid (ptid))
1263 {
1264 /* A request to wait for a specific tgid. This is not possible
1265 with waitpid, so instead, we wait for any child, and leave
1266 children we're not interested in right now with a pending
1267 status to report later. */
1268 wait_ptid = minus_one_ptid;
1269 }
1270 else
1271 wait_ptid = ptid;
1272
1273 while (1)
1274 {
1275 int event_pid;
1276
1277 event_pid = linux_wait_for_event_1 (wait_ptid, wstat, options);
1278
1279 if (event_pid > 0
1280 && ptid_is_pid (ptid) && ptid_get_pid (ptid) != event_pid)
1281 {
1282 struct lwp_info *event_child = find_lwp_pid (pid_to_ptid (event_pid));
1283
1284 if (! WIFSTOPPED (*wstat))
1285 mark_lwp_dead (event_child, *wstat);
1286 else
1287 {
1288 event_child->status_pending_p = 1;
1289 event_child->status_pending = *wstat;
1290 }
1291 }
1292 else
1293 return event_pid;
1294 }
1295}
1296
0d62e5e8 1297/* Wait for process, returns status. */
da6d8c04 1298
95954743
PA
1299static ptid_t
1300linux_wait_1 (ptid_t ptid,
1301 struct target_waitstatus *ourstatus, int target_options)
da6d8c04 1302{
e5f1222d 1303 int w;
bd99dc85
PA
1304 struct thread_info *thread = NULL;
1305 struct lwp_info *lwp = NULL;
1306 int options;
bd99dc85
PA
1307 int pid;
1308
1309 /* Translate generic target options into linux options. */
1310 options = __WALL;
1311 if (target_options & TARGET_WNOHANG)
1312 options |= WNOHANG;
0d62e5e8
DJ
1313
1314retry:
bd99dc85
PA
1315 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1316
0d62e5e8
DJ
1317 /* If we were only supposed to resume one thread, only wait for
1318 that thread - if it's still alive. If it died, however - which
1319 can happen if we're coming from the thread death case below -
1320 then we need to make sure we restart the other threads. We could
1321 pick a thread at random or restart all; restarting all is less
1322 arbitrary. */
95954743
PA
1323 if (!non_stop
1324 && !ptid_equal (cont_thread, null_ptid)
1325 && !ptid_equal (cont_thread, minus_one_ptid))
0d62e5e8 1326 {
bd99dc85
PA
1327 thread = (struct thread_info *) find_inferior_id (&all_threads,
1328 cont_thread);
0d62e5e8
DJ
1329
1330 /* No stepping, no signal - unless one is pending already, of course. */
bd99dc85 1331 if (thread == NULL)
64386c31
DJ
1332 {
1333 struct thread_resume resume_info;
95954743 1334 resume_info.thread = minus_one_ptid;
bd99dc85
PA
1335 resume_info.kind = resume_continue;
1336 resume_info.sig = 0;
2bd7c093 1337 linux_resume (&resume_info, 1);
64386c31 1338 }
bd99dc85 1339 else
95954743 1340 ptid = cont_thread;
0d62e5e8 1341 }
da6d8c04 1342
95954743 1343 pid = linux_wait_for_event (ptid, &w, options);
bd99dc85 1344 if (pid == 0) /* only if TARGET_WNOHANG */
95954743 1345 return null_ptid;
bd99dc85
PA
1346
1347 lwp = get_thread_lwp (current_inferior);
da6d8c04 1348
0d62e5e8
DJ
1349 /* If we are waiting for a particular child, and it exited,
1350 linux_wait_for_event will return its exit status. Similarly if
1351 the last child exited. If this is not the last child, however,
1352 do not report it as exited until there is a 'thread exited' response
1353 available in the remote protocol. Instead, just wait for another event.
1354 This should be safe, because if the thread crashed we will already
1355 have reported the termination signal to GDB; that should stop any
1356 in-progress stepping operations, etc.
1357
1358 Report the exit status of the last thread to exit. This matches
1359 LinuxThreads' behavior. */
1360
95954743 1361 if (last_thread_of_process_p (current_inferior))
da6d8c04 1362 {
bd99dc85 1363 if (WIFEXITED (w) || WIFSIGNALED (w))
0d62e5e8 1364 {
95954743
PA
1365 int pid = pid_of (lwp);
1366 struct process_info *process = find_process_pid (pid);
5b1c542e 1367
bd99dc85 1368 delete_lwp (lwp);
5091eb23 1369 linux_remove_process (process);
5b1c542e 1370
bd99dc85 1371 current_inferior = NULL;
5b1c542e 1372
bd99dc85
PA
1373 if (WIFEXITED (w))
1374 {
1375 ourstatus->kind = TARGET_WAITKIND_EXITED;
1376 ourstatus->value.integer = WEXITSTATUS (w);
1377
1378 if (debug_threads)
1379 fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
1380 }
1381 else
1382 {
1383 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1384 ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));
1385
1386 if (debug_threads)
1387 fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
1388
1389 }
5b1c542e 1390
95954743 1391 return pid_to_ptid (pid);
0d62e5e8 1392 }
da6d8c04 1393 }
0d62e5e8 1394 else
da6d8c04 1395 {
0d62e5e8
DJ
1396 if (!WIFSTOPPED (w))
1397 goto retry;
da6d8c04
DJ
1398 }
1399
bd99dc85
PA
1400 /* In all-stop, stop all threads. Be careful to only do this if
1401 we're about to report an event to GDB. */
1402 if (!non_stop)
1403 stop_all_lwps ();
1404
5b1c542e 1405 ourstatus->kind = TARGET_WAITKIND_STOPPED;
5b1c542e 1406
bd99dc85
PA
1407 if (lwp->suspended && WSTOPSIG (w) == SIGSTOP)
1408 {
1409 /* A thread that has been requested to stop by GDB with vCont;t,
1410 and it stopped cleanly, so report as SIG0. The use of
1411 SIGSTOP is an implementation detail. */
1412 ourstatus->value.sig = TARGET_SIGNAL_0;
1413 }
1414 else if (lwp->suspended && WSTOPSIG (w) != SIGSTOP)
1415 {
1416 /* A thread that has been requested to stop by GDB with vCont;t,
1417 but, it stopped for other reasons. Set stop_expected so the
1418 pending SIGSTOP is ignored and the LWP is resumed. */
1419 lwp->stop_expected = 1;
1420 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
1421 }
1422 else
1423 {
1424 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
1425 }
1426
1427 if (debug_threads)
95954743
PA
1428 fprintf (stderr, "linux_wait ret = %s, %d, %d\n",
1429 target_pid_to_str (lwp->head.id),
bd99dc85
PA
1430 ourstatus->kind,
1431 ourstatus->value.sig);
1432
95954743 1433 return lwp->head.id;
bd99dc85
PA
1434}
1435
1436/* Get rid of any pending event in the pipe. */
1437static void
1438async_file_flush (void)
1439{
1440 int ret;
1441 char buf;
1442
1443 do
1444 ret = read (linux_event_pipe[0], &buf, 1);
1445 while (ret >= 0 || (ret == -1 && errno == EINTR));
1446}
1447
1448/* Put something in the pipe, so the event loop wakes up. */
1449static void
1450async_file_mark (void)
1451{
1452 int ret;
1453
1454 async_file_flush ();
1455
1456 do
1457 ret = write (linux_event_pipe[1], "+", 1);
1458 while (ret == 0 || (ret == -1 && errno == EINTR));
1459
1460 /* Ignore EAGAIN. If the pipe is full, the event loop will already
1461 be awakened anyway. */
1462}
1463
95954743
PA
1464static ptid_t
1465linux_wait (ptid_t ptid,
1466 struct target_waitstatus *ourstatus, int target_options)
bd99dc85 1467{
95954743 1468 ptid_t event_ptid;
bd99dc85
PA
1469
1470 if (debug_threads)
95954743 1471 fprintf (stderr, "linux_wait: [%s]\n", target_pid_to_str (ptid));
bd99dc85
PA
1472
1473 /* Flush the async file first. */
1474 if (target_is_async_p ())
1475 async_file_flush ();
1476
95954743 1477 event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
bd99dc85
PA
1478
1479 /* If at least one stop was reported, there may be more. A single
1480 SIGCHLD can signal more than one child stop. */
1481 if (target_is_async_p ()
1482 && (target_options & TARGET_WNOHANG) != 0
95954743 1483 && !ptid_equal (event_ptid, null_ptid))
bd99dc85
PA
1484 async_file_mark ();
1485
1486 return event_ptid;
da6d8c04
DJ
1487}
1488
fd500816
DJ
1489/* Send a signal to an LWP. For LinuxThreads, kill is enough; however, if
1490 thread groups are in use, we need to use tkill. */
1491
1492static int
a1928bad 1493kill_lwp (unsigned long lwpid, int signo)
fd500816
DJ
1494{
1495 static int tkill_failed;
1496
1497 errno = 0;
1498
1499#ifdef SYS_tkill
1500 if (!tkill_failed)
1501 {
1502 int ret = syscall (SYS_tkill, lwpid, signo);
1503 if (errno != ENOSYS)
1b3f6016 1504 return ret;
fd500816
DJ
1505 errno = 0;
1506 tkill_failed = 1;
1507 }
1508#endif
1509
1510 return kill (lwpid, signo);
1511}
1512
0d62e5e8
DJ
1513static void
1514send_sigstop (struct inferior_list_entry *entry)
1515{
54a0b537 1516 struct lwp_info *lwp = (struct lwp_info *) entry;
bd99dc85 1517 int pid;
0d62e5e8 1518
54a0b537 1519 if (lwp->stopped)
0d62e5e8
DJ
1520 return;
1521
bd99dc85
PA
1522 pid = lwpid_of (lwp);
1523
0d62e5e8
DJ
1524 /* If we already have a pending stop signal for this process, don't
1525 send another. */
54a0b537 1526 if (lwp->stop_expected)
0d62e5e8 1527 {
ae13219e 1528 if (debug_threads)
bd99dc85 1529 fprintf (stderr, "Have pending sigstop for lwp %d\n", pid);
ae13219e
DJ
1530
1531 /* We clear the stop_expected flag so that wait_for_sigstop
1532 will receive the SIGSTOP event (instead of silently resuming and
1533 waiting again). It'll be reset below. */
54a0b537 1534 lwp->stop_expected = 0;
0d62e5e8
DJ
1535 return;
1536 }
1537
1538 if (debug_threads)
bd99dc85 1539 fprintf (stderr, "Sending sigstop to lwp %d\n", pid);
0d62e5e8 1540
bd99dc85 1541 kill_lwp (pid, SIGSTOP);
0d62e5e8
DJ
1542}
1543
95954743
PA
1544static void
1545mark_lwp_dead (struct lwp_info *lwp, int wstat)
1546{
1547 /* It's dead, really. */
1548 lwp->dead = 1;
1549
1550 /* Store the exit status for later. */
1551 lwp->status_pending_p = 1;
1552 lwp->status_pending = wstat;
1553
1554 /* So that check_removed_breakpoint doesn't try to figure out if
1555 this is stopped at a breakpoint. */
1556 lwp->pending_is_breakpoint = 0;
1557
1558 /* Prevent trying to stop it. */
1559 lwp->stopped = 1;
1560
1561 /* No further stops are expected from a dead lwp. */
1562 lwp->stop_expected = 0;
1563}
1564
0d62e5e8
DJ
1565static void
1566wait_for_sigstop (struct inferior_list_entry *entry)
1567{
54a0b537 1568 struct lwp_info *lwp = (struct lwp_info *) entry;
bd99dc85 1569 struct thread_info *saved_inferior;
a1928bad 1570 int wstat;
95954743
PA
1571 ptid_t saved_tid;
1572 ptid_t ptid;
0d62e5e8 1573
54a0b537 1574 if (lwp->stopped)
0d62e5e8
DJ
1575 return;
1576
1577 saved_inferior = current_inferior;
bd99dc85
PA
1578 if (saved_inferior != NULL)
1579 saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
1580 else
95954743 1581 saved_tid = null_ptid; /* avoid bogus unused warning */
bd99dc85 1582
95954743 1583 ptid = lwp->head.id;
bd99dc85
PA
1584
1585 linux_wait_for_event (ptid, &wstat, __WALL);
0d62e5e8
DJ
1586
1587 /* If we stopped with a non-SIGSTOP signal, save it for later
1588 and record the pending SIGSTOP. If the process exited, just
1589 return. */
1590 if (WIFSTOPPED (wstat)
1591 && WSTOPSIG (wstat) != SIGSTOP)
1592 {
1593 if (debug_threads)
24a09b5f 1594 fprintf (stderr, "LWP %ld stopped with non-sigstop status %06x\n",
bd99dc85 1595 lwpid_of (lwp), wstat);
c35fafde
PA
1596
1597 /* Do not leave a pending single-step finish to be reported to
1598 the client. The client will give us a new action for this
1599 thread, possibly a continue request --- otherwise, the client
1600 would consider this pending SIGTRAP reported later a spurious
1601 signal. */
1602 if (WSTOPSIG (wstat) == SIGTRAP
1603 && lwp->stepping
1604 && !linux_stopped_by_watchpoint ())
1605 {
1606 if (debug_threads)
1607 fprintf (stderr, " single-step SIGTRAP ignored\n");
1608 }
1609 else
1610 {
1611 lwp->status_pending_p = 1;
1612 lwp->status_pending = wstat;
1613 }
54a0b537 1614 lwp->stop_expected = 1;
0d62e5e8 1615 }
95954743
PA
1616 else if (!WIFSTOPPED (wstat))
1617 {
1618 if (debug_threads)
1619 fprintf (stderr, "Process %ld exited while stopping LWPs\n",
1620 lwpid_of (lwp));
1621
1622 /* Leave this status pending for the next time we're able to
1623 report it. In the mean time, we'll report this lwp as dead
1624 to GDB, so GDB doesn't try to read registers and memory from
1625 it. */
1626 mark_lwp_dead (lwp, wstat);
1627 }
0d62e5e8 1628
bd99dc85 1629 if (saved_inferior == NULL || linux_thread_alive (saved_tid))
0d62e5e8
DJ
1630 current_inferior = saved_inferior;
1631 else
1632 {
1633 if (debug_threads)
1634 fprintf (stderr, "Previously current thread died.\n");
1635
bd99dc85
PA
1636 if (non_stop)
1637 {
1638 /* We can't change the current inferior behind GDB's back,
1639 otherwise, a subsequent command may apply to the wrong
1640 process. */
1641 current_inferior = NULL;
1642 }
1643 else
1644 {
1645 /* Set a valid thread as current. */
1646 set_desired_inferior (0);
1647 }
0d62e5e8
DJ
1648 }
1649}
1650
1651static void
54a0b537 1652stop_all_lwps (void)
0d62e5e8
DJ
1653{
1654 stopping_threads = 1;
54a0b537
PA
1655 for_each_inferior (&all_lwps, send_sigstop);
1656 for_each_inferior (&all_lwps, wait_for_sigstop);
0d62e5e8
DJ
1657 stopping_threads = 0;
1658}
1659
da6d8c04
DJ
1660/* Resume execution of the inferior process.
1661 If STEP is nonzero, single-step it.
1662 If SIGNAL is nonzero, give it that signal. */
1663
ce3a066d 1664static void
2acc282a 1665linux_resume_one_lwp (struct lwp_info *lwp,
54a0b537 1666 int step, int signal, siginfo_t *info)
da6d8c04 1667{
0d62e5e8
DJ
1668 struct thread_info *saved_inferior;
1669
54a0b537 1670 if (lwp->stopped == 0)
0d62e5e8
DJ
1671 return;
1672
1673 /* If we have pending signals or status, and a new signal, enqueue the
1674 signal. Also enqueue the signal if we are waiting to reinsert a
1675 breakpoint; it will be picked up again below. */
1676 if (signal != 0
54a0b537
PA
1677 && (lwp->status_pending_p || lwp->pending_signals != NULL
1678 || lwp->bp_reinsert != 0))
0d62e5e8
DJ
1679 {
1680 struct pending_signals *p_sig;
bca929d3 1681 p_sig = xmalloc (sizeof (*p_sig));
54a0b537 1682 p_sig->prev = lwp->pending_signals;
0d62e5e8 1683 p_sig->signal = signal;
32ca6d61
DJ
1684 if (info == NULL)
1685 memset (&p_sig->info, 0, sizeof (siginfo_t));
1686 else
1687 memcpy (&p_sig->info, info, sizeof (siginfo_t));
54a0b537 1688 lwp->pending_signals = p_sig;
0d62e5e8
DJ
1689 }
1690
54a0b537 1691 if (lwp->status_pending_p && !check_removed_breakpoint (lwp))
0d62e5e8
DJ
1692 return;
1693
1694 saved_inferior = current_inferior;
54a0b537 1695 current_inferior = get_lwp_thread (lwp);
0d62e5e8
DJ
1696
1697 if (debug_threads)
1b3f6016 1698 fprintf (stderr, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
bd99dc85 1699 lwpid_of (lwp), step ? "step" : "continue", signal,
54a0b537 1700 lwp->stop_expected ? "expected" : "not expected");
0d62e5e8
DJ
1701
1702 /* This bit needs some thinking about. If we get a signal that
1703 we must report while a single-step reinsert is still pending,
1704 we often end up resuming the thread. It might be better to
1705 (ew) allow a stack of pending events; then we could be sure that
1706 the reinsert happened right away and not lose any signals.
1707
1708 Making this stack would also shrink the window in which breakpoints are
54a0b537 1709 uninserted (see comment in linux_wait_for_lwp) but not enough for
0d62e5e8
DJ
1710 complete correctness, so it won't solve that problem. It may be
1711 worthwhile just to solve this one, however. */
54a0b537 1712 if (lwp->bp_reinsert != 0)
0d62e5e8
DJ
1713 {
1714 if (debug_threads)
54a0b537 1715 fprintf (stderr, " pending reinsert at %08lx", (long)lwp->bp_reinsert);
0d62e5e8
DJ
1716 if (step == 0)
1717 fprintf (stderr, "BAD - reinserting but not stepping.\n");
1718 step = 1;
1719
1720 /* Postpone any pending signal. It was enqueued above. */
1721 signal = 0;
1722 }
1723
54a0b537 1724 check_removed_breakpoint (lwp);
0d62e5e8 1725
aa691b87 1726 if (debug_threads && the_low_target.get_pc != NULL)
0d62e5e8 1727 {
47c0c975
DE
1728 CORE_ADDR pc = (*the_low_target.get_pc) ();
1729 fprintf (stderr, " resuming from pc 0x%lx\n", (long) pc);
0d62e5e8
DJ
1730 }
1731
1732 /* If we have pending signals, consume one unless we are trying to reinsert
1733 a breakpoint. */
54a0b537 1734 if (lwp->pending_signals != NULL && lwp->bp_reinsert == 0)
0d62e5e8
DJ
1735 {
1736 struct pending_signals **p_sig;
1737
54a0b537 1738 p_sig = &lwp->pending_signals;
0d62e5e8
DJ
1739 while ((*p_sig)->prev != NULL)
1740 p_sig = &(*p_sig)->prev;
1741
1742 signal = (*p_sig)->signal;
32ca6d61 1743 if ((*p_sig)->info.si_signo != 0)
bd99dc85 1744 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
32ca6d61 1745
0d62e5e8
DJ
1746 free (*p_sig);
1747 *p_sig = NULL;
1748 }
1749
aa5ca48f
DE
1750 if (the_low_target.prepare_to_resume != NULL)
1751 the_low_target.prepare_to_resume (lwp);
1752
0d62e5e8 1753 regcache_invalidate_one ((struct inferior_list_entry *)
54a0b537 1754 get_lwp_thread (lwp));
da6d8c04 1755 errno = 0;
54a0b537
PA
1756 lwp->stopped = 0;
1757 lwp->stepping = step;
bd99dc85 1758 ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp), 0, signal);
0d62e5e8
DJ
1759
1760 current_inferior = saved_inferior;
da6d8c04 1761 if (errno)
3221518c
UW
1762 {
1763 /* ESRCH from ptrace either means that the thread was already
1764 running (an error) or that it is gone (a race condition). If
1765 it's gone, we will get a notification the next time we wait,
1766 so we can ignore the error. We could differentiate these
1767 two, but it's tricky without waiting; the thread still exists
1768 as a zombie, so sending it signal 0 would succeed. So just
1769 ignore ESRCH. */
1770 if (errno == ESRCH)
1771 return;
1772
1773 perror_with_name ("ptrace");
1774 }
da6d8c04
DJ
1775}
1776
2bd7c093
PA
1777struct thread_resume_array
1778{
1779 struct thread_resume *resume;
1780 size_t n;
1781};
64386c31
DJ
1782
1783/* This function is called once per thread. We look up the thread
5544ad89
DJ
1784 in RESUME_PTR, and mark the thread with a pointer to the appropriate
1785 resume request.
1786
1787 This algorithm is O(threads * resume elements), but resume elements
1788 is small (and will remain small at least until GDB supports thread
1789 suspension). */
2bd7c093
PA
1790static int
1791linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
0d62e5e8 1792{
54a0b537 1793 struct lwp_info *lwp;
64386c31 1794 struct thread_info *thread;
5544ad89 1795 int ndx;
2bd7c093 1796 struct thread_resume_array *r;
64386c31
DJ
1797
1798 thread = (struct thread_info *) entry;
54a0b537 1799 lwp = get_thread_lwp (thread);
2bd7c093 1800 r = arg;
64386c31 1801
2bd7c093 1802 for (ndx = 0; ndx < r->n; ndx++)
95954743
PA
1803 {
1804 ptid_t ptid = r->resume[ndx].thread;
1805 if (ptid_equal (ptid, minus_one_ptid)
1806 || ptid_equal (ptid, entry->id)
1807 || (ptid_is_pid (ptid)
1808 && (ptid_get_pid (ptid) == pid_of (lwp)))
1809 || (ptid_get_lwp (ptid) == -1
1810 && (ptid_get_pid (ptid) == pid_of (lwp))))
1811 {
1812 lwp->resume = &r->resume[ndx];
1813 return 0;
1814 }
1815 }
2bd7c093
PA
1816
1817 /* No resume action for this thread. */
1818 lwp->resume = NULL;
64386c31 1819
2bd7c093 1820 return 0;
5544ad89
DJ
1821}
1822
5544ad89 1823
bd99dc85
PA
1824/* Set *FLAG_P if this lwp has an interesting status pending. */
1825static int
1826resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
5544ad89 1827{
bd99dc85 1828 struct lwp_info *lwp = (struct lwp_info *) entry;
5544ad89 1829
bd99dc85
PA
1830 /* LWPs which will not be resumed are not interesting, because
1831 we might not wait for them next time through linux_wait. */
2bd7c093 1832 if (lwp->resume == NULL)
bd99dc85 1833 return 0;
64386c31 1834
bd99dc85
PA
1835 /* If this thread has a removed breakpoint, we won't have any
1836 events to report later, so check now. check_removed_breakpoint
1837 may clear status_pending_p. We avoid calling check_removed_breakpoint
1838 for any thread that we are not otherwise going to resume - this
1839 lets us preserve stopped status when two threads hit a breakpoint.
1840 GDB removes the breakpoint to single-step a particular thread
1841 past it, then re-inserts it and resumes all threads. We want
1842 to report the second thread without resuming it in the interim. */
1843 if (lwp->status_pending_p)
1844 check_removed_breakpoint (lwp);
5544ad89 1845
bd99dc85
PA
1846 if (lwp->status_pending_p)
1847 * (int *) flag_p = 1;
c6ecbae5 1848
bd99dc85 1849 return 0;
5544ad89
DJ
1850}
1851
1852/* This function is called once per thread. We check the thread's resume
1853 request, which will tell us whether to resume, step, or leave the thread
bd99dc85 1854 stopped; and what signal, if any, it should be sent.
5544ad89 1855
bd99dc85
PA
1856 For threads which we aren't explicitly told otherwise, we preserve
1857 the stepping flag; this is used for stepping over gdbserver-placed
1858 breakpoints.
1859
1860 If pending_flags was set in any thread, we queue any needed
1861 signals, since we won't actually resume. We already have a pending
1862 event to report, so we don't need to preserve any step requests;
1863 they should be re-issued if necessary. */
1864
1865static int
1866linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
5544ad89 1867{
54a0b537 1868 struct lwp_info *lwp;
5544ad89 1869 struct thread_info *thread;
bd99dc85
PA
1870 int step;
1871 int pending_flag = * (int *) arg;
5544ad89
DJ
1872
1873 thread = (struct thread_info *) entry;
54a0b537 1874 lwp = get_thread_lwp (thread);
5544ad89 1875
2bd7c093 1876 if (lwp->resume == NULL)
bd99dc85 1877 return 0;
5544ad89 1878
bd99dc85 1879 if (lwp->resume->kind == resume_stop)
5544ad89 1880 {
bd99dc85
PA
1881 if (debug_threads)
1882 fprintf (stderr, "suspending LWP %ld\n", lwpid_of (lwp));
1883
1884 if (!lwp->stopped)
1885 {
1886 if (debug_threads)
95954743 1887 fprintf (stderr, "running -> suspending LWP %ld\n", lwpid_of (lwp));
bd99dc85
PA
1888
1889 lwp->suspended = 1;
1890 send_sigstop (&lwp->head);
1891 }
1892 else
1893 {
1894 if (debug_threads)
1895 {
1896 if (lwp->suspended)
1897 fprintf (stderr, "already stopped/suspended LWP %ld\n",
1898 lwpid_of (lwp));
1899 else
1900 fprintf (stderr, "already stopped/not suspended LWP %ld\n",
1901 lwpid_of (lwp));
1902 }
32ca6d61 1903
bd99dc85
PA
1904 /* Make sure we leave the LWP suspended, so we don't try to
1905 resume it without GDB telling us to. FIXME: The LWP may
1906 have been stopped in an internal event that was not meant
1907 to be notified back to GDB (e.g., gdbserver breakpoint),
1908 so we should be reporting a stop event in that case
1909 too. */
1910 lwp->suspended = 1;
1911 }
32ca6d61 1912
bd99dc85
PA
1913 /* For stop requests, we're done. */
1914 lwp->resume = NULL;
1915 return 0;
5544ad89 1916 }
bd99dc85
PA
1917 else
1918 lwp->suspended = 0;
5544ad89 1919
bd99dc85
PA
1920 /* If this thread which is about to be resumed has a pending status,
1921 then don't resume any threads - we can just report the pending
1922 status. Make sure to queue any signals that would otherwise be
1923 sent. In all-stop mode, we do this decision based on if *any*
1924 thread has a pending status. */
1925 if (non_stop)
1926 resume_status_pending_p (&lwp->head, &pending_flag);
5544ad89 1927
bd99dc85
PA
1928 if (!pending_flag)
1929 {
1930 if (debug_threads)
1931 fprintf (stderr, "resuming LWP %ld\n", lwpid_of (lwp));
5544ad89 1932
95954743 1933 if (ptid_equal (lwp->resume->thread, minus_one_ptid)
bd99dc85
PA
1934 && lwp->stepping
1935 && lwp->pending_is_breakpoint)
1936 step = 1;
1937 else
1938 step = (lwp->resume->kind == resume_step);
5544ad89 1939
2acc282a 1940 linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL);
bd99dc85
PA
1941 }
1942 else
1943 {
1944 if (debug_threads)
1945 fprintf (stderr, "leaving LWP %ld stopped\n", lwpid_of (lwp));
5544ad89 1946
bd99dc85
PA
1947 /* If we have a new signal, enqueue the signal. */
1948 if (lwp->resume->sig != 0)
1949 {
1950 struct pending_signals *p_sig;
1951 p_sig = xmalloc (sizeof (*p_sig));
1952 p_sig->prev = lwp->pending_signals;
1953 p_sig->signal = lwp->resume->sig;
1954 memset (&p_sig->info, 0, sizeof (siginfo_t));
1955
1956 /* If this is the same signal we were previously stopped by,
1957 make sure to queue its siginfo. We can ignore the return
1958 value of ptrace; if it fails, we'll skip
1959 PTRACE_SETSIGINFO. */
1960 if (WIFSTOPPED (lwp->last_status)
1961 && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
1962 ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
1963
1964 lwp->pending_signals = p_sig;
1965 }
1966 }
5544ad89 1967
bd99dc85 1968 lwp->resume = NULL;
5544ad89 1969 return 0;
0d62e5e8
DJ
1970}
1971
1972static void
2bd7c093 1973linux_resume (struct thread_resume *resume_info, size_t n)
0d62e5e8 1974{
5544ad89 1975 int pending_flag;
2bd7c093 1976 struct thread_resume_array array = { resume_info, n };
c6ecbae5 1977
2bd7c093 1978 find_inferior (&all_threads, linux_set_resume_request, &array);
5544ad89
DJ
1979
1980 /* If there is a thread which would otherwise be resumed, which
1981 has a pending status, then don't resume any threads - we can just
1982 report the pending status. Make sure to queue any signals
bd99dc85
PA
1983 that would otherwise be sent. In non-stop mode, we'll apply this
1984 logic to each thread individually. */
5544ad89 1985 pending_flag = 0;
bd99dc85
PA
1986 if (!non_stop)
1987 find_inferior (&all_lwps, resume_status_pending_p, &pending_flag);
5544ad89
DJ
1988
1989 if (debug_threads)
1990 {
1991 if (pending_flag)
1992 fprintf (stderr, "Not resuming, pending status\n");
1993 else
1994 fprintf (stderr, "Resuming, no pending status\n");
1995 }
1996
bd99dc85 1997 find_inferior (&all_threads, linux_resume_one_thread, &pending_flag);
0d62e5e8
DJ
1998}
1999
2000#ifdef HAVE_LINUX_USRREGS
da6d8c04
DJ
2001
2002int
0a30fbc4 2003register_addr (int regnum)
da6d8c04
DJ
2004{
2005 int addr;
2006
2ec06d2e 2007 if (regnum < 0 || regnum >= the_low_target.num_regs)
da6d8c04
DJ
2008 error ("Invalid register number %d.", regnum);
2009
2ec06d2e 2010 addr = the_low_target.regmap[regnum];
da6d8c04
DJ
2011
2012 return addr;
2013}
2014
58caa3dc 2015/* Fetch one register. */
da6d8c04
DJ
2016static void
2017fetch_register (int regno)
2018{
2019 CORE_ADDR regaddr;
48d93c75 2020 int i, size;
0d62e5e8 2021 char *buf;
95954743 2022 int pid;
da6d8c04 2023
2ec06d2e 2024 if (regno >= the_low_target.num_regs)
0a30fbc4 2025 return;
2ec06d2e 2026 if ((*the_low_target.cannot_fetch_register) (regno))
0a30fbc4 2027 return;
da6d8c04 2028
0a30fbc4
DJ
2029 regaddr = register_addr (regno);
2030 if (regaddr == -1)
2031 return;
95954743
PA
2032
2033 pid = lwpid_of (get_thread_lwp (current_inferior));
1b3f6016
PA
2034 size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
2035 & - sizeof (PTRACE_XFER_TYPE));
48d93c75
UW
2036 buf = alloca (size);
2037 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
da6d8c04
DJ
2038 {
2039 errno = 0;
0d62e5e8 2040 *(PTRACE_XFER_TYPE *) (buf + i) =
95954743 2041 ptrace (PTRACE_PEEKUSER, pid, (PTRACE_ARG3_TYPE) regaddr, 0);
da6d8c04
DJ
2042 regaddr += sizeof (PTRACE_XFER_TYPE);
2043 if (errno != 0)
2044 {
2045 /* Warning, not error, in case we are attached; sometimes the
2046 kernel doesn't let us at the registers. */
2047 char *err = strerror (errno);
2048 char *msg = alloca (strlen (err) + 128);
2049 sprintf (msg, "reading register %d: %s", regno, err);
2050 error (msg);
2051 goto error_exit;
2052 }
2053 }
ee1a7ae4
UW
2054
2055 if (the_low_target.supply_ptrace_register)
2056 the_low_target.supply_ptrace_register (regno, buf);
5a1f5858
DJ
2057 else
2058 supply_register (regno, buf);
0d62e5e8 2059
da6d8c04
DJ
2060error_exit:;
2061}
2062
2063/* Fetch all registers, or just one, from the child process. */
58caa3dc
DJ
2064static void
2065usr_fetch_inferior_registers (int regno)
da6d8c04 2066{
4463ce24 2067 if (regno == -1)
2ec06d2e 2068 for (regno = 0; regno < the_low_target.num_regs; regno++)
da6d8c04
DJ
2069 fetch_register (regno);
2070 else
2071 fetch_register (regno);
2072}
2073
2074/* Store our register values back into the inferior.
2075 If REGNO is -1, do this for all registers.
2076 Otherwise, REGNO specifies which register (so we can save time). */
58caa3dc
DJ
2077static void
2078usr_store_inferior_registers (int regno)
da6d8c04
DJ
2079{
2080 CORE_ADDR regaddr;
48d93c75 2081 int i, size;
0d62e5e8 2082 char *buf;
55ac2b99 2083 int pid;
da6d8c04
DJ
2084
2085 if (regno >= 0)
2086 {
2ec06d2e 2087 if (regno >= the_low_target.num_regs)
0a30fbc4
DJ
2088 return;
2089
bc1e36ca 2090 if ((*the_low_target.cannot_store_register) (regno) == 1)
0a30fbc4
DJ
2091 return;
2092
2093 regaddr = register_addr (regno);
2094 if (regaddr == -1)
da6d8c04 2095 return;
da6d8c04 2096 errno = 0;
48d93c75
UW
2097 size = (register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
2098 & - sizeof (PTRACE_XFER_TYPE);
2099 buf = alloca (size);
2100 memset (buf, 0, size);
ee1a7ae4
UW
2101
2102 if (the_low_target.collect_ptrace_register)
2103 the_low_target.collect_ptrace_register (regno, buf);
5a1f5858
DJ
2104 else
2105 collect_register (regno, buf);
ee1a7ae4 2106
95954743 2107 pid = lwpid_of (get_thread_lwp (current_inferior));
48d93c75 2108 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
da6d8c04 2109 {
0a30fbc4 2110 errno = 0;
95954743 2111 ptrace (PTRACE_POKEUSER, pid, (PTRACE_ARG3_TYPE) regaddr,
2ff29de4 2112 *(PTRACE_XFER_TYPE *) (buf + i));
da6d8c04
DJ
2113 if (errno != 0)
2114 {
1b3f6016
PA
2115 /* At this point, ESRCH should mean the process is
2116 already gone, in which case we simply ignore attempts
2117 to change its registers. See also the related
2118 comment in linux_resume_one_lwp. */
3221518c
UW
2119 if (errno == ESRCH)
2120 return;
2121
bc1e36ca
DJ
2122 if ((*the_low_target.cannot_store_register) (regno) == 0)
2123 {
2124 char *err = strerror (errno);
2125 char *msg = alloca (strlen (err) + 128);
2126 sprintf (msg, "writing register %d: %s",
2127 regno, err);
2128 error (msg);
2129 return;
2130 }
da6d8c04 2131 }
2ff29de4 2132 regaddr += sizeof (PTRACE_XFER_TYPE);
da6d8c04 2133 }
da6d8c04
DJ
2134 }
2135 else
2ec06d2e 2136 for (regno = 0; regno < the_low_target.num_regs; regno++)
0d62e5e8 2137 usr_store_inferior_registers (regno);
da6d8c04 2138}
58caa3dc
DJ
2139#endif /* HAVE_LINUX_USRREGS */
2140
2141
2142
2143#ifdef HAVE_LINUX_REGSETS
2144
2145static int
0d62e5e8 2146regsets_fetch_inferior_registers ()
58caa3dc
DJ
2147{
2148 struct regset_info *regset;
e9d25b98 2149 int saw_general_regs = 0;
95954743 2150 int pid;
58caa3dc
DJ
2151
2152 regset = target_regsets;
2153
95954743 2154 pid = lwpid_of (get_thread_lwp (current_inferior));
58caa3dc
DJ
2155 while (regset->size >= 0)
2156 {
2157 void *buf;
2158 int res;
2159
52fa2412 2160 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
58caa3dc
DJ
2161 {
2162 regset ++;
2163 continue;
2164 }
2165
bca929d3 2166 buf = xmalloc (regset->size);
dfb64f85 2167#ifndef __sparc__
95954743 2168 res = ptrace (regset->get_request, pid, 0, buf);
dfb64f85 2169#else
95954743 2170 res = ptrace (regset->get_request, pid, buf, 0);
dfb64f85 2171#endif
58caa3dc
DJ
2172 if (res < 0)
2173 {
2174 if (errno == EIO)
2175 {
52fa2412
UW
2176 /* If we get EIO on a regset, do not try it again for
2177 this process. */
2178 disabled_regsets[regset - target_regsets] = 1;
fdeb2a12 2179 free (buf);
52fa2412 2180 continue;
58caa3dc
DJ
2181 }
2182 else
2183 {
0d62e5e8 2184 char s[256];
95954743
PA
2185 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
2186 pid);
0d62e5e8 2187 perror (s);
58caa3dc
DJ
2188 }
2189 }
e9d25b98
DJ
2190 else if (regset->type == GENERAL_REGS)
2191 saw_general_regs = 1;
58caa3dc
DJ
2192 regset->store_function (buf);
2193 regset ++;
fdeb2a12 2194 free (buf);
58caa3dc 2195 }
e9d25b98
DJ
2196 if (saw_general_regs)
2197 return 0;
2198 else
2199 return 1;
58caa3dc
DJ
2200}
2201
2202static int
0d62e5e8 2203regsets_store_inferior_registers ()
58caa3dc
DJ
2204{
2205 struct regset_info *regset;
e9d25b98 2206 int saw_general_regs = 0;
95954743 2207 int pid;
58caa3dc
DJ
2208
2209 regset = target_regsets;
2210
95954743 2211 pid = lwpid_of (get_thread_lwp (current_inferior));
58caa3dc
DJ
2212 while (regset->size >= 0)
2213 {
2214 void *buf;
2215 int res;
2216
52fa2412 2217 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
58caa3dc
DJ
2218 {
2219 regset ++;
2220 continue;
2221 }
2222
bca929d3 2223 buf = xmalloc (regset->size);
545587ee
DJ
2224
2225 /* First fill the buffer with the current register set contents,
2226 in case there are any items in the kernel's regset that are
2227 not in gdbserver's regcache. */
dfb64f85 2228#ifndef __sparc__
95954743 2229 res = ptrace (regset->get_request, pid, 0, buf);
dfb64f85 2230#else
95954743 2231 res = ptrace (regset->get_request, pid, buf, 0);
dfb64f85 2232#endif
545587ee
DJ
2233
2234 if (res == 0)
2235 {
2236 /* Then overlay our cached registers on that. */
2237 regset->fill_function (buf);
2238
2239 /* Only now do we write the register set. */
dfb64f85 2240#ifndef __sparc__
95954743 2241 res = ptrace (regset->set_request, pid, 0, buf);
dfb64f85 2242#else
95954743 2243 res = ptrace (regset->set_request, pid, buf, 0);
dfb64f85 2244#endif
545587ee
DJ
2245 }
2246
58caa3dc
DJ
2247 if (res < 0)
2248 {
2249 if (errno == EIO)
2250 {
52fa2412
UW
2251 /* If we get EIO on a regset, do not try it again for
2252 this process. */
2253 disabled_regsets[regset - target_regsets] = 1;
fdeb2a12 2254 free (buf);
52fa2412 2255 continue;
58caa3dc 2256 }
3221518c
UW
2257 else if (errno == ESRCH)
2258 {
1b3f6016
PA
2259 /* At this point, ESRCH should mean the process is
2260 already gone, in which case we simply ignore attempts
2261 to change its registers. See also the related
2262 comment in linux_resume_one_lwp. */
fdeb2a12 2263 free (buf);
3221518c
UW
2264 return 0;
2265 }
58caa3dc
DJ
2266 else
2267 {
ce3a066d 2268 perror ("Warning: ptrace(regsets_store_inferior_registers)");
58caa3dc
DJ
2269 }
2270 }
e9d25b98
DJ
2271 else if (regset->type == GENERAL_REGS)
2272 saw_general_regs = 1;
58caa3dc 2273 regset ++;
09ec9b38 2274 free (buf);
58caa3dc 2275 }
e9d25b98
DJ
2276 if (saw_general_regs)
2277 return 0;
2278 else
2279 return 1;
ce3a066d 2280 return 0;
58caa3dc
DJ
2281}
2282
2283#endif /* HAVE_LINUX_REGSETS */
2284
2285
2286void
ce3a066d 2287linux_fetch_registers (int regno)
58caa3dc
DJ
2288{
2289#ifdef HAVE_LINUX_REGSETS
52fa2412
UW
2290 if (regsets_fetch_inferior_registers () == 0)
2291 return;
58caa3dc
DJ
2292#endif
2293#ifdef HAVE_LINUX_USRREGS
2294 usr_fetch_inferior_registers (regno);
2295#endif
2296}
2297
2298void
ce3a066d 2299linux_store_registers (int regno)
58caa3dc
DJ
2300{
2301#ifdef HAVE_LINUX_REGSETS
52fa2412
UW
2302 if (regsets_store_inferior_registers () == 0)
2303 return;
58caa3dc
DJ
2304#endif
2305#ifdef HAVE_LINUX_USRREGS
2306 usr_store_inferior_registers (regno);
2307#endif
2308}
2309
da6d8c04 2310
da6d8c04
DJ
2311/* Copy LEN bytes from inferior's memory starting at MEMADDR
2312 to debugger memory starting at MYADDR. */
2313
c3e735a6 2314static int
f450004a 2315linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
da6d8c04
DJ
2316{
2317 register int i;
2318 /* Round starting address down to longword boundary. */
2319 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
2320 /* Round ending address up; get number of longwords that makes. */
aa691b87
RM
2321 register int count
2322 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
da6d8c04
DJ
2323 / sizeof (PTRACE_XFER_TYPE);
2324 /* Allocate buffer of that many longwords. */
aa691b87 2325 register PTRACE_XFER_TYPE *buffer
da6d8c04 2326 = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
fd462a61
DJ
2327 int fd;
2328 char filename[64];
95954743 2329 int pid = lwpid_of (get_thread_lwp (current_inferior));
fd462a61
DJ
2330
2331 /* Try using /proc. Don't bother for one word. */
2332 if (len >= 3 * sizeof (long))
2333 {
2334 /* We could keep this file open and cache it - possibly one per
2335 thread. That requires some juggling, but is even faster. */
95954743 2336 sprintf (filename, "/proc/%d/mem", pid);
fd462a61
DJ
2337 fd = open (filename, O_RDONLY | O_LARGEFILE);
2338 if (fd == -1)
2339 goto no_proc;
2340
2341 /* If pread64 is available, use it. It's faster if the kernel
2342 supports it (only one syscall), and it's 64-bit safe even on
2343 32-bit platforms (for instance, SPARC debugging a SPARC64
2344 application). */
2345#ifdef HAVE_PREAD64
2346 if (pread64 (fd, myaddr, len, memaddr) != len)
2347#else
2348 if (lseek (fd, memaddr, SEEK_SET) == -1 || read (fd, memaddr, len) != len)
2349#endif
2350 {
2351 close (fd);
2352 goto no_proc;
2353 }
2354
2355 close (fd);
2356 return 0;
2357 }
da6d8c04 2358
fd462a61 2359 no_proc:
da6d8c04
DJ
2360 /* Read all the longwords */
2361 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
2362 {
c3e735a6 2363 errno = 0;
95954743 2364 buffer[i] = ptrace (PTRACE_PEEKTEXT, pid, (PTRACE_ARG3_TYPE) addr, 0);
c3e735a6
DJ
2365 if (errno)
2366 return errno;
da6d8c04
DJ
2367 }
2368
2369 /* Copy appropriate bytes out of the buffer. */
1b3f6016
PA
2370 memcpy (myaddr,
2371 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
2372 len);
c3e735a6
DJ
2373
2374 return 0;
da6d8c04
DJ
2375}
2376
2377/* Copy LEN bytes of data from debugger memory at MYADDR
2378 to inferior's memory at MEMADDR.
2379 On failure (cannot write the inferior)
2380 returns the value of errno. */
2381
ce3a066d 2382static int
f450004a 2383linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
da6d8c04
DJ
2384{
2385 register int i;
2386 /* Round starting address down to longword boundary. */
2387 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
2388 /* Round ending address up; get number of longwords that makes. */
2389 register int count
2390 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) / sizeof (PTRACE_XFER_TYPE);
2391 /* Allocate buffer of that many longwords. */
2392 register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
95954743 2393 int pid = lwpid_of (get_thread_lwp (current_inferior));
da6d8c04 2394
0d62e5e8
DJ
2395 if (debug_threads)
2396 {
58d6951d
DJ
2397 /* Dump up to four bytes. */
2398 unsigned int val = * (unsigned int *) myaddr;
2399 if (len == 1)
2400 val = val & 0xff;
2401 else if (len == 2)
2402 val = val & 0xffff;
2403 else if (len == 3)
2404 val = val & 0xffffff;
2405 fprintf (stderr, "Writing %0*x to 0x%08lx\n", 2 * ((len < 4) ? len : 4),
2406 val, (long)memaddr);
0d62e5e8
DJ
2407 }
2408
da6d8c04
DJ
2409 /* Fill start and end extra bytes of buffer with existing memory data. */
2410
95954743 2411 buffer[0] = ptrace (PTRACE_PEEKTEXT, pid, (PTRACE_ARG3_TYPE) addr, 0);
da6d8c04
DJ
2412
2413 if (count > 1)
2414 {
2415 buffer[count - 1]
95954743 2416 = ptrace (PTRACE_PEEKTEXT, pid,
d844cde6
DJ
2417 (PTRACE_ARG3_TYPE) (addr + (count - 1)
2418 * sizeof (PTRACE_XFER_TYPE)),
2419 0);
da6d8c04
DJ
2420 }
2421
2422 /* Copy data to be written over corresponding part of buffer */
2423
2424 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), myaddr, len);
2425
2426 /* Write the entire buffer. */
2427
2428 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
2429 {
2430 errno = 0;
95954743 2431 ptrace (PTRACE_POKETEXT, pid, (PTRACE_ARG3_TYPE) addr, buffer[i]);
da6d8c04
DJ
2432 if (errno)
2433 return errno;
2434 }
2435
2436 return 0;
2437}
2f2893d9 2438
24a09b5f
DJ
2439static int linux_supports_tracefork_flag;
2440
51c2684e 2441/* Helper functions for linux_test_for_tracefork, called via clone (). */
24a09b5f 2442
51c2684e
DJ
2443static int
2444linux_tracefork_grandchild (void *arg)
2445{
2446 _exit (0);
2447}
2448
7407e2de
AS
2449#define STACK_SIZE 4096
2450
51c2684e
DJ
2451static int
2452linux_tracefork_child (void *arg)
24a09b5f
DJ
2453{
2454 ptrace (PTRACE_TRACEME, 0, 0, 0);
2455 kill (getpid (), SIGSTOP);
7407e2de
AS
2456#ifdef __ia64__
2457 __clone2 (linux_tracefork_grandchild, arg, STACK_SIZE,
2458 CLONE_VM | SIGCHLD, NULL);
2459#else
2460 clone (linux_tracefork_grandchild, arg + STACK_SIZE,
2461 CLONE_VM | SIGCHLD, NULL);
2462#endif
24a09b5f
DJ
2463 _exit (0);
2464}
2465
bd99dc85
PA
2466/* Wrapper function for waitpid which handles EINTR, and emulates
2467 __WALL for systems where that is not available. */
24a09b5f
DJ
2468
2469static int
2470my_waitpid (int pid, int *status, int flags)
2471{
bd99dc85
PA
2472 int ret, out_errno;
2473
2474 if (debug_threads)
2475 fprintf (stderr, "my_waitpid (%d, 0x%x)\n", pid, flags);
2476
2477 if (flags & __WALL)
24a09b5f 2478 {
bd99dc85
PA
2479 sigset_t block_mask, org_mask, wake_mask;
2480 int wnohang;
2481
2482 wnohang = (flags & WNOHANG) != 0;
2483 flags &= ~(__WALL | __WCLONE);
2484 flags |= WNOHANG;
2485
2486 /* Block all signals while here. This avoids knowing about
2487 LinuxThread's signals. */
2488 sigfillset (&block_mask);
2489 sigprocmask (SIG_BLOCK, &block_mask, &org_mask);
2490
2491 /* ... except during the sigsuspend below. */
2492 sigemptyset (&wake_mask);
2493
2494 while (1)
2495 {
2496 /* Since all signals are blocked, there's no need to check
2497 for EINTR here. */
2498 ret = waitpid (pid, status, flags);
2499 out_errno = errno;
2500
2501 if (ret == -1 && out_errno != ECHILD)
2502 break;
2503 else if (ret > 0)
2504 break;
2505
2506 if (flags & __WCLONE)
2507 {
2508 /* We've tried both flavors now. If WNOHANG is set,
2509 there's nothing else to do, just bail out. */
2510 if (wnohang)
2511 break;
2512
2513 if (debug_threads)
2514 fprintf (stderr, "blocking\n");
2515
2516 /* Block waiting for signals. */
2517 sigsuspend (&wake_mask);
2518 }
2519
2520 flags ^= __WCLONE;
2521 }
2522
2523 sigprocmask (SIG_SETMASK, &org_mask, NULL);
24a09b5f 2524 }
bd99dc85
PA
2525 else
2526 {
2527 do
2528 ret = waitpid (pid, status, flags);
2529 while (ret == -1 && errno == EINTR);
2530 out_errno = errno;
2531 }
2532
2533 if (debug_threads)
2534 fprintf (stderr, "my_waitpid (%d, 0x%x): status(%x), %d\n",
2535 pid, flags, status ? *status : -1, ret);
24a09b5f 2536
bd99dc85 2537 errno = out_errno;
24a09b5f
DJ
2538 return ret;
2539}
2540
2541/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
2542 sure that we can enable the option, and that it had the desired
2543 effect. */
2544
2545static void
2546linux_test_for_tracefork (void)
2547{
2548 int child_pid, ret, status;
2549 long second_pid;
bca929d3 2550 char *stack = xmalloc (STACK_SIZE * 4);
24a09b5f
DJ
2551
2552 linux_supports_tracefork_flag = 0;
2553
51c2684e 2554 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
7407e2de
AS
2555#ifdef __ia64__
2556 child_pid = __clone2 (linux_tracefork_child, stack, STACK_SIZE,
2557 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
2558#else
2559 child_pid = clone (linux_tracefork_child, stack + STACK_SIZE,
2560 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
2561#endif
24a09b5f 2562 if (child_pid == -1)
51c2684e 2563 perror_with_name ("clone");
24a09b5f
DJ
2564
2565 ret = my_waitpid (child_pid, &status, 0);
2566 if (ret == -1)
2567 perror_with_name ("waitpid");
2568 else if (ret != child_pid)
2569 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
2570 if (! WIFSTOPPED (status))
2571 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
2572
2573 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
2574 if (ret != 0)
2575 {
2576 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
2577 if (ret != 0)
2578 {
2579 warning ("linux_test_for_tracefork: failed to kill child");
2580 return;
2581 }
2582
2583 ret = my_waitpid (child_pid, &status, 0);
2584 if (ret != child_pid)
2585 warning ("linux_test_for_tracefork: failed to wait for killed child");
2586 else if (!WIFSIGNALED (status))
2587 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
2588 "killed child", status);
2589
2590 return;
2591 }
2592
2593 ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
2594 if (ret != 0)
2595 warning ("linux_test_for_tracefork: failed to resume child");
2596
2597 ret = my_waitpid (child_pid, &status, 0);
2598
2599 if (ret == child_pid && WIFSTOPPED (status)
2600 && status >> 16 == PTRACE_EVENT_FORK)
2601 {
2602 second_pid = 0;
2603 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
2604 if (ret == 0 && second_pid != 0)
2605 {
2606 int second_status;
2607
2608 linux_supports_tracefork_flag = 1;
2609 my_waitpid (second_pid, &second_status, 0);
2610 ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
2611 if (ret != 0)
2612 warning ("linux_test_for_tracefork: failed to kill second child");
2613 my_waitpid (second_pid, &status, 0);
2614 }
2615 }
2616 else
2617 warning ("linux_test_for_tracefork: unexpected result from waitpid "
2618 "(%d, status 0x%x)", ret, status);
2619
2620 do
2621 {
2622 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
2623 if (ret != 0)
2624 warning ("linux_test_for_tracefork: failed to kill child");
2625 my_waitpid (child_pid, &status, 0);
2626 }
2627 while (WIFSTOPPED (status));
51c2684e
DJ
2628
2629 free (stack);
24a09b5f
DJ
2630}
2631
2632
2f2893d9
DJ
2633static void
2634linux_look_up_symbols (void)
2635{
0d62e5e8 2636#ifdef USE_THREAD_DB
95954743
PA
2637 struct process_info *proc = current_process ();
2638
2639 if (proc->private->thread_db_active)
0d62e5e8
DJ
2640 return;
2641
95954743
PA
2642 proc->private->thread_db_active
2643 = thread_db_init (!linux_supports_tracefork_flag);
0d62e5e8
DJ
2644#endif
2645}
2646
e5379b03 2647static void
ef57601b 2648linux_request_interrupt (void)
e5379b03 2649{
a1928bad 2650 extern unsigned long signal_pid;
e5379b03 2651
95954743
PA
2652 if (!ptid_equal (cont_thread, null_ptid)
2653 && !ptid_equal (cont_thread, minus_one_ptid))
e5379b03 2654 {
54a0b537 2655 struct lwp_info *lwp;
bd99dc85 2656 int lwpid;
e5379b03 2657
54a0b537 2658 lwp = get_thread_lwp (current_inferior);
bd99dc85
PA
2659 lwpid = lwpid_of (lwp);
2660 kill_lwp (lwpid, SIGINT);
e5379b03
DJ
2661 }
2662 else
ef57601b 2663 kill_lwp (signal_pid, SIGINT);
e5379b03
DJ
2664}
2665
aa691b87
RM
2666/* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
2667 to debugger memory starting at MYADDR. */
2668
2669static int
f450004a 2670linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len)
aa691b87
RM
2671{
2672 char filename[PATH_MAX];
2673 int fd, n;
95954743 2674 int pid = lwpid_of (get_thread_lwp (current_inferior));
aa691b87 2675
95954743 2676 snprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
aa691b87
RM
2677
2678 fd = open (filename, O_RDONLY);
2679 if (fd < 0)
2680 return -1;
2681
2682 if (offset != (CORE_ADDR) 0
2683 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
2684 n = -1;
2685 else
2686 n = read (fd, myaddr, len);
2687
2688 close (fd);
2689
2690 return n;
2691}
2692
d993e290
PA
2693/* These breakpoint and watchpoint related wrapper functions simply
2694 pass on the function call if the target has registered a
2695 corresponding function. */
e013ee27
OF
2696
2697static int
d993e290 2698linux_insert_point (char type, CORE_ADDR addr, int len)
e013ee27 2699{
d993e290
PA
2700 if (the_low_target.insert_point != NULL)
2701 return the_low_target.insert_point (type, addr, len);
e013ee27
OF
2702 else
2703 /* Unsupported (see target.h). */
2704 return 1;
2705}
2706
2707static int
d993e290 2708linux_remove_point (char type, CORE_ADDR addr, int len)
e013ee27 2709{
d993e290
PA
2710 if (the_low_target.remove_point != NULL)
2711 return the_low_target.remove_point (type, addr, len);
e013ee27
OF
2712 else
2713 /* Unsupported (see target.h). */
2714 return 1;
2715}
2716
2717static int
2718linux_stopped_by_watchpoint (void)
2719{
2720 if (the_low_target.stopped_by_watchpoint != NULL)
2721 return the_low_target.stopped_by_watchpoint ();
2722 else
2723 return 0;
2724}
2725
2726static CORE_ADDR
2727linux_stopped_data_address (void)
2728{
2729 if (the_low_target.stopped_data_address != NULL)
2730 return the_low_target.stopped_data_address ();
2731 else
2732 return 0;
2733}
2734
42c81e2a 2735#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437
NS
2736#if defined(__mcoldfire__)
2737/* These should really be defined in the kernel's ptrace.h header. */
2738#define PT_TEXT_ADDR 49*4
2739#define PT_DATA_ADDR 50*4
2740#define PT_TEXT_END_ADDR 51*4
2741#endif
2742
2743/* Under uClinux, programs are loaded at non-zero offsets, which we need
2744 to tell gdb about. */
2745
2746static int
2747linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
2748{
2749#if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
2750 unsigned long text, text_end, data;
bd99dc85 2751 int pid = lwpid_of (get_thread_lwp (current_inferior));
52fb6437
NS
2752
2753 errno = 0;
2754
2755 text = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_ADDR, 0);
2756 text_end = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_END_ADDR, 0);
2757 data = ptrace (PTRACE_PEEKUSER, pid, (long)PT_DATA_ADDR, 0);
2758
2759 if (errno == 0)
2760 {
2761 /* Both text and data offsets produced at compile-time (and so
1b3f6016
PA
2762 used by gdb) are relative to the beginning of the program,
2763 with the data segment immediately following the text segment.
2764 However, the actual runtime layout in memory may put the data
2765 somewhere else, so when we send gdb a data base-address, we
2766 use the real data base address and subtract the compile-time
2767 data base-address from it (which is just the length of the
2768 text segment). BSS immediately follows data in both
2769 cases. */
52fb6437
NS
2770 *text_p = text;
2771 *data_p = data - (text_end - text);
1b3f6016 2772
52fb6437
NS
2773 return 1;
2774 }
2775#endif
2776 return 0;
2777}
2778#endif
2779
07e059b5
VP
2780static int
2781linux_qxfer_osdata (const char *annex,
1b3f6016
PA
2782 unsigned char *readbuf, unsigned const char *writebuf,
2783 CORE_ADDR offset, int len)
07e059b5
VP
2784{
2785 /* We make the process list snapshot when the object starts to be
2786 read. */
2787 static const char *buf;
2788 static long len_avail = -1;
2789 static struct buffer buffer;
2790
2791 DIR *dirp;
2792
2793 if (strcmp (annex, "processes") != 0)
2794 return 0;
2795
2796 if (!readbuf || writebuf)
2797 return 0;
2798
2799 if (offset == 0)
2800 {
2801 if (len_avail != -1 && len_avail != 0)
2802 buffer_free (&buffer);
2803 len_avail = 0;
2804 buf = NULL;
2805 buffer_init (&buffer);
2806 buffer_grow_str (&buffer, "<osdata type=\"processes\">");
2807
2808 dirp = opendir ("/proc");
2809 if (dirp)
2810 {
1b3f6016
PA
2811 struct dirent *dp;
2812 while ((dp = readdir (dirp)) != NULL)
2813 {
2814 struct stat statbuf;
2815 char procentry[sizeof ("/proc/4294967295")];
2816
2817 if (!isdigit (dp->d_name[0])
2818 || strlen (dp->d_name) > sizeof ("4294967295") - 1)
2819 continue;
2820
2821 sprintf (procentry, "/proc/%s", dp->d_name);
2822 if (stat (procentry, &statbuf) == 0
2823 && S_ISDIR (statbuf.st_mode))
2824 {
2825 char pathname[128];
2826 FILE *f;
2827 char cmd[MAXPATHLEN + 1];
2828 struct passwd *entry;
2829
2830 sprintf (pathname, "/proc/%s/cmdline", dp->d_name);
2831 entry = getpwuid (statbuf.st_uid);
2832
2833 if ((f = fopen (pathname, "r")) != NULL)
2834 {
2835 size_t len = fread (cmd, 1, sizeof (cmd) - 1, f);
2836 if (len > 0)
2837 {
2838 int i;
2839 for (i = 0; i < len; i++)
2840 if (cmd[i] == '\0')
2841 cmd[i] = ' ';
2842 cmd[len] = '\0';
2843
2844 buffer_xml_printf (
07e059b5
VP
2845 &buffer,
2846 "<item>"
2847 "<column name=\"pid\">%s</column>"
2848 "<column name=\"user\">%s</column>"
2849 "<column name=\"command\">%s</column>"
2850 "</item>",
2851 dp->d_name,
2852 entry ? entry->pw_name : "?",
2853 cmd);
1b3f6016
PA
2854 }
2855 fclose (f);
2856 }
2857 }
2858 }
07e059b5 2859
1b3f6016 2860 closedir (dirp);
07e059b5
VP
2861 }
2862 buffer_grow_str0 (&buffer, "</osdata>\n");
2863 buf = buffer_finish (&buffer);
2864 len_avail = strlen (buf);
2865 }
2866
2867 if (offset >= len_avail)
2868 {
2869 /* Done. Get rid of the data. */
2870 buffer_free (&buffer);
2871 buf = NULL;
2872 len_avail = 0;
2873 return 0;
2874 }
2875
2876 if (len > len_avail - offset)
2877 len = len_avail - offset;
2878 memcpy (readbuf, buf + offset, len);
2879
2880 return len;
2881}
2882
d0722149
DE
2883/* Convert a native/host siginfo object, into/from the siginfo in the
2884 layout of the inferiors' architecture. */
2885
2886static void
2887siginfo_fixup (struct siginfo *siginfo, void *inf_siginfo, int direction)
2888{
2889 int done = 0;
2890
2891 if (the_low_target.siginfo_fixup != NULL)
2892 done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
2893
2894 /* If there was no callback, or the callback didn't do anything,
2895 then just do a straight memcpy. */
2896 if (!done)
2897 {
2898 if (direction == 1)
2899 memcpy (siginfo, inf_siginfo, sizeof (struct siginfo));
2900 else
2901 memcpy (inf_siginfo, siginfo, sizeof (struct siginfo));
2902 }
2903}
2904
4aa995e1
PA
2905static int
2906linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
2907 unsigned const char *writebuf, CORE_ADDR offset, int len)
2908{
d0722149 2909 int pid;
4aa995e1 2910 struct siginfo siginfo;
d0722149 2911 char inf_siginfo[sizeof (struct siginfo)];
4aa995e1
PA
2912
2913 if (current_inferior == NULL)
2914 return -1;
2915
bd99dc85 2916 pid = lwpid_of (get_thread_lwp (current_inferior));
4aa995e1
PA
2917
2918 if (debug_threads)
d0722149 2919 fprintf (stderr, "%s siginfo for lwp %d.\n",
4aa995e1
PA
2920 readbuf != NULL ? "Reading" : "Writing",
2921 pid);
2922
2923 if (offset > sizeof (siginfo))
2924 return -1;
2925
2926 if (ptrace (PTRACE_GETSIGINFO, pid, 0, &siginfo) != 0)
2927 return -1;
2928
d0722149
DE
2929 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
2930 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
2931 inferior with a 64-bit GDBSERVER should look the same as debugging it
2932 with a 32-bit GDBSERVER, we need to convert it. */
2933 siginfo_fixup (&siginfo, inf_siginfo, 0);
2934
4aa995e1
PA
2935 if (offset + len > sizeof (siginfo))
2936 len = sizeof (siginfo) - offset;
2937
2938 if (readbuf != NULL)
d0722149 2939 memcpy (readbuf, inf_siginfo + offset, len);
4aa995e1
PA
2940 else
2941 {
d0722149
DE
2942 memcpy (inf_siginfo + offset, writebuf, len);
2943
2944 /* Convert back to ptrace layout before flushing it out. */
2945 siginfo_fixup (&siginfo, inf_siginfo, 1);
2946
4aa995e1
PA
2947 if (ptrace (PTRACE_SETSIGINFO, pid, 0, &siginfo) != 0)
2948 return -1;
2949 }
2950
2951 return len;
2952}
2953
bd99dc85
PA
2954/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
2955 so we notice when children change state; as the handler for the
2956 sigsuspend in my_waitpid. */
2957
2958static void
2959sigchld_handler (int signo)
2960{
2961 int old_errno = errno;
2962
2963 if (debug_threads)
2964 /* fprintf is not async-signal-safe, so call write directly. */
2965 write (2, "sigchld_handler\n", sizeof ("sigchld_handler\n") - 1);
2966
2967 if (target_is_async_p ())
2968 async_file_mark (); /* trigger a linux_wait */
2969
2970 errno = old_errno;
2971}
2972
2973static int
2974linux_supports_non_stop (void)
2975{
2976 return 1;
2977}
2978
2979static int
2980linux_async (int enable)
2981{
2982 int previous = (linux_event_pipe[0] != -1);
2983
2984 if (previous != enable)
2985 {
2986 sigset_t mask;
2987 sigemptyset (&mask);
2988 sigaddset (&mask, SIGCHLD);
2989
2990 sigprocmask (SIG_BLOCK, &mask, NULL);
2991
2992 if (enable)
2993 {
2994 if (pipe (linux_event_pipe) == -1)
2995 fatal ("creating event pipe failed.");
2996
2997 fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
2998 fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
2999
3000 /* Register the event loop handler. */
3001 add_file_handler (linux_event_pipe[0],
3002 handle_target_event, NULL);
3003
3004 /* Always trigger a linux_wait. */
3005 async_file_mark ();
3006 }
3007 else
3008 {
3009 delete_file_handler (linux_event_pipe[0]);
3010
3011 close (linux_event_pipe[0]);
3012 close (linux_event_pipe[1]);
3013 linux_event_pipe[0] = -1;
3014 linux_event_pipe[1] = -1;
3015 }
3016
3017 sigprocmask (SIG_UNBLOCK, &mask, NULL);
3018 }
3019
3020 return previous;
3021}
3022
3023static int
3024linux_start_non_stop (int nonstop)
3025{
3026 /* Register or unregister from event-loop accordingly. */
3027 linux_async (nonstop);
3028 return 0;
3029}
3030
cf8fd78b
PA
3031static int
3032linux_supports_multi_process (void)
3033{
3034 return 1;
3035}
3036
ce3a066d
DJ
3037static struct target_ops linux_target_ops = {
3038 linux_create_inferior,
3039 linux_attach,
3040 linux_kill,
6ad8ae5c 3041 linux_detach,
444d6139 3042 linux_join,
ce3a066d
DJ
3043 linux_thread_alive,
3044 linux_resume,
3045 linux_wait,
3046 linux_fetch_registers,
3047 linux_store_registers,
3048 linux_read_memory,
3049 linux_write_memory,
2f2893d9 3050 linux_look_up_symbols,
ef57601b 3051 linux_request_interrupt,
aa691b87 3052 linux_read_auxv,
d993e290
PA
3053 linux_insert_point,
3054 linux_remove_point,
e013ee27
OF
3055 linux_stopped_by_watchpoint,
3056 linux_stopped_data_address,
42c81e2a 3057#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437 3058 linux_read_offsets,
dae5f5cf
DJ
3059#else
3060 NULL,
3061#endif
3062#ifdef USE_THREAD_DB
3063 thread_db_get_tls_address,
3064#else
3065 NULL,
52fb6437 3066#endif
59a016f0
PA
3067 NULL,
3068 hostio_last_error_from_errno,
07e059b5 3069 linux_qxfer_osdata,
4aa995e1 3070 linux_xfer_siginfo,
bd99dc85
PA
3071 linux_supports_non_stop,
3072 linux_async,
3073 linux_start_non_stop,
cf8fd78b 3074 linux_supports_multi_process
ce3a066d
DJ
3075};
3076
0d62e5e8
DJ
3077static void
3078linux_init_signals ()
3079{
3080 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
3081 to find what the cancel signal actually is. */
254787d4 3082 signal (__SIGRTMIN+1, SIG_IGN);
0d62e5e8
DJ
3083}
3084
da6d8c04
DJ
3085void
3086initialize_low (void)
3087{
bd99dc85
PA
3088 struct sigaction sigchld_action;
3089 memset (&sigchld_action, 0, sizeof (sigchld_action));
ce3a066d 3090 set_target_ops (&linux_target_ops);
611cb4a5
DJ
3091 set_breakpoint_data (the_low_target.breakpoint,
3092 the_low_target.breakpoint_len);
0d62e5e8 3093 linux_init_signals ();
24a09b5f 3094 linux_test_for_tracefork ();
52fa2412
UW
3095#ifdef HAVE_LINUX_REGSETS
3096 for (num_regsets = 0; target_regsets[num_regsets].size >= 0; num_regsets++)
3097 ;
bca929d3 3098 disabled_regsets = xmalloc (num_regsets);
52fa2412 3099#endif
bd99dc85
PA
3100
3101 sigchld_action.sa_handler = sigchld_handler;
3102 sigemptyset (&sigchld_action.sa_mask);
3103 sigchld_action.sa_flags = SA_RESTART;
3104 sigaction (SIGCHLD, &sigchld_action, NULL);
da6d8c04 3105}