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