]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/gdbserver/linux-low.c
2012-02-27 Luis Machado <lgustavo@codesourcery.com>
[thirdparty/binutils-gdb.git] / gdb / gdbserver / linux-low.c
CommitLineData
da6d8c04 1/* Low level interface to ptrace, for the remote server for GDB.
0b302171 2 Copyright (C) 1995-1996, 1998-2012 Free Software Foundation, Inc.
da6d8c04
DJ
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
a9762ec7 8 the Free Software Foundation; either version 3 of the License, or
da6d8c04
DJ
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
a9762ec7 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
da6d8c04
DJ
18
19#include "server.h"
58caa3dc 20#include "linux-low.h"
d26e3629 21#include "linux-osdata.h"
da6d8c04 22
58caa3dc 23#include <sys/wait.h>
da6d8c04
DJ
24#include <stdio.h>
25#include <sys/param.h>
da6d8c04 26#include <sys/ptrace.h>
af96c192 27#include "linux-ptrace.h"
e3deef73 28#include "linux-procfs.h"
da6d8c04
DJ
29#include <signal.h>
30#include <sys/ioctl.h>
31#include <fcntl.h>
d07c63e7 32#include <string.h>
0a30fbc4
DJ
33#include <stdlib.h>
34#include <unistd.h>
fa6a77dc 35#include <errno.h>
fd500816 36#include <sys/syscall.h>
f9387fc3 37#include <sched.h>
07e059b5
VP
38#include <ctype.h>
39#include <pwd.h>
40#include <sys/types.h>
41#include <dirent.h>
efcbbd14
UW
42#include <sys/stat.h>
43#include <sys/vfs.h>
1570b33e 44#include <sys/uio.h>
957f3f49
DE
45#ifndef ELFMAG0
46/* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
47 then ELFMAG0 will have been defined. If it didn't get included by
48 gdb_proc_service.h then including it will likely introduce a duplicate
49 definition of elf_fpregset_t. */
50#include <elf.h>
51#endif
efcbbd14
UW
52
53#ifndef SPUFS_MAGIC
54#define SPUFS_MAGIC 0x23c9b64e
55#endif
da6d8c04 56
03583c20
UW
57#ifdef HAVE_PERSONALITY
58# include <sys/personality.h>
59# if !HAVE_DECL_ADDR_NO_RANDOMIZE
60# define ADDR_NO_RANDOMIZE 0x0040000
61# endif
62#endif
63
fd462a61
DJ
64#ifndef O_LARGEFILE
65#define O_LARGEFILE 0
66#endif
67
ec8ebe72
DE
68#ifndef W_STOPCODE
69#define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
70#endif
71
1a981360
PA
72/* This is the kernel's hard limit. Not to be confused with
73 SIGRTMIN. */
74#ifndef __SIGRTMIN
75#define __SIGRTMIN 32
76#endif
77
42c81e2a
DJ
78#ifdef __UCLIBC__
79#if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
80#define HAS_NOMMU
81#endif
82#endif
83
24a09b5f
DJ
84/* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
85 representation of the thread ID.
611cb4a5 86
54a0b537 87 ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
95954743
PA
88 the same as the LWP ID.
89
90 ``all_processes'' is keyed by the "overall process ID", which
91 GNU/Linux calls tgid, "thread group ID". */
0d62e5e8 92
54a0b537 93struct inferior_list all_lwps;
0d62e5e8 94
24a09b5f
DJ
95/* A list of all unknown processes which receive stop signals. Some other
96 process will presumably claim each of these as forked children
97 momentarily. */
98
99struct inferior_list stopped_pids;
100
0d62e5e8
DJ
101/* FIXME this is a bit of a hack, and could be removed. */
102int stopping_threads;
103
104/* FIXME make into a target method? */
24a09b5f 105int using_threads = 1;
24a09b5f 106
fa593d66
PA
107/* True if we're presently stabilizing threads (moving them out of
108 jump pads). */
109static int stabilizing_threads;
110
95954743
PA
111/* This flag is true iff we've just created or attached to our first
112 inferior but it has not stopped yet. As soon as it does, we need
113 to call the low target's arch_setup callback. Doing this only on
114 the first inferior avoids reinializing the architecture on every
115 inferior, and avoids messing with the register caches of the
116 already running inferiors. NOTE: this assumes all inferiors under
117 control of gdbserver have the same architecture. */
d61ddec4
UW
118static int new_inferior;
119
2acc282a 120static void linux_resume_one_lwp (struct lwp_info *lwp,
54a0b537 121 int step, int signal, siginfo_t *info);
2bd7c093 122static void linux_resume (struct thread_resume *resume_info, size_t n);
7984d532
PA
123static void stop_all_lwps (int suspend, struct lwp_info *except);
124static void unstop_all_lwps (int unsuspend, struct lwp_info *except);
95954743 125static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
95954743 126static void *add_lwp (ptid_t ptid);
c35fafde 127static int linux_stopped_by_watchpoint (void);
95954743 128static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
d50171e4 129static void proceed_all_lwps (void);
d50171e4
PA
130static int finish_step_over (struct lwp_info *lwp);
131static CORE_ADDR get_stop_pc (struct lwp_info *lwp);
132static int kill_lwp (unsigned long lwpid, int signo);
1e7fc18c 133static void linux_enable_event_reporting (int pid);
d50171e4
PA
134
135/* True if the low target can hardware single-step. Such targets
136 don't need a BREAKPOINT_REINSERT_ADDR callback. */
137
138static int
139can_hardware_single_step (void)
140{
141 return (the_low_target.breakpoint_reinsert_addr == NULL);
142}
143
144/* True if the low target supports memory breakpoints. If so, we'll
145 have a GET_PC implementation. */
146
147static int
148supports_breakpoints (void)
149{
150 return (the_low_target.get_pc != NULL);
151}
0d62e5e8 152
fa593d66
PA
153/* Returns true if this target can support fast tracepoints. This
154 does not mean that the in-process agent has been loaded in the
155 inferior. */
156
157static int
158supports_fast_tracepoints (void)
159{
160 return the_low_target.install_fast_tracepoint_jump_pad != NULL;
161}
162
0d62e5e8
DJ
163struct pending_signals
164{
165 int signal;
32ca6d61 166 siginfo_t info;
0d62e5e8
DJ
167 struct pending_signals *prev;
168};
611cb4a5 169
14ce3065
DE
170#define PTRACE_ARG3_TYPE void *
171#define PTRACE_ARG4_TYPE void *
c6ecbae5 172#define PTRACE_XFER_TYPE long
da6d8c04 173
58caa3dc 174#ifdef HAVE_LINUX_REGSETS
52fa2412
UW
175static char *disabled_regsets;
176static int num_regsets;
58caa3dc
DJ
177#endif
178
bd99dc85
PA
179/* The read/write ends of the pipe registered as waitable file in the
180 event loop. */
181static int linux_event_pipe[2] = { -1, -1 };
182
183/* True if we're currently in async mode. */
184#define target_is_async_p() (linux_event_pipe[0] != -1)
185
02fc4de7 186static void send_sigstop (struct lwp_info *lwp);
bd99dc85
PA
187static void wait_for_sigstop (struct inferior_list_entry *entry);
188
d0722149
DE
189/* Return non-zero if HEADER is a 64-bit ELF file. */
190
191static int
957f3f49 192elf_64_header_p (const Elf64_Ehdr *header)
d0722149
DE
193{
194 return (header->e_ident[EI_MAG0] == ELFMAG0
195 && header->e_ident[EI_MAG1] == ELFMAG1
196 && header->e_ident[EI_MAG2] == ELFMAG2
197 && header->e_ident[EI_MAG3] == ELFMAG3
198 && header->e_ident[EI_CLASS] == ELFCLASS64);
199}
200
201/* Return non-zero if FILE is a 64-bit ELF file,
202 zero if the file is not a 64-bit ELF file,
203 and -1 if the file is not accessible or doesn't exist. */
204
be07f1a2 205static int
d0722149
DE
206elf_64_file_p (const char *file)
207{
957f3f49 208 Elf64_Ehdr header;
d0722149
DE
209 int fd;
210
211 fd = open (file, O_RDONLY);
212 if (fd < 0)
213 return -1;
214
215 if (read (fd, &header, sizeof (header)) != sizeof (header))
216 {
217 close (fd);
218 return 0;
219 }
220 close (fd);
221
222 return elf_64_header_p (&header);
223}
224
be07f1a2
PA
225/* Accepts an integer PID; Returns true if the executable PID is
226 running is a 64-bit ELF file.. */
227
228int
229linux_pid_exe_is_elf_64_file (int pid)
230{
231 char file[MAXPATHLEN];
232
233 sprintf (file, "/proc/%d/exe", pid);
234 return elf_64_file_p (file);
235}
236
bd99dc85
PA
237static void
238delete_lwp (struct lwp_info *lwp)
239{
240 remove_thread (get_lwp_thread (lwp));
241 remove_inferior (&all_lwps, &lwp->head);
aa5ca48f 242 free (lwp->arch_private);
bd99dc85
PA
243 free (lwp);
244}
245
95954743
PA
246/* Add a process to the common process list, and set its private
247 data. */
248
249static struct process_info *
250linux_add_process (int pid, int attached)
251{
252 struct process_info *proc;
253
254 /* Is this the first process? If so, then set the arch. */
255 if (all_processes.head == NULL)
256 new_inferior = 1;
257
258 proc = add_process (pid, attached);
259 proc->private = xcalloc (1, sizeof (*proc->private));
260
aa5ca48f
DE
261 if (the_low_target.new_process != NULL)
262 proc->private->arch_private = the_low_target.new_process ();
263
95954743
PA
264 return proc;
265}
266
07d4f67e
DE
267/* Wrapper function for waitpid which handles EINTR, and emulates
268 __WALL for systems where that is not available. */
269
270static int
271my_waitpid (int pid, int *status, int flags)
272{
273 int ret, out_errno;
274
275 if (debug_threads)
276 fprintf (stderr, "my_waitpid (%d, 0x%x)\n", pid, flags);
277
278 if (flags & __WALL)
279 {
280 sigset_t block_mask, org_mask, wake_mask;
281 int wnohang;
282
283 wnohang = (flags & WNOHANG) != 0;
284 flags &= ~(__WALL | __WCLONE);
285 flags |= WNOHANG;
286
287 /* Block all signals while here. This avoids knowing about
288 LinuxThread's signals. */
289 sigfillset (&block_mask);
290 sigprocmask (SIG_BLOCK, &block_mask, &org_mask);
291
292 /* ... except during the sigsuspend below. */
293 sigemptyset (&wake_mask);
294
295 while (1)
296 {
297 /* Since all signals are blocked, there's no need to check
298 for EINTR here. */
299 ret = waitpid (pid, status, flags);
300 out_errno = errno;
301
302 if (ret == -1 && out_errno != ECHILD)
303 break;
304 else if (ret > 0)
305 break;
306
307 if (flags & __WCLONE)
308 {
309 /* We've tried both flavors now. If WNOHANG is set,
310 there's nothing else to do, just bail out. */
311 if (wnohang)
312 break;
313
314 if (debug_threads)
315 fprintf (stderr, "blocking\n");
316
317 /* Block waiting for signals. */
318 sigsuspend (&wake_mask);
319 }
320
321 flags ^= __WCLONE;
322 }
323
324 sigprocmask (SIG_SETMASK, &org_mask, NULL);
325 }
326 else
327 {
328 do
329 ret = waitpid (pid, status, flags);
330 while (ret == -1 && errno == EINTR);
331 out_errno = errno;
332 }
333
334 if (debug_threads)
335 fprintf (stderr, "my_waitpid (%d, 0x%x): status(%x), %d\n",
336 pid, flags, status ? *status : -1, ret);
337
338 errno = out_errno;
339 return ret;
340}
341
bd99dc85
PA
342/* Handle a GNU/Linux extended wait response. If we see a clone
343 event, we need to add the new LWP to our list (and not report the
344 trap to higher layers). */
0d62e5e8 345
24a09b5f 346static void
54a0b537 347handle_extended_wait (struct lwp_info *event_child, int wstat)
24a09b5f
DJ
348{
349 int event = wstat >> 16;
54a0b537 350 struct lwp_info *new_lwp;
24a09b5f
DJ
351
352 if (event == PTRACE_EVENT_CLONE)
353 {
95954743 354 ptid_t ptid;
24a09b5f 355 unsigned long new_pid;
836acd6d 356 int ret, status = W_STOPCODE (SIGSTOP);
24a09b5f 357
bd99dc85 358 ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), 0, &new_pid);
24a09b5f
DJ
359
360 /* If we haven't already seen the new PID stop, wait for it now. */
361 if (! pull_pid_from_list (&stopped_pids, new_pid))
362 {
363 /* The new child has a pending SIGSTOP. We can't affect it until it
364 hits the SIGSTOP, but we're already attached. */
365
97438e3f 366 ret = my_waitpid (new_pid, &status, __WALL);
24a09b5f
DJ
367
368 if (ret == -1)
369 perror_with_name ("waiting for new child");
370 else if (ret != new_pid)
371 warning ("wait returned unexpected PID %d", ret);
da5898ce 372 else if (!WIFSTOPPED (status))
24a09b5f
DJ
373 warning ("wait returned unexpected status 0x%x", status);
374 }
375
1e7fc18c 376 linux_enable_event_reporting (new_pid);
24a09b5f 377
95954743
PA
378 ptid = ptid_build (pid_of (event_child), new_pid, 0);
379 new_lwp = (struct lwp_info *) add_lwp (ptid);
380 add_thread (ptid, new_lwp);
24a09b5f 381
e27d73f6
DE
382 /* Either we're going to immediately resume the new thread
383 or leave it stopped. linux_resume_one_lwp is a nop if it
384 thinks the thread is currently running, so set this first
385 before calling linux_resume_one_lwp. */
386 new_lwp->stopped = 1;
387
da5898ce
DJ
388 /* Normally we will get the pending SIGSTOP. But in some cases
389 we might get another signal delivered to the group first.
f21cc1a2 390 If we do get another signal, be sure not to lose it. */
da5898ce
DJ
391 if (WSTOPSIG (status) == SIGSTOP)
392 {
d50171e4
PA
393 if (stopping_threads)
394 new_lwp->stop_pc = get_stop_pc (new_lwp);
395 else
e27d73f6 396 linux_resume_one_lwp (new_lwp, 0, 0, NULL);
da5898ce 397 }
24a09b5f 398 else
da5898ce 399 {
54a0b537 400 new_lwp->stop_expected = 1;
d50171e4 401
da5898ce
DJ
402 if (stopping_threads)
403 {
d50171e4 404 new_lwp->stop_pc = get_stop_pc (new_lwp);
54a0b537
PA
405 new_lwp->status_pending_p = 1;
406 new_lwp->status_pending = status;
da5898ce
DJ
407 }
408 else
409 /* Pass the signal on. This is what GDB does - except
410 shouldn't we really report it instead? */
e27d73f6 411 linux_resume_one_lwp (new_lwp, 0, WSTOPSIG (status), NULL);
da5898ce 412 }
24a09b5f
DJ
413
414 /* Always resume the current thread. If we are stopping
415 threads, it will have a pending SIGSTOP; we may as well
416 collect it now. */
2acc282a 417 linux_resume_one_lwp (event_child, event_child->stepping, 0, NULL);
24a09b5f
DJ
418 }
419}
420
d50171e4
PA
421/* Return the PC as read from the regcache of LWP, without any
422 adjustment. */
423
424static CORE_ADDR
425get_pc (struct lwp_info *lwp)
426{
427 struct thread_info *saved_inferior;
428 struct regcache *regcache;
429 CORE_ADDR pc;
430
431 if (the_low_target.get_pc == NULL)
432 return 0;
433
434 saved_inferior = current_inferior;
435 current_inferior = get_lwp_thread (lwp);
436
437 regcache = get_thread_regcache (current_inferior, 1);
438 pc = (*the_low_target.get_pc) (regcache);
439
440 if (debug_threads)
441 fprintf (stderr, "pc is 0x%lx\n", (long) pc);
442
443 current_inferior = saved_inferior;
444 return pc;
445}
446
447/* This function should only be called if LWP got a SIGTRAP.
0d62e5e8
DJ
448 The SIGTRAP could mean several things.
449
450 On i386, where decr_pc_after_break is non-zero:
451 If we were single-stepping this process using PTRACE_SINGLESTEP,
452 we will get only the one SIGTRAP (even if the instruction we
453 stepped over was a breakpoint). The value of $eip will be the
454 next instruction.
455 If we continue the process using PTRACE_CONT, we will get a
456 SIGTRAP when we hit a breakpoint. The value of $eip will be
457 the instruction after the breakpoint (i.e. needs to be
458 decremented). If we report the SIGTRAP to GDB, we must also
459 report the undecremented PC. If we cancel the SIGTRAP, we
460 must resume at the decremented PC.
461
462 (Presumably, not yet tested) On a non-decr_pc_after_break machine
463 with hardware or kernel single-step:
464 If we single-step over a breakpoint instruction, our PC will
465 point at the following instruction. If we continue and hit a
466 breakpoint instruction, our PC will point at the breakpoint
467 instruction. */
468
469static CORE_ADDR
d50171e4 470get_stop_pc (struct lwp_info *lwp)
0d62e5e8 471{
d50171e4
PA
472 CORE_ADDR stop_pc;
473
474 if (the_low_target.get_pc == NULL)
475 return 0;
0d62e5e8 476
d50171e4
PA
477 stop_pc = get_pc (lwp);
478
bdabb078
PA
479 if (WSTOPSIG (lwp->last_status) == SIGTRAP
480 && !lwp->stepping
481 && !lwp->stopped_by_watchpoint
482 && lwp->last_status >> 16 == 0)
47c0c975
DE
483 stop_pc -= the_low_target.decr_pc_after_break;
484
485 if (debug_threads)
486 fprintf (stderr, "stop pc is 0x%lx\n", (long) stop_pc);
487
488 return stop_pc;
0d62e5e8 489}
ce3a066d 490
0d62e5e8 491static void *
95954743 492add_lwp (ptid_t ptid)
611cb4a5 493{
54a0b537 494 struct lwp_info *lwp;
0d62e5e8 495
54a0b537
PA
496 lwp = (struct lwp_info *) xmalloc (sizeof (*lwp));
497 memset (lwp, 0, sizeof (*lwp));
0d62e5e8 498
95954743 499 lwp->head.id = ptid;
0d62e5e8 500
aa5ca48f
DE
501 if (the_low_target.new_thread != NULL)
502 lwp->arch_private = the_low_target.new_thread ();
503
54a0b537 504 add_inferior_to_list (&all_lwps, &lwp->head);
0d62e5e8 505
54a0b537 506 return lwp;
0d62e5e8 507}
611cb4a5 508
da6d8c04
DJ
509/* Start an inferior process and returns its pid.
510 ALLARGS is a vector of program-name and args. */
511
ce3a066d
DJ
512static int
513linux_create_inferior (char *program, char **allargs)
da6d8c04 514{
03583c20
UW
515#ifdef HAVE_PERSONALITY
516 int personality_orig = 0, personality_set = 0;
517#endif
a6dbe5df 518 struct lwp_info *new_lwp;
da6d8c04 519 int pid;
95954743 520 ptid_t ptid;
da6d8c04 521
03583c20
UW
522#ifdef HAVE_PERSONALITY
523 if (disable_randomization)
524 {
525 errno = 0;
526 personality_orig = personality (0xffffffff);
527 if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
528 {
529 personality_set = 1;
530 personality (personality_orig | ADDR_NO_RANDOMIZE);
531 }
532 if (errno != 0 || (personality_set
533 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
534 warning ("Error disabling address space randomization: %s",
535 strerror (errno));
536 }
537#endif
538
42c81e2a 539#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437
NS
540 pid = vfork ();
541#else
da6d8c04 542 pid = fork ();
52fb6437 543#endif
da6d8c04
DJ
544 if (pid < 0)
545 perror_with_name ("fork");
546
547 if (pid == 0)
548 {
549 ptrace (PTRACE_TRACEME, 0, 0, 0);
550
1a981360 551#ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
254787d4 552 signal (__SIGRTMIN + 1, SIG_DFL);
60c3d7b0 553#endif
0d62e5e8 554
a9fa9f7d
DJ
555 setpgid (0, 0);
556
e0f9f062
DE
557 /* If gdbserver is connected to gdb via stdio, redirect the inferior's
558 stdout to stderr so that inferior i/o doesn't corrupt the connection.
559 Also, redirect stdin to /dev/null. */
560 if (remote_connection_is_stdio ())
561 {
562 close (0);
563 open ("/dev/null", O_RDONLY);
564 dup2 (2, 1);
3e52c33d
JK
565 if (write (2, "stdin/stdout redirected\n",
566 sizeof ("stdin/stdout redirected\n") - 1) < 0)
567 /* Errors ignored. */;
e0f9f062
DE
568 }
569
2b876972
DJ
570 execv (program, allargs);
571 if (errno == ENOENT)
572 execvp (program, allargs);
da6d8c04
DJ
573
574 fprintf (stderr, "Cannot exec %s: %s.\n", program,
d07c63e7 575 strerror (errno));
da6d8c04
DJ
576 fflush (stderr);
577 _exit (0177);
578 }
579
03583c20
UW
580#ifdef HAVE_PERSONALITY
581 if (personality_set)
582 {
583 errno = 0;
584 personality (personality_orig);
585 if (errno != 0)
586 warning ("Error restoring address space randomization: %s",
587 strerror (errno));
588 }
589#endif
590
95954743
PA
591 linux_add_process (pid, 0);
592
593 ptid = ptid_build (pid, pid, 0);
594 new_lwp = add_lwp (ptid);
595 add_thread (ptid, new_lwp);
a6dbe5df 596 new_lwp->must_set_ptrace_flags = 1;
611cb4a5 597
a9fa9f7d 598 return pid;
da6d8c04
DJ
599}
600
601/* Attach to an inferior process. */
602
95954743
PA
603static void
604linux_attach_lwp_1 (unsigned long lwpid, int initial)
da6d8c04 605{
95954743 606 ptid_t ptid;
54a0b537 607 struct lwp_info *new_lwp;
611cb4a5 608
95954743 609 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) != 0)
da6d8c04 610 {
95954743 611 if (!initial)
2d717e4f
DJ
612 {
613 /* If we fail to attach to an LWP, just warn. */
95954743 614 fprintf (stderr, "Cannot attach to lwp %ld: %s (%d)\n", lwpid,
2d717e4f
DJ
615 strerror (errno), errno);
616 fflush (stderr);
617 return;
618 }
619 else
620 /* If we fail to attach to a process, report an error. */
95954743 621 error ("Cannot attach to lwp %ld: %s (%d)\n", lwpid,
43d5792c 622 strerror (errno), errno);
da6d8c04
DJ
623 }
624
95954743 625 if (initial)
e3deef73
LM
626 /* If lwp is the tgid, we handle adding existing threads later.
627 Otherwise we just add lwp without bothering about any other
628 threads. */
95954743
PA
629 ptid = ptid_build (lwpid, lwpid, 0);
630 else
631 {
632 /* Note that extracting the pid from the current inferior is
633 safe, since we're always called in the context of the same
634 process as this new thread. */
635 int pid = pid_of (get_thread_lwp (current_inferior));
636 ptid = ptid_build (pid, lwpid, 0);
637 }
24a09b5f 638
95954743
PA
639 new_lwp = (struct lwp_info *) add_lwp (ptid);
640 add_thread (ptid, new_lwp);
0d62e5e8 641
a6dbe5df
PA
642 /* We need to wait for SIGSTOP before being able to make the next
643 ptrace call on this LWP. */
644 new_lwp->must_set_ptrace_flags = 1;
645
0d62e5e8 646 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
0e21c1ec
DE
647 brings it to a halt.
648
649 There are several cases to consider here:
650
651 1) gdbserver has already attached to the process and is being notified
1b3f6016 652 of a new thread that is being created.
d50171e4
PA
653 In this case we should ignore that SIGSTOP and resume the
654 process. This is handled below by setting stop_expected = 1,
8336d594 655 and the fact that add_thread sets last_resume_kind ==
d50171e4 656 resume_continue.
0e21c1ec
DE
657
658 2) This is the first thread (the process thread), and we're attaching
1b3f6016
PA
659 to it via attach_inferior.
660 In this case we want the process thread to stop.
d50171e4
PA
661 This is handled by having linux_attach set last_resume_kind ==
662 resume_stop after we return.
e3deef73
LM
663
664 If the pid we are attaching to is also the tgid, we attach to and
665 stop all the existing threads. Otherwise, we attach to pid and
666 ignore any other threads in the same group as this pid.
0e21c1ec
DE
667
668 3) GDB is connecting to gdbserver and is requesting an enumeration of all
1b3f6016
PA
669 existing threads.
670 In this case we want the thread to stop.
671 FIXME: This case is currently not properly handled.
672 We should wait for the SIGSTOP but don't. Things work apparently
673 because enough time passes between when we ptrace (ATTACH) and when
674 gdb makes the next ptrace call on the thread.
0d62e5e8
DJ
675
676 On the other hand, if we are currently trying to stop all threads, we
677 should treat the new thread as if we had sent it a SIGSTOP. This works
54a0b537 678 because we are guaranteed that the add_lwp call above added us to the
0e21c1ec
DE
679 end of the list, and so the new thread has not yet reached
680 wait_for_sigstop (but will). */
d50171e4 681 new_lwp->stop_expected = 1;
0d62e5e8
DJ
682}
683
95954743
PA
684void
685linux_attach_lwp (unsigned long lwpid)
686{
687 linux_attach_lwp_1 (lwpid, 0);
688}
689
e3deef73
LM
690/* Attach to PID. If PID is the tgid, attach to it and all
691 of its threads. */
692
0d62e5e8 693int
a1928bad 694linux_attach (unsigned long pid)
0d62e5e8 695{
e3deef73
LM
696 /* Attach to PID. We will check for other threads
697 soon. */
95954743 698 linux_attach_lwp_1 (pid, 1);
95954743 699 linux_add_process (pid, 1);
0d62e5e8 700
bd99dc85
PA
701 if (!non_stop)
702 {
8336d594
PA
703 struct thread_info *thread;
704
705 /* Don't ignore the initial SIGSTOP if we just attached to this
706 process. It will be collected by wait shortly. */
707 thread = find_thread_ptid (ptid_build (pid, pid, 0));
708 thread->last_resume_kind = resume_stop;
bd99dc85 709 }
0d62e5e8 710
e3deef73
LM
711 if (linux_proc_get_tgid (pid) == pid)
712 {
713 DIR *dir;
714 char pathname[128];
715
716 sprintf (pathname, "/proc/%ld/task", pid);
717
718 dir = opendir (pathname);
719
720 if (!dir)
721 {
722 fprintf (stderr, "Could not open /proc/%ld/task.\n", pid);
723 fflush (stderr);
724 }
725 else
726 {
727 /* At this point we attached to the tgid. Scan the task for
728 existing threads. */
729 unsigned long lwp;
730 int new_threads_found;
731 int iterations = 0;
732 struct dirent *dp;
733
734 while (iterations < 2)
735 {
736 new_threads_found = 0;
737 /* Add all the other threads. While we go through the
738 threads, new threads may be spawned. Cycle through
739 the list of threads until we have done two iterations without
740 finding new threads. */
741 while ((dp = readdir (dir)) != NULL)
742 {
743 /* Fetch one lwp. */
744 lwp = strtoul (dp->d_name, NULL, 10);
745
746 /* Is this a new thread? */
747 if (lwp
748 && find_thread_ptid (ptid_build (pid, lwp, 0)) == NULL)
749 {
750 linux_attach_lwp_1 (lwp, 0);
751 new_threads_found++;
752
753 if (debug_threads)
754 fprintf (stderr, "\
755Found and attached to new lwp %ld\n", lwp);
756 }
757 }
758
759 if (!new_threads_found)
760 iterations++;
761 else
762 iterations = 0;
763
764 rewinddir (dir);
765 }
766 closedir (dir);
767 }
768 }
769
95954743
PA
770 return 0;
771}
772
773struct counter
774{
775 int pid;
776 int count;
777};
778
779static int
780second_thread_of_pid_p (struct inferior_list_entry *entry, void *args)
781{
782 struct counter *counter = args;
783
784 if (ptid_get_pid (entry->id) == counter->pid)
785 {
786 if (++counter->count > 1)
787 return 1;
788 }
d61ddec4 789
da6d8c04
DJ
790 return 0;
791}
792
95954743
PA
793static int
794last_thread_of_process_p (struct thread_info *thread)
795{
796 ptid_t ptid = ((struct inferior_list_entry *)thread)->id;
797 int pid = ptid_get_pid (ptid);
798 struct counter counter = { pid , 0 };
da6d8c04 799
95954743
PA
800 return (find_inferior (&all_threads,
801 second_thread_of_pid_p, &counter) == NULL);
802}
803
da84f473
PA
804/* Kill LWP. */
805
806static void
807linux_kill_one_lwp (struct lwp_info *lwp)
808{
809 int pid = lwpid_of (lwp);
810
811 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
812 there is no signal context, and ptrace(PTRACE_KILL) (or
813 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
814 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
815 alternative is to kill with SIGKILL. We only need one SIGKILL
816 per process, not one for each thread. But since we still support
817 linuxthreads, and we also support debugging programs using raw
818 clone without CLONE_THREAD, we send one for each thread. For
819 years, we used PTRACE_KILL only, so we're being a bit paranoid
820 about some old kernels where PTRACE_KILL might work better
821 (dubious if there are any such, but that's why it's paranoia), so
822 we try SIGKILL first, PTRACE_KILL second, and so we're fine
823 everywhere. */
824
825 errno = 0;
826 kill (pid, SIGKILL);
827 if (debug_threads)
828 fprintf (stderr,
829 "LKL: kill (SIGKILL) %s, 0, 0 (%s)\n",
830 target_pid_to_str (ptid_of (lwp)),
831 errno ? strerror (errno) : "OK");
832
833 errno = 0;
834 ptrace (PTRACE_KILL, pid, 0, 0);
835 if (debug_threads)
836 fprintf (stderr,
837 "LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
838 target_pid_to_str (ptid_of (lwp)),
839 errno ? strerror (errno) : "OK");
840}
841
842/* Callback for `find_inferior'. Kills an lwp of a given process,
843 except the leader. */
95954743
PA
844
845static int
da84f473 846kill_one_lwp_callback (struct inferior_list_entry *entry, void *args)
da6d8c04 847{
0d62e5e8 848 struct thread_info *thread = (struct thread_info *) entry;
54a0b537 849 struct lwp_info *lwp = get_thread_lwp (thread);
0d62e5e8 850 int wstat;
95954743
PA
851 int pid = * (int *) args;
852
853 if (ptid_get_pid (entry->id) != pid)
854 return 0;
0d62e5e8 855
fd500816
DJ
856 /* We avoid killing the first thread here, because of a Linux kernel (at
857 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
858 the children get a chance to be reaped, it will remain a zombie
859 forever. */
95954743 860
12b42a12 861 if (lwpid_of (lwp) == pid)
95954743
PA
862 {
863 if (debug_threads)
864 fprintf (stderr, "lkop: is last of process %s\n",
865 target_pid_to_str (entry->id));
866 return 0;
867 }
fd500816 868
0d62e5e8
DJ
869 do
870 {
da84f473 871 linux_kill_one_lwp (lwp);
0d62e5e8
DJ
872
873 /* Make sure it died. The loop is most likely unnecessary. */
95954743 874 pid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
bd99dc85 875 } while (pid > 0 && WIFSTOPPED (wstat));
95954743
PA
876
877 return 0;
da6d8c04
DJ
878}
879
95954743
PA
880static int
881linux_kill (int pid)
0d62e5e8 882{
95954743 883 struct process_info *process;
54a0b537 884 struct lwp_info *lwp;
fd500816 885 int wstat;
95954743 886 int lwpid;
fd500816 887
95954743
PA
888 process = find_process_pid (pid);
889 if (process == NULL)
890 return -1;
9d606399 891
f9e39928
PA
892 /* If we're killing a running inferior, make sure it is stopped
893 first, as PTRACE_KILL will not work otherwise. */
7984d532 894 stop_all_lwps (0, NULL);
f9e39928 895
da84f473 896 find_inferior (&all_threads, kill_one_lwp_callback , &pid);
fd500816 897
54a0b537 898 /* See the comment in linux_kill_one_lwp. We did not kill the first
fd500816 899 thread in the list, so do so now. */
95954743 900 lwp = find_lwp_pid (pid_to_ptid (pid));
bd99dc85 901
784867a5 902 if (lwp == NULL)
fd500816 903 {
784867a5
JK
904 if (debug_threads)
905 fprintf (stderr, "lk_1: cannot find lwp %ld, for pid: %d\n",
906 lwpid_of (lwp), pid);
907 }
908 else
909 {
910 if (debug_threads)
911 fprintf (stderr, "lk_1: killing lwp %ld, for pid: %d\n",
912 lwpid_of (lwp), pid);
fd500816 913
784867a5
JK
914 do
915 {
da84f473 916 linux_kill_one_lwp (lwp);
784867a5
JK
917
918 /* Make sure it died. The loop is most likely unnecessary. */
919 lwpid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
920 } while (lwpid > 0 && WIFSTOPPED (wstat));
921 }
2d717e4f 922
8336d594 923 the_target->mourn (process);
f9e39928
PA
924
925 /* Since we presently can only stop all lwps of all processes, we
926 need to unstop lwps of other processes. */
7984d532 927 unstop_all_lwps (0, NULL);
95954743 928 return 0;
0d62e5e8
DJ
929}
930
95954743
PA
931static int
932linux_detach_one_lwp (struct inferior_list_entry *entry, void *args)
6ad8ae5c
DJ
933{
934 struct thread_info *thread = (struct thread_info *) entry;
54a0b537 935 struct lwp_info *lwp = get_thread_lwp (thread);
95954743
PA
936 int pid = * (int *) args;
937
938 if (ptid_get_pid (entry->id) != pid)
939 return 0;
6ad8ae5c 940
ae13219e
DJ
941 /* If this process is stopped but is expecting a SIGSTOP, then make
942 sure we take care of that now. This isn't absolutely guaranteed
943 to collect the SIGSTOP, but is fairly likely to. */
54a0b537 944 if (lwp->stop_expected)
ae13219e 945 {
bd99dc85 946 int wstat;
ae13219e 947 /* Clear stop_expected, so that the SIGSTOP will be reported. */
54a0b537 948 lwp->stop_expected = 0;
f9e39928 949 linux_resume_one_lwp (lwp, 0, 0, NULL);
95954743 950 linux_wait_for_event (lwp->head.id, &wstat, __WALL);
ae13219e
DJ
951 }
952
953 /* Flush any pending changes to the process's registers. */
954 regcache_invalidate_one ((struct inferior_list_entry *)
54a0b537 955 get_lwp_thread (lwp));
ae13219e
DJ
956
957 /* Finally, let it resume. */
82bfbe7e
PA
958 if (the_low_target.prepare_to_resume != NULL)
959 the_low_target.prepare_to_resume (lwp);
bd99dc85
PA
960 ptrace (PTRACE_DETACH, lwpid_of (lwp), 0, 0);
961
962 delete_lwp (lwp);
95954743 963 return 0;
6ad8ae5c
DJ
964}
965
95954743
PA
966static int
967linux_detach (int pid)
968{
969 struct process_info *process;
970
971 process = find_process_pid (pid);
972 if (process == NULL)
973 return -1;
974
f9e39928
PA
975 /* Stop all threads before detaching. First, ptrace requires that
976 the thread is stopped to sucessfully detach. Second, thread_db
977 may need to uninstall thread event breakpoints from memory, which
978 only works with a stopped process anyway. */
7984d532 979 stop_all_lwps (0, NULL);
f9e39928 980
ca5c370d 981#ifdef USE_THREAD_DB
8336d594 982 thread_db_detach (process);
ca5c370d
PA
983#endif
984
fa593d66
PA
985 /* Stabilize threads (move out of jump pads). */
986 stabilize_threads ();
987
95954743 988 find_inferior (&all_threads, linux_detach_one_lwp, &pid);
8336d594
PA
989
990 the_target->mourn (process);
f9e39928
PA
991
992 /* Since we presently can only stop all lwps of all processes, we
993 need to unstop lwps of other processes. */
7984d532 994 unstop_all_lwps (0, NULL);
f9e39928
PA
995 return 0;
996}
997
998/* Remove all LWPs that belong to process PROC from the lwp list. */
999
1000static int
1001delete_lwp_callback (struct inferior_list_entry *entry, void *proc)
1002{
1003 struct lwp_info *lwp = (struct lwp_info *) entry;
1004 struct process_info *process = proc;
1005
1006 if (pid_of (lwp) == pid_of (process))
1007 delete_lwp (lwp);
1008
dd6953e1 1009 return 0;
6ad8ae5c
DJ
1010}
1011
8336d594
PA
1012static void
1013linux_mourn (struct process_info *process)
1014{
1015 struct process_info_private *priv;
1016
1017#ifdef USE_THREAD_DB
1018 thread_db_mourn (process);
1019#endif
1020
f9e39928
PA
1021 find_inferior (&all_lwps, delete_lwp_callback, process);
1022
8336d594
PA
1023 /* Freeing all private data. */
1024 priv = process->private;
1025 free (priv->arch_private);
1026 free (priv);
1027 process->private = NULL;
505106cd
PA
1028
1029 remove_process (process);
8336d594
PA
1030}
1031
444d6139 1032static void
95954743 1033linux_join (int pid)
444d6139 1034{
444d6139
PA
1035 int status, ret;
1036
1037 do {
95954743 1038 ret = my_waitpid (pid, &status, 0);
444d6139
PA
1039 if (WIFEXITED (status) || WIFSIGNALED (status))
1040 break;
1041 } while (ret != -1 || errno != ECHILD);
1042}
1043
6ad8ae5c 1044/* Return nonzero if the given thread is still alive. */
0d62e5e8 1045static int
95954743 1046linux_thread_alive (ptid_t ptid)
0d62e5e8 1047{
95954743
PA
1048 struct lwp_info *lwp = find_lwp_pid (ptid);
1049
1050 /* We assume we always know if a thread exits. If a whole process
1051 exited but we still haven't been able to report it to GDB, we'll
1052 hold on to the last lwp of the dead process. */
1053 if (lwp != NULL)
1054 return !lwp->dead;
0d62e5e8
DJ
1055 else
1056 return 0;
1057}
1058
6bf5e0ba 1059/* Return 1 if this lwp has an interesting status pending. */
611cb4a5 1060static int
d50171e4 1061status_pending_p_callback (struct inferior_list_entry *entry, void *arg)
0d62e5e8 1062{
54a0b537 1063 struct lwp_info *lwp = (struct lwp_info *) entry;
95954743 1064 ptid_t ptid = * (ptid_t *) arg;
7984d532 1065 struct thread_info *thread;
95954743
PA
1066
1067 /* Check if we're only interested in events from a specific process
1068 or its lwps. */
1069 if (!ptid_equal (minus_one_ptid, ptid)
1070 && ptid_get_pid (ptid) != ptid_get_pid (lwp->head.id))
1071 return 0;
0d62e5e8 1072
d50171e4
PA
1073 thread = get_lwp_thread (lwp);
1074
1075 /* If we got a `vCont;t', but we haven't reported a stop yet, do
1076 report any status pending the LWP may have. */
8336d594 1077 if (thread->last_resume_kind == resume_stop
7984d532 1078 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
d50171e4 1079 return 0;
0d62e5e8 1080
d50171e4 1081 return lwp->status_pending_p;
0d62e5e8
DJ
1082}
1083
95954743
PA
1084static int
1085same_lwp (struct inferior_list_entry *entry, void *data)
1086{
1087 ptid_t ptid = *(ptid_t *) data;
1088 int lwp;
1089
1090 if (ptid_get_lwp (ptid) != 0)
1091 lwp = ptid_get_lwp (ptid);
1092 else
1093 lwp = ptid_get_pid (ptid);
1094
1095 if (ptid_get_lwp (entry->id) == lwp)
1096 return 1;
1097
1098 return 0;
1099}
1100
1101struct lwp_info *
1102find_lwp_pid (ptid_t ptid)
1103{
1104 return (struct lwp_info*) find_inferior (&all_lwps, same_lwp, &ptid);
1105}
1106
bd99dc85 1107static struct lwp_info *
95954743 1108linux_wait_for_lwp (ptid_t ptid, int *wstatp, int options)
611cb4a5 1109{
0d62e5e8 1110 int ret;
95954743 1111 int to_wait_for = -1;
bd99dc85 1112 struct lwp_info *child = NULL;
0d62e5e8 1113
bd99dc85 1114 if (debug_threads)
95954743
PA
1115 fprintf (stderr, "linux_wait_for_lwp: %s\n", target_pid_to_str (ptid));
1116
1117 if (ptid_equal (ptid, minus_one_ptid))
1118 to_wait_for = -1; /* any child */
1119 else
1120 to_wait_for = ptid_get_lwp (ptid); /* this lwp only */
0d62e5e8 1121
bd99dc85 1122 options |= __WALL;
0d62e5e8 1123
bd99dc85 1124retry:
0d62e5e8 1125
bd99dc85
PA
1126 ret = my_waitpid (to_wait_for, wstatp, options);
1127 if (ret == 0 || (ret == -1 && errno == ECHILD && (options & WNOHANG)))
1128 return NULL;
1129 else if (ret == -1)
1130 perror_with_name ("waitpid");
0d62e5e8
DJ
1131
1132 if (debug_threads
1133 && (!WIFSTOPPED (*wstatp)
1134 || (WSTOPSIG (*wstatp) != 32
1135 && WSTOPSIG (*wstatp) != 33)))
1136 fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
1137
95954743 1138 child = find_lwp_pid (pid_to_ptid (ret));
0d62e5e8 1139
24a09b5f
DJ
1140 /* If we didn't find a process, one of two things presumably happened:
1141 - A process we started and then detached from has exited. Ignore it.
1142 - A process we are controlling has forked and the new child's stop
1143 was reported to us by the kernel. Save its PID. */
bd99dc85 1144 if (child == NULL && WIFSTOPPED (*wstatp))
24a09b5f
DJ
1145 {
1146 add_pid_to_list (&stopped_pids, ret);
1147 goto retry;
1148 }
bd99dc85 1149 else if (child == NULL)
24a09b5f
DJ
1150 goto retry;
1151
bd99dc85 1152 child->stopped = 1;
0d62e5e8 1153
bd99dc85 1154 child->last_status = *wstatp;
32ca6d61 1155
d61ddec4
UW
1156 /* Architecture-specific setup after inferior is running.
1157 This needs to happen after we have attached to the inferior
1158 and it is stopped for the first time, but before we access
1159 any inferior registers. */
1160 if (new_inferior)
1161 {
1162 the_low_target.arch_setup ();
52fa2412
UW
1163#ifdef HAVE_LINUX_REGSETS
1164 memset (disabled_regsets, 0, num_regsets);
1165#endif
d61ddec4
UW
1166 new_inferior = 0;
1167 }
1168
c3adc08c
PA
1169 /* Fetch the possibly triggered data watchpoint info and store it in
1170 CHILD.
1171
1172 On some archs, like x86, that use debug registers to set
1173 watchpoints, it's possible that the way to know which watched
1174 address trapped, is to check the register that is used to select
1175 which address to watch. Problem is, between setting the
1176 watchpoint and reading back which data address trapped, the user
1177 may change the set of watchpoints, and, as a consequence, GDB
1178 changes the debug registers in the inferior. To avoid reading
1179 back a stale stopped-data-address when that happens, we cache in
1180 LP the fact that a watchpoint trapped, and the corresponding data
1181 address, as soon as we see CHILD stop with a SIGTRAP. If GDB
1182 changes the debug registers meanwhile, we have the cached data we
1183 can rely on. */
1184
1185 if (WIFSTOPPED (*wstatp) && WSTOPSIG (*wstatp) == SIGTRAP)
1186 {
1187 if (the_low_target.stopped_by_watchpoint == NULL)
1188 {
1189 child->stopped_by_watchpoint = 0;
1190 }
1191 else
1192 {
1193 struct thread_info *saved_inferior;
1194
1195 saved_inferior = current_inferior;
1196 current_inferior = get_lwp_thread (child);
1197
1198 child->stopped_by_watchpoint
1199 = the_low_target.stopped_by_watchpoint ();
1200
1201 if (child->stopped_by_watchpoint)
1202 {
1203 if (the_low_target.stopped_data_address != NULL)
1204 child->stopped_data_address
1205 = the_low_target.stopped_data_address ();
1206 else
1207 child->stopped_data_address = 0;
1208 }
1209
1210 current_inferior = saved_inferior;
1211 }
1212 }
1213
d50171e4
PA
1214 /* Store the STOP_PC, with adjustment applied. This depends on the
1215 architecture being defined already (so that CHILD has a valid
1216 regcache), and on LAST_STATUS being set (to check for SIGTRAP or
1217 not). */
1218 if (WIFSTOPPED (*wstatp))
1219 child->stop_pc = get_stop_pc (child);
1220
0d62e5e8 1221 if (debug_threads
47c0c975
DE
1222 && WIFSTOPPED (*wstatp)
1223 && the_low_target.get_pc != NULL)
0d62e5e8 1224 {
896c7fbb 1225 struct thread_info *saved_inferior = current_inferior;
bce522a2 1226 struct regcache *regcache;
47c0c975
DE
1227 CORE_ADDR pc;
1228
d50171e4 1229 current_inferior = get_lwp_thread (child);
bce522a2 1230 regcache = get_thread_regcache (current_inferior, 1);
442ea881 1231 pc = (*the_low_target.get_pc) (regcache);
47c0c975 1232 fprintf (stderr, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc);
896c7fbb 1233 current_inferior = saved_inferior;
0d62e5e8 1234 }
bd99dc85
PA
1235
1236 return child;
0d62e5e8 1237}
611cb4a5 1238
219f2f23
PA
1239/* This function should only be called if the LWP got a SIGTRAP.
1240
1241 Handle any tracepoint steps or hits. Return true if a tracepoint
1242 event was handled, 0 otherwise. */
1243
1244static int
1245handle_tracepoints (struct lwp_info *lwp)
1246{
1247 struct thread_info *tinfo = get_lwp_thread (lwp);
1248 int tpoint_related_event = 0;
1249
7984d532
PA
1250 /* If this tracepoint hit causes a tracing stop, we'll immediately
1251 uninsert tracepoints. To do this, we temporarily pause all
1252 threads, unpatch away, and then unpause threads. We need to make
1253 sure the unpausing doesn't resume LWP too. */
1254 lwp->suspended++;
1255
219f2f23
PA
1256 /* And we need to be sure that any all-threads-stopping doesn't try
1257 to move threads out of the jump pads, as it could deadlock the
1258 inferior (LWP could be in the jump pad, maybe even holding the
1259 lock.) */
1260
1261 /* Do any necessary step collect actions. */
1262 tpoint_related_event |= tracepoint_finished_step (tinfo, lwp->stop_pc);
1263
fa593d66
PA
1264 tpoint_related_event |= handle_tracepoint_bkpts (tinfo, lwp->stop_pc);
1265
219f2f23
PA
1266 /* See if we just hit a tracepoint and do its main collect
1267 actions. */
1268 tpoint_related_event |= tracepoint_was_hit (tinfo, lwp->stop_pc);
1269
7984d532
PA
1270 lwp->suspended--;
1271
1272 gdb_assert (lwp->suspended == 0);
fa593d66 1273 gdb_assert (!stabilizing_threads || lwp->collecting_fast_tracepoint);
7984d532 1274
219f2f23
PA
1275 if (tpoint_related_event)
1276 {
1277 if (debug_threads)
1278 fprintf (stderr, "got a tracepoint event\n");
1279 return 1;
1280 }
1281
1282 return 0;
1283}
1284
fa593d66
PA
1285/* Convenience wrapper. Returns true if LWP is presently collecting a
1286 fast tracepoint. */
1287
1288static int
1289linux_fast_tracepoint_collecting (struct lwp_info *lwp,
1290 struct fast_tpoint_collect_status *status)
1291{
1292 CORE_ADDR thread_area;
1293
1294 if (the_low_target.get_thread_area == NULL)
1295 return 0;
1296
1297 /* Get the thread area address. This is used to recognize which
1298 thread is which when tracing with the in-process agent library.
1299 We don't read anything from the address, and treat it as opaque;
1300 it's the address itself that we assume is unique per-thread. */
1301 if ((*the_low_target.get_thread_area) (lwpid_of (lwp), &thread_area) == -1)
1302 return 0;
1303
1304 return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status);
1305}
1306
1307/* The reason we resume in the caller, is because we want to be able
1308 to pass lwp->status_pending as WSTAT, and we need to clear
1309 status_pending_p before resuming, otherwise, linux_resume_one_lwp
1310 refuses to resume. */
1311
1312static int
1313maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
1314{
1315 struct thread_info *saved_inferior;
1316
1317 saved_inferior = current_inferior;
1318 current_inferior = get_lwp_thread (lwp);
1319
1320 if ((wstat == NULL
1321 || (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
1322 && supports_fast_tracepoints ()
1323 && in_process_agent_loaded ())
1324 {
1325 struct fast_tpoint_collect_status status;
1326 int r;
1327
1328 if (debug_threads)
1329 fprintf (stderr, "\
1330Checking whether LWP %ld needs to move out of the jump pad.\n",
1331 lwpid_of (lwp));
1332
1333 r = linux_fast_tracepoint_collecting (lwp, &status);
1334
1335 if (wstat == NULL
1336 || (WSTOPSIG (*wstat) != SIGILL
1337 && WSTOPSIG (*wstat) != SIGFPE
1338 && WSTOPSIG (*wstat) != SIGSEGV
1339 && WSTOPSIG (*wstat) != SIGBUS))
1340 {
1341 lwp->collecting_fast_tracepoint = r;
1342
1343 if (r != 0)
1344 {
1345 if (r == 1 && lwp->exit_jump_pad_bkpt == NULL)
1346 {
1347 /* Haven't executed the original instruction yet.
1348 Set breakpoint there, and wait till it's hit,
1349 then single-step until exiting the jump pad. */
1350 lwp->exit_jump_pad_bkpt
1351 = set_breakpoint_at (status.adjusted_insn_addr, NULL);
1352 }
1353
1354 if (debug_threads)
1355 fprintf (stderr, "\
1356Checking whether LWP %ld needs to move out of the jump pad...it does\n",
1357 lwpid_of (lwp));
0cccb683 1358 current_inferior = saved_inferior;
fa593d66
PA
1359
1360 return 1;
1361 }
1362 }
1363 else
1364 {
1365 /* If we get a synchronous signal while collecting, *and*
1366 while executing the (relocated) original instruction,
1367 reset the PC to point at the tpoint address, before
1368 reporting to GDB. Otherwise, it's an IPA lib bug: just
1369 report the signal to GDB, and pray for the best. */
1370
1371 lwp->collecting_fast_tracepoint = 0;
1372
1373 if (r != 0
1374 && (status.adjusted_insn_addr <= lwp->stop_pc
1375 && lwp->stop_pc < status.adjusted_insn_addr_end))
1376 {
1377 siginfo_t info;
1378 struct regcache *regcache;
1379
1380 /* The si_addr on a few signals references the address
1381 of the faulting instruction. Adjust that as
1382 well. */
1383 if ((WSTOPSIG (*wstat) == SIGILL
1384 || WSTOPSIG (*wstat) == SIGFPE
1385 || WSTOPSIG (*wstat) == SIGBUS
1386 || WSTOPSIG (*wstat) == SIGSEGV)
1387 && ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &info) == 0
1388 /* Final check just to make sure we don't clobber
1389 the siginfo of non-kernel-sent signals. */
1390 && (uintptr_t) info.si_addr == lwp->stop_pc)
1391 {
1392 info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
1393 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &info);
1394 }
1395
1396 regcache = get_thread_regcache (get_lwp_thread (lwp), 1);
1397 (*the_low_target.set_pc) (regcache, status.tpoint_addr);
1398 lwp->stop_pc = status.tpoint_addr;
1399
1400 /* Cancel any fast tracepoint lock this thread was
1401 holding. */
1402 force_unlock_trace_buffer ();
1403 }
1404
1405 if (lwp->exit_jump_pad_bkpt != NULL)
1406 {
1407 if (debug_threads)
1408 fprintf (stderr,
1409 "Cancelling fast exit-jump-pad: removing bkpt. "
1410 "stopping all threads momentarily.\n");
1411
1412 stop_all_lwps (1, lwp);
1413 cancel_breakpoints ();
1414
1415 delete_breakpoint (lwp->exit_jump_pad_bkpt);
1416 lwp->exit_jump_pad_bkpt = NULL;
1417
1418 unstop_all_lwps (1, lwp);
1419
1420 gdb_assert (lwp->suspended >= 0);
1421 }
1422 }
1423 }
1424
1425 if (debug_threads)
1426 fprintf (stderr, "\
1427Checking whether LWP %ld needs to move out of the jump pad...no\n",
1428 lwpid_of (lwp));
0cccb683
YQ
1429
1430 current_inferior = saved_inferior;
fa593d66
PA
1431 return 0;
1432}
1433
1434/* Enqueue one signal in the "signals to report later when out of the
1435 jump pad" list. */
1436
1437static void
1438enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
1439{
1440 struct pending_signals *p_sig;
1441
1442 if (debug_threads)
1443 fprintf (stderr, "\
1444Deferring signal %d for LWP %ld.\n", WSTOPSIG (*wstat), lwpid_of (lwp));
1445
1446 if (debug_threads)
1447 {
1448 struct pending_signals *sig;
1449
1450 for (sig = lwp->pending_signals_to_report;
1451 sig != NULL;
1452 sig = sig->prev)
1453 fprintf (stderr,
1454 " Already queued %d\n",
1455 sig->signal);
1456
1457 fprintf (stderr, " (no more currently queued signals)\n");
1458 }
1459
1a981360
PA
1460 /* Don't enqueue non-RT signals if they are already in the deferred
1461 queue. (SIGSTOP being the easiest signal to see ending up here
1462 twice) */
1463 if (WSTOPSIG (*wstat) < __SIGRTMIN)
1464 {
1465 struct pending_signals *sig;
1466
1467 for (sig = lwp->pending_signals_to_report;
1468 sig != NULL;
1469 sig = sig->prev)
1470 {
1471 if (sig->signal == WSTOPSIG (*wstat))
1472 {
1473 if (debug_threads)
1474 fprintf (stderr,
1475 "Not requeuing already queued non-RT signal %d"
1476 " for LWP %ld\n",
1477 sig->signal,
1478 lwpid_of (lwp));
1479 return;
1480 }
1481 }
1482 }
1483
fa593d66
PA
1484 p_sig = xmalloc (sizeof (*p_sig));
1485 p_sig->prev = lwp->pending_signals_to_report;
1486 p_sig->signal = WSTOPSIG (*wstat);
1487 memset (&p_sig->info, 0, sizeof (siginfo_t));
1488 ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
1489
1490 lwp->pending_signals_to_report = p_sig;
1491}
1492
1493/* Dequeue one signal from the "signals to report later when out of
1494 the jump pad" list. */
1495
1496static int
1497dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
1498{
1499 if (lwp->pending_signals_to_report != NULL)
1500 {
1501 struct pending_signals **p_sig;
1502
1503 p_sig = &lwp->pending_signals_to_report;
1504 while ((*p_sig)->prev != NULL)
1505 p_sig = &(*p_sig)->prev;
1506
1507 *wstat = W_STOPCODE ((*p_sig)->signal);
1508 if ((*p_sig)->info.si_signo != 0)
1509 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
1510 free (*p_sig);
1511 *p_sig = NULL;
1512
1513 if (debug_threads)
1514 fprintf (stderr, "Reporting deferred signal %d for LWP %ld.\n",
1515 WSTOPSIG (*wstat), lwpid_of (lwp));
1516
1517 if (debug_threads)
1518 {
1519 struct pending_signals *sig;
1520
1521 for (sig = lwp->pending_signals_to_report;
1522 sig != NULL;
1523 sig = sig->prev)
1524 fprintf (stderr,
1525 " Still queued %d\n",
1526 sig->signal);
1527
1528 fprintf (stderr, " (no more queued signals)\n");
1529 }
1530
1531 return 1;
1532 }
1533
1534 return 0;
1535}
1536
d50171e4
PA
1537/* Arrange for a breakpoint to be hit again later. We don't keep the
1538 SIGTRAP status and don't forward the SIGTRAP signal to the LWP. We
1539 will handle the current event, eventually we will resume this LWP,
1540 and this breakpoint will trap again. */
1541
1542static int
1543cancel_breakpoint (struct lwp_info *lwp)
1544{
1545 struct thread_info *saved_inferior;
d50171e4
PA
1546
1547 /* There's nothing to do if we don't support breakpoints. */
1548 if (!supports_breakpoints ())
1549 return 0;
1550
d50171e4
PA
1551 /* breakpoint_at reads from current inferior. */
1552 saved_inferior = current_inferior;
1553 current_inferior = get_lwp_thread (lwp);
1554
1555 if ((*the_low_target.breakpoint_at) (lwp->stop_pc))
1556 {
1557 if (debug_threads)
1558 fprintf (stderr,
1559 "CB: Push back breakpoint for %s\n",
fc7238bb 1560 target_pid_to_str (ptid_of (lwp)));
d50171e4
PA
1561
1562 /* Back up the PC if necessary. */
1563 if (the_low_target.decr_pc_after_break)
1564 {
1565 struct regcache *regcache
fc7238bb 1566 = get_thread_regcache (current_inferior, 1);
d50171e4
PA
1567 (*the_low_target.set_pc) (regcache, lwp->stop_pc);
1568 }
1569
1570 current_inferior = saved_inferior;
1571 return 1;
1572 }
1573 else
1574 {
1575 if (debug_threads)
1576 fprintf (stderr,
1577 "CB: No breakpoint found at %s for [%s]\n",
1578 paddress (lwp->stop_pc),
fc7238bb 1579 target_pid_to_str (ptid_of (lwp)));
d50171e4
PA
1580 }
1581
1582 current_inferior = saved_inferior;
1583 return 0;
1584}
1585
1586/* When the event-loop is doing a step-over, this points at the thread
1587 being stepped. */
1588ptid_t step_over_bkpt;
1589
bd99dc85
PA
1590/* Wait for an event from child PID. If PID is -1, wait for any
1591 child. Store the stop status through the status pointer WSTAT.
1592 OPTIONS is passed to the waitpid call. Return 0 if no child stop
1593 event was found and OPTIONS contains WNOHANG. Return the PID of
1594 the stopped child otherwise. */
1595
0d62e5e8 1596static int
d8301ad1 1597linux_wait_for_event (ptid_t ptid, int *wstat, int options)
0d62e5e8 1598{
d50171e4 1599 struct lwp_info *event_child, *requested_child;
d8301ad1 1600 ptid_t wait_ptid;
d50171e4 1601
d50171e4
PA
1602 event_child = NULL;
1603 requested_child = NULL;
0d62e5e8 1604
95954743 1605 /* Check for a lwp with a pending status. */
bd99dc85 1606
e825046f 1607 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
0d62e5e8 1608 {
54a0b537 1609 event_child = (struct lwp_info *)
d50171e4 1610 find_inferior (&all_lwps, status_pending_p_callback, &ptid);
0d62e5e8 1611 if (debug_threads && event_child)
bd99dc85 1612 fprintf (stderr, "Got a pending child %ld\n", lwpid_of (event_child));
0d62e5e8
DJ
1613 }
1614 else
1615 {
95954743 1616 requested_child = find_lwp_pid (ptid);
d50171e4 1617
fa593d66
PA
1618 if (!stopping_threads
1619 && requested_child->status_pending_p
1620 && requested_child->collecting_fast_tracepoint)
1621 {
1622 enqueue_one_deferred_signal (requested_child,
1623 &requested_child->status_pending);
1624 requested_child->status_pending_p = 0;
1625 requested_child->status_pending = 0;
1626 linux_resume_one_lwp (requested_child, 0, 0, NULL);
1627 }
1628
1629 if (requested_child->suspended
1630 && requested_child->status_pending_p)
1631 fatal ("requesting an event out of a suspended child?");
1632
d50171e4 1633 if (requested_child->status_pending_p)
bd99dc85 1634 event_child = requested_child;
0d62e5e8 1635 }
611cb4a5 1636
0d62e5e8
DJ
1637 if (event_child != NULL)
1638 {
bd99dc85
PA
1639 if (debug_threads)
1640 fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
1641 lwpid_of (event_child), event_child->status_pending);
1642 *wstat = event_child->status_pending;
1643 event_child->status_pending_p = 0;
1644 event_child->status_pending = 0;
1645 current_inferior = get_lwp_thread (event_child);
1646 return lwpid_of (event_child);
0d62e5e8
DJ
1647 }
1648
d8301ad1
JK
1649 if (ptid_is_pid (ptid))
1650 {
1651 /* A request to wait for a specific tgid. This is not possible
1652 with waitpid, so instead, we wait for any child, and leave
1653 children we're not interested in right now with a pending
1654 status to report later. */
1655 wait_ptid = minus_one_ptid;
1656 }
1657 else
1658 wait_ptid = ptid;
1659
0d62e5e8
DJ
1660 /* We only enter this loop if no process has a pending wait status. Thus
1661 any action taken in response to a wait status inside this loop is
1662 responding as soon as we detect the status, not after any pending
1663 events. */
1664 while (1)
1665 {
d8301ad1 1666 event_child = linux_wait_for_lwp (wait_ptid, wstat, options);
0d62e5e8 1667
bd99dc85 1668 if ((options & WNOHANG) && event_child == NULL)
d50171e4
PA
1669 {
1670 if (debug_threads)
1671 fprintf (stderr, "WNOHANG set, no event found\n");
1672 return 0;
1673 }
0d62e5e8
DJ
1674
1675 if (event_child == NULL)
1676 error ("event from unknown child");
611cb4a5 1677
d8301ad1
JK
1678 if (ptid_is_pid (ptid)
1679 && ptid_get_pid (ptid) != ptid_get_pid (ptid_of (event_child)))
1680 {
1681 if (! WIFSTOPPED (*wstat))
1682 mark_lwp_dead (event_child, *wstat);
1683 else
1684 {
1685 event_child->status_pending_p = 1;
1686 event_child->status_pending = *wstat;
1687 }
1688 continue;
1689 }
1690
bd99dc85 1691 current_inferior = get_lwp_thread (event_child);
0d62e5e8 1692
89be2091 1693 /* Check for thread exit. */
bd99dc85 1694 if (! WIFSTOPPED (*wstat))
0d62e5e8 1695 {
89be2091 1696 if (debug_threads)
95954743 1697 fprintf (stderr, "LWP %ld exiting\n", lwpid_of (event_child));
89be2091
DJ
1698
1699 /* If the last thread is exiting, just return. */
95954743 1700 if (last_thread_of_process_p (current_inferior))
bd99dc85
PA
1701 {
1702 if (debug_threads)
95954743
PA
1703 fprintf (stderr, "LWP %ld is last lwp of process\n",
1704 lwpid_of (event_child));
bd99dc85
PA
1705 return lwpid_of (event_child);
1706 }
89be2091 1707
bd99dc85
PA
1708 if (!non_stop)
1709 {
1710 current_inferior = (struct thread_info *) all_threads.head;
1711 if (debug_threads)
1712 fprintf (stderr, "Current inferior is now %ld\n",
1713 lwpid_of (get_thread_lwp (current_inferior)));
1714 }
1715 else
1716 {
1717 current_inferior = NULL;
1718 if (debug_threads)
1719 fprintf (stderr, "Current inferior is now <NULL>\n");
1720 }
89be2091
DJ
1721
1722 /* If we were waiting for this particular child to do something...
1723 well, it did something. */
bd99dc85 1724 if (requested_child != NULL)
d50171e4
PA
1725 {
1726 int lwpid = lwpid_of (event_child);
1727
1728 /* Cancel the step-over operation --- the thread that
1729 started it is gone. */
1730 if (finish_step_over (event_child))
7984d532 1731 unstop_all_lwps (1, event_child);
d50171e4
PA
1732 delete_lwp (event_child);
1733 return lwpid;
1734 }
1735
1736 delete_lwp (event_child);
89be2091
DJ
1737
1738 /* Wait for a more interesting event. */
1739 continue;
1740 }
1741
a6dbe5df
PA
1742 if (event_child->must_set_ptrace_flags)
1743 {
1e7fc18c 1744 linux_enable_event_reporting (lwpid_of (event_child));
a6dbe5df
PA
1745 event_child->must_set_ptrace_flags = 0;
1746 }
1747
bd99dc85
PA
1748 if (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) == SIGTRAP
1749 && *wstat >> 16 != 0)
24a09b5f 1750 {
bd99dc85 1751 handle_extended_wait (event_child, *wstat);
24a09b5f
DJ
1752 continue;
1753 }
1754
d50171e4
PA
1755 if (WIFSTOPPED (*wstat)
1756 && WSTOPSIG (*wstat) == SIGSTOP
1757 && event_child->stop_expected)
1758 {
1759 int should_stop;
1760
1761 if (debug_threads)
1762 fprintf (stderr, "Expected stop.\n");
1763 event_child->stop_expected = 0;
1764
8336d594 1765 should_stop = (current_inferior->last_resume_kind == resume_stop
d50171e4
PA
1766 || stopping_threads);
1767
1768 if (!should_stop)
1769 {
1770 linux_resume_one_lwp (event_child,
1771 event_child->stepping, 0, NULL);
1772 continue;
1773 }
1774 }
1775
bd99dc85 1776 return lwpid_of (event_child);
611cb4a5 1777 }
0d62e5e8 1778
611cb4a5
DJ
1779 /* NOTREACHED */
1780 return 0;
1781}
1782
6bf5e0ba
PA
1783/* Count the LWP's that have had events. */
1784
1785static int
1786count_events_callback (struct inferior_list_entry *entry, void *data)
1787{
1788 struct lwp_info *lp = (struct lwp_info *) entry;
8336d594 1789 struct thread_info *thread = get_lwp_thread (lp);
6bf5e0ba
PA
1790 int *count = data;
1791
1792 gdb_assert (count != NULL);
1793
1794 /* Count only resumed LWPs that have a SIGTRAP event pending that
1795 should be reported to GDB. */
8336d594
PA
1796 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
1797 && thread->last_resume_kind != resume_stop
6bf5e0ba
PA
1798 && lp->status_pending_p
1799 && WIFSTOPPED (lp->status_pending)
1800 && WSTOPSIG (lp->status_pending) == SIGTRAP
1801 && !breakpoint_inserted_here (lp->stop_pc))
1802 (*count)++;
1803
1804 return 0;
1805}
1806
1807/* Select the LWP (if any) that is currently being single-stepped. */
1808
1809static int
1810select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data)
1811{
1812 struct lwp_info *lp = (struct lwp_info *) entry;
8336d594 1813 struct thread_info *thread = get_lwp_thread (lp);
6bf5e0ba 1814
8336d594
PA
1815 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
1816 && thread->last_resume_kind == resume_step
6bf5e0ba
PA
1817 && lp->status_pending_p)
1818 return 1;
1819 else
1820 return 0;
1821}
1822
1823/* Select the Nth LWP that has had a SIGTRAP event that should be
1824 reported to GDB. */
1825
1826static int
1827select_event_lwp_callback (struct inferior_list_entry *entry, void *data)
1828{
1829 struct lwp_info *lp = (struct lwp_info *) entry;
8336d594 1830 struct thread_info *thread = get_lwp_thread (lp);
6bf5e0ba
PA
1831 int *selector = data;
1832
1833 gdb_assert (selector != NULL);
1834
1835 /* Select only resumed LWPs that have a SIGTRAP event pending. */
8336d594
PA
1836 if (thread->last_resume_kind != resume_stop
1837 && thread->last_status.kind == TARGET_WAITKIND_IGNORE
6bf5e0ba
PA
1838 && lp->status_pending_p
1839 && WIFSTOPPED (lp->status_pending)
1840 && WSTOPSIG (lp->status_pending) == SIGTRAP
1841 && !breakpoint_inserted_here (lp->stop_pc))
1842 if ((*selector)-- == 0)
1843 return 1;
1844
1845 return 0;
1846}
1847
1848static int
1849cancel_breakpoints_callback (struct inferior_list_entry *entry, void *data)
1850{
1851 struct lwp_info *lp = (struct lwp_info *) entry;
8336d594 1852 struct thread_info *thread = get_lwp_thread (lp);
6bf5e0ba
PA
1853 struct lwp_info *event_lp = data;
1854
1855 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
1856 if (lp == event_lp)
1857 return 0;
1858
1859 /* If a LWP other than the LWP that we're reporting an event for has
1860 hit a GDB breakpoint (as opposed to some random trap signal),
1861 then just arrange for it to hit it again later. We don't keep
1862 the SIGTRAP status and don't forward the SIGTRAP signal to the
1863 LWP. We will handle the current event, eventually we will resume
1864 all LWPs, and this one will get its breakpoint trap again.
1865
1866 If we do not do this, then we run the risk that the user will
1867 delete or disable the breakpoint, but the LWP will have already
1868 tripped on it. */
1869
8336d594
PA
1870 if (thread->last_resume_kind != resume_stop
1871 && thread->last_status.kind == TARGET_WAITKIND_IGNORE
6bf5e0ba
PA
1872 && lp->status_pending_p
1873 && WIFSTOPPED (lp->status_pending)
1874 && WSTOPSIG (lp->status_pending) == SIGTRAP
bdabb078
PA
1875 && !lp->stepping
1876 && !lp->stopped_by_watchpoint
6bf5e0ba
PA
1877 && cancel_breakpoint (lp))
1878 /* Throw away the SIGTRAP. */
1879 lp->status_pending_p = 0;
1880
1881 return 0;
1882}
1883
7984d532
PA
1884static void
1885linux_cancel_breakpoints (void)
1886{
1887 find_inferior (&all_lwps, cancel_breakpoints_callback, NULL);
1888}
1889
6bf5e0ba
PA
1890/* Select one LWP out of those that have events pending. */
1891
1892static void
1893select_event_lwp (struct lwp_info **orig_lp)
1894{
1895 int num_events = 0;
1896 int random_selector;
1897 struct lwp_info *event_lp;
1898
1899 /* Give preference to any LWP that is being single-stepped. */
1900 event_lp
1901 = (struct lwp_info *) find_inferior (&all_lwps,
1902 select_singlestep_lwp_callback, NULL);
1903 if (event_lp != NULL)
1904 {
1905 if (debug_threads)
1906 fprintf (stderr,
1907 "SEL: Select single-step %s\n",
1908 target_pid_to_str (ptid_of (event_lp)));
1909 }
1910 else
1911 {
1912 /* No single-stepping LWP. Select one at random, out of those
1913 which have had SIGTRAP events. */
1914
1915 /* First see how many SIGTRAP events we have. */
1916 find_inferior (&all_lwps, count_events_callback, &num_events);
1917
1918 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
1919 random_selector = (int)
1920 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
1921
1922 if (debug_threads && num_events > 1)
1923 fprintf (stderr,
1924 "SEL: Found %d SIGTRAP events, selecting #%d\n",
1925 num_events, random_selector);
1926
1927 event_lp = (struct lwp_info *) find_inferior (&all_lwps,
1928 select_event_lwp_callback,
1929 &random_selector);
1930 }
1931
1932 if (event_lp != NULL)
1933 {
1934 /* Switch the event LWP. */
1935 *orig_lp = event_lp;
1936 }
1937}
1938
7984d532
PA
1939/* Decrement the suspend count of an LWP. */
1940
1941static int
1942unsuspend_one_lwp (struct inferior_list_entry *entry, void *except)
1943{
1944 struct lwp_info *lwp = (struct lwp_info *) entry;
1945
1946 /* Ignore EXCEPT. */
1947 if (lwp == except)
1948 return 0;
1949
1950 lwp->suspended--;
1951
1952 gdb_assert (lwp->suspended >= 0);
1953 return 0;
1954}
1955
1956/* Decrement the suspend count of all LWPs, except EXCEPT, if non
1957 NULL. */
1958
1959static void
1960unsuspend_all_lwps (struct lwp_info *except)
1961{
1962 find_inferior (&all_lwps, unsuspend_one_lwp, except);
1963}
1964
fa593d66
PA
1965static void move_out_of_jump_pad_callback (struct inferior_list_entry *entry);
1966static int stuck_in_jump_pad_callback (struct inferior_list_entry *entry,
1967 void *data);
1968static int lwp_running (struct inferior_list_entry *entry, void *data);
1969static ptid_t linux_wait_1 (ptid_t ptid,
1970 struct target_waitstatus *ourstatus,
1971 int target_options);
1972
1973/* Stabilize threads (move out of jump pads).
1974
1975 If a thread is midway collecting a fast tracepoint, we need to
1976 finish the collection and move it out of the jump pad before
1977 reporting the signal.
1978
1979 This avoids recursion while collecting (when a signal arrives
1980 midway, and the signal handler itself collects), which would trash
1981 the trace buffer. In case the user set a breakpoint in a signal
1982 handler, this avoids the backtrace showing the jump pad, etc..
1983 Most importantly, there are certain things we can't do safely if
1984 threads are stopped in a jump pad (or in its callee's). For
1985 example:
1986
1987 - starting a new trace run. A thread still collecting the
1988 previous run, could trash the trace buffer when resumed. The trace
1989 buffer control structures would have been reset but the thread had
1990 no way to tell. The thread could even midway memcpy'ing to the
1991 buffer, which would mean that when resumed, it would clobber the
1992 trace buffer that had been set for a new run.
1993
1994 - we can't rewrite/reuse the jump pads for new tracepoints
1995 safely. Say you do tstart while a thread is stopped midway while
1996 collecting. When the thread is later resumed, it finishes the
1997 collection, and returns to the jump pad, to execute the original
1998 instruction that was under the tracepoint jump at the time the
1999 older run had been started. If the jump pad had been rewritten
2000 since for something else in the new run, the thread would now
2001 execute the wrong / random instructions. */
2002
2003static void
2004linux_stabilize_threads (void)
2005{
2006 struct thread_info *save_inferior;
2007 struct lwp_info *lwp_stuck;
2008
2009 lwp_stuck
2010 = (struct lwp_info *) find_inferior (&all_lwps,
2011 stuck_in_jump_pad_callback, NULL);
2012 if (lwp_stuck != NULL)
2013 {
b4d51a55
PA
2014 if (debug_threads)
2015 fprintf (stderr, "can't stabilize, LWP %ld is stuck in jump pad\n",
2016 lwpid_of (lwp_stuck));
fa593d66
PA
2017 return;
2018 }
2019
2020 save_inferior = current_inferior;
2021
2022 stabilizing_threads = 1;
2023
2024 /* Kick 'em all. */
2025 for_each_inferior (&all_lwps, move_out_of_jump_pad_callback);
2026
2027 /* Loop until all are stopped out of the jump pads. */
2028 while (find_inferior (&all_lwps, lwp_running, NULL) != NULL)
2029 {
2030 struct target_waitstatus ourstatus;
2031 struct lwp_info *lwp;
fa593d66
PA
2032 int wstat;
2033
2034 /* Note that we go through the full wait even loop. While
2035 moving threads out of jump pad, we need to be able to step
2036 over internal breakpoints and such. */
32fcada3 2037 linux_wait_1 (minus_one_ptid, &ourstatus, 0);
fa593d66
PA
2038
2039 if (ourstatus.kind == TARGET_WAITKIND_STOPPED)
2040 {
2041 lwp = get_thread_lwp (current_inferior);
2042
2043 /* Lock it. */
2044 lwp->suspended++;
2045
2046 if (ourstatus.value.sig != TARGET_SIGNAL_0
2047 || current_inferior->last_resume_kind == resume_stop)
2048 {
2049 wstat = W_STOPCODE (target_signal_to_host (ourstatus.value.sig));
2050 enqueue_one_deferred_signal (lwp, &wstat);
2051 }
2052 }
2053 }
2054
2055 find_inferior (&all_lwps, unsuspend_one_lwp, NULL);
2056
2057 stabilizing_threads = 0;
2058
2059 current_inferior = save_inferior;
2060
b4d51a55 2061 if (debug_threads)
fa593d66 2062 {
b4d51a55
PA
2063 lwp_stuck
2064 = (struct lwp_info *) find_inferior (&all_lwps,
2065 stuck_in_jump_pad_callback, NULL);
2066 if (lwp_stuck != NULL)
fa593d66
PA
2067 fprintf (stderr, "couldn't stabilize, LWP %ld got stuck in jump pad\n",
2068 lwpid_of (lwp_stuck));
2069 }
2070}
2071
0d62e5e8 2072/* Wait for process, returns status. */
da6d8c04 2073
95954743
PA
2074static ptid_t
2075linux_wait_1 (ptid_t ptid,
2076 struct target_waitstatus *ourstatus, int target_options)
da6d8c04 2077{
e5f1222d 2078 int w;
fc7238bb 2079 struct lwp_info *event_child;
bd99dc85 2080 int options;
bd99dc85 2081 int pid;
6bf5e0ba
PA
2082 int step_over_finished;
2083 int bp_explains_trap;
2084 int maybe_internal_trap;
2085 int report_to_gdb;
219f2f23 2086 int trace_event;
bd99dc85
PA
2087
2088 /* Translate generic target options into linux options. */
2089 options = __WALL;
2090 if (target_options & TARGET_WNOHANG)
2091 options |= WNOHANG;
0d62e5e8
DJ
2092
2093retry:
fa593d66
PA
2094 bp_explains_trap = 0;
2095 trace_event = 0;
bd99dc85
PA
2096 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2097
0d62e5e8
DJ
2098 /* If we were only supposed to resume one thread, only wait for
2099 that thread - if it's still alive. If it died, however - which
2100 can happen if we're coming from the thread death case below -
2101 then we need to make sure we restart the other threads. We could
2102 pick a thread at random or restart all; restarting all is less
2103 arbitrary. */
95954743
PA
2104 if (!non_stop
2105 && !ptid_equal (cont_thread, null_ptid)
2106 && !ptid_equal (cont_thread, minus_one_ptid))
0d62e5e8 2107 {
fc7238bb
PA
2108 struct thread_info *thread;
2109
bd99dc85
PA
2110 thread = (struct thread_info *) find_inferior_id (&all_threads,
2111 cont_thread);
0d62e5e8
DJ
2112
2113 /* No stepping, no signal - unless one is pending already, of course. */
bd99dc85 2114 if (thread == NULL)
64386c31
DJ
2115 {
2116 struct thread_resume resume_info;
95954743 2117 resume_info.thread = minus_one_ptid;
bd99dc85
PA
2118 resume_info.kind = resume_continue;
2119 resume_info.sig = 0;
2bd7c093 2120 linux_resume (&resume_info, 1);
64386c31 2121 }
bd99dc85 2122 else
95954743 2123 ptid = cont_thread;
0d62e5e8 2124 }
da6d8c04 2125
6bf5e0ba
PA
2126 if (ptid_equal (step_over_bkpt, null_ptid))
2127 pid = linux_wait_for_event (ptid, &w, options);
2128 else
2129 {
2130 if (debug_threads)
2131 fprintf (stderr, "step_over_bkpt set [%s], doing a blocking wait\n",
2132 target_pid_to_str (step_over_bkpt));
2133 pid = linux_wait_for_event (step_over_bkpt, &w, options & ~WNOHANG);
2134 }
2135
bd99dc85 2136 if (pid == 0) /* only if TARGET_WNOHANG */
95954743 2137 return null_ptid;
bd99dc85 2138
6bf5e0ba 2139 event_child = get_thread_lwp (current_inferior);
da6d8c04 2140
0d62e5e8
DJ
2141 /* If we are waiting for a particular child, and it exited,
2142 linux_wait_for_event will return its exit status. Similarly if
2143 the last child exited. If this is not the last child, however,
2144 do not report it as exited until there is a 'thread exited' response
2145 available in the remote protocol. Instead, just wait for another event.
2146 This should be safe, because if the thread crashed we will already
2147 have reported the termination signal to GDB; that should stop any
2148 in-progress stepping operations, etc.
2149
2150 Report the exit status of the last thread to exit. This matches
2151 LinuxThreads' behavior. */
2152
95954743 2153 if (last_thread_of_process_p (current_inferior))
da6d8c04 2154 {
bd99dc85 2155 if (WIFEXITED (w) || WIFSIGNALED (w))
0d62e5e8 2156 {
bd99dc85
PA
2157 if (WIFEXITED (w))
2158 {
2159 ourstatus->kind = TARGET_WAITKIND_EXITED;
2160 ourstatus->value.integer = WEXITSTATUS (w);
2161
2162 if (debug_threads)
493e2a69
MS
2163 fprintf (stderr,
2164 "\nChild exited with retcode = %x \n",
2165 WEXITSTATUS (w));
bd99dc85
PA
2166 }
2167 else
2168 {
2169 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2170 ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));
2171
2172 if (debug_threads)
493e2a69
MS
2173 fprintf (stderr,
2174 "\nChild terminated with signal = %x \n",
2175 WTERMSIG (w));
bd99dc85
PA
2176
2177 }
5b1c542e 2178
3e4c1235 2179 return ptid_of (event_child);
0d62e5e8 2180 }
da6d8c04 2181 }
0d62e5e8 2182 else
da6d8c04 2183 {
0d62e5e8
DJ
2184 if (!WIFSTOPPED (w))
2185 goto retry;
da6d8c04
DJ
2186 }
2187
6bf5e0ba
PA
2188 /* If this event was not handled before, and is not a SIGTRAP, we
2189 report it. SIGILL and SIGSEGV are also treated as traps in case
2190 a breakpoint is inserted at the current PC. If this target does
2191 not support internal breakpoints at all, we also report the
2192 SIGTRAP without further processing; it's of no concern to us. */
2193 maybe_internal_trap
2194 = (supports_breakpoints ()
2195 && (WSTOPSIG (w) == SIGTRAP
2196 || ((WSTOPSIG (w) == SIGILL
2197 || WSTOPSIG (w) == SIGSEGV)
2198 && (*the_low_target.breakpoint_at) (event_child->stop_pc))));
2199
2200 if (maybe_internal_trap)
2201 {
2202 /* Handle anything that requires bookkeeping before deciding to
2203 report the event or continue waiting. */
2204
2205 /* First check if we can explain the SIGTRAP with an internal
2206 breakpoint, or if we should possibly report the event to GDB.
2207 Do this before anything that may remove or insert a
2208 breakpoint. */
2209 bp_explains_trap = breakpoint_inserted_here (event_child->stop_pc);
2210
2211 /* We have a SIGTRAP, possibly a step-over dance has just
2212 finished. If so, tweak the state machine accordingly,
2213 reinsert breakpoints and delete any reinsert (software
2214 single-step) breakpoints. */
2215 step_over_finished = finish_step_over (event_child);
2216
2217 /* Now invoke the callbacks of any internal breakpoints there. */
2218 check_breakpoints (event_child->stop_pc);
2219
219f2f23
PA
2220 /* Handle tracepoint data collecting. This may overflow the
2221 trace buffer, and cause a tracing stop, removing
2222 breakpoints. */
2223 trace_event = handle_tracepoints (event_child);
2224
6bf5e0ba
PA
2225 if (bp_explains_trap)
2226 {
2227 /* If we stepped or ran into an internal breakpoint, we've
2228 already handled it. So next time we resume (from this
2229 PC), we should step over it. */
2230 if (debug_threads)
2231 fprintf (stderr, "Hit a gdbserver breakpoint.\n");
2232
8b07ae33
PA
2233 if (breakpoint_here (event_child->stop_pc))
2234 event_child->need_step_over = 1;
6bf5e0ba
PA
2235 }
2236 }
2237 else
2238 {
2239 /* We have some other signal, possibly a step-over dance was in
2240 progress, and it should be cancelled too. */
2241 step_over_finished = finish_step_over (event_child);
fa593d66
PA
2242 }
2243
2244 /* We have all the data we need. Either report the event to GDB, or
2245 resume threads and keep waiting for more. */
2246
2247 /* If we're collecting a fast tracepoint, finish the collection and
2248 move out of the jump pad before delivering a signal. See
2249 linux_stabilize_threads. */
2250
2251 if (WIFSTOPPED (w)
2252 && WSTOPSIG (w) != SIGTRAP
2253 && supports_fast_tracepoints ()
2254 && in_process_agent_loaded ())
2255 {
2256 if (debug_threads)
2257 fprintf (stderr,
2258 "Got signal %d for LWP %ld. Check if we need "
2259 "to defer or adjust it.\n",
2260 WSTOPSIG (w), lwpid_of (event_child));
2261
2262 /* Allow debugging the jump pad itself. */
2263 if (current_inferior->last_resume_kind != resume_step
2264 && maybe_move_out_of_jump_pad (event_child, &w))
2265 {
2266 enqueue_one_deferred_signal (event_child, &w);
2267
2268 if (debug_threads)
2269 fprintf (stderr,
2270 "Signal %d for LWP %ld deferred (in jump pad)\n",
2271 WSTOPSIG (w), lwpid_of (event_child));
2272
2273 linux_resume_one_lwp (event_child, 0, 0, NULL);
2274 goto retry;
2275 }
2276 }
219f2f23 2277
fa593d66
PA
2278 if (event_child->collecting_fast_tracepoint)
2279 {
2280 if (debug_threads)
2281 fprintf (stderr, "\
2282LWP %ld was trying to move out of the jump pad (%d). \
2283Check if we're already there.\n",
2284 lwpid_of (event_child),
2285 event_child->collecting_fast_tracepoint);
2286
2287 trace_event = 1;
2288
2289 event_child->collecting_fast_tracepoint
2290 = linux_fast_tracepoint_collecting (event_child, NULL);
2291
2292 if (event_child->collecting_fast_tracepoint != 1)
2293 {
2294 /* No longer need this breakpoint. */
2295 if (event_child->exit_jump_pad_bkpt != NULL)
2296 {
2297 if (debug_threads)
2298 fprintf (stderr,
2299 "No longer need exit-jump-pad bkpt; removing it."
2300 "stopping all threads momentarily.\n");
2301
2302 /* Other running threads could hit this breakpoint.
2303 We don't handle moribund locations like GDB does,
2304 instead we always pause all threads when removing
2305 breakpoints, so that any step-over or
2306 decr_pc_after_break adjustment is always taken
2307 care of while the breakpoint is still
2308 inserted. */
2309 stop_all_lwps (1, event_child);
2310 cancel_breakpoints ();
2311
2312 delete_breakpoint (event_child->exit_jump_pad_bkpt);
2313 event_child->exit_jump_pad_bkpt = NULL;
2314
2315 unstop_all_lwps (1, event_child);
2316
2317 gdb_assert (event_child->suspended >= 0);
2318 }
2319 }
2320
2321 if (event_child->collecting_fast_tracepoint == 0)
2322 {
2323 if (debug_threads)
2324 fprintf (stderr,
2325 "fast tracepoint finished "
2326 "collecting successfully.\n");
2327
2328 /* We may have a deferred signal to report. */
2329 if (dequeue_one_deferred_signal (event_child, &w))
2330 {
2331 if (debug_threads)
2332 fprintf (stderr, "dequeued one signal.\n");
2333 }
3c11dd79 2334 else
fa593d66 2335 {
3c11dd79
PA
2336 if (debug_threads)
2337 fprintf (stderr, "no deferred signals.\n");
fa593d66
PA
2338
2339 if (stabilizing_threads)
2340 {
2341 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2342 ourstatus->value.sig = TARGET_SIGNAL_0;
2343 return ptid_of (event_child);
2344 }
2345 }
2346 }
6bf5e0ba
PA
2347 }
2348
e471f25b
PA
2349 /* Check whether GDB would be interested in this event. */
2350
2351 /* If GDB is not interested in this signal, don't stop other
2352 threads, and don't report it to GDB. Just resume the inferior
2353 right away. We do this for threading-related signals as well as
2354 any that GDB specifically requested we ignore. But never ignore
2355 SIGSTOP if we sent it ourselves, and do not ignore signals when
2356 stepping - they may require special handling to skip the signal
2357 handler. */
2358 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
2359 thread library? */
2360 if (WIFSTOPPED (w)
2361 && current_inferior->last_resume_kind != resume_step
2362 && (
1a981360 2363#if defined (USE_THREAD_DB) && !defined (__ANDROID__)
e471f25b
PA
2364 (current_process ()->private->thread_db != NULL
2365 && (WSTOPSIG (w) == __SIGRTMIN
2366 || WSTOPSIG (w) == __SIGRTMIN + 1))
2367 ||
2368#endif
2369 (pass_signals[target_signal_from_host (WSTOPSIG (w))]
2370 && !(WSTOPSIG (w) == SIGSTOP
2371 && current_inferior->last_resume_kind == resume_stop))))
2372 {
2373 siginfo_t info, *info_p;
2374
2375 if (debug_threads)
2376 fprintf (stderr, "Ignored signal %d for LWP %ld.\n",
2377 WSTOPSIG (w), lwpid_of (event_child));
2378
2379 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child), 0, &info) == 0)
2380 info_p = &info;
2381 else
2382 info_p = NULL;
2383 linux_resume_one_lwp (event_child, event_child->stepping,
2384 WSTOPSIG (w), info_p);
2385 goto retry;
2386 }
2387
2388 /* If GDB wanted this thread to single step, we always want to
2389 report the SIGTRAP, and let GDB handle it. Watchpoints should
2390 always be reported. So should signals we can't explain. A
2391 SIGTRAP we can't explain could be a GDB breakpoint --- we may or
2392 not support Z0 breakpoints. If we do, we're be able to handle
2393 GDB breakpoints on top of internal breakpoints, by handling the
2394 internal breakpoint and still reporting the event to GDB. If we
2395 don't, we're out of luck, GDB won't see the breakpoint hit. */
6bf5e0ba 2396 report_to_gdb = (!maybe_internal_trap
8336d594 2397 || current_inferior->last_resume_kind == resume_step
6bf5e0ba 2398 || event_child->stopped_by_watchpoint
493e2a69
MS
2399 || (!step_over_finished
2400 && !bp_explains_trap && !trace_event)
9f3a5c85
LM
2401 || (gdb_breakpoint_here (event_child->stop_pc)
2402 && gdb_condition_true_at_breakpoint (event_child->stop_pc)));
6bf5e0ba
PA
2403
2404 /* We found no reason GDB would want us to stop. We either hit one
2405 of our own breakpoints, or finished an internal step GDB
2406 shouldn't know about. */
2407 if (!report_to_gdb)
2408 {
2409 if (debug_threads)
2410 {
2411 if (bp_explains_trap)
2412 fprintf (stderr, "Hit a gdbserver breakpoint.\n");
2413 if (step_over_finished)
2414 fprintf (stderr, "Step-over finished.\n");
219f2f23
PA
2415 if (trace_event)
2416 fprintf (stderr, "Tracepoint event.\n");
6bf5e0ba
PA
2417 }
2418
2419 /* We're not reporting this breakpoint to GDB, so apply the
2420 decr_pc_after_break adjustment to the inferior's regcache
2421 ourselves. */
2422
2423 if (the_low_target.set_pc != NULL)
2424 {
2425 struct regcache *regcache
2426 = get_thread_regcache (get_lwp_thread (event_child), 1);
2427 (*the_low_target.set_pc) (regcache, event_child->stop_pc);
2428 }
2429
7984d532
PA
2430 /* We may have finished stepping over a breakpoint. If so,
2431 we've stopped and suspended all LWPs momentarily except the
2432 stepping one. This is where we resume them all again. We're
2433 going to keep waiting, so use proceed, which handles stepping
2434 over the next breakpoint. */
6bf5e0ba
PA
2435 if (debug_threads)
2436 fprintf (stderr, "proceeding all threads.\n");
7984d532
PA
2437
2438 if (step_over_finished)
2439 unsuspend_all_lwps (event_child);
2440
6bf5e0ba
PA
2441 proceed_all_lwps ();
2442 goto retry;
2443 }
2444
2445 if (debug_threads)
2446 {
8336d594 2447 if (current_inferior->last_resume_kind == resume_step)
6bf5e0ba
PA
2448 fprintf (stderr, "GDB wanted to single-step, reporting event.\n");
2449 if (event_child->stopped_by_watchpoint)
2450 fprintf (stderr, "Stopped by watchpoint.\n");
8b07ae33
PA
2451 if (gdb_breakpoint_here (event_child->stop_pc))
2452 fprintf (stderr, "Stopped by GDB breakpoint.\n");
6bf5e0ba
PA
2453 if (debug_threads)
2454 fprintf (stderr, "Hit a non-gdbserver trap event.\n");
2455 }
2456
2457 /* Alright, we're going to report a stop. */
2458
fa593d66 2459 if (!non_stop && !stabilizing_threads)
6bf5e0ba
PA
2460 {
2461 /* In all-stop, stop all threads. */
7984d532 2462 stop_all_lwps (0, NULL);
6bf5e0ba
PA
2463
2464 /* If we're not waiting for a specific LWP, choose an event LWP
2465 from among those that have had events. Giving equal priority
2466 to all LWPs that have had events helps prevent
2467 starvation. */
2468 if (ptid_equal (ptid, minus_one_ptid))
2469 {
2470 event_child->status_pending_p = 1;
2471 event_child->status_pending = w;
2472
2473 select_event_lwp (&event_child);
2474
2475 event_child->status_pending_p = 0;
2476 w = event_child->status_pending;
2477 }
2478
2479 /* Now that we've selected our final event LWP, cancel any
2480 breakpoints in other LWPs that have hit a GDB breakpoint.
2481 See the comment in cancel_breakpoints_callback to find out
2482 why. */
2483 find_inferior (&all_lwps, cancel_breakpoints_callback, event_child);
fa593d66
PA
2484
2485 /* Stabilize threads (move out of jump pads). */
2486 stabilize_threads ();
6bf5e0ba
PA
2487 }
2488 else
2489 {
2490 /* If we just finished a step-over, then all threads had been
2491 momentarily paused. In all-stop, that's fine, we want
2492 threads stopped by now anyway. In non-stop, we need to
2493 re-resume threads that GDB wanted to be running. */
2494 if (step_over_finished)
7984d532 2495 unstop_all_lwps (1, event_child);
6bf5e0ba
PA
2496 }
2497
5b1c542e 2498 ourstatus->kind = TARGET_WAITKIND_STOPPED;
5b1c542e 2499
8336d594
PA
2500 if (current_inferior->last_resume_kind == resume_stop
2501 && WSTOPSIG (w) == SIGSTOP)
bd99dc85
PA
2502 {
2503 /* A thread that has been requested to stop by GDB with vCont;t,
2504 and it stopped cleanly, so report as SIG0. The use of
2505 SIGSTOP is an implementation detail. */
2506 ourstatus->value.sig = TARGET_SIGNAL_0;
2507 }
8336d594
PA
2508 else if (current_inferior->last_resume_kind == resume_stop
2509 && WSTOPSIG (w) != SIGSTOP)
bd99dc85
PA
2510 {
2511 /* A thread that has been requested to stop by GDB with vCont;t,
d50171e4 2512 but, it stopped for other reasons. */
bd99dc85
PA
2513 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
2514 }
2515 else
2516 {
2517 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
2518 }
2519
d50171e4
PA
2520 gdb_assert (ptid_equal (step_over_bkpt, null_ptid));
2521
bd99dc85 2522 if (debug_threads)
95954743 2523 fprintf (stderr, "linux_wait ret = %s, %d, %d\n",
6bf5e0ba 2524 target_pid_to_str (ptid_of (event_child)),
bd99dc85
PA
2525 ourstatus->kind,
2526 ourstatus->value.sig);
2527
6bf5e0ba 2528 return ptid_of (event_child);
bd99dc85
PA
2529}
2530
2531/* Get rid of any pending event in the pipe. */
2532static void
2533async_file_flush (void)
2534{
2535 int ret;
2536 char buf;
2537
2538 do
2539 ret = read (linux_event_pipe[0], &buf, 1);
2540 while (ret >= 0 || (ret == -1 && errno == EINTR));
2541}
2542
2543/* Put something in the pipe, so the event loop wakes up. */
2544static void
2545async_file_mark (void)
2546{
2547 int ret;
2548
2549 async_file_flush ();
2550
2551 do
2552 ret = write (linux_event_pipe[1], "+", 1);
2553 while (ret == 0 || (ret == -1 && errno == EINTR));
2554
2555 /* Ignore EAGAIN. If the pipe is full, the event loop will already
2556 be awakened anyway. */
2557}
2558
95954743
PA
2559static ptid_t
2560linux_wait (ptid_t ptid,
2561 struct target_waitstatus *ourstatus, int target_options)
bd99dc85 2562{
95954743 2563 ptid_t event_ptid;
bd99dc85
PA
2564
2565 if (debug_threads)
95954743 2566 fprintf (stderr, "linux_wait: [%s]\n", target_pid_to_str (ptid));
bd99dc85
PA
2567
2568 /* Flush the async file first. */
2569 if (target_is_async_p ())
2570 async_file_flush ();
2571
95954743 2572 event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
bd99dc85
PA
2573
2574 /* If at least one stop was reported, there may be more. A single
2575 SIGCHLD can signal more than one child stop. */
2576 if (target_is_async_p ()
2577 && (target_options & TARGET_WNOHANG) != 0
95954743 2578 && !ptid_equal (event_ptid, null_ptid))
bd99dc85
PA
2579 async_file_mark ();
2580
2581 return event_ptid;
da6d8c04
DJ
2582}
2583
c5f62d5f 2584/* Send a signal to an LWP. */
fd500816
DJ
2585
2586static int
a1928bad 2587kill_lwp (unsigned long lwpid, int signo)
fd500816 2588{
c5f62d5f
DE
2589 /* Use tkill, if possible, in case we are using nptl threads. If tkill
2590 fails, then we are not using nptl threads and we should be using kill. */
fd500816 2591
c5f62d5f
DE
2592#ifdef __NR_tkill
2593 {
2594 static int tkill_failed;
fd500816 2595
c5f62d5f
DE
2596 if (!tkill_failed)
2597 {
2598 int ret;
2599
2600 errno = 0;
2601 ret = syscall (__NR_tkill, lwpid, signo);
2602 if (errno != ENOSYS)
2603 return ret;
2604 tkill_failed = 1;
2605 }
2606 }
fd500816
DJ
2607#endif
2608
2609 return kill (lwpid, signo);
2610}
2611
964e4306
PA
2612void
2613linux_stop_lwp (struct lwp_info *lwp)
2614{
2615 send_sigstop (lwp);
2616}
2617
0d62e5e8 2618static void
02fc4de7 2619send_sigstop (struct lwp_info *lwp)
0d62e5e8 2620{
bd99dc85 2621 int pid;
0d62e5e8 2622
bd99dc85
PA
2623 pid = lwpid_of (lwp);
2624
0d62e5e8
DJ
2625 /* If we already have a pending stop signal for this process, don't
2626 send another. */
54a0b537 2627 if (lwp->stop_expected)
0d62e5e8 2628 {
ae13219e 2629 if (debug_threads)
bd99dc85 2630 fprintf (stderr, "Have pending sigstop for lwp %d\n", pid);
ae13219e 2631
0d62e5e8
DJ
2632 return;
2633 }
2634
2635 if (debug_threads)
bd99dc85 2636 fprintf (stderr, "Sending sigstop to lwp %d\n", pid);
0d62e5e8 2637
d50171e4 2638 lwp->stop_expected = 1;
bd99dc85 2639 kill_lwp (pid, SIGSTOP);
0d62e5e8
DJ
2640}
2641
7984d532
PA
2642static int
2643send_sigstop_callback (struct inferior_list_entry *entry, void *except)
02fc4de7
PA
2644{
2645 struct lwp_info *lwp = (struct lwp_info *) entry;
2646
7984d532
PA
2647 /* Ignore EXCEPT. */
2648 if (lwp == except)
2649 return 0;
2650
02fc4de7 2651 if (lwp->stopped)
7984d532 2652 return 0;
02fc4de7
PA
2653
2654 send_sigstop (lwp);
7984d532
PA
2655 return 0;
2656}
2657
2658/* Increment the suspend count of an LWP, and stop it, if not stopped
2659 yet. */
2660static int
2661suspend_and_send_sigstop_callback (struct inferior_list_entry *entry,
2662 void *except)
2663{
2664 struct lwp_info *lwp = (struct lwp_info *) entry;
2665
2666 /* Ignore EXCEPT. */
2667 if (lwp == except)
2668 return 0;
2669
2670 lwp->suspended++;
2671
2672 return send_sigstop_callback (entry, except);
02fc4de7
PA
2673}
2674
95954743
PA
2675static void
2676mark_lwp_dead (struct lwp_info *lwp, int wstat)
2677{
2678 /* It's dead, really. */
2679 lwp->dead = 1;
2680
2681 /* Store the exit status for later. */
2682 lwp->status_pending_p = 1;
2683 lwp->status_pending = wstat;
2684
95954743
PA
2685 /* Prevent trying to stop it. */
2686 lwp->stopped = 1;
2687
2688 /* No further stops are expected from a dead lwp. */
2689 lwp->stop_expected = 0;
2690}
2691
0d62e5e8
DJ
2692static void
2693wait_for_sigstop (struct inferior_list_entry *entry)
2694{
54a0b537 2695 struct lwp_info *lwp = (struct lwp_info *) entry;
bd99dc85 2696 struct thread_info *saved_inferior;
a1928bad 2697 int wstat;
95954743
PA
2698 ptid_t saved_tid;
2699 ptid_t ptid;
d50171e4 2700 int pid;
0d62e5e8 2701
54a0b537 2702 if (lwp->stopped)
d50171e4
PA
2703 {
2704 if (debug_threads)
2705 fprintf (stderr, "wait_for_sigstop: LWP %ld already stopped\n",
2706 lwpid_of (lwp));
2707 return;
2708 }
0d62e5e8
DJ
2709
2710 saved_inferior = current_inferior;
bd99dc85
PA
2711 if (saved_inferior != NULL)
2712 saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
2713 else
95954743 2714 saved_tid = null_ptid; /* avoid bogus unused warning */
bd99dc85 2715
95954743 2716 ptid = lwp->head.id;
bd99dc85 2717
d50171e4
PA
2718 if (debug_threads)
2719 fprintf (stderr, "wait_for_sigstop: pulling one event\n");
2720
2721 pid = linux_wait_for_event (ptid, &wstat, __WALL);
0d62e5e8
DJ
2722
2723 /* If we stopped with a non-SIGSTOP signal, save it for later
2724 and record the pending SIGSTOP. If the process exited, just
2725 return. */
d50171e4 2726 if (WIFSTOPPED (wstat))
0d62e5e8
DJ
2727 {
2728 if (debug_threads)
d50171e4
PA
2729 fprintf (stderr, "LWP %ld stopped with signal %d\n",
2730 lwpid_of (lwp), WSTOPSIG (wstat));
c35fafde 2731
d50171e4 2732 if (WSTOPSIG (wstat) != SIGSTOP)
c35fafde
PA
2733 {
2734 if (debug_threads)
d50171e4
PA
2735 fprintf (stderr, "LWP %ld stopped with non-sigstop status %06x\n",
2736 lwpid_of (lwp), wstat);
2737
c35fafde
PA
2738 lwp->status_pending_p = 1;
2739 lwp->status_pending = wstat;
2740 }
0d62e5e8 2741 }
d50171e4 2742 else
95954743
PA
2743 {
2744 if (debug_threads)
d50171e4 2745 fprintf (stderr, "Process %d exited while stopping LWPs\n", pid);
95954743 2746
d50171e4
PA
2747 lwp = find_lwp_pid (pid_to_ptid (pid));
2748 if (lwp)
2749 {
2750 /* Leave this status pending for the next time we're able to
2751 report it. In the mean time, we'll report this lwp as
2752 dead to GDB, so GDB doesn't try to read registers and
2753 memory from it. This can only happen if this was the
2754 last thread of the process; otherwise, PID is removed
2755 from the thread tables before linux_wait_for_event
2756 returns. */
2757 mark_lwp_dead (lwp, wstat);
2758 }
95954743 2759 }
0d62e5e8 2760
bd99dc85 2761 if (saved_inferior == NULL || linux_thread_alive (saved_tid))
0d62e5e8
DJ
2762 current_inferior = saved_inferior;
2763 else
2764 {
2765 if (debug_threads)
2766 fprintf (stderr, "Previously current thread died.\n");
2767
bd99dc85
PA
2768 if (non_stop)
2769 {
2770 /* We can't change the current inferior behind GDB's back,
2771 otherwise, a subsequent command may apply to the wrong
2772 process. */
2773 current_inferior = NULL;
2774 }
2775 else
2776 {
2777 /* Set a valid thread as current. */
2778 set_desired_inferior (0);
2779 }
0d62e5e8
DJ
2780 }
2781}
2782
fa593d66
PA
2783/* Returns true if LWP ENTRY is stopped in a jump pad, and we can't
2784 move it out, because we need to report the stop event to GDB. For
2785 example, if the user puts a breakpoint in the jump pad, it's
2786 because she wants to debug it. */
2787
2788static int
2789stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data)
2790{
2791 struct lwp_info *lwp = (struct lwp_info *) entry;
2792 struct thread_info *thread = get_lwp_thread (lwp);
2793
2794 gdb_assert (lwp->suspended == 0);
2795 gdb_assert (lwp->stopped);
2796
2797 /* Allow debugging the jump pad, gdb_collect, etc.. */
2798 return (supports_fast_tracepoints ()
2799 && in_process_agent_loaded ()
2800 && (gdb_breakpoint_here (lwp->stop_pc)
2801 || lwp->stopped_by_watchpoint
2802 || thread->last_resume_kind == resume_step)
2803 && linux_fast_tracepoint_collecting (lwp, NULL));
2804}
2805
2806static void
2807move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
2808{
2809 struct lwp_info *lwp = (struct lwp_info *) entry;
2810 struct thread_info *thread = get_lwp_thread (lwp);
2811 int *wstat;
2812
2813 gdb_assert (lwp->suspended == 0);
2814 gdb_assert (lwp->stopped);
2815
2816 wstat = lwp->status_pending_p ? &lwp->status_pending : NULL;
2817
2818 /* Allow debugging the jump pad, gdb_collect, etc. */
2819 if (!gdb_breakpoint_here (lwp->stop_pc)
2820 && !lwp->stopped_by_watchpoint
2821 && thread->last_resume_kind != resume_step
2822 && maybe_move_out_of_jump_pad (lwp, wstat))
2823 {
2824 if (debug_threads)
2825 fprintf (stderr,
2826 "LWP %ld needs stabilizing (in jump pad)\n",
2827 lwpid_of (lwp));
2828
2829 if (wstat)
2830 {
2831 lwp->status_pending_p = 0;
2832 enqueue_one_deferred_signal (lwp, wstat);
2833
2834 if (debug_threads)
2835 fprintf (stderr,
2836 "Signal %d for LWP %ld deferred "
2837 "(in jump pad)\n",
2838 WSTOPSIG (*wstat), lwpid_of (lwp));
2839 }
2840
2841 linux_resume_one_lwp (lwp, 0, 0, NULL);
2842 }
2843 else
2844 lwp->suspended++;
2845}
2846
2847static int
2848lwp_running (struct inferior_list_entry *entry, void *data)
2849{
2850 struct lwp_info *lwp = (struct lwp_info *) entry;
2851
2852 if (lwp->dead)
2853 return 0;
2854 if (lwp->stopped)
2855 return 0;
2856 return 1;
2857}
2858
7984d532
PA
2859/* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
2860 If SUSPEND, then also increase the suspend count of every LWP,
2861 except EXCEPT. */
2862
0d62e5e8 2863static void
7984d532 2864stop_all_lwps (int suspend, struct lwp_info *except)
0d62e5e8
DJ
2865{
2866 stopping_threads = 1;
7984d532
PA
2867
2868 if (suspend)
2869 find_inferior (&all_lwps, suspend_and_send_sigstop_callback, except);
2870 else
2871 find_inferior (&all_lwps, send_sigstop_callback, except);
54a0b537 2872 for_each_inferior (&all_lwps, wait_for_sigstop);
0d62e5e8
DJ
2873 stopping_threads = 0;
2874}
2875
da6d8c04
DJ
2876/* Resume execution of the inferior process.
2877 If STEP is nonzero, single-step it.
2878 If SIGNAL is nonzero, give it that signal. */
2879
ce3a066d 2880static void
2acc282a 2881linux_resume_one_lwp (struct lwp_info *lwp,
54a0b537 2882 int step, int signal, siginfo_t *info)
da6d8c04 2883{
0d62e5e8 2884 struct thread_info *saved_inferior;
fa593d66 2885 int fast_tp_collecting;
0d62e5e8 2886
54a0b537 2887 if (lwp->stopped == 0)
0d62e5e8
DJ
2888 return;
2889
fa593d66
PA
2890 fast_tp_collecting = lwp->collecting_fast_tracepoint;
2891
2892 gdb_assert (!stabilizing_threads || fast_tp_collecting);
2893
219f2f23
PA
2894 /* Cancel actions that rely on GDB not changing the PC (e.g., the
2895 user used the "jump" command, or "set $pc = foo"). */
2896 if (lwp->stop_pc != get_pc (lwp))
2897 {
2898 /* Collecting 'while-stepping' actions doesn't make sense
2899 anymore. */
2900 release_while_stepping_state_list (get_lwp_thread (lwp));
2901 }
2902
0d62e5e8
DJ
2903 /* If we have pending signals or status, and a new signal, enqueue the
2904 signal. Also enqueue the signal if we are waiting to reinsert a
2905 breakpoint; it will be picked up again below. */
2906 if (signal != 0
fa593d66
PA
2907 && (lwp->status_pending_p
2908 || lwp->pending_signals != NULL
2909 || lwp->bp_reinsert != 0
2910 || fast_tp_collecting))
0d62e5e8
DJ
2911 {
2912 struct pending_signals *p_sig;
bca929d3 2913 p_sig = xmalloc (sizeof (*p_sig));
54a0b537 2914 p_sig->prev = lwp->pending_signals;
0d62e5e8 2915 p_sig->signal = signal;
32ca6d61
DJ
2916 if (info == NULL)
2917 memset (&p_sig->info, 0, sizeof (siginfo_t));
2918 else
2919 memcpy (&p_sig->info, info, sizeof (siginfo_t));
54a0b537 2920 lwp->pending_signals = p_sig;
0d62e5e8
DJ
2921 }
2922
d50171e4
PA
2923 if (lwp->status_pending_p)
2924 {
2925 if (debug_threads)
2926 fprintf (stderr, "Not resuming lwp %ld (%s, signal %d, stop %s);"
2927 " has pending status\n",
2928 lwpid_of (lwp), step ? "step" : "continue", signal,
2929 lwp->stop_expected ? "expected" : "not expected");
2930 return;
2931 }
0d62e5e8
DJ
2932
2933 saved_inferior = current_inferior;
54a0b537 2934 current_inferior = get_lwp_thread (lwp);
0d62e5e8
DJ
2935
2936 if (debug_threads)
1b3f6016 2937 fprintf (stderr, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
bd99dc85 2938 lwpid_of (lwp), step ? "step" : "continue", signal,
54a0b537 2939 lwp->stop_expected ? "expected" : "not expected");
0d62e5e8
DJ
2940
2941 /* This bit needs some thinking about. If we get a signal that
2942 we must report while a single-step reinsert is still pending,
2943 we often end up resuming the thread. It might be better to
2944 (ew) allow a stack of pending events; then we could be sure that
2945 the reinsert happened right away and not lose any signals.
2946
2947 Making this stack would also shrink the window in which breakpoints are
54a0b537 2948 uninserted (see comment in linux_wait_for_lwp) but not enough for
0d62e5e8
DJ
2949 complete correctness, so it won't solve that problem. It may be
2950 worthwhile just to solve this one, however. */
54a0b537 2951 if (lwp->bp_reinsert != 0)
0d62e5e8
DJ
2952 {
2953 if (debug_threads)
d50171e4
PA
2954 fprintf (stderr, " pending reinsert at 0x%s\n",
2955 paddress (lwp->bp_reinsert));
2956
2957 if (lwp->bp_reinsert != 0 && can_hardware_single_step ())
2958 {
fa593d66
PA
2959 if (fast_tp_collecting == 0)
2960 {
2961 if (step == 0)
2962 fprintf (stderr, "BAD - reinserting but not stepping.\n");
2963 if (lwp->suspended)
2964 fprintf (stderr, "BAD - reinserting and suspended(%d).\n",
2965 lwp->suspended);
2966 }
d50171e4
PA
2967
2968 step = 1;
2969 }
0d62e5e8
DJ
2970
2971 /* Postpone any pending signal. It was enqueued above. */
2972 signal = 0;
2973 }
2974
fa593d66
PA
2975 if (fast_tp_collecting == 1)
2976 {
2977 if (debug_threads)
2978 fprintf (stderr, "\
2979lwp %ld wants to get out of fast tracepoint jump pad (exit-jump-pad-bkpt)\n",
2980 lwpid_of (lwp));
2981
2982 /* Postpone any pending signal. It was enqueued above. */
2983 signal = 0;
2984 }
2985 else if (fast_tp_collecting == 2)
2986 {
2987 if (debug_threads)
2988 fprintf (stderr, "\
2989lwp %ld wants to get out of fast tracepoint jump pad single-stepping\n",
2990 lwpid_of (lwp));
2991
2992 if (can_hardware_single_step ())
2993 step = 1;
2994 else
2995 fatal ("moving out of jump pad single-stepping"
2996 " not implemented on this target");
2997
2998 /* Postpone any pending signal. It was enqueued above. */
2999 signal = 0;
3000 }
3001
219f2f23
PA
3002 /* If we have while-stepping actions in this thread set it stepping.
3003 If we have a signal to deliver, it may or may not be set to
3004 SIG_IGN, we don't know. Assume so, and allow collecting
3005 while-stepping into a signal handler. A possible smart thing to
3006 do would be to set an internal breakpoint at the signal return
3007 address, continue, and carry on catching this while-stepping
3008 action only when that breakpoint is hit. A future
3009 enhancement. */
3010 if (get_lwp_thread (lwp)->while_stepping != NULL
3011 && can_hardware_single_step ())
3012 {
3013 if (debug_threads)
3014 fprintf (stderr,
3015 "lwp %ld has a while-stepping action -> forcing step.\n",
3016 lwpid_of (lwp));
3017 step = 1;
3018 }
3019
aa691b87 3020 if (debug_threads && the_low_target.get_pc != NULL)
0d62e5e8 3021 {
442ea881
PA
3022 struct regcache *regcache = get_thread_regcache (current_inferior, 1);
3023 CORE_ADDR pc = (*the_low_target.get_pc) (regcache);
47c0c975 3024 fprintf (stderr, " resuming from pc 0x%lx\n", (long) pc);
0d62e5e8
DJ
3025 }
3026
fa593d66
PA
3027 /* If we have pending signals, consume one unless we are trying to
3028 reinsert a breakpoint or we're trying to finish a fast tracepoint
3029 collect. */
3030 if (lwp->pending_signals != NULL
3031 && lwp->bp_reinsert == 0
3032 && fast_tp_collecting == 0)
0d62e5e8
DJ
3033 {
3034 struct pending_signals **p_sig;
3035
54a0b537 3036 p_sig = &lwp->pending_signals;
0d62e5e8
DJ
3037 while ((*p_sig)->prev != NULL)
3038 p_sig = &(*p_sig)->prev;
3039
3040 signal = (*p_sig)->signal;
32ca6d61 3041 if ((*p_sig)->info.si_signo != 0)
bd99dc85 3042 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
32ca6d61 3043
0d62e5e8
DJ
3044 free (*p_sig);
3045 *p_sig = NULL;
3046 }
3047
aa5ca48f
DE
3048 if (the_low_target.prepare_to_resume != NULL)
3049 the_low_target.prepare_to_resume (lwp);
3050
0d62e5e8 3051 regcache_invalidate_one ((struct inferior_list_entry *)
54a0b537 3052 get_lwp_thread (lwp));
da6d8c04 3053 errno = 0;
54a0b537 3054 lwp->stopped = 0;
c3adc08c 3055 lwp->stopped_by_watchpoint = 0;
54a0b537 3056 lwp->stepping = step;
14ce3065
DE
3057 ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp), 0,
3058 /* Coerce to a uintptr_t first to avoid potential gcc warning
3059 of coercing an 8 byte integer to a 4 byte pointer. */
3060 (PTRACE_ARG4_TYPE) (uintptr_t) signal);
0d62e5e8
DJ
3061
3062 current_inferior = saved_inferior;
da6d8c04 3063 if (errno)
3221518c
UW
3064 {
3065 /* ESRCH from ptrace either means that the thread was already
3066 running (an error) or that it is gone (a race condition). If
3067 it's gone, we will get a notification the next time we wait,
3068 so we can ignore the error. We could differentiate these
3069 two, but it's tricky without waiting; the thread still exists
3070 as a zombie, so sending it signal 0 would succeed. So just
3071 ignore ESRCH. */
3072 if (errno == ESRCH)
3073 return;
3074
3075 perror_with_name ("ptrace");
3076 }
da6d8c04
DJ
3077}
3078
2bd7c093
PA
3079struct thread_resume_array
3080{
3081 struct thread_resume *resume;
3082 size_t n;
3083};
64386c31
DJ
3084
3085/* This function is called once per thread. We look up the thread
5544ad89
DJ
3086 in RESUME_PTR, and mark the thread with a pointer to the appropriate
3087 resume request.
3088
3089 This algorithm is O(threads * resume elements), but resume elements
3090 is small (and will remain small at least until GDB supports thread
3091 suspension). */
2bd7c093
PA
3092static int
3093linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
0d62e5e8 3094{
54a0b537 3095 struct lwp_info *lwp;
64386c31 3096 struct thread_info *thread;
5544ad89 3097 int ndx;
2bd7c093 3098 struct thread_resume_array *r;
64386c31
DJ
3099
3100 thread = (struct thread_info *) entry;
54a0b537 3101 lwp = get_thread_lwp (thread);
2bd7c093 3102 r = arg;
64386c31 3103
2bd7c093 3104 for (ndx = 0; ndx < r->n; ndx++)
95954743
PA
3105 {
3106 ptid_t ptid = r->resume[ndx].thread;
3107 if (ptid_equal (ptid, minus_one_ptid)
3108 || ptid_equal (ptid, entry->id)
3109 || (ptid_is_pid (ptid)
3110 && (ptid_get_pid (ptid) == pid_of (lwp)))
3111 || (ptid_get_lwp (ptid) == -1
3112 && (ptid_get_pid (ptid) == pid_of (lwp))))
3113 {
d50171e4 3114 if (r->resume[ndx].kind == resume_stop
8336d594 3115 && thread->last_resume_kind == resume_stop)
d50171e4
PA
3116 {
3117 if (debug_threads)
3118 fprintf (stderr, "already %s LWP %ld at GDB's request\n",
3119 thread->last_status.kind == TARGET_WAITKIND_STOPPED
3120 ? "stopped"
3121 : "stopping",
3122 lwpid_of (lwp));
3123
3124 continue;
3125 }
3126
95954743 3127 lwp->resume = &r->resume[ndx];
8336d594 3128 thread->last_resume_kind = lwp->resume->kind;
fa593d66
PA
3129
3130 /* If we had a deferred signal to report, dequeue one now.
3131 This can happen if LWP gets more than one signal while
3132 trying to get out of a jump pad. */
3133 if (lwp->stopped
3134 && !lwp->status_pending_p
3135 && dequeue_one_deferred_signal (lwp, &lwp->status_pending))
3136 {
3137 lwp->status_pending_p = 1;
3138
3139 if (debug_threads)
3140 fprintf (stderr,
3141 "Dequeueing deferred signal %d for LWP %ld, "
3142 "leaving status pending.\n",
3143 WSTOPSIG (lwp->status_pending), lwpid_of (lwp));
3144 }
3145
95954743
PA
3146 return 0;
3147 }
3148 }
2bd7c093
PA
3149
3150 /* No resume action for this thread. */
3151 lwp->resume = NULL;
64386c31 3152
2bd7c093 3153 return 0;
5544ad89
DJ
3154}
3155
5544ad89 3156
bd99dc85
PA
3157/* Set *FLAG_P if this lwp has an interesting status pending. */
3158static int
3159resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
5544ad89 3160{
bd99dc85 3161 struct lwp_info *lwp = (struct lwp_info *) entry;
5544ad89 3162
bd99dc85
PA
3163 /* LWPs which will not be resumed are not interesting, because
3164 we might not wait for them next time through linux_wait. */
2bd7c093 3165 if (lwp->resume == NULL)
bd99dc85 3166 return 0;
64386c31 3167
bd99dc85 3168 if (lwp->status_pending_p)
d50171e4
PA
3169 * (int *) flag_p = 1;
3170
3171 return 0;
3172}
3173
3174/* Return 1 if this lwp that GDB wants running is stopped at an
3175 internal breakpoint that we need to step over. It assumes that any
3176 required STOP_PC adjustment has already been propagated to the
3177 inferior's regcache. */
3178
3179static int
3180need_step_over_p (struct inferior_list_entry *entry, void *dummy)
3181{
3182 struct lwp_info *lwp = (struct lwp_info *) entry;
8336d594 3183 struct thread_info *thread;
d50171e4
PA
3184 struct thread_info *saved_inferior;
3185 CORE_ADDR pc;
3186
3187 /* LWPs which will not be resumed are not interesting, because we
3188 might not wait for them next time through linux_wait. */
3189
3190 if (!lwp->stopped)
3191 {
3192 if (debug_threads)
3193 fprintf (stderr,
3194 "Need step over [LWP %ld]? Ignoring, not stopped\n",
3195 lwpid_of (lwp));
3196 return 0;
3197 }
3198
8336d594
PA
3199 thread = get_lwp_thread (lwp);
3200
3201 if (thread->last_resume_kind == resume_stop)
d50171e4
PA
3202 {
3203 if (debug_threads)
3204 fprintf (stderr,
3205 "Need step over [LWP %ld]? Ignoring, should remain stopped\n",
3206 lwpid_of (lwp));
3207 return 0;
3208 }
3209
7984d532
PA
3210 gdb_assert (lwp->suspended >= 0);
3211
3212 if (lwp->suspended)
3213 {
3214 if (debug_threads)
3215 fprintf (stderr,
3216 "Need step over [LWP %ld]? Ignoring, suspended\n",
3217 lwpid_of (lwp));
3218 return 0;
3219 }
3220
d50171e4
PA
3221 if (!lwp->need_step_over)
3222 {
3223 if (debug_threads)
3224 fprintf (stderr,
3225 "Need step over [LWP %ld]? No\n", lwpid_of (lwp));
3226 }
5544ad89 3227
bd99dc85 3228 if (lwp->status_pending_p)
d50171e4
PA
3229 {
3230 if (debug_threads)
3231 fprintf (stderr,
3232 "Need step over [LWP %ld]? Ignoring, has pending status.\n",
3233 lwpid_of (lwp));
3234 return 0;
3235 }
3236
3237 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
3238 or we have. */
3239 pc = get_pc (lwp);
3240
3241 /* If the PC has changed since we stopped, then don't do anything,
3242 and let the breakpoint/tracepoint be hit. This happens if, for
3243 instance, GDB handled the decr_pc_after_break subtraction itself,
3244 GDB is OOL stepping this thread, or the user has issued a "jump"
3245 command, or poked thread's registers herself. */
3246 if (pc != lwp->stop_pc)
3247 {
3248 if (debug_threads)
3249 fprintf (stderr,
3250 "Need step over [LWP %ld]? Cancelling, PC was changed. "
3251 "Old stop_pc was 0x%s, PC is now 0x%s\n",
3252 lwpid_of (lwp), paddress (lwp->stop_pc), paddress (pc));
3253
3254 lwp->need_step_over = 0;
3255 return 0;
3256 }
3257
3258 saved_inferior = current_inferior;
8336d594 3259 current_inferior = thread;
d50171e4 3260
8b07ae33 3261 /* We can only step over breakpoints we know about. */
fa593d66 3262 if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
d50171e4 3263 {
8b07ae33 3264 /* Don't step over a breakpoint that GDB expects to hit
9f3a5c85
LM
3265 though. If the condition is being evaluated on the target's side
3266 and it evaluate to false, step over this breakpoint as well. */
3267 if (gdb_breakpoint_here (pc)
3268 && gdb_condition_true_at_breakpoint (pc))
8b07ae33
PA
3269 {
3270 if (debug_threads)
3271 fprintf (stderr,
3272 "Need step over [LWP %ld]? yes, but found"
3273 " GDB breakpoint at 0x%s; skipping step over\n",
3274 lwpid_of (lwp), paddress (pc));
d50171e4 3275
8b07ae33
PA
3276 current_inferior = saved_inferior;
3277 return 0;
3278 }
3279 else
3280 {
3281 if (debug_threads)
3282 fprintf (stderr,
493e2a69
MS
3283 "Need step over [LWP %ld]? yes, "
3284 "found breakpoint at 0x%s\n",
8b07ae33 3285 lwpid_of (lwp), paddress (pc));
d50171e4 3286
8b07ae33
PA
3287 /* We've found an lwp that needs stepping over --- return 1 so
3288 that find_inferior stops looking. */
3289 current_inferior = saved_inferior;
3290
3291 /* If the step over is cancelled, this is set again. */
3292 lwp->need_step_over = 0;
3293 return 1;
3294 }
d50171e4
PA
3295 }
3296
3297 current_inferior = saved_inferior;
3298
3299 if (debug_threads)
3300 fprintf (stderr,
3301 "Need step over [LWP %ld]? No, no breakpoint found at 0x%s\n",
3302 lwpid_of (lwp), paddress (pc));
c6ecbae5 3303
bd99dc85 3304 return 0;
5544ad89
DJ
3305}
3306
d50171e4
PA
3307/* Start a step-over operation on LWP. When LWP stopped at a
3308 breakpoint, to make progress, we need to remove the breakpoint out
3309 of the way. If we let other threads run while we do that, they may
3310 pass by the breakpoint location and miss hitting it. To avoid
3311 that, a step-over momentarily stops all threads while LWP is
3312 single-stepped while the breakpoint is temporarily uninserted from
3313 the inferior. When the single-step finishes, we reinsert the
3314 breakpoint, and let all threads that are supposed to be running,
3315 run again.
3316
3317 On targets that don't support hardware single-step, we don't
3318 currently support full software single-stepping. Instead, we only
3319 support stepping over the thread event breakpoint, by asking the
3320 low target where to place a reinsert breakpoint. Since this
3321 routine assumes the breakpoint being stepped over is a thread event
3322 breakpoint, it usually assumes the return address of the current
3323 function is a good enough place to set the reinsert breakpoint. */
3324
3325static int
3326start_step_over (struct lwp_info *lwp)
3327{
3328 struct thread_info *saved_inferior;
3329 CORE_ADDR pc;
3330 int step;
3331
3332 if (debug_threads)
3333 fprintf (stderr,
3334 "Starting step-over on LWP %ld. Stopping all threads\n",
3335 lwpid_of (lwp));
3336
7984d532
PA
3337 stop_all_lwps (1, lwp);
3338 gdb_assert (lwp->suspended == 0);
d50171e4
PA
3339
3340 if (debug_threads)
3341 fprintf (stderr, "Done stopping all threads for step-over.\n");
3342
3343 /* Note, we should always reach here with an already adjusted PC,
3344 either by GDB (if we're resuming due to GDB's request), or by our
3345 caller, if we just finished handling an internal breakpoint GDB
3346 shouldn't care about. */
3347 pc = get_pc (lwp);
3348
3349 saved_inferior = current_inferior;
3350 current_inferior = get_lwp_thread (lwp);
3351
3352 lwp->bp_reinsert = pc;
3353 uninsert_breakpoints_at (pc);
fa593d66 3354 uninsert_fast_tracepoint_jumps_at (pc);
d50171e4
PA
3355
3356 if (can_hardware_single_step ())
3357 {
3358 step = 1;
3359 }
3360 else
3361 {
3362 CORE_ADDR raddr = (*the_low_target.breakpoint_reinsert_addr) ();
3363 set_reinsert_breakpoint (raddr);
3364 step = 0;
3365 }
3366
3367 current_inferior = saved_inferior;
3368
3369 linux_resume_one_lwp (lwp, step, 0, NULL);
3370
3371 /* Require next event from this LWP. */
3372 step_over_bkpt = lwp->head.id;
3373 return 1;
3374}
3375
3376/* Finish a step-over. Reinsert the breakpoint we had uninserted in
3377 start_step_over, if still there, and delete any reinsert
3378 breakpoints we've set, on non hardware single-step targets. */
3379
3380static int
3381finish_step_over (struct lwp_info *lwp)
3382{
3383 if (lwp->bp_reinsert != 0)
3384 {
3385 if (debug_threads)
3386 fprintf (stderr, "Finished step over.\n");
3387
3388 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
3389 may be no breakpoint to reinsert there by now. */
3390 reinsert_breakpoints_at (lwp->bp_reinsert);
fa593d66 3391 reinsert_fast_tracepoint_jumps_at (lwp->bp_reinsert);
d50171e4
PA
3392
3393 lwp->bp_reinsert = 0;
3394
3395 /* Delete any software-single-step reinsert breakpoints. No
3396 longer needed. We don't have to worry about other threads
3397 hitting this trap, and later not being able to explain it,
3398 because we were stepping over a breakpoint, and we hold all
3399 threads but LWP stopped while doing that. */
3400 if (!can_hardware_single_step ())
3401 delete_reinsert_breakpoints ();
3402
3403 step_over_bkpt = null_ptid;
3404 return 1;
3405 }
3406 else
3407 return 0;
3408}
3409
5544ad89
DJ
3410/* This function is called once per thread. We check the thread's resume
3411 request, which will tell us whether to resume, step, or leave the thread
bd99dc85 3412 stopped; and what signal, if any, it should be sent.
5544ad89 3413
bd99dc85
PA
3414 For threads which we aren't explicitly told otherwise, we preserve
3415 the stepping flag; this is used for stepping over gdbserver-placed
3416 breakpoints.
3417
3418 If pending_flags was set in any thread, we queue any needed
3419 signals, since we won't actually resume. We already have a pending
3420 event to report, so we don't need to preserve any step requests;
3421 they should be re-issued if necessary. */
3422
3423static int
3424linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
5544ad89 3425{
54a0b537 3426 struct lwp_info *lwp;
5544ad89 3427 struct thread_info *thread;
bd99dc85 3428 int step;
d50171e4
PA
3429 int leave_all_stopped = * (int *) arg;
3430 int leave_pending;
5544ad89
DJ
3431
3432 thread = (struct thread_info *) entry;
54a0b537 3433 lwp = get_thread_lwp (thread);
5544ad89 3434
2bd7c093 3435 if (lwp->resume == NULL)
bd99dc85 3436 return 0;
5544ad89 3437
bd99dc85 3438 if (lwp->resume->kind == resume_stop)
5544ad89 3439 {
bd99dc85 3440 if (debug_threads)
d50171e4 3441 fprintf (stderr, "resume_stop request for LWP %ld\n", lwpid_of (lwp));
bd99dc85
PA
3442
3443 if (!lwp->stopped)
3444 {
3445 if (debug_threads)
d50171e4 3446 fprintf (stderr, "stopping LWP %ld\n", lwpid_of (lwp));
bd99dc85 3447
d50171e4
PA
3448 /* Stop the thread, and wait for the event asynchronously,
3449 through the event loop. */
02fc4de7 3450 send_sigstop (lwp);
bd99dc85
PA
3451 }
3452 else
3453 {
3454 if (debug_threads)
d50171e4
PA
3455 fprintf (stderr, "already stopped LWP %ld\n",
3456 lwpid_of (lwp));
3457
3458 /* The LWP may have been stopped in an internal event that
3459 was not meant to be notified back to GDB (e.g., gdbserver
3460 breakpoint), so we should be reporting a stop event in
3461 this case too. */
3462
3463 /* If the thread already has a pending SIGSTOP, this is a
3464 no-op. Otherwise, something later will presumably resume
3465 the thread and this will cause it to cancel any pending
3466 operation, due to last_resume_kind == resume_stop. If
3467 the thread already has a pending status to report, we
3468 will still report it the next time we wait - see
3469 status_pending_p_callback. */
1a981360
PA
3470
3471 /* If we already have a pending signal to report, then
3472 there's no need to queue a SIGSTOP, as this means we're
3473 midway through moving the LWP out of the jumppad, and we
3474 will report the pending signal as soon as that is
3475 finished. */
3476 if (lwp->pending_signals_to_report == NULL)
3477 send_sigstop (lwp);
bd99dc85 3478 }
32ca6d61 3479
bd99dc85
PA
3480 /* For stop requests, we're done. */
3481 lwp->resume = NULL;
fc7238bb 3482 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
bd99dc85 3483 return 0;
5544ad89
DJ
3484 }
3485
bd99dc85
PA
3486 /* If this thread which is about to be resumed has a pending status,
3487 then don't resume any threads - we can just report the pending
3488 status. Make sure to queue any signals that would otherwise be
3489 sent. In all-stop mode, we do this decision based on if *any*
d50171e4
PA
3490 thread has a pending status. If there's a thread that needs the
3491 step-over-breakpoint dance, then don't resume any other thread
3492 but that particular one. */
3493 leave_pending = (lwp->status_pending_p || leave_all_stopped);
5544ad89 3494
d50171e4 3495 if (!leave_pending)
bd99dc85
PA
3496 {
3497 if (debug_threads)
3498 fprintf (stderr, "resuming LWP %ld\n", lwpid_of (lwp));
5544ad89 3499
d50171e4 3500 step = (lwp->resume->kind == resume_step);
2acc282a 3501 linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL);
bd99dc85
PA
3502 }
3503 else
3504 {
3505 if (debug_threads)
3506 fprintf (stderr, "leaving LWP %ld stopped\n", lwpid_of (lwp));
5544ad89 3507
bd99dc85
PA
3508 /* If we have a new signal, enqueue the signal. */
3509 if (lwp->resume->sig != 0)
3510 {
3511 struct pending_signals *p_sig;
3512 p_sig = xmalloc (sizeof (*p_sig));
3513 p_sig->prev = lwp->pending_signals;
3514 p_sig->signal = lwp->resume->sig;
3515 memset (&p_sig->info, 0, sizeof (siginfo_t));
3516
3517 /* If this is the same signal we were previously stopped by,
3518 make sure to queue its siginfo. We can ignore the return
3519 value of ptrace; if it fails, we'll skip
3520 PTRACE_SETSIGINFO. */
3521 if (WIFSTOPPED (lwp->last_status)
3522 && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
3523 ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
3524
3525 lwp->pending_signals = p_sig;
3526 }
3527 }
5544ad89 3528
fc7238bb 3529 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
bd99dc85 3530 lwp->resume = NULL;
5544ad89 3531 return 0;
0d62e5e8
DJ
3532}
3533
3534static void
2bd7c093 3535linux_resume (struct thread_resume *resume_info, size_t n)
0d62e5e8 3536{
2bd7c093 3537 struct thread_resume_array array = { resume_info, n };
d50171e4
PA
3538 struct lwp_info *need_step_over = NULL;
3539 int any_pending;
3540 int leave_all_stopped;
c6ecbae5 3541
2bd7c093 3542 find_inferior (&all_threads, linux_set_resume_request, &array);
5544ad89 3543
d50171e4
PA
3544 /* If there is a thread which would otherwise be resumed, which has
3545 a pending status, then don't resume any threads - we can just
3546 report the pending status. Make sure to queue any signals that
3547 would otherwise be sent. In non-stop mode, we'll apply this
3548 logic to each thread individually. We consume all pending events
3549 before considering to start a step-over (in all-stop). */
3550 any_pending = 0;
bd99dc85 3551 if (!non_stop)
d50171e4
PA
3552 find_inferior (&all_lwps, resume_status_pending_p, &any_pending);
3553
3554 /* If there is a thread which would otherwise be resumed, which is
3555 stopped at a breakpoint that needs stepping over, then don't
3556 resume any threads - have it step over the breakpoint with all
3557 other threads stopped, then resume all threads again. Make sure
3558 to queue any signals that would otherwise be delivered or
3559 queued. */
3560 if (!any_pending && supports_breakpoints ())
3561 need_step_over
3562 = (struct lwp_info *) find_inferior (&all_lwps,
3563 need_step_over_p, NULL);
3564
3565 leave_all_stopped = (need_step_over != NULL || any_pending);
3566
3567 if (debug_threads)
3568 {
3569 if (need_step_over != NULL)
3570 fprintf (stderr, "Not resuming all, need step over\n");
3571 else if (any_pending)
3572 fprintf (stderr,
3573 "Not resuming, all-stop and found "
3574 "an LWP with pending status\n");
3575 else
3576 fprintf (stderr, "Resuming, no pending status or step over needed\n");
3577 }
3578
3579 /* Even if we're leaving threads stopped, queue all signals we'd
3580 otherwise deliver. */
3581 find_inferior (&all_threads, linux_resume_one_thread, &leave_all_stopped);
3582
3583 if (need_step_over)
3584 start_step_over (need_step_over);
3585}
3586
3587/* This function is called once per thread. We check the thread's
3588 last resume request, which will tell us whether to resume, step, or
3589 leave the thread stopped. Any signal the client requested to be
3590 delivered has already been enqueued at this point.
3591
3592 If any thread that GDB wants running is stopped at an internal
3593 breakpoint that needs stepping over, we start a step-over operation
3594 on that particular thread, and leave all others stopped. */
3595
7984d532
PA
3596static int
3597proceed_one_lwp (struct inferior_list_entry *entry, void *except)
d50171e4 3598{
7984d532 3599 struct lwp_info *lwp = (struct lwp_info *) entry;
8336d594 3600 struct thread_info *thread;
d50171e4
PA
3601 int step;
3602
7984d532
PA
3603 if (lwp == except)
3604 return 0;
d50171e4
PA
3605
3606 if (debug_threads)
3607 fprintf (stderr,
3608 "proceed_one_lwp: lwp %ld\n", lwpid_of (lwp));
3609
3610 if (!lwp->stopped)
3611 {
3612 if (debug_threads)
3613 fprintf (stderr, " LWP %ld already running\n", lwpid_of (lwp));
7984d532 3614 return 0;
d50171e4
PA
3615 }
3616
8336d594
PA
3617 thread = get_lwp_thread (lwp);
3618
02fc4de7
PA
3619 if (thread->last_resume_kind == resume_stop
3620 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
d50171e4
PA
3621 {
3622 if (debug_threads)
02fc4de7
PA
3623 fprintf (stderr, " client wants LWP to remain %ld stopped\n",
3624 lwpid_of (lwp));
7984d532 3625 return 0;
d50171e4
PA
3626 }
3627
3628 if (lwp->status_pending_p)
3629 {
3630 if (debug_threads)
3631 fprintf (stderr, " LWP %ld has pending status, leaving stopped\n",
3632 lwpid_of (lwp));
7984d532 3633 return 0;
d50171e4
PA
3634 }
3635
7984d532
PA
3636 gdb_assert (lwp->suspended >= 0);
3637
d50171e4
PA
3638 if (lwp->suspended)
3639 {
3640 if (debug_threads)
3641 fprintf (stderr, " LWP %ld is suspended\n", lwpid_of (lwp));
7984d532 3642 return 0;
d50171e4
PA
3643 }
3644
1a981360
PA
3645 if (thread->last_resume_kind == resume_stop
3646 && lwp->pending_signals_to_report == NULL
3647 && lwp->collecting_fast_tracepoint == 0)
02fc4de7
PA
3648 {
3649 /* We haven't reported this LWP as stopped yet (otherwise, the
3650 last_status.kind check above would catch it, and we wouldn't
3651 reach here. This LWP may have been momentarily paused by a
3652 stop_all_lwps call while handling for example, another LWP's
3653 step-over. In that case, the pending expected SIGSTOP signal
3654 that was queued at vCont;t handling time will have already
3655 been consumed by wait_for_sigstop, and so we need to requeue
3656 another one here. Note that if the LWP already has a SIGSTOP
3657 pending, this is a no-op. */
3658
3659 if (debug_threads)
3660 fprintf (stderr,
3661 "Client wants LWP %ld to stop. "
3662 "Making sure it has a SIGSTOP pending\n",
3663 lwpid_of (lwp));
3664
3665 send_sigstop (lwp);
3666 }
3667
8336d594 3668 step = thread->last_resume_kind == resume_step;
d50171e4 3669 linux_resume_one_lwp (lwp, step, 0, NULL);
7984d532
PA
3670 return 0;
3671}
3672
3673static int
3674unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except)
3675{
3676 struct lwp_info *lwp = (struct lwp_info *) entry;
3677
3678 if (lwp == except)
3679 return 0;
3680
3681 lwp->suspended--;
3682 gdb_assert (lwp->suspended >= 0);
3683
3684 return proceed_one_lwp (entry, except);
d50171e4
PA
3685}
3686
3687/* When we finish a step-over, set threads running again. If there's
3688 another thread that may need a step-over, now's the time to start
3689 it. Eventually, we'll move all threads past their breakpoints. */
3690
3691static void
3692proceed_all_lwps (void)
3693{
3694 struct lwp_info *need_step_over;
3695
3696 /* If there is a thread which would otherwise be resumed, which is
3697 stopped at a breakpoint that needs stepping over, then don't
3698 resume any threads - have it step over the breakpoint with all
3699 other threads stopped, then resume all threads again. */
3700
3701 if (supports_breakpoints ())
3702 {
3703 need_step_over
3704 = (struct lwp_info *) find_inferior (&all_lwps,
3705 need_step_over_p, NULL);
3706
3707 if (need_step_over != NULL)
3708 {
3709 if (debug_threads)
3710 fprintf (stderr, "proceed_all_lwps: found "
3711 "thread %ld needing a step-over\n",
3712 lwpid_of (need_step_over));
3713
3714 start_step_over (need_step_over);
3715 return;
3716 }
3717 }
5544ad89 3718
d50171e4
PA
3719 if (debug_threads)
3720 fprintf (stderr, "Proceeding, no step-over needed\n");
3721
7984d532 3722 find_inferior (&all_lwps, proceed_one_lwp, NULL);
d50171e4
PA
3723}
3724
3725/* Stopped LWPs that the client wanted to be running, that don't have
3726 pending statuses, are set to run again, except for EXCEPT, if not
3727 NULL. This undoes a stop_all_lwps call. */
3728
3729static void
7984d532 3730unstop_all_lwps (int unsuspend, struct lwp_info *except)
d50171e4 3731{
5544ad89
DJ
3732 if (debug_threads)
3733 {
d50171e4
PA
3734 if (except)
3735 fprintf (stderr,
3736 "unstopping all lwps, except=(LWP %ld)\n", lwpid_of (except));
5544ad89 3737 else
d50171e4
PA
3738 fprintf (stderr,
3739 "unstopping all lwps\n");
5544ad89
DJ
3740 }
3741
7984d532
PA
3742 if (unsuspend)
3743 find_inferior (&all_lwps, unsuspend_and_proceed_one_lwp, except);
3744 else
3745 find_inferior (&all_lwps, proceed_one_lwp, except);
0d62e5e8
DJ
3746}
3747
3748#ifdef HAVE_LINUX_USRREGS
da6d8c04
DJ
3749
3750int
0a30fbc4 3751register_addr (int regnum)
da6d8c04
DJ
3752{
3753 int addr;
3754
2ec06d2e 3755 if (regnum < 0 || regnum >= the_low_target.num_regs)
da6d8c04
DJ
3756 error ("Invalid register number %d.", regnum);
3757
2ec06d2e 3758 addr = the_low_target.regmap[regnum];
da6d8c04
DJ
3759
3760 return addr;
3761}
3762
58caa3dc 3763/* Fetch one register. */
da6d8c04 3764static void
442ea881 3765fetch_register (struct regcache *regcache, int regno)
da6d8c04
DJ
3766{
3767 CORE_ADDR regaddr;
48d93c75 3768 int i, size;
0d62e5e8 3769 char *buf;
95954743 3770 int pid;
da6d8c04 3771
2ec06d2e 3772 if (regno >= the_low_target.num_regs)
0a30fbc4 3773 return;
2ec06d2e 3774 if ((*the_low_target.cannot_fetch_register) (regno))
0a30fbc4 3775 return;
da6d8c04 3776
0a30fbc4
DJ
3777 regaddr = register_addr (regno);
3778 if (regaddr == -1)
3779 return;
95954743 3780
1b3f6016 3781 size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
50275556 3782 & -sizeof (PTRACE_XFER_TYPE));
48d93c75 3783 buf = alloca (size);
50275556
MR
3784
3785 pid = lwpid_of (get_thread_lwp (current_inferior));
48d93c75 3786 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
da6d8c04
DJ
3787 {
3788 errno = 0;
0d62e5e8 3789 *(PTRACE_XFER_TYPE *) (buf + i) =
14ce3065
DE
3790 ptrace (PTRACE_PEEKUSER, pid,
3791 /* Coerce to a uintptr_t first to avoid potential gcc warning
3792 of coercing an 8 byte integer to a 4 byte pointer. */
3793 (PTRACE_ARG3_TYPE) (uintptr_t) regaddr, 0);
da6d8c04
DJ
3794 regaddr += sizeof (PTRACE_XFER_TYPE);
3795 if (errno != 0)
f52cd8cd 3796 error ("reading register %d: %s", regno, strerror (errno));
da6d8c04 3797 }
ee1a7ae4
UW
3798
3799 if (the_low_target.supply_ptrace_register)
442ea881 3800 the_low_target.supply_ptrace_register (regcache, regno, buf);
5a1f5858 3801 else
442ea881 3802 supply_register (regcache, regno, buf);
da6d8c04
DJ
3803}
3804
7325beb4
MR
3805/* Store one register. */
3806static void
3807store_register (struct regcache *regcache, int regno)
3808{
3809 CORE_ADDR regaddr;
3810 int i, size;
3811 char *buf;
3812 int pid;
3813
3814 if (regno >= the_low_target.num_regs)
3815 return;
50275556 3816 if ((*the_low_target.cannot_store_register) (regno))
7325beb4
MR
3817 return;
3818
3819 regaddr = register_addr (regno);
3820 if (regaddr == -1)
3821 return;
50275556
MR
3822
3823 size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
3824 & -sizeof (PTRACE_XFER_TYPE));
7325beb4
MR
3825 buf = alloca (size);
3826 memset (buf, 0, size);
3827
3828 if (the_low_target.collect_ptrace_register)
3829 the_low_target.collect_ptrace_register (regcache, regno, buf);
3830 else
3831 collect_register (regcache, regno, buf);
3832
3833 pid = lwpid_of (get_thread_lwp (current_inferior));
3834 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
3835 {
3836 errno = 0;
3837 ptrace (PTRACE_POKEUSER, pid,
3838 /* Coerce to a uintptr_t first to avoid potential gcc warning
3839 about coercing an 8 byte integer to a 4 byte pointer. */
3840 (PTRACE_ARG3_TYPE) (uintptr_t) regaddr,
3841 (PTRACE_ARG4_TYPE) *(PTRACE_XFER_TYPE *) (buf + i));
3842 if (errno != 0)
3843 {
3844 /* At this point, ESRCH should mean the process is
3845 already gone, in which case we simply ignore attempts
3846 to change its registers. See also the related
3847 comment in linux_resume_one_lwp. */
3848 if (errno == ESRCH)
3849 return;
3850
3851 if ((*the_low_target.cannot_store_register) (regno) == 0)
3852 error ("writing register %d: %s", regno, strerror (errno));
3853 }
3854 regaddr += sizeof (PTRACE_XFER_TYPE);
3855 }
3856}
3857
da6d8c04 3858/* Fetch all registers, or just one, from the child process. */
58caa3dc 3859static void
442ea881 3860usr_fetch_inferior_registers (struct regcache *regcache, int regno)
da6d8c04 3861{
4463ce24 3862 if (regno == -1)
2ec06d2e 3863 for (regno = 0; regno < the_low_target.num_regs; regno++)
442ea881 3864 fetch_register (regcache, regno);
da6d8c04 3865 else
442ea881 3866 fetch_register (regcache, regno);
da6d8c04
DJ
3867}
3868
3869/* Store our register values back into the inferior.
3870 If REGNO is -1, do this for all registers.
3871 Otherwise, REGNO specifies which register (so we can save time). */
58caa3dc 3872static void
442ea881 3873usr_store_inferior_registers (struct regcache *regcache, int regno)
da6d8c04 3874{
7325beb4 3875 if (regno == -1)
2ec06d2e 3876 for (regno = 0; regno < the_low_target.num_regs; regno++)
7325beb4
MR
3877 store_register (regcache, regno);
3878 else
3879 store_register (regcache, regno);
da6d8c04 3880}
58caa3dc
DJ
3881#endif /* HAVE_LINUX_USRREGS */
3882
3883
3884
3885#ifdef HAVE_LINUX_REGSETS
3886
3887static int
442ea881 3888regsets_fetch_inferior_registers (struct regcache *regcache)
58caa3dc
DJ
3889{
3890 struct regset_info *regset;
e9d25b98 3891 int saw_general_regs = 0;
95954743 3892 int pid;
1570b33e 3893 struct iovec iov;
58caa3dc
DJ
3894
3895 regset = target_regsets;
3896
95954743 3897 pid = lwpid_of (get_thread_lwp (current_inferior));
58caa3dc
DJ
3898 while (regset->size >= 0)
3899 {
1570b33e
L
3900 void *buf, *data;
3901 int nt_type, res;
58caa3dc 3902
52fa2412 3903 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
58caa3dc
DJ
3904 {
3905 regset ++;
3906 continue;
3907 }
3908
bca929d3 3909 buf = xmalloc (regset->size);
1570b33e
L
3910
3911 nt_type = regset->nt_type;
3912 if (nt_type)
3913 {
3914 iov.iov_base = buf;
3915 iov.iov_len = regset->size;
3916 data = (void *) &iov;
3917 }
3918 else
3919 data = buf;
3920
dfb64f85 3921#ifndef __sparc__
1570b33e 3922 res = ptrace (regset->get_request, pid, nt_type, data);
dfb64f85 3923#else
1570b33e 3924 res = ptrace (regset->get_request, pid, data, nt_type);
dfb64f85 3925#endif
58caa3dc
DJ
3926 if (res < 0)
3927 {
3928 if (errno == EIO)
3929 {
52fa2412
UW
3930 /* If we get EIO on a regset, do not try it again for
3931 this process. */
3932 disabled_regsets[regset - target_regsets] = 1;
fdeb2a12 3933 free (buf);
52fa2412 3934 continue;
58caa3dc
DJ
3935 }
3936 else
3937 {
0d62e5e8 3938 char s[256];
95954743
PA
3939 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
3940 pid);
0d62e5e8 3941 perror (s);
58caa3dc
DJ
3942 }
3943 }
e9d25b98
DJ
3944 else if (regset->type == GENERAL_REGS)
3945 saw_general_regs = 1;
442ea881 3946 regset->store_function (regcache, buf);
58caa3dc 3947 regset ++;
fdeb2a12 3948 free (buf);
58caa3dc 3949 }
e9d25b98
DJ
3950 if (saw_general_regs)
3951 return 0;
3952 else
3953 return 1;
58caa3dc
DJ
3954}
3955
3956static int
442ea881 3957regsets_store_inferior_registers (struct regcache *regcache)
58caa3dc
DJ
3958{
3959 struct regset_info *regset;
e9d25b98 3960 int saw_general_regs = 0;
95954743 3961 int pid;
1570b33e 3962 struct iovec iov;
58caa3dc
DJ
3963
3964 regset = target_regsets;
3965
95954743 3966 pid = lwpid_of (get_thread_lwp (current_inferior));
58caa3dc
DJ
3967 while (regset->size >= 0)
3968 {
1570b33e
L
3969 void *buf, *data;
3970 int nt_type, res;
58caa3dc 3971
52fa2412 3972 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
58caa3dc
DJ
3973 {
3974 regset ++;
3975 continue;
3976 }
3977
bca929d3 3978 buf = xmalloc (regset->size);
545587ee
DJ
3979
3980 /* First fill the buffer with the current register set contents,
3981 in case there are any items in the kernel's regset that are
3982 not in gdbserver's regcache. */
1570b33e
L
3983
3984 nt_type = regset->nt_type;
3985 if (nt_type)
3986 {
3987 iov.iov_base = buf;
3988 iov.iov_len = regset->size;
3989 data = (void *) &iov;
3990 }
3991 else
3992 data = buf;
3993
dfb64f85 3994#ifndef __sparc__
1570b33e 3995 res = ptrace (regset->get_request, pid, nt_type, data);
dfb64f85 3996#else
1570b33e 3997 res = ptrace (regset->get_request, pid, &iov, data);
dfb64f85 3998#endif
545587ee
DJ
3999
4000 if (res == 0)
4001 {
4002 /* Then overlay our cached registers on that. */
442ea881 4003 regset->fill_function (regcache, buf);
545587ee
DJ
4004
4005 /* Only now do we write the register set. */
dfb64f85 4006#ifndef __sparc__
1570b33e 4007 res = ptrace (regset->set_request, pid, nt_type, data);
dfb64f85 4008#else
1570b33e 4009 res = ptrace (regset->set_request, pid, data, nt_type);
dfb64f85 4010#endif
545587ee
DJ
4011 }
4012
58caa3dc
DJ
4013 if (res < 0)
4014 {
4015 if (errno == EIO)
4016 {
52fa2412
UW
4017 /* If we get EIO on a regset, do not try it again for
4018 this process. */
4019 disabled_regsets[regset - target_regsets] = 1;
fdeb2a12 4020 free (buf);
52fa2412 4021 continue;
58caa3dc 4022 }
3221518c
UW
4023 else if (errno == ESRCH)
4024 {
1b3f6016
PA
4025 /* At this point, ESRCH should mean the process is
4026 already gone, in which case we simply ignore attempts
4027 to change its registers. See also the related
4028 comment in linux_resume_one_lwp. */
fdeb2a12 4029 free (buf);
3221518c
UW
4030 return 0;
4031 }
58caa3dc
DJ
4032 else
4033 {
ce3a066d 4034 perror ("Warning: ptrace(regsets_store_inferior_registers)");
58caa3dc
DJ
4035 }
4036 }
e9d25b98
DJ
4037 else if (regset->type == GENERAL_REGS)
4038 saw_general_regs = 1;
58caa3dc 4039 regset ++;
09ec9b38 4040 free (buf);
58caa3dc 4041 }
e9d25b98
DJ
4042 if (saw_general_regs)
4043 return 0;
4044 else
4045 return 1;
ce3a066d 4046 return 0;
58caa3dc
DJ
4047}
4048
4049#endif /* HAVE_LINUX_REGSETS */
4050
4051
4052void
442ea881 4053linux_fetch_registers (struct regcache *regcache, int regno)
58caa3dc
DJ
4054{
4055#ifdef HAVE_LINUX_REGSETS
442ea881 4056 if (regsets_fetch_inferior_registers (regcache) == 0)
52fa2412 4057 return;
58caa3dc
DJ
4058#endif
4059#ifdef HAVE_LINUX_USRREGS
442ea881 4060 usr_fetch_inferior_registers (regcache, regno);
58caa3dc
DJ
4061#endif
4062}
4063
4064void
442ea881 4065linux_store_registers (struct regcache *regcache, int regno)
58caa3dc
DJ
4066{
4067#ifdef HAVE_LINUX_REGSETS
442ea881 4068 if (regsets_store_inferior_registers (regcache) == 0)
52fa2412 4069 return;
58caa3dc
DJ
4070#endif
4071#ifdef HAVE_LINUX_USRREGS
442ea881 4072 usr_store_inferior_registers (regcache, regno);
58caa3dc
DJ
4073#endif
4074}
4075
da6d8c04 4076
da6d8c04
DJ
4077/* Copy LEN bytes from inferior's memory starting at MEMADDR
4078 to debugger memory starting at MYADDR. */
4079
c3e735a6 4080static int
f450004a 4081linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
da6d8c04
DJ
4082{
4083 register int i;
4084 /* Round starting address down to longword boundary. */
4085 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
4086 /* Round ending address up; get number of longwords that makes. */
aa691b87
RM
4087 register int count
4088 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
da6d8c04
DJ
4089 / sizeof (PTRACE_XFER_TYPE);
4090 /* Allocate buffer of that many longwords. */
aa691b87 4091 register PTRACE_XFER_TYPE *buffer
da6d8c04 4092 = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
fd462a61
DJ
4093 int fd;
4094 char filename[64];
95954743 4095 int pid = lwpid_of (get_thread_lwp (current_inferior));
fd462a61
DJ
4096
4097 /* Try using /proc. Don't bother for one word. */
4098 if (len >= 3 * sizeof (long))
4099 {
4100 /* We could keep this file open and cache it - possibly one per
4101 thread. That requires some juggling, but is even faster. */
95954743 4102 sprintf (filename, "/proc/%d/mem", pid);
fd462a61
DJ
4103 fd = open (filename, O_RDONLY | O_LARGEFILE);
4104 if (fd == -1)
4105 goto no_proc;
4106
4107 /* If pread64 is available, use it. It's faster if the kernel
4108 supports it (only one syscall), and it's 64-bit safe even on
4109 32-bit platforms (for instance, SPARC debugging a SPARC64
4110 application). */
4111#ifdef HAVE_PREAD64
4112 if (pread64 (fd, myaddr, len, memaddr) != len)
4113#else
1de1badb 4114 if (lseek (fd, memaddr, SEEK_SET) == -1 || read (fd, myaddr, len) != len)
fd462a61
DJ
4115#endif
4116 {
4117 close (fd);
4118 goto no_proc;
4119 }
4120
4121 close (fd);
4122 return 0;
4123 }
da6d8c04 4124
fd462a61 4125 no_proc:
da6d8c04
DJ
4126 /* Read all the longwords */
4127 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
4128 {
c3e735a6 4129 errno = 0;
14ce3065
DE
4130 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
4131 about coercing an 8 byte integer to a 4 byte pointer. */
4132 buffer[i] = ptrace (PTRACE_PEEKTEXT, pid,
4133 (PTRACE_ARG3_TYPE) (uintptr_t) addr, 0);
c3e735a6
DJ
4134 if (errno)
4135 return errno;
da6d8c04
DJ
4136 }
4137
4138 /* Copy appropriate bytes out of the buffer. */
1b3f6016
PA
4139 memcpy (myaddr,
4140 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
4141 len);
c3e735a6
DJ
4142
4143 return 0;
da6d8c04
DJ
4144}
4145
93ae6fdc
PA
4146/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
4147 memory at MEMADDR. On failure (cannot write to the inferior)
da6d8c04
DJ
4148 returns the value of errno. */
4149
ce3a066d 4150static int
f450004a 4151linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
da6d8c04
DJ
4152{
4153 register int i;
4154 /* Round starting address down to longword boundary. */
4155 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
4156 /* Round ending address up; get number of longwords that makes. */
4157 register int count
493e2a69
MS
4158 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
4159 / sizeof (PTRACE_XFER_TYPE);
4160
da6d8c04 4161 /* Allocate buffer of that many longwords. */
493e2a69
MS
4162 register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *)
4163 alloca (count * sizeof (PTRACE_XFER_TYPE));
4164
95954743 4165 int pid = lwpid_of (get_thread_lwp (current_inferior));
da6d8c04 4166
0d62e5e8
DJ
4167 if (debug_threads)
4168 {
58d6951d
DJ
4169 /* Dump up to four bytes. */
4170 unsigned int val = * (unsigned int *) myaddr;
4171 if (len == 1)
4172 val = val & 0xff;
4173 else if (len == 2)
4174 val = val & 0xffff;
4175 else if (len == 3)
4176 val = val & 0xffffff;
4177 fprintf (stderr, "Writing %0*x to 0x%08lx\n", 2 * ((len < 4) ? len : 4),
4178 val, (long)memaddr);
0d62e5e8
DJ
4179 }
4180
da6d8c04
DJ
4181 /* Fill start and end extra bytes of buffer with existing memory data. */
4182
93ae6fdc 4183 errno = 0;
14ce3065
DE
4184 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
4185 about coercing an 8 byte integer to a 4 byte pointer. */
4186 buffer[0] = ptrace (PTRACE_PEEKTEXT, pid,
4187 (PTRACE_ARG3_TYPE) (uintptr_t) addr, 0);
93ae6fdc
PA
4188 if (errno)
4189 return errno;
da6d8c04
DJ
4190
4191 if (count > 1)
4192 {
93ae6fdc 4193 errno = 0;
da6d8c04 4194 buffer[count - 1]
95954743 4195 = ptrace (PTRACE_PEEKTEXT, pid,
14ce3065
DE
4196 /* Coerce to a uintptr_t first to avoid potential gcc warning
4197 about coercing an 8 byte integer to a 4 byte pointer. */
4198 (PTRACE_ARG3_TYPE) (uintptr_t) (addr + (count - 1)
4199 * sizeof (PTRACE_XFER_TYPE)),
d844cde6 4200 0);
93ae6fdc
PA
4201 if (errno)
4202 return errno;
da6d8c04
DJ
4203 }
4204
93ae6fdc 4205 /* Copy data to be written over corresponding part of buffer. */
da6d8c04 4206
493e2a69
MS
4207 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
4208 myaddr, len);
da6d8c04
DJ
4209
4210 /* Write the entire buffer. */
4211
4212 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
4213 {
4214 errno = 0;
14ce3065
DE
4215 ptrace (PTRACE_POKETEXT, pid,
4216 /* Coerce to a uintptr_t first to avoid potential gcc warning
4217 about coercing an 8 byte integer to a 4 byte pointer. */
4218 (PTRACE_ARG3_TYPE) (uintptr_t) addr,
4219 (PTRACE_ARG4_TYPE) buffer[i]);
da6d8c04
DJ
4220 if (errno)
4221 return errno;
4222 }
4223
4224 return 0;
4225}
2f2893d9 4226
6076632b 4227/* Non-zero if the kernel supports PTRACE_O_TRACEFORK. */
24a09b5f
DJ
4228static int linux_supports_tracefork_flag;
4229
1e7fc18c
PA
4230static void
4231linux_enable_event_reporting (int pid)
4232{
4233 if (!linux_supports_tracefork_flag)
4234 return;
4235
4236 ptrace (PTRACE_SETOPTIONS, pid, 0, (PTRACE_ARG4_TYPE) PTRACE_O_TRACECLONE);
4237}
4238
51c2684e 4239/* Helper functions for linux_test_for_tracefork, called via clone (). */
24a09b5f 4240
51c2684e
DJ
4241static int
4242linux_tracefork_grandchild (void *arg)
4243{
4244 _exit (0);
4245}
4246
7407e2de
AS
4247#define STACK_SIZE 4096
4248
51c2684e
DJ
4249static int
4250linux_tracefork_child (void *arg)
24a09b5f
DJ
4251{
4252 ptrace (PTRACE_TRACEME, 0, 0, 0);
4253 kill (getpid (), SIGSTOP);
e4b7f41c
JK
4254
4255#if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
4256
4257 if (fork () == 0)
4258 linux_tracefork_grandchild (NULL);
4259
4260#else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4261
7407e2de
AS
4262#ifdef __ia64__
4263 __clone2 (linux_tracefork_grandchild, arg, STACK_SIZE,
4264 CLONE_VM | SIGCHLD, NULL);
4265#else
a1f2ce7d 4266 clone (linux_tracefork_grandchild, (char *) arg + STACK_SIZE,
7407e2de
AS
4267 CLONE_VM | SIGCHLD, NULL);
4268#endif
e4b7f41c
JK
4269
4270#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4271
24a09b5f
DJ
4272 _exit (0);
4273}
4274
24a09b5f
DJ
4275/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
4276 sure that we can enable the option, and that it had the desired
4277 effect. */
4278
4279static void
4280linux_test_for_tracefork (void)
4281{
4282 int child_pid, ret, status;
4283 long second_pid;
e4b7f41c 4284#if defined(__UCLIBC__) && defined(HAS_NOMMU)
bca929d3 4285 char *stack = xmalloc (STACK_SIZE * 4);
e4b7f41c 4286#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
24a09b5f
DJ
4287
4288 linux_supports_tracefork_flag = 0;
4289
e4b7f41c
JK
4290#if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
4291
4292 child_pid = fork ();
4293 if (child_pid == 0)
4294 linux_tracefork_child (NULL);
4295
4296#else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4297
51c2684e 4298 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
7407e2de
AS
4299#ifdef __ia64__
4300 child_pid = __clone2 (linux_tracefork_child, stack, STACK_SIZE,
4301 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
e4b7f41c 4302#else /* !__ia64__ */
7407e2de
AS
4303 child_pid = clone (linux_tracefork_child, stack + STACK_SIZE,
4304 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
e4b7f41c
JK
4305#endif /* !__ia64__ */
4306
4307#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4308
24a09b5f 4309 if (child_pid == -1)
51c2684e 4310 perror_with_name ("clone");
24a09b5f
DJ
4311
4312 ret = my_waitpid (child_pid, &status, 0);
4313 if (ret == -1)
4314 perror_with_name ("waitpid");
4315 else if (ret != child_pid)
4316 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
4317 if (! WIFSTOPPED (status))
4318 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
4319
14ce3065
DE
4320 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
4321 (PTRACE_ARG4_TYPE) PTRACE_O_TRACEFORK);
24a09b5f
DJ
4322 if (ret != 0)
4323 {
4324 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
4325 if (ret != 0)
4326 {
4327 warning ("linux_test_for_tracefork: failed to kill child");
4328 return;
4329 }
4330
4331 ret = my_waitpid (child_pid, &status, 0);
4332 if (ret != child_pid)
4333 warning ("linux_test_for_tracefork: failed to wait for killed child");
4334 else if (!WIFSIGNALED (status))
4335 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
4336 "killed child", status);
4337
4338 return;
4339 }
4340
4341 ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
4342 if (ret != 0)
4343 warning ("linux_test_for_tracefork: failed to resume child");
4344
4345 ret = my_waitpid (child_pid, &status, 0);
4346
4347 if (ret == child_pid && WIFSTOPPED (status)
4348 && status >> 16 == PTRACE_EVENT_FORK)
4349 {
4350 second_pid = 0;
4351 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
4352 if (ret == 0 && second_pid != 0)
4353 {
4354 int second_status;
4355
4356 linux_supports_tracefork_flag = 1;
4357 my_waitpid (second_pid, &second_status, 0);
4358 ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
4359 if (ret != 0)
4360 warning ("linux_test_for_tracefork: failed to kill second child");
4361 my_waitpid (second_pid, &status, 0);
4362 }
4363 }
4364 else
4365 warning ("linux_test_for_tracefork: unexpected result from waitpid "
4366 "(%d, status 0x%x)", ret, status);
4367
4368 do
4369 {
4370 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
4371 if (ret != 0)
4372 warning ("linux_test_for_tracefork: failed to kill child");
4373 my_waitpid (child_pid, &status, 0);
4374 }
4375 while (WIFSTOPPED (status));
51c2684e 4376
e4b7f41c 4377#if defined(__UCLIBC__) && defined(HAS_NOMMU)
51c2684e 4378 free (stack);
e4b7f41c 4379#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
24a09b5f
DJ
4380}
4381
4382
2f2893d9
DJ
4383static void
4384linux_look_up_symbols (void)
4385{
0d62e5e8 4386#ifdef USE_THREAD_DB
95954743
PA
4387 struct process_info *proc = current_process ();
4388
cdbfd419 4389 if (proc->private->thread_db != NULL)
0d62e5e8
DJ
4390 return;
4391
6076632b
DE
4392 /* If the kernel supports tracing forks then it also supports tracing
4393 clones, and then we don't need to use the magic thread event breakpoint
4394 to learn about threads. */
cdbfd419 4395 thread_db_init (!linux_supports_tracefork_flag);
0d62e5e8
DJ
4396#endif
4397}
4398
e5379b03 4399static void
ef57601b 4400linux_request_interrupt (void)
e5379b03 4401{
a1928bad 4402 extern unsigned long signal_pid;
e5379b03 4403
95954743
PA
4404 if (!ptid_equal (cont_thread, null_ptid)
4405 && !ptid_equal (cont_thread, minus_one_ptid))
e5379b03 4406 {
54a0b537 4407 struct lwp_info *lwp;
bd99dc85 4408 int lwpid;
e5379b03 4409
54a0b537 4410 lwp = get_thread_lwp (current_inferior);
bd99dc85
PA
4411 lwpid = lwpid_of (lwp);
4412 kill_lwp (lwpid, SIGINT);
e5379b03
DJ
4413 }
4414 else
ef57601b 4415 kill_lwp (signal_pid, SIGINT);
e5379b03
DJ
4416}
4417
aa691b87
RM
4418/* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
4419 to debugger memory starting at MYADDR. */
4420
4421static int
f450004a 4422linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len)
aa691b87
RM
4423{
4424 char filename[PATH_MAX];
4425 int fd, n;
95954743 4426 int pid = lwpid_of (get_thread_lwp (current_inferior));
aa691b87 4427
6cebaf6e 4428 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
aa691b87
RM
4429
4430 fd = open (filename, O_RDONLY);
4431 if (fd < 0)
4432 return -1;
4433
4434 if (offset != (CORE_ADDR) 0
4435 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4436 n = -1;
4437 else
4438 n = read (fd, myaddr, len);
4439
4440 close (fd);
4441
4442 return n;
4443}
4444
d993e290
PA
4445/* These breakpoint and watchpoint related wrapper functions simply
4446 pass on the function call if the target has registered a
4447 corresponding function. */
e013ee27
OF
4448
4449static int
d993e290 4450linux_insert_point (char type, CORE_ADDR addr, int len)
e013ee27 4451{
d993e290
PA
4452 if (the_low_target.insert_point != NULL)
4453 return the_low_target.insert_point (type, addr, len);
e013ee27
OF
4454 else
4455 /* Unsupported (see target.h). */
4456 return 1;
4457}
4458
4459static int
d993e290 4460linux_remove_point (char type, CORE_ADDR addr, int len)
e013ee27 4461{
d993e290
PA
4462 if (the_low_target.remove_point != NULL)
4463 return the_low_target.remove_point (type, addr, len);
e013ee27
OF
4464 else
4465 /* Unsupported (see target.h). */
4466 return 1;
4467}
4468
4469static int
4470linux_stopped_by_watchpoint (void)
4471{
c3adc08c
PA
4472 struct lwp_info *lwp = get_thread_lwp (current_inferior);
4473
4474 return lwp->stopped_by_watchpoint;
e013ee27
OF
4475}
4476
4477static CORE_ADDR
4478linux_stopped_data_address (void)
4479{
c3adc08c
PA
4480 struct lwp_info *lwp = get_thread_lwp (current_inferior);
4481
4482 return lwp->stopped_data_address;
e013ee27
OF
4483}
4484
42c81e2a 4485#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437
NS
4486#if defined(__mcoldfire__)
4487/* These should really be defined in the kernel's ptrace.h header. */
4488#define PT_TEXT_ADDR 49*4
4489#define PT_DATA_ADDR 50*4
4490#define PT_TEXT_END_ADDR 51*4
eb826dc6
MF
4491#elif defined(BFIN)
4492#define PT_TEXT_ADDR 220
4493#define PT_TEXT_END_ADDR 224
4494#define PT_DATA_ADDR 228
58dbd541
YQ
4495#elif defined(__TMS320C6X__)
4496#define PT_TEXT_ADDR (0x10000*4)
4497#define PT_DATA_ADDR (0x10004*4)
4498#define PT_TEXT_END_ADDR (0x10008*4)
52fb6437
NS
4499#endif
4500
4501/* Under uClinux, programs are loaded at non-zero offsets, which we need
4502 to tell gdb about. */
4503
4504static int
4505linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
4506{
4507#if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
4508 unsigned long text, text_end, data;
bd99dc85 4509 int pid = lwpid_of (get_thread_lwp (current_inferior));
52fb6437
NS
4510
4511 errno = 0;
4512
4513 text = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_ADDR, 0);
4514 text_end = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_END_ADDR, 0);
4515 data = ptrace (PTRACE_PEEKUSER, pid, (long)PT_DATA_ADDR, 0);
4516
4517 if (errno == 0)
4518 {
4519 /* Both text and data offsets produced at compile-time (and so
1b3f6016
PA
4520 used by gdb) are relative to the beginning of the program,
4521 with the data segment immediately following the text segment.
4522 However, the actual runtime layout in memory may put the data
4523 somewhere else, so when we send gdb a data base-address, we
4524 use the real data base address and subtract the compile-time
4525 data base-address from it (which is just the length of the
4526 text segment). BSS immediately follows data in both
4527 cases. */
52fb6437
NS
4528 *text_p = text;
4529 *data_p = data - (text_end - text);
1b3f6016 4530
52fb6437
NS
4531 return 1;
4532 }
4533#endif
4534 return 0;
4535}
4536#endif
4537
07e059b5
VP
4538static int
4539linux_qxfer_osdata (const char *annex,
1b3f6016
PA
4540 unsigned char *readbuf, unsigned const char *writebuf,
4541 CORE_ADDR offset, int len)
07e059b5 4542{
d26e3629 4543 return linux_common_xfer_osdata (annex, readbuf, offset, len);
07e059b5
VP
4544}
4545
d0722149
DE
4546/* Convert a native/host siginfo object, into/from the siginfo in the
4547 layout of the inferiors' architecture. */
4548
4549static void
4550siginfo_fixup (struct siginfo *siginfo, void *inf_siginfo, int direction)
4551{
4552 int done = 0;
4553
4554 if (the_low_target.siginfo_fixup != NULL)
4555 done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
4556
4557 /* If there was no callback, or the callback didn't do anything,
4558 then just do a straight memcpy. */
4559 if (!done)
4560 {
4561 if (direction == 1)
4562 memcpy (siginfo, inf_siginfo, sizeof (struct siginfo));
4563 else
4564 memcpy (inf_siginfo, siginfo, sizeof (struct siginfo));
4565 }
4566}
4567
4aa995e1
PA
4568static int
4569linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
4570 unsigned const char *writebuf, CORE_ADDR offset, int len)
4571{
d0722149 4572 int pid;
4aa995e1 4573 struct siginfo siginfo;
d0722149 4574 char inf_siginfo[sizeof (struct siginfo)];
4aa995e1
PA
4575
4576 if (current_inferior == NULL)
4577 return -1;
4578
bd99dc85 4579 pid = lwpid_of (get_thread_lwp (current_inferior));
4aa995e1
PA
4580
4581 if (debug_threads)
d0722149 4582 fprintf (stderr, "%s siginfo for lwp %d.\n",
4aa995e1
PA
4583 readbuf != NULL ? "Reading" : "Writing",
4584 pid);
4585
0adea5f7 4586 if (offset >= sizeof (siginfo))
4aa995e1
PA
4587 return -1;
4588
4589 if (ptrace (PTRACE_GETSIGINFO, pid, 0, &siginfo) != 0)
4590 return -1;
4591
d0722149
DE
4592 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
4593 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
4594 inferior with a 64-bit GDBSERVER should look the same as debugging it
4595 with a 32-bit GDBSERVER, we need to convert it. */
4596 siginfo_fixup (&siginfo, inf_siginfo, 0);
4597
4aa995e1
PA
4598 if (offset + len > sizeof (siginfo))
4599 len = sizeof (siginfo) - offset;
4600
4601 if (readbuf != NULL)
d0722149 4602 memcpy (readbuf, inf_siginfo + offset, len);
4aa995e1
PA
4603 else
4604 {
d0722149
DE
4605 memcpy (inf_siginfo + offset, writebuf, len);
4606
4607 /* Convert back to ptrace layout before flushing it out. */
4608 siginfo_fixup (&siginfo, inf_siginfo, 1);
4609
4aa995e1
PA
4610 if (ptrace (PTRACE_SETSIGINFO, pid, 0, &siginfo) != 0)
4611 return -1;
4612 }
4613
4614 return len;
4615}
4616
bd99dc85
PA
4617/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4618 so we notice when children change state; as the handler for the
4619 sigsuspend in my_waitpid. */
4620
4621static void
4622sigchld_handler (int signo)
4623{
4624 int old_errno = errno;
4625
4626 if (debug_threads)
e581f2b4
PA
4627 {
4628 do
4629 {
4630 /* fprintf is not async-signal-safe, so call write
4631 directly. */
4632 if (write (2, "sigchld_handler\n",
4633 sizeof ("sigchld_handler\n") - 1) < 0)
4634 break; /* just ignore */
4635 } while (0);
4636 }
bd99dc85
PA
4637
4638 if (target_is_async_p ())
4639 async_file_mark (); /* trigger a linux_wait */
4640
4641 errno = old_errno;
4642}
4643
4644static int
4645linux_supports_non_stop (void)
4646{
4647 return 1;
4648}
4649
4650static int
4651linux_async (int enable)
4652{
4653 int previous = (linux_event_pipe[0] != -1);
4654
8336d594
PA
4655 if (debug_threads)
4656 fprintf (stderr, "linux_async (%d), previous=%d\n",
4657 enable, previous);
4658
bd99dc85
PA
4659 if (previous != enable)
4660 {
4661 sigset_t mask;
4662 sigemptyset (&mask);
4663 sigaddset (&mask, SIGCHLD);
4664
4665 sigprocmask (SIG_BLOCK, &mask, NULL);
4666
4667 if (enable)
4668 {
4669 if (pipe (linux_event_pipe) == -1)
4670 fatal ("creating event pipe failed.");
4671
4672 fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
4673 fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
4674
4675 /* Register the event loop handler. */
4676 add_file_handler (linux_event_pipe[0],
4677 handle_target_event, NULL);
4678
4679 /* Always trigger a linux_wait. */
4680 async_file_mark ();
4681 }
4682 else
4683 {
4684 delete_file_handler (linux_event_pipe[0]);
4685
4686 close (linux_event_pipe[0]);
4687 close (linux_event_pipe[1]);
4688 linux_event_pipe[0] = -1;
4689 linux_event_pipe[1] = -1;
4690 }
4691
4692 sigprocmask (SIG_UNBLOCK, &mask, NULL);
4693 }
4694
4695 return previous;
4696}
4697
4698static int
4699linux_start_non_stop (int nonstop)
4700{
4701 /* Register or unregister from event-loop accordingly. */
4702 linux_async (nonstop);
4703 return 0;
4704}
4705
cf8fd78b
PA
4706static int
4707linux_supports_multi_process (void)
4708{
4709 return 1;
4710}
4711
03583c20
UW
4712static int
4713linux_supports_disable_randomization (void)
4714{
4715#ifdef HAVE_PERSONALITY
4716 return 1;
4717#else
4718 return 0;
4719#endif
4720}
efcbbd14
UW
4721
4722/* Enumerate spufs IDs for process PID. */
4723static int
4724spu_enumerate_spu_ids (long pid, unsigned char *buf, CORE_ADDR offset, int len)
4725{
4726 int pos = 0;
4727 int written = 0;
4728 char path[128];
4729 DIR *dir;
4730 struct dirent *entry;
4731
4732 sprintf (path, "/proc/%ld/fd", pid);
4733 dir = opendir (path);
4734 if (!dir)
4735 return -1;
4736
4737 rewinddir (dir);
4738 while ((entry = readdir (dir)) != NULL)
4739 {
4740 struct stat st;
4741 struct statfs stfs;
4742 int fd;
4743
4744 fd = atoi (entry->d_name);
4745 if (!fd)
4746 continue;
4747
4748 sprintf (path, "/proc/%ld/fd/%d", pid, fd);
4749 if (stat (path, &st) != 0)
4750 continue;
4751 if (!S_ISDIR (st.st_mode))
4752 continue;
4753
4754 if (statfs (path, &stfs) != 0)
4755 continue;
4756 if (stfs.f_type != SPUFS_MAGIC)
4757 continue;
4758
4759 if (pos >= offset && pos + 4 <= offset + len)
4760 {
4761 *(unsigned int *)(buf + pos - offset) = fd;
4762 written += 4;
4763 }
4764 pos += 4;
4765 }
4766
4767 closedir (dir);
4768 return written;
4769}
4770
4771/* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
4772 object type, using the /proc file system. */
4773static int
4774linux_qxfer_spu (const char *annex, unsigned char *readbuf,
4775 unsigned const char *writebuf,
4776 CORE_ADDR offset, int len)
4777{
4778 long pid = lwpid_of (get_thread_lwp (current_inferior));
4779 char buf[128];
4780 int fd = 0;
4781 int ret = 0;
4782
4783 if (!writebuf && !readbuf)
4784 return -1;
4785
4786 if (!*annex)
4787 {
4788 if (!readbuf)
4789 return -1;
4790 else
4791 return spu_enumerate_spu_ids (pid, readbuf, offset, len);
4792 }
4793
4794 sprintf (buf, "/proc/%ld/fd/%s", pid, annex);
4795 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
4796 if (fd <= 0)
4797 return -1;
4798
4799 if (offset != 0
4800 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4801 {
4802 close (fd);
4803 return 0;
4804 }
4805
4806 if (writebuf)
4807 ret = write (fd, writebuf, (size_t) len);
4808 else
4809 ret = read (fd, readbuf, (size_t) len);
4810
4811 close (fd);
4812 return ret;
4813}
4814
723b724b 4815#if defined PT_GETDSBT || defined PTRACE_GETFDPIC
78d85199
YQ
4816struct target_loadseg
4817{
4818 /* Core address to which the segment is mapped. */
4819 Elf32_Addr addr;
4820 /* VMA recorded in the program header. */
4821 Elf32_Addr p_vaddr;
4822 /* Size of this segment in memory. */
4823 Elf32_Word p_memsz;
4824};
4825
723b724b 4826# if defined PT_GETDSBT
78d85199
YQ
4827struct target_loadmap
4828{
4829 /* Protocol version number, must be zero. */
4830 Elf32_Word version;
4831 /* Pointer to the DSBT table, its size, and the DSBT index. */
4832 unsigned *dsbt_table;
4833 unsigned dsbt_size, dsbt_index;
4834 /* Number of segments in this map. */
4835 Elf32_Word nsegs;
4836 /* The actual memory map. */
4837 struct target_loadseg segs[/*nsegs*/];
4838};
723b724b
MF
4839# define LINUX_LOADMAP PT_GETDSBT
4840# define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
4841# define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
4842# else
4843struct target_loadmap
4844{
4845 /* Protocol version number, must be zero. */
4846 Elf32_Half version;
4847 /* Number of segments in this map. */
4848 Elf32_Half nsegs;
4849 /* The actual memory map. */
4850 struct target_loadseg segs[/*nsegs*/];
4851};
4852# define LINUX_LOADMAP PTRACE_GETFDPIC
4853# define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
4854# define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
4855# endif
78d85199 4856
78d85199
YQ
4857static int
4858linux_read_loadmap (const char *annex, CORE_ADDR offset,
4859 unsigned char *myaddr, unsigned int len)
4860{
4861 int pid = lwpid_of (get_thread_lwp (current_inferior));
4862 int addr = -1;
4863 struct target_loadmap *data = NULL;
4864 unsigned int actual_length, copy_length;
4865
4866 if (strcmp (annex, "exec") == 0)
723b724b 4867 addr = (int) LINUX_LOADMAP_EXEC;
78d85199 4868 else if (strcmp (annex, "interp") == 0)
723b724b 4869 addr = (int) LINUX_LOADMAP_INTERP;
78d85199
YQ
4870 else
4871 return -1;
4872
723b724b 4873 if (ptrace (LINUX_LOADMAP, pid, addr, &data) != 0)
78d85199
YQ
4874 return -1;
4875
4876 if (data == NULL)
4877 return -1;
4878
4879 actual_length = sizeof (struct target_loadmap)
4880 + sizeof (struct target_loadseg) * data->nsegs;
4881
4882 if (offset < 0 || offset > actual_length)
4883 return -1;
4884
4885 copy_length = actual_length - offset < len ? actual_length - offset : len;
4886 memcpy (myaddr, (char *) data + offset, copy_length);
4887 return copy_length;
4888}
723b724b
MF
4889#else
4890# define linux_read_loadmap NULL
4891#endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
78d85199 4892
1570b33e
L
4893static void
4894linux_process_qsupported (const char *query)
4895{
4896 if (the_low_target.process_qsupported != NULL)
4897 the_low_target.process_qsupported (query);
4898}
4899
219f2f23
PA
4900static int
4901linux_supports_tracepoints (void)
4902{
4903 if (*the_low_target.supports_tracepoints == NULL)
4904 return 0;
4905
4906 return (*the_low_target.supports_tracepoints) ();
4907}
4908
4909static CORE_ADDR
4910linux_read_pc (struct regcache *regcache)
4911{
4912 if (the_low_target.get_pc == NULL)
4913 return 0;
4914
4915 return (*the_low_target.get_pc) (regcache);
4916}
4917
4918static void
4919linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
4920{
4921 gdb_assert (the_low_target.set_pc != NULL);
4922
4923 (*the_low_target.set_pc) (regcache, pc);
4924}
4925
8336d594
PA
4926static int
4927linux_thread_stopped (struct thread_info *thread)
4928{
4929 return get_thread_lwp (thread)->stopped;
4930}
4931
4932/* This exposes stop-all-threads functionality to other modules. */
4933
4934static void
7984d532 4935linux_pause_all (int freeze)
8336d594 4936{
7984d532
PA
4937 stop_all_lwps (freeze, NULL);
4938}
4939
4940/* This exposes unstop-all-threads functionality to other gdbserver
4941 modules. */
4942
4943static void
4944linux_unpause_all (int unfreeze)
4945{
4946 unstop_all_lwps (unfreeze, NULL);
8336d594
PA
4947}
4948
90d74c30
PA
4949static int
4950linux_prepare_to_access_memory (void)
4951{
4952 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
4953 running LWP. */
4954 if (non_stop)
4955 linux_pause_all (1);
4956 return 0;
4957}
4958
4959static void
0146f85b 4960linux_done_accessing_memory (void)
90d74c30
PA
4961{
4962 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
4963 running LWP. */
4964 if (non_stop)
4965 linux_unpause_all (1);
4966}
4967
fa593d66
PA
4968static int
4969linux_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, CORE_ADDR tpaddr,
4970 CORE_ADDR collector,
4971 CORE_ADDR lockaddr,
4972 ULONGEST orig_size,
4973 CORE_ADDR *jump_entry,
405f8e94
SS
4974 CORE_ADDR *trampoline,
4975 ULONGEST *trampoline_size,
fa593d66
PA
4976 unsigned char *jjump_pad_insn,
4977 ULONGEST *jjump_pad_insn_size,
4978 CORE_ADDR *adjusted_insn_addr,
405f8e94
SS
4979 CORE_ADDR *adjusted_insn_addr_end,
4980 char *err)
fa593d66
PA
4981{
4982 return (*the_low_target.install_fast_tracepoint_jump_pad)
4983 (tpoint, tpaddr, collector, lockaddr, orig_size,
405f8e94
SS
4984 jump_entry, trampoline, trampoline_size,
4985 jjump_pad_insn, jjump_pad_insn_size,
4986 adjusted_insn_addr, adjusted_insn_addr_end,
4987 err);
fa593d66
PA
4988}
4989
6a271cae
PA
4990static struct emit_ops *
4991linux_emit_ops (void)
4992{
4993 if (the_low_target.emit_ops != NULL)
4994 return (*the_low_target.emit_ops) ();
4995 else
4996 return NULL;
4997}
4998
405f8e94
SS
4999static int
5000linux_get_min_fast_tracepoint_insn_len (void)
5001{
5002 return (*the_low_target.get_min_fast_tracepoint_insn_len) ();
5003}
5004
2268b414
JK
5005/* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
5006
5007static int
5008get_phdr_phnum_from_proc_auxv (const int pid, const int is_elf64,
5009 CORE_ADDR *phdr_memaddr, int *num_phdr)
5010{
5011 char filename[PATH_MAX];
5012 int fd;
5013 const int auxv_size = is_elf64
5014 ? sizeof (Elf64_auxv_t) : sizeof (Elf32_auxv_t);
5015 char buf[sizeof (Elf64_auxv_t)]; /* The larger of the two. */
5016
5017 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
5018
5019 fd = open (filename, O_RDONLY);
5020 if (fd < 0)
5021 return 1;
5022
5023 *phdr_memaddr = 0;
5024 *num_phdr = 0;
5025 while (read (fd, buf, auxv_size) == auxv_size
5026 && (*phdr_memaddr == 0 || *num_phdr == 0))
5027 {
5028 if (is_elf64)
5029 {
5030 Elf64_auxv_t *const aux = (Elf64_auxv_t *) buf;
5031
5032 switch (aux->a_type)
5033 {
5034 case AT_PHDR:
5035 *phdr_memaddr = aux->a_un.a_val;
5036 break;
5037 case AT_PHNUM:
5038 *num_phdr = aux->a_un.a_val;
5039 break;
5040 }
5041 }
5042 else
5043 {
5044 Elf32_auxv_t *const aux = (Elf32_auxv_t *) buf;
5045
5046 switch (aux->a_type)
5047 {
5048 case AT_PHDR:
5049 *phdr_memaddr = aux->a_un.a_val;
5050 break;
5051 case AT_PHNUM:
5052 *num_phdr = aux->a_un.a_val;
5053 break;
5054 }
5055 }
5056 }
5057
5058 close (fd);
5059
5060 if (*phdr_memaddr == 0 || *num_phdr == 0)
5061 {
5062 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
5063 "phdr_memaddr = %ld, phdr_num = %d",
5064 (long) *phdr_memaddr, *num_phdr);
5065 return 2;
5066 }
5067
5068 return 0;
5069}
5070
5071/* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
5072
5073static CORE_ADDR
5074get_dynamic (const int pid, const int is_elf64)
5075{
5076 CORE_ADDR phdr_memaddr, relocation;
5077 int num_phdr, i;
5078 unsigned char *phdr_buf;
5079 const int phdr_size = is_elf64 ? sizeof (Elf64_Phdr) : sizeof (Elf32_Phdr);
5080
5081 if (get_phdr_phnum_from_proc_auxv (pid, is_elf64, &phdr_memaddr, &num_phdr))
5082 return 0;
5083
5084 gdb_assert (num_phdr < 100); /* Basic sanity check. */
5085 phdr_buf = alloca (num_phdr * phdr_size);
5086
5087 if (linux_read_memory (phdr_memaddr, phdr_buf, num_phdr * phdr_size))
5088 return 0;
5089
5090 /* Compute relocation: it is expected to be 0 for "regular" executables,
5091 non-zero for PIE ones. */
5092 relocation = -1;
5093 for (i = 0; relocation == -1 && i < num_phdr; i++)
5094 if (is_elf64)
5095 {
5096 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
5097
5098 if (p->p_type == PT_PHDR)
5099 relocation = phdr_memaddr - p->p_vaddr;
5100 }
5101 else
5102 {
5103 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
5104
5105 if (p->p_type == PT_PHDR)
5106 relocation = phdr_memaddr - p->p_vaddr;
5107 }
5108
5109 if (relocation == -1)
5110 {
5111 warning ("Unexpected missing PT_PHDR");
5112 return 0;
5113 }
5114
5115 for (i = 0; i < num_phdr; i++)
5116 {
5117 if (is_elf64)
5118 {
5119 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
5120
5121 if (p->p_type == PT_DYNAMIC)
5122 return p->p_vaddr + relocation;
5123 }
5124 else
5125 {
5126 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
5127
5128 if (p->p_type == PT_DYNAMIC)
5129 return p->p_vaddr + relocation;
5130 }
5131 }
5132
5133 return 0;
5134}
5135
5136/* Return &_r_debug in the inferior, or -1 if not present. Return value
5137 can be 0 if the inferior does not yet have the library list initialized. */
5138
5139static CORE_ADDR
5140get_r_debug (const int pid, const int is_elf64)
5141{
5142 CORE_ADDR dynamic_memaddr;
5143 const int dyn_size = is_elf64 ? sizeof (Elf64_Dyn) : sizeof (Elf32_Dyn);
5144 unsigned char buf[sizeof (Elf64_Dyn)]; /* The larger of the two. */
5145
5146 dynamic_memaddr = get_dynamic (pid, is_elf64);
5147 if (dynamic_memaddr == 0)
5148 return (CORE_ADDR) -1;
5149
5150 while (linux_read_memory (dynamic_memaddr, buf, dyn_size) == 0)
5151 {
5152 if (is_elf64)
5153 {
5154 Elf64_Dyn *const dyn = (Elf64_Dyn *) buf;
5155
5156 if (dyn->d_tag == DT_DEBUG)
5157 return dyn->d_un.d_val;
5158
5159 if (dyn->d_tag == DT_NULL)
5160 break;
5161 }
5162 else
5163 {
5164 Elf32_Dyn *const dyn = (Elf32_Dyn *) buf;
5165
5166 if (dyn->d_tag == DT_DEBUG)
5167 return dyn->d_un.d_val;
5168
5169 if (dyn->d_tag == DT_NULL)
5170 break;
5171 }
5172
5173 dynamic_memaddr += dyn_size;
5174 }
5175
5176 return (CORE_ADDR) -1;
5177}
5178
5179/* Read one pointer from MEMADDR in the inferior. */
5180
5181static int
5182read_one_ptr (CORE_ADDR memaddr, CORE_ADDR *ptr, int ptr_size)
5183{
5184 *ptr = 0;
5185 return linux_read_memory (memaddr, (unsigned char *) ptr, ptr_size);
5186}
5187
5188struct link_map_offsets
5189 {
5190 /* Offset and size of r_debug.r_version. */
5191 int r_version_offset;
5192
5193 /* Offset and size of r_debug.r_map. */
5194 int r_map_offset;
5195
5196 /* Offset to l_addr field in struct link_map. */
5197 int l_addr_offset;
5198
5199 /* Offset to l_name field in struct link_map. */
5200 int l_name_offset;
5201
5202 /* Offset to l_ld field in struct link_map. */
5203 int l_ld_offset;
5204
5205 /* Offset to l_next field in struct link_map. */
5206 int l_next_offset;
5207
5208 /* Offset to l_prev field in struct link_map. */
5209 int l_prev_offset;
5210 };
5211
5212/* Construct qXfer:libraries:read reply. */
5213
5214static int
5215linux_qxfer_libraries_svr4 (const char *annex, unsigned char *readbuf,
5216 unsigned const char *writebuf,
5217 CORE_ADDR offset, int len)
5218{
5219 char *document;
5220 unsigned document_len;
5221 struct process_info_private *const priv = current_process ()->private;
5222 char filename[PATH_MAX];
5223 int pid, is_elf64;
5224
5225 static const struct link_map_offsets lmo_32bit_offsets =
5226 {
5227 0, /* r_version offset. */
5228 4, /* r_debug.r_map offset. */
5229 0, /* l_addr offset in link_map. */
5230 4, /* l_name offset in link_map. */
5231 8, /* l_ld offset in link_map. */
5232 12, /* l_next offset in link_map. */
5233 16 /* l_prev offset in link_map. */
5234 };
5235
5236 static const struct link_map_offsets lmo_64bit_offsets =
5237 {
5238 0, /* r_version offset. */
5239 8, /* r_debug.r_map offset. */
5240 0, /* l_addr offset in link_map. */
5241 8, /* l_name offset in link_map. */
5242 16, /* l_ld offset in link_map. */
5243 24, /* l_next offset in link_map. */
5244 32 /* l_prev offset in link_map. */
5245 };
5246 const struct link_map_offsets *lmo;
5247
5248 if (writebuf != NULL)
5249 return -2;
5250 if (readbuf == NULL)
5251 return -1;
5252
5253 pid = lwpid_of (get_thread_lwp (current_inferior));
5254 xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
5255 is_elf64 = elf_64_file_p (filename);
5256 lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
5257
5258 if (priv->r_debug == 0)
5259 priv->r_debug = get_r_debug (pid, is_elf64);
5260
5261 if (priv->r_debug == (CORE_ADDR) -1 || priv->r_debug == 0)
5262 {
5263 document = xstrdup ("<library-list-svr4 version=\"1.0\"/>\n");
5264 }
5265 else
5266 {
5267 int allocated = 1024;
5268 char *p;
5269 const int ptr_size = is_elf64 ? 8 : 4;
5270 CORE_ADDR lm_addr, lm_prev, l_name, l_addr, l_ld, l_next, l_prev;
5271 int r_version, header_done = 0;
5272
5273 document = xmalloc (allocated);
5274 strcpy (document, "<library-list-svr4 version=\"1.0\"");
5275 p = document + strlen (document);
5276
5277 r_version = 0;
5278 if (linux_read_memory (priv->r_debug + lmo->r_version_offset,
5279 (unsigned char *) &r_version,
5280 sizeof (r_version)) != 0
5281 || r_version != 1)
5282 {
5283 warning ("unexpected r_debug version %d", r_version);
5284 goto done;
5285 }
5286
5287 if (read_one_ptr (priv->r_debug + lmo->r_map_offset,
5288 &lm_addr, ptr_size) != 0)
5289 {
5290 warning ("unable to read r_map from 0x%lx",
5291 (long) priv->r_debug + lmo->r_map_offset);
5292 goto done;
5293 }
5294
5295 lm_prev = 0;
5296 while (read_one_ptr (lm_addr + lmo->l_name_offset,
5297 &l_name, ptr_size) == 0
5298 && read_one_ptr (lm_addr + lmo->l_addr_offset,
5299 &l_addr, ptr_size) == 0
5300 && read_one_ptr (lm_addr + lmo->l_ld_offset,
5301 &l_ld, ptr_size) == 0
5302 && read_one_ptr (lm_addr + lmo->l_prev_offset,
5303 &l_prev, ptr_size) == 0
5304 && read_one_ptr (lm_addr + lmo->l_next_offset,
5305 &l_next, ptr_size) == 0)
5306 {
5307 unsigned char libname[PATH_MAX];
5308
5309 if (lm_prev != l_prev)
5310 {
5311 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
5312 (long) lm_prev, (long) l_prev);
5313 break;
5314 }
5315
5316 /* Not checking for error because reading may stop before
5317 we've got PATH_MAX worth of characters. */
5318 libname[0] = '\0';
5319 linux_read_memory (l_name, libname, sizeof (libname) - 1);
5320 libname[sizeof (libname) - 1] = '\0';
5321 if (libname[0] != '\0')
5322 {
5323 /* 6x the size for xml_escape_text below. */
5324 size_t len = 6 * strlen ((char *) libname);
5325 char *name;
5326
5327 if (!header_done)
5328 {
5329 /* Terminate `<library-list-svr4'. */
5330 *p++ = '>';
5331 header_done = 1;
5332 }
5333
5334 while (allocated < p - document + len + 200)
5335 {
5336 /* Expand to guarantee sufficient storage. */
5337 uintptr_t document_len = p - document;
5338
5339 document = xrealloc (document, 2 * allocated);
5340 allocated *= 2;
5341 p = document + document_len;
5342 }
5343
5344 name = xml_escape_text ((char *) libname);
5345 p += sprintf (p, "<library name=\"%s\" lm=\"0x%lx\" "
5346 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
5347 name, (unsigned long) lm_addr,
5348 (unsigned long) l_addr, (unsigned long) l_ld);
5349 free (name);
5350 }
5351 else if (lm_prev == 0)
5352 {
5353 sprintf (p, " main-lm=\"0x%lx\"", (unsigned long) lm_addr);
5354 p = p + strlen (p);
5355 }
5356
5357 if (l_next == 0)
5358 break;
5359
5360 lm_prev = lm_addr;
5361 lm_addr = l_next;
5362 }
5363 done:
5364 strcpy (p, "</library-list-svr4>");
5365 }
5366
5367 document_len = strlen (document);
5368 if (offset < document_len)
5369 document_len -= offset;
5370 else
5371 document_len = 0;
5372 if (len > document_len)
5373 len = document_len;
5374
5375 memcpy (readbuf, document + offset, len);
5376 xfree (document);
5377
5378 return len;
5379}
5380
ce3a066d
DJ
5381static struct target_ops linux_target_ops = {
5382 linux_create_inferior,
5383 linux_attach,
5384 linux_kill,
6ad8ae5c 5385 linux_detach,
8336d594 5386 linux_mourn,
444d6139 5387 linux_join,
ce3a066d
DJ
5388 linux_thread_alive,
5389 linux_resume,
5390 linux_wait,
5391 linux_fetch_registers,
5392 linux_store_registers,
90d74c30 5393 linux_prepare_to_access_memory,
0146f85b 5394 linux_done_accessing_memory,
ce3a066d
DJ
5395 linux_read_memory,
5396 linux_write_memory,
2f2893d9 5397 linux_look_up_symbols,
ef57601b 5398 linux_request_interrupt,
aa691b87 5399 linux_read_auxv,
d993e290
PA
5400 linux_insert_point,
5401 linux_remove_point,
e013ee27
OF
5402 linux_stopped_by_watchpoint,
5403 linux_stopped_data_address,
42c81e2a 5404#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437 5405 linux_read_offsets,
dae5f5cf
DJ
5406#else
5407 NULL,
5408#endif
5409#ifdef USE_THREAD_DB
5410 thread_db_get_tls_address,
5411#else
5412 NULL,
52fb6437 5413#endif
efcbbd14 5414 linux_qxfer_spu,
59a016f0 5415 hostio_last_error_from_errno,
07e059b5 5416 linux_qxfer_osdata,
4aa995e1 5417 linux_xfer_siginfo,
bd99dc85
PA
5418 linux_supports_non_stop,
5419 linux_async,
5420 linux_start_non_stop,
cdbfd419
PP
5421 linux_supports_multi_process,
5422#ifdef USE_THREAD_DB
dc146f7c 5423 thread_db_handle_monitor_command,
cdbfd419 5424#else
dc146f7c 5425 NULL,
cdbfd419 5426#endif
d26e3629 5427 linux_common_core_of_thread,
78d85199 5428 linux_read_loadmap,
219f2f23
PA
5429 linux_process_qsupported,
5430 linux_supports_tracepoints,
5431 linux_read_pc,
8336d594
PA
5432 linux_write_pc,
5433 linux_thread_stopped,
7984d532 5434 NULL,
711e434b 5435 linux_pause_all,
7984d532 5436 linux_unpause_all,
fa593d66
PA
5437 linux_cancel_breakpoints,
5438 linux_stabilize_threads,
6a271cae 5439 linux_install_fast_tracepoint_jump_pad,
03583c20
UW
5440 linux_emit_ops,
5441 linux_supports_disable_randomization,
405f8e94 5442 linux_get_min_fast_tracepoint_insn_len,
2268b414 5443 linux_qxfer_libraries_svr4,
ce3a066d
DJ
5444};
5445
0d62e5e8
DJ
5446static void
5447linux_init_signals ()
5448{
5449 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
5450 to find what the cancel signal actually is. */
1a981360 5451#ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
254787d4 5452 signal (__SIGRTMIN+1, SIG_IGN);
60c3d7b0 5453#endif
0d62e5e8
DJ
5454}
5455
da6d8c04
DJ
5456void
5457initialize_low (void)
5458{
bd99dc85
PA
5459 struct sigaction sigchld_action;
5460 memset (&sigchld_action, 0, sizeof (sigchld_action));
ce3a066d 5461 set_target_ops (&linux_target_ops);
611cb4a5
DJ
5462 set_breakpoint_data (the_low_target.breakpoint,
5463 the_low_target.breakpoint_len);
0d62e5e8 5464 linux_init_signals ();
24a09b5f 5465 linux_test_for_tracefork ();
52fa2412
UW
5466#ifdef HAVE_LINUX_REGSETS
5467 for (num_regsets = 0; target_regsets[num_regsets].size >= 0; num_regsets++)
5468 ;
bca929d3 5469 disabled_regsets = xmalloc (num_regsets);
52fa2412 5470#endif
bd99dc85
PA
5471
5472 sigchld_action.sa_handler = sigchld_handler;
5473 sigemptyset (&sigchld_action.sa_mask);
5474 sigchld_action.sa_flags = SA_RESTART;
5475 sigaction (SIGCHLD, &sigchld_action, NULL);
da6d8c04 5476}