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