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