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