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