gdb, gdbserver, gdbsupport: fix leading space vs tabs issues
[deliverable/binutils-gdb.git] / gdb / linux-nat.c
CommitLineData
3993f6b1 1/* GNU/Linux native-dependent code common to multiple platforms.
dba24537 2
b811d2c2 3 Copyright (C) 2001-2020 Free Software Foundation, Inc.
3993f6b1
DJ
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
3993f6b1
DJ
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
3993f6b1
DJ
19
20#include "defs.h"
21#include "inferior.h"
45741a9c 22#include "infrun.h"
3993f6b1 23#include "target.h"
96d7229d
LM
24#include "nat/linux-nat.h"
25#include "nat/linux-waitpid.h"
268a13a5 26#include "gdbsupport/gdb_wait.h"
d6b0e80f
AC
27#include <unistd.h>
28#include <sys/syscall.h>
5826e159 29#include "nat/gdb_ptrace.h"
0274a8ce 30#include "linux-nat.h"
125f8a3d
GB
31#include "nat/linux-ptrace.h"
32#include "nat/linux-procfs.h"
8cc73a39 33#include "nat/linux-personality.h"
ac264b3b 34#include "linux-fork.h"
d6b0e80f
AC
35#include "gdbthread.h"
36#include "gdbcmd.h"
37#include "regcache.h"
4f844a66 38#include "regset.h"
dab06dbe 39#include "inf-child.h"
10d6c8cd
DJ
40#include "inf-ptrace.h"
41#include "auxv.h"
1777feb0 42#include <sys/procfs.h> /* for elf_gregset etc. */
dba24537
AC
43#include "elf-bfd.h" /* for elfcore_write_* */
44#include "gregset.h" /* for gregset */
45#include "gdbcore.h" /* for get_exec_file */
46#include <ctype.h> /* for isdigit */
53ce3c39 47#include <sys/stat.h> /* for struct stat */
dba24537 48#include <fcntl.h> /* for O_RDONLY */
b84876c2 49#include "inf-loop.h"
400b5eca 50#include "gdbsupport/event-loop.h"
b84876c2 51#include "event-top.h"
07e059b5
VP
52#include <pwd.h>
53#include <sys/types.h>
2978b111 54#include <dirent.h>
07e059b5 55#include "xml-support.h"
efcbbd14 56#include <sys/vfs.h>
6c95b8df 57#include "solib.h"
125f8a3d 58#include "nat/linux-osdata.h"
6432734d 59#include "linux-tdep.h"
7dcd53a0 60#include "symfile.h"
268a13a5 61#include "gdbsupport/agent.h"
5808517f 62#include "tracepoint.h"
268a13a5 63#include "gdbsupport/buffer.h"
6ecd4729 64#include "target-descriptions.h"
268a13a5 65#include "gdbsupport/filestuff.h"
77e371c0 66#include "objfiles.h"
7a6a1731 67#include "nat/linux-namespaces.h"
268a13a5
TT
68#include "gdbsupport/fileio.h"
69#include "gdbsupport/scope-exit.h"
21987b9c 70#include "gdbsupport/gdb-sigmask.h"
ba988419 71#include "gdbsupport/common-debug.h"
efcbbd14 72
1777feb0 73/* This comment documents high-level logic of this file.
8a77dff3
VP
74
75Waiting for events in sync mode
76===============================
77
4a6ed09b
PA
78When waiting for an event in a specific thread, we just use waitpid,
79passing the specific pid, and not passing WNOHANG.
80
81When waiting for an event in all threads, waitpid is not quite good:
82
83- If the thread group leader exits while other threads in the thread
84 group still exist, waitpid(TGID, ...) hangs. That waitpid won't
85 return an exit status until the other threads in the group are
86 reaped.
87
88- When a non-leader thread execs, that thread just vanishes without
89 reporting an exit (so we'd hang if we waited for it explicitly in
90 that case). The exec event is instead reported to the TGID pid.
91
92The solution is to always use -1 and WNOHANG, together with
93sigsuspend.
94
95First, we use non-blocking waitpid to check for events. If nothing is
96found, we use sigsuspend to wait for SIGCHLD. When SIGCHLD arrives,
97it means something happened to a child process. As soon as we know
98there's an event, we get back to calling nonblocking waitpid.
99
100Note that SIGCHLD should be blocked between waitpid and sigsuspend
101calls, so that we don't miss a signal. If SIGCHLD arrives in between,
102when it's blocked, the signal becomes pending and sigsuspend
103immediately notices it and returns.
104
105Waiting for events in async mode (TARGET_WNOHANG)
106=================================================
8a77dff3 107
7feb7d06
PA
108In async mode, GDB should always be ready to handle both user input
109and target events, so neither blocking waitpid nor sigsuspend are
110viable options. Instead, we should asynchronously notify the GDB main
111event loop whenever there's an unprocessed event from the target. We
112detect asynchronous target events by handling SIGCHLD signals. To
113notify the event loop about target events, the self-pipe trick is used
114--- a pipe is registered as waitable event source in the event loop,
115the event loop select/poll's on the read end of this pipe (as well on
116other event sources, e.g., stdin), and the SIGCHLD handler writes a
117byte to this pipe. This is more portable than relying on
118pselect/ppoll, since on kernels that lack those syscalls, libc
119emulates them with select/poll+sigprocmask, and that is racy
120(a.k.a. plain broken).
121
122Obviously, if we fail to notify the event loop if there's a target
123event, it's bad. OTOH, if we notify the event loop when there's no
124event from the target, linux_nat_wait will detect that there's no real
125event to report, and return event of type TARGET_WAITKIND_IGNORE.
126This is mostly harmless, but it will waste time and is better avoided.
127
128The main design point is that every time GDB is outside linux-nat.c,
129we have a SIGCHLD handler installed that is called when something
130happens to the target and notifies the GDB event loop. Whenever GDB
131core decides to handle the event, and calls into linux-nat.c, we
132process things as in sync mode, except that the we never block in
133sigsuspend.
134
135While processing an event, we may end up momentarily blocked in
136waitpid calls. Those waitpid calls, while blocking, are guarantied to
137return quickly. E.g., in all-stop mode, before reporting to the core
138that an LWP hit a breakpoint, all LWPs are stopped by sending them
139SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
140Note that this is different from blocking indefinitely waiting for the
141next event --- here, we're already handling an event.
8a77dff3
VP
142
143Use of signals
144==============
145
146We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
147signal is not entirely significant; we just need for a signal to be delivered,
148so that we can intercept it. SIGSTOP's advantage is that it can not be
149blocked. A disadvantage is that it is not a real-time signal, so it can only
150be queued once; we do not keep track of other sources of SIGSTOP.
151
152Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
153use them, because they have special behavior when the signal is generated -
154not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
155kills the entire thread group.
156
157A delivered SIGSTOP would stop the entire thread group, not just the thread we
158tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
159cancel it (by PTRACE_CONT without passing SIGSTOP).
160
161We could use a real-time signal instead. This would solve those problems; we
162could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
163But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
164generates it, and there are races with trying to find a signal that is not
4a6ed09b
PA
165blocked.
166
167Exec events
168===========
169
170The case of a thread group (process) with 3 or more threads, and a
171thread other than the leader execs is worth detailing:
172
173On an exec, the Linux kernel destroys all threads except the execing
174one in the thread group, and resets the execing thread's tid to the
175tgid. No exit notification is sent for the execing thread -- from the
176ptracer's perspective, it appears as though the execing thread just
177vanishes. Until we reap all other threads except the leader and the
178execing thread, the leader will be zombie, and the execing thread will
179be in `D (disc sleep)' state. As soon as all other threads are
180reaped, the execing thread changes its tid to the tgid, and the
181previous (zombie) leader vanishes, giving place to the "new"
182leader. */
a0ef4274 183
dba24537
AC
184#ifndef O_LARGEFILE
185#define O_LARGEFILE 0
186#endif
0274a8ce 187
f6ac5f3d
PA
188struct linux_nat_target *linux_target;
189
433bbbf8 190/* Does the current host support PTRACE_GETREGSET? */
0bdb2f78 191enum tribool have_ptrace_getregset = TRIBOOL_UNKNOWN;
433bbbf8 192
ccce17b0 193static unsigned int debug_linux_nat;
920d2a44
AC
194static void
195show_debug_linux_nat (struct ui_file *file, int from_tty,
196 struct cmd_list_element *c, const char *value)
197{
198 fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
199 value);
200}
d6b0e80f 201
17417fb0 202/* Print a linux-nat debug statement. */
9327494e
SM
203
204#define linux_nat_debug_printf(fmt, ...) \
4f0469cd
AB
205 do \
206 { \
207 if (debug_linux_nat) \
208 debug_prefixed_printf ("linux-nat", __func__, fmt, ##__VA_ARGS__); \
209 } \
210 while (0)
9327494e 211
ae087d01
DJ
212struct simple_pid_list
213{
214 int pid;
3d799a95 215 int status;
ae087d01
DJ
216 struct simple_pid_list *next;
217};
05c309a8 218static struct simple_pid_list *stopped_pids;
ae087d01 219
aa01bd36
PA
220/* Whether target_thread_events is in effect. */
221static int report_thread_events;
222
3dd5b83d
PA
223/* Async mode support. */
224
b84876c2
PA
225/* The read/write ends of the pipe registered as waitable file in the
226 event loop. */
227static int linux_nat_event_pipe[2] = { -1, -1 };
228
198297aa
PA
229/* True if we're currently in async mode. */
230#define linux_is_async_p() (linux_nat_event_pipe[0] != -1)
231
7feb7d06 232/* Flush the event pipe. */
b84876c2 233
7feb7d06
PA
234static void
235async_file_flush (void)
b84876c2 236{
7feb7d06
PA
237 int ret;
238 char buf;
b84876c2 239
7feb7d06 240 do
b84876c2 241 {
7feb7d06 242 ret = read (linux_nat_event_pipe[0], &buf, 1);
b84876c2 243 }
7feb7d06 244 while (ret >= 0 || (ret == -1 && errno == EINTR));
b84876c2
PA
245}
246
7feb7d06
PA
247/* Put something (anything, doesn't matter what, or how much) in event
248 pipe, so that the select/poll in the event-loop realizes we have
249 something to process. */
252fbfc8 250
b84876c2 251static void
7feb7d06 252async_file_mark (void)
b84876c2 253{
7feb7d06 254 int ret;
b84876c2 255
7feb7d06
PA
256 /* It doesn't really matter what the pipe contains, as long we end
257 up with something in it. Might as well flush the previous
258 left-overs. */
259 async_file_flush ();
b84876c2 260
7feb7d06 261 do
b84876c2 262 {
7feb7d06 263 ret = write (linux_nat_event_pipe[1], "+", 1);
b84876c2 264 }
7feb7d06 265 while (ret == -1 && errno == EINTR);
b84876c2 266
7feb7d06
PA
267 /* Ignore EAGAIN. If the pipe is full, the event loop will already
268 be awakened anyway. */
b84876c2
PA
269}
270
7feb7d06
PA
271static int kill_lwp (int lwpid, int signo);
272
d3a70e03 273static int stop_callback (struct lwp_info *lp);
7feb7d06
PA
274
275static void block_child_signals (sigset_t *prev_mask);
276static void restore_child_signals_mask (sigset_t *prev_mask);
2277426b
PA
277
278struct lwp_info;
279static struct lwp_info *add_lwp (ptid_t ptid);
280static void purge_lwp_list (int pid);
4403d8e9 281static void delete_lwp (ptid_t ptid);
2277426b
PA
282static struct lwp_info *find_lwp_pid (ptid_t ptid);
283
8a99810d
PA
284static int lwp_status_pending_p (struct lwp_info *lp);
285
e7ad2f14
PA
286static void save_stop_reason (struct lwp_info *lp);
287
cff068da
GB
288\f
289/* LWP accessors. */
290
291/* See nat/linux-nat.h. */
292
293ptid_t
294ptid_of_lwp (struct lwp_info *lwp)
295{
296 return lwp->ptid;
297}
298
299/* See nat/linux-nat.h. */
300
4b134ca1
GB
301void
302lwp_set_arch_private_info (struct lwp_info *lwp,
303 struct arch_lwp_info *info)
304{
305 lwp->arch_private = info;
306}
307
308/* See nat/linux-nat.h. */
309
310struct arch_lwp_info *
311lwp_arch_private_info (struct lwp_info *lwp)
312{
313 return lwp->arch_private;
314}
315
316/* See nat/linux-nat.h. */
317
cff068da
GB
318int
319lwp_is_stopped (struct lwp_info *lwp)
320{
321 return lwp->stopped;
322}
323
324/* See nat/linux-nat.h. */
325
326enum target_stop_reason
327lwp_stop_reason (struct lwp_info *lwp)
328{
329 return lwp->stop_reason;
330}
331
0e00e962
AA
332/* See nat/linux-nat.h. */
333
334int
335lwp_is_stepping (struct lwp_info *lwp)
336{
337 return lwp->step;
338}
339
ae087d01
DJ
340\f
341/* Trivial list manipulation functions to keep track of a list of
342 new stopped processes. */
343static void
3d799a95 344add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
ae087d01 345{
8d749320 346 struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
e0881a8e 347
ae087d01 348 new_pid->pid = pid;
3d799a95 349 new_pid->status = status;
ae087d01
DJ
350 new_pid->next = *listp;
351 *listp = new_pid;
352}
353
354static int
46a96992 355pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
ae087d01
DJ
356{
357 struct simple_pid_list **p;
358
359 for (p = listp; *p != NULL; p = &(*p)->next)
360 if ((*p)->pid == pid)
361 {
362 struct simple_pid_list *next = (*p)->next;
e0881a8e 363
46a96992 364 *statusp = (*p)->status;
ae087d01
DJ
365 xfree (*p);
366 *p = next;
367 return 1;
368 }
369 return 0;
370}
371
de0d863e
DB
372/* Return the ptrace options that we want to try to enable. */
373
374static int
375linux_nat_ptrace_options (int attached)
376{
377 int options = 0;
378
379 if (!attached)
380 options |= PTRACE_O_EXITKILL;
381
382 options |= (PTRACE_O_TRACESYSGOOD
383 | PTRACE_O_TRACEVFORKDONE
384 | PTRACE_O_TRACEVFORK
385 | PTRACE_O_TRACEFORK
386 | PTRACE_O_TRACEEXEC);
387
388 return options;
389}
390
1b919490
VB
391/* Initialize ptrace and procfs warnings and check for supported
392 ptrace features given PID.
beed38b8
JB
393
394 ATTACHED should be nonzero iff we attached to the inferior. */
3993f6b1
DJ
395
396static void
1b919490 397linux_init_ptrace_procfs (pid_t pid, int attached)
3993f6b1 398{
de0d863e
DB
399 int options = linux_nat_ptrace_options (attached);
400
401 linux_enable_event_reporting (pid, options);
96d7229d 402 linux_ptrace_init_warnings ();
1b919490 403 linux_proc_init_warnings ();
4de4c07c
DJ
404}
405
f6ac5f3d
PA
406linux_nat_target::~linux_nat_target ()
407{}
408
409void
410linux_nat_target::post_attach (int pid)
4de4c07c 411{
1b919490 412 linux_init_ptrace_procfs (pid, 1);
4de4c07c
DJ
413}
414
f6ac5f3d
PA
415void
416linux_nat_target::post_startup_inferior (ptid_t ptid)
4de4c07c 417{
1b919490 418 linux_init_ptrace_procfs (ptid.pid (), 0);
4de4c07c
DJ
419}
420
4403d8e9
JK
421/* Return the number of known LWPs in the tgid given by PID. */
422
423static int
424num_lwps (int pid)
425{
426 int count = 0;
427 struct lwp_info *lp;
428
429 for (lp = lwp_list; lp; lp = lp->next)
e99b03dc 430 if (lp->ptid.pid () == pid)
4403d8e9
JK
431 count++;
432
433 return count;
434}
435
169bb27b 436/* Deleter for lwp_info unique_ptr specialisation. */
4403d8e9 437
169bb27b 438struct lwp_deleter
4403d8e9 439{
169bb27b
AB
440 void operator() (struct lwp_info *lwp) const
441 {
442 delete_lwp (lwp->ptid);
443 }
444};
4403d8e9 445
169bb27b
AB
446/* A unique_ptr specialisation for lwp_info. */
447
448typedef std::unique_ptr<struct lwp_info, lwp_deleter> lwp_info_up;
4403d8e9 449
d83ad864
DB
450/* Target hook for follow_fork. On entry inferior_ptid must be the
451 ptid of the followed inferior. At return, inferior_ptid will be
452 unchanged. */
453
5ab2fbf1
SM
454bool
455linux_nat_target::follow_fork (bool follow_child, bool detach_fork)
3993f6b1 456{
d83ad864 457 if (!follow_child)
4de4c07c 458 {
6c95b8df 459 struct lwp_info *child_lp = NULL;
d83ad864 460 int has_vforked;
79639e11 461 ptid_t parent_ptid, child_ptid;
d83ad864
DB
462 int parent_pid, child_pid;
463
464 has_vforked = (inferior_thread ()->pending_follow.kind
465 == TARGET_WAITKIND_VFORKED);
79639e11
PA
466 parent_ptid = inferior_ptid;
467 child_ptid = inferior_thread ()->pending_follow.value.related_pid;
e38504b3
TT
468 parent_pid = parent_ptid.lwp ();
469 child_pid = child_ptid.lwp ();
4de4c07c 470
1777feb0 471 /* We're already attached to the parent, by default. */
2989a365 472 child_lp = add_lwp (child_ptid);
d83ad864
DB
473 child_lp->stopped = 1;
474 child_lp->last_resume_kind = resume_stop;
4de4c07c 475
ac264b3b
MS
476 /* Detach new forked process? */
477 if (detach_fork)
f75c00e4 478 {
95347337
AB
479 int child_stop_signal = 0;
480 bool detach_child = true;
4403d8e9 481
169bb27b
AB
482 /* Move CHILD_LP into a unique_ptr and clear the source pointer
483 to prevent us doing anything stupid with it. */
484 lwp_info_up child_lp_ptr (child_lp);
485 child_lp = nullptr;
486
487 linux_target->low_prepare_to_resume (child_lp_ptr.get ());
c077881a
HZ
488
489 /* When debugging an inferior in an architecture that supports
490 hardware single stepping on a kernel without commit
491 6580807da14c423f0d0a708108e6df6ebc8bc83d, the vfork child
492 process starts with the TIF_SINGLESTEP/X86_EFLAGS_TF bits
493 set if the parent process had them set.
494 To work around this, single step the child process
495 once before detaching to clear the flags. */
496
2fd9d7ca
PA
497 /* Note that we consult the parent's architecture instead of
498 the child's because there's no inferior for the child at
499 this point. */
c077881a 500 if (!gdbarch_software_single_step_p (target_thread_architecture
2fd9d7ca 501 (parent_ptid)))
c077881a 502 {
95347337
AB
503 int status;
504
c077881a
HZ
505 linux_disable_event_reporting (child_pid);
506 if (ptrace (PTRACE_SINGLESTEP, child_pid, 0, 0) < 0)
507 perror_with_name (_("Couldn't do single step"));
508 if (my_waitpid (child_pid, &status, 0) < 0)
509 perror_with_name (_("Couldn't wait vfork process"));
95347337
AB
510 else
511 {
512 detach_child = WIFSTOPPED (status);
513 child_stop_signal = WSTOPSIG (status);
514 }
c077881a
HZ
515 }
516
95347337 517 if (detach_child)
9caaaa83 518 {
95347337 519 int signo = child_stop_signal;
9caaaa83 520
9caaaa83
PA
521 if (signo != 0
522 && !signal_pass_state (gdb_signal_from_host (signo)))
523 signo = 0;
524 ptrace (PTRACE_DETACH, child_pid, 0, signo);
525 }
ac264b3b
MS
526 }
527 else
528 {
5b6d1e4f
PA
529 /* Switching inferior_ptid is not enough, because then
530 inferior_thread () would crash by not finding the thread
531 in the current inferior. */
532 scoped_restore_current_thread restore_current_thread;
533 thread_info *child = find_thread_ptid (this, child_ptid);
534 switch_to_thread (child);
2989a365 535
6c95b8df 536 /* Let the thread_db layer learn about this new process. */
2277426b 537 check_for_thread_db ();
ac264b3b 538 }
9016a515
DJ
539
540 if (has_vforked)
541 {
3ced3da4 542 struct lwp_info *parent_lp;
6c95b8df 543
79639e11 544 parent_lp = find_lwp_pid (parent_ptid);
96d7229d 545 gdb_assert (linux_supports_tracefork () >= 0);
3ced3da4 546
96d7229d 547 if (linux_supports_tracevforkdone ())
9016a515 548 {
9327494e
SM
549 linux_nat_debug_printf ("waiting for VFORK_DONE on %d",
550 parent_pid);
3ced3da4 551 parent_lp->stopped = 1;
9016a515 552
6c95b8df
PA
553 /* We'll handle the VFORK_DONE event like any other
554 event, in target_wait. */
9016a515
DJ
555 }
556 else
557 {
558 /* We can't insert breakpoints until the child has
559 finished with the shared memory region. We need to
560 wait until that happens. Ideal would be to just
561 call:
562 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
563 - waitpid (parent_pid, &status, __WALL);
564 However, most architectures can't handle a syscall
565 being traced on the way out if it wasn't traced on
566 the way in.
567
568 We might also think to loop, continuing the child
569 until it exits or gets a SIGTRAP. One problem is
570 that the child might call ptrace with PTRACE_TRACEME.
571
572 There's no simple and reliable way to figure out when
573 the vforked child will be done with its copy of the
574 shared memory. We could step it out of the syscall,
575 two instructions, let it go, and then single-step the
576 parent once. When we have hardware single-step, this
577 would work; with software single-step it could still
578 be made to work but we'd have to be able to insert
579 single-step breakpoints in the child, and we'd have
580 to insert -just- the single-step breakpoint in the
581 parent. Very awkward.
582
583 In the end, the best we can do is to make sure it
584 runs for a little while. Hopefully it will be out of
585 range of any breakpoints we reinsert. Usually this
586 is only the single-step breakpoint at vfork's return
587 point. */
588
9327494e 589 linux_nat_debug_printf ("no VFORK_DONE support, sleeping a bit");
6c95b8df 590
9016a515 591 usleep (10000);
9016a515 592
6c95b8df
PA
593 /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
594 and leave it pending. The next linux_nat_resume call
595 will notice a pending event, and bypasses actually
596 resuming the inferior. */
3ced3da4
PA
597 parent_lp->status = 0;
598 parent_lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
599 parent_lp->stopped = 1;
6c95b8df
PA
600
601 /* If we're in async mode, need to tell the event loop
602 there's something here to process. */
d9d41e78 603 if (target_is_async_p ())
6c95b8df
PA
604 async_file_mark ();
605 }
9016a515 606 }
4de4c07c 607 }
3993f6b1 608 else
4de4c07c 609 {
3ced3da4 610 struct lwp_info *child_lp;
4de4c07c 611
3ced3da4
PA
612 child_lp = add_lwp (inferior_ptid);
613 child_lp->stopped = 1;
25289eb2 614 child_lp->last_resume_kind = resume_stop;
6c95b8df 615
6c95b8df 616 /* Let the thread_db layer learn about this new process. */
ef29ce1a 617 check_for_thread_db ();
4de4c07c
DJ
618 }
619
5ab2fbf1 620 return false;
4de4c07c
DJ
621}
622
4de4c07c 623\f
f6ac5f3d
PA
624int
625linux_nat_target::insert_fork_catchpoint (int pid)
4de4c07c 626{
96d7229d 627 return !linux_supports_tracefork ();
3993f6b1
DJ
628}
629
f6ac5f3d
PA
630int
631linux_nat_target::remove_fork_catchpoint (int pid)
eb73ad13
PA
632{
633 return 0;
634}
635
f6ac5f3d
PA
636int
637linux_nat_target::insert_vfork_catchpoint (int pid)
3993f6b1 638{
96d7229d 639 return !linux_supports_tracefork ();
3993f6b1
DJ
640}
641
f6ac5f3d
PA
642int
643linux_nat_target::remove_vfork_catchpoint (int pid)
eb73ad13
PA
644{
645 return 0;
646}
647
f6ac5f3d
PA
648int
649linux_nat_target::insert_exec_catchpoint (int pid)
3993f6b1 650{
96d7229d 651 return !linux_supports_tracefork ();
3993f6b1
DJ
652}
653
f6ac5f3d
PA
654int
655linux_nat_target::remove_exec_catchpoint (int pid)
eb73ad13
PA
656{
657 return 0;
658}
659
f6ac5f3d
PA
660int
661linux_nat_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
662 gdb::array_view<const int> syscall_counts)
a96d9b2e 663{
96d7229d 664 if (!linux_supports_tracesysgood ())
77b06cd7
TJB
665 return 1;
666
a96d9b2e
SDJ
667 /* On GNU/Linux, we ignore the arguments. It means that we only
668 enable the syscall catchpoints, but do not disable them.
77b06cd7 669
649a140c 670 Also, we do not use the `syscall_counts' information because we do not
a96d9b2e
SDJ
671 filter system calls here. We let GDB do the logic for us. */
672 return 0;
673}
674
774113b0
PA
675/* List of known LWPs, keyed by LWP PID. This speeds up the common
676 case of mapping a PID returned from the kernel to our corresponding
677 lwp_info data structure. */
678static htab_t lwp_lwpid_htab;
679
680/* Calculate a hash from a lwp_info's LWP PID. */
681
682static hashval_t
683lwp_info_hash (const void *ap)
684{
685 const struct lwp_info *lp = (struct lwp_info *) ap;
e38504b3 686 pid_t pid = lp->ptid.lwp ();
774113b0
PA
687
688 return iterative_hash_object (pid, 0);
689}
690
691/* Equality function for the lwp_info hash table. Compares the LWP's
692 PID. */
693
694static int
695lwp_lwpid_htab_eq (const void *a, const void *b)
696{
697 const struct lwp_info *entry = (const struct lwp_info *) a;
698 const struct lwp_info *element = (const struct lwp_info *) b;
699
e38504b3 700 return entry->ptid.lwp () == element->ptid.lwp ();
774113b0
PA
701}
702
703/* Create the lwp_lwpid_htab hash table. */
704
705static void
706lwp_lwpid_htab_create (void)
707{
708 lwp_lwpid_htab = htab_create (100, lwp_info_hash, lwp_lwpid_htab_eq, NULL);
709}
710
711/* Add LP to the hash table. */
712
713static void
714lwp_lwpid_htab_add_lwp (struct lwp_info *lp)
715{
716 void **slot;
717
718 slot = htab_find_slot (lwp_lwpid_htab, lp, INSERT);
719 gdb_assert (slot != NULL && *slot == NULL);
720 *slot = lp;
721}
722
723/* Head of doubly-linked list of known LWPs. Sorted by reverse
724 creation order. This order is assumed in some cases. E.g.,
725 reaping status after killing alls lwps of a process: the leader LWP
726 must be reaped last. */
9f0bdab8 727struct lwp_info *lwp_list;
774113b0
PA
728
729/* Add LP to sorted-by-reverse-creation-order doubly-linked list. */
730
731static void
732lwp_list_add (struct lwp_info *lp)
733{
734 lp->next = lwp_list;
735 if (lwp_list != NULL)
736 lwp_list->prev = lp;
737 lwp_list = lp;
738}
739
740/* Remove LP from sorted-by-reverse-creation-order doubly-linked
741 list. */
742
743static void
744lwp_list_remove (struct lwp_info *lp)
745{
746 /* Remove from sorted-by-creation-order list. */
747 if (lp->next != NULL)
748 lp->next->prev = lp->prev;
749 if (lp->prev != NULL)
750 lp->prev->next = lp->next;
751 if (lp == lwp_list)
752 lwp_list = lp->next;
753}
754
d6b0e80f
AC
755\f
756
d6b0e80f
AC
757/* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
758 _initialize_linux_nat. */
759static sigset_t suspend_mask;
760
7feb7d06
PA
761/* Signals to block to make that sigsuspend work. */
762static sigset_t blocked_mask;
763
764/* SIGCHLD action. */
765struct sigaction sigchld_action;
b84876c2 766
7feb7d06
PA
767/* Block child signals (SIGCHLD and linux threads signals), and store
768 the previous mask in PREV_MASK. */
84e46146 769
7feb7d06
PA
770static void
771block_child_signals (sigset_t *prev_mask)
772{
773 /* Make sure SIGCHLD is blocked. */
774 if (!sigismember (&blocked_mask, SIGCHLD))
775 sigaddset (&blocked_mask, SIGCHLD);
776
21987b9c 777 gdb_sigmask (SIG_BLOCK, &blocked_mask, prev_mask);
7feb7d06
PA
778}
779
780/* Restore child signals mask, previously returned by
781 block_child_signals. */
782
783static void
784restore_child_signals_mask (sigset_t *prev_mask)
785{
21987b9c 786 gdb_sigmask (SIG_SETMASK, prev_mask, NULL);
7feb7d06 787}
2455069d
UW
788
789/* Mask of signals to pass directly to the inferior. */
790static sigset_t pass_mask;
791
792/* Update signals to pass to the inferior. */
f6ac5f3d 793void
adc6a863
PA
794linux_nat_target::pass_signals
795 (gdb::array_view<const unsigned char> pass_signals)
2455069d
UW
796{
797 int signo;
798
799 sigemptyset (&pass_mask);
800
801 for (signo = 1; signo < NSIG; signo++)
802 {
2ea28649 803 int target_signo = gdb_signal_from_host (signo);
adc6a863 804 if (target_signo < pass_signals.size () && pass_signals[target_signo])
dda83cd7 805 sigaddset (&pass_mask, signo);
2455069d
UW
806 }
807}
808
d6b0e80f
AC
809\f
810
811/* Prototypes for local functions. */
d3a70e03
TT
812static int stop_wait_callback (struct lwp_info *lp);
813static int resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid);
ced2dffb 814static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp);
710151dd 815
d6b0e80f 816\f
d6b0e80f 817
7b50312a
PA
818/* Destroy and free LP. */
819
820static void
821lwp_free (struct lwp_info *lp)
822{
466eecee 823 /* Let the arch specific bits release arch_lwp_info. */
135340af 824 linux_target->low_delete_thread (lp->arch_private);
466eecee 825
7b50312a
PA
826 xfree (lp);
827}
828
774113b0 829/* Traversal function for purge_lwp_list. */
d90e17a7 830
774113b0
PA
831static int
832lwp_lwpid_htab_remove_pid (void **slot, void *info)
d90e17a7 833{
774113b0
PA
834 struct lwp_info *lp = (struct lwp_info *) *slot;
835 int pid = *(int *) info;
d90e17a7 836
e99b03dc 837 if (lp->ptid.pid () == pid)
d90e17a7 838 {
774113b0
PA
839 htab_clear_slot (lwp_lwpid_htab, slot);
840 lwp_list_remove (lp);
841 lwp_free (lp);
842 }
d90e17a7 843
774113b0
PA
844 return 1;
845}
d90e17a7 846
774113b0
PA
847/* Remove all LWPs belong to PID from the lwp list. */
848
849static void
850purge_lwp_list (int pid)
851{
852 htab_traverse_noresize (lwp_lwpid_htab, lwp_lwpid_htab_remove_pid, &pid);
d90e17a7
PA
853}
854
26cb8b7c
PA
855/* Add the LWP specified by PTID to the list. PTID is the first LWP
856 in the process. Return a pointer to the structure describing the
857 new LWP.
858
859 This differs from add_lwp in that we don't let the arch specific
860 bits know about this new thread. Current clients of this callback
861 take the opportunity to install watchpoints in the new thread, and
862 we shouldn't do that for the first thread. If we're spawning a
863 child ("run"), the thread executes the shell wrapper first, and we
864 shouldn't touch it until it execs the program we want to debug.
865 For "attach", it'd be okay to call the callback, but it's not
866 necessary, because watchpoints can't yet have been inserted into
867 the inferior. */
d6b0e80f
AC
868
869static struct lwp_info *
26cb8b7c 870add_initial_lwp (ptid_t ptid)
d6b0e80f
AC
871{
872 struct lwp_info *lp;
873
15a9e13e 874 gdb_assert (ptid.lwp_p ());
d6b0e80f 875
8d749320 876 lp = XNEW (struct lwp_info);
d6b0e80f
AC
877
878 memset (lp, 0, sizeof (struct lwp_info));
879
25289eb2 880 lp->last_resume_kind = resume_continue;
d6b0e80f
AC
881 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
882
883 lp->ptid = ptid;
dc146f7c 884 lp->core = -1;
d6b0e80f 885
774113b0
PA
886 /* Add to sorted-by-reverse-creation-order list. */
887 lwp_list_add (lp);
888
889 /* Add to keyed-by-pid htab. */
890 lwp_lwpid_htab_add_lwp (lp);
d6b0e80f 891
26cb8b7c
PA
892 return lp;
893}
894
895/* Add the LWP specified by PID to the list. Return a pointer to the
896 structure describing the new LWP. The LWP should already be
897 stopped. */
898
899static struct lwp_info *
900add_lwp (ptid_t ptid)
901{
902 struct lwp_info *lp;
903
904 lp = add_initial_lwp (ptid);
905
6e012a6c
PA
906 /* Let the arch specific bits know about this new thread. Current
907 clients of this callback take the opportunity to install
26cb8b7c
PA
908 watchpoints in the new thread. We don't do this for the first
909 thread though. See add_initial_lwp. */
135340af 910 linux_target->low_new_thread (lp);
9f0bdab8 911
d6b0e80f
AC
912 return lp;
913}
914
915/* Remove the LWP specified by PID from the list. */
916
917static void
918delete_lwp (ptid_t ptid)
919{
774113b0
PA
920 struct lwp_info *lp;
921 void **slot;
922 struct lwp_info dummy;
d6b0e80f 923
774113b0
PA
924 dummy.ptid = ptid;
925 slot = htab_find_slot (lwp_lwpid_htab, &dummy, NO_INSERT);
926 if (slot == NULL)
927 return;
d6b0e80f 928
774113b0
PA
929 lp = *(struct lwp_info **) slot;
930 gdb_assert (lp != NULL);
d6b0e80f 931
774113b0 932 htab_clear_slot (lwp_lwpid_htab, slot);
d6b0e80f 933
774113b0
PA
934 /* Remove from sorted-by-creation-order list. */
935 lwp_list_remove (lp);
d6b0e80f 936
774113b0 937 /* Release. */
7b50312a 938 lwp_free (lp);
d6b0e80f
AC
939}
940
941/* Return a pointer to the structure describing the LWP corresponding
942 to PID. If no corresponding LWP could be found, return NULL. */
943
944static struct lwp_info *
945find_lwp_pid (ptid_t ptid)
946{
947 struct lwp_info *lp;
948 int lwp;
774113b0 949 struct lwp_info dummy;
d6b0e80f 950
15a9e13e 951 if (ptid.lwp_p ())
e38504b3 952 lwp = ptid.lwp ();
d6b0e80f 953 else
e99b03dc 954 lwp = ptid.pid ();
d6b0e80f 955
fd79271b 956 dummy.ptid = ptid_t (0, lwp, 0);
774113b0
PA
957 lp = (struct lwp_info *) htab_find (lwp_lwpid_htab, &dummy);
958 return lp;
d6b0e80f
AC
959}
960
6d4ee8c6 961/* See nat/linux-nat.h. */
d6b0e80f
AC
962
963struct lwp_info *
d90e17a7 964iterate_over_lwps (ptid_t filter,
d3a70e03 965 gdb::function_view<iterate_over_lwps_ftype> callback)
d6b0e80f
AC
966{
967 struct lwp_info *lp, *lpnext;
968
969 for (lp = lwp_list; lp; lp = lpnext)
970 {
971 lpnext = lp->next;
d90e17a7 972
26a57c92 973 if (lp->ptid.matches (filter))
d90e17a7 974 {
d3a70e03 975 if (callback (lp) != 0)
d90e17a7
PA
976 return lp;
977 }
d6b0e80f
AC
978 }
979
980 return NULL;
981}
982
2277426b
PA
983/* Update our internal state when changing from one checkpoint to
984 another indicated by NEW_PTID. We can only switch single-threaded
985 applications, so we only create one new LWP, and the previous list
986 is discarded. */
f973ed9c
DJ
987
988void
989linux_nat_switch_fork (ptid_t new_ptid)
990{
991 struct lwp_info *lp;
992
e99b03dc 993 purge_lwp_list (inferior_ptid.pid ());
2277426b 994
f973ed9c
DJ
995 lp = add_lwp (new_ptid);
996 lp->stopped = 1;
e26af52f 997
2277426b
PA
998 /* This changes the thread's ptid while preserving the gdb thread
999 num. Also changes the inferior pid, while preserving the
1000 inferior num. */
5b6d1e4f 1001 thread_change_ptid (linux_target, inferior_ptid, new_ptid);
2277426b
PA
1002
1003 /* We've just told GDB core that the thread changed target id, but,
1004 in fact, it really is a different thread, with different register
1005 contents. */
1006 registers_changed ();
e26af52f
DJ
1007}
1008
e26af52f
DJ
1009/* Handle the exit of a single thread LP. */
1010
1011static void
1012exit_lwp (struct lwp_info *lp)
1013{
5b6d1e4f 1014 struct thread_info *th = find_thread_ptid (linux_target, lp->ptid);
063bfe2e
VP
1015
1016 if (th)
e26af52f 1017 {
17faa917 1018 if (print_thread_events)
a068643d
TT
1019 printf_unfiltered (_("[%s exited]\n"),
1020 target_pid_to_str (lp->ptid).c_str ());
17faa917 1021
00431a78 1022 delete_thread (th);
e26af52f
DJ
1023 }
1024
1025 delete_lwp (lp->ptid);
1026}
1027
a0ef4274
DJ
1028/* Wait for the LWP specified by LP, which we have just attached to.
1029 Returns a wait status for that LWP, to cache. */
1030
1031static int
22827c51 1032linux_nat_post_attach_wait (ptid_t ptid, int *signalled)
a0ef4274 1033{
e38504b3 1034 pid_t new_pid, pid = ptid.lwp ();
a0ef4274
DJ
1035 int status;
1036
644cebc9 1037 if (linux_proc_pid_is_stopped (pid))
a0ef4274 1038 {
9327494e 1039 linux_nat_debug_printf ("Attaching to a stopped process");
a0ef4274
DJ
1040
1041 /* The process is definitely stopped. It is in a job control
1042 stop, unless the kernel predates the TASK_STOPPED /
1043 TASK_TRACED distinction, in which case it might be in a
1044 ptrace stop. Make sure it is in a ptrace stop; from there we
1045 can kill it, signal it, et cetera.
1046
dda83cd7 1047 First make sure there is a pending SIGSTOP. Since we are
a0ef4274
DJ
1048 already attached, the process can not transition from stopped
1049 to running without a PTRACE_CONT; so we know this signal will
1050 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1051 probably already in the queue (unless this kernel is old
1052 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1053 is not an RT signal, it can only be queued once. */
1054 kill_lwp (pid, SIGSTOP);
1055
1056 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1057 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1058 ptrace (PTRACE_CONT, pid, 0, 0);
1059 }
1060
1061 /* Make sure the initial process is stopped. The user-level threads
1062 layer might want to poke around in the inferior, and that won't
1063 work if things haven't stabilized yet. */
4a6ed09b 1064 new_pid = my_waitpid (pid, &status, __WALL);
dacc9cb2
PP
1065 gdb_assert (pid == new_pid);
1066
1067 if (!WIFSTOPPED (status))
1068 {
1069 /* The pid we tried to attach has apparently just exited. */
9327494e
SM
1070 linux_nat_debug_printf ("Failed to stop %d: %s", pid,
1071 status_to_str (status));
dacc9cb2
PP
1072 return status;
1073 }
a0ef4274
DJ
1074
1075 if (WSTOPSIG (status) != SIGSTOP)
1076 {
1077 *signalled = 1;
9327494e
SM
1078 linux_nat_debug_printf ("Received %s after attaching",
1079 status_to_str (status));
a0ef4274
DJ
1080 }
1081
1082 return status;
1083}
1084
f6ac5f3d
PA
1085void
1086linux_nat_target::create_inferior (const char *exec_file,
1087 const std::string &allargs,
1088 char **env, int from_tty)
b84876c2 1089{
41272101
TT
1090 maybe_disable_address_space_randomization restore_personality
1091 (disable_randomization);
b84876c2
PA
1092
1093 /* The fork_child mechanism is synchronous and calls target_wait, so
1094 we have to mask the async mode. */
1095
2455069d 1096 /* Make sure we report all signals during startup. */
adc6a863 1097 pass_signals ({});
2455069d 1098
f6ac5f3d 1099 inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty);
b84876c2
PA
1100}
1101
8784d563
PA
1102/* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1103 already attached. Returns true if a new LWP is found, false
1104 otherwise. */
1105
1106static int
1107attach_proc_task_lwp_callback (ptid_t ptid)
1108{
1109 struct lwp_info *lp;
1110
1111 /* Ignore LWPs we're already attached to. */
1112 lp = find_lwp_pid (ptid);
1113 if (lp == NULL)
1114 {
e38504b3 1115 int lwpid = ptid.lwp ();
8784d563
PA
1116
1117 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1118 {
1119 int err = errno;
1120
1121 /* Be quiet if we simply raced with the thread exiting.
1122 EPERM is returned if the thread's task still exists, and
1123 is marked as exited or zombie, as well as other
1124 conditions, so in that case, confirm the status in
1125 /proc/PID/status. */
1126 if (err == ESRCH
1127 || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
1128 {
9327494e
SM
1129 linux_nat_debug_printf
1130 ("Cannot attach to lwp %d: thread is gone (%d: %s)",
1131 lwpid, err, safe_strerror (err));
1132
8784d563
PA
1133 }
1134 else
1135 {
4d9b86e1 1136 std::string reason
50fa3001 1137 = linux_ptrace_attach_fail_reason_string (ptid, err);
4d9b86e1 1138
f71f0b0d 1139 warning (_("Cannot attach to lwp %d: %s"),
4d9b86e1 1140 lwpid, reason.c_str ());
8784d563
PA
1141 }
1142 }
1143 else
1144 {
9327494e
SM
1145 linux_nat_debug_printf ("PTRACE_ATTACH %s, 0, 0 (OK)",
1146 target_pid_to_str (ptid).c_str ());
8784d563
PA
1147
1148 lp = add_lwp (ptid);
8784d563
PA
1149
1150 /* The next time we wait for this LWP we'll see a SIGSTOP as
1151 PTRACE_ATTACH brings it to a halt. */
1152 lp->signalled = 1;
1153
1154 /* We need to wait for a stop before being able to make the
1155 next ptrace call on this LWP. */
1156 lp->must_set_ptrace_flags = 1;
026a9174
PA
1157
1158 /* So that wait collects the SIGSTOP. */
1159 lp->resumed = 1;
1160
1161 /* Also add the LWP to gdb's thread list, in case a
1162 matching libthread_db is not found (or the process uses
1163 raw clone). */
5b6d1e4f 1164 add_thread (linux_target, lp->ptid);
719546c4
SM
1165 set_running (linux_target, lp->ptid, true);
1166 set_executing (linux_target, lp->ptid, true);
8784d563
PA
1167 }
1168
1169 return 1;
1170 }
1171 return 0;
1172}
1173
f6ac5f3d
PA
1174void
1175linux_nat_target::attach (const char *args, int from_tty)
d6b0e80f
AC
1176{
1177 struct lwp_info *lp;
d6b0e80f 1178 int status;
af990527 1179 ptid_t ptid;
d6b0e80f 1180
2455069d 1181 /* Make sure we report all signals during attach. */
adc6a863 1182 pass_signals ({});
2455069d 1183
a70b8144 1184 try
87b0bb13 1185 {
f6ac5f3d 1186 inf_ptrace_target::attach (args, from_tty);
87b0bb13 1187 }
230d2906 1188 catch (const gdb_exception_error &ex)
87b0bb13
JK
1189 {
1190 pid_t pid = parse_pid_to_attach (args);
50fa3001 1191 std::string reason = linux_ptrace_attach_fail_reason (pid);
87b0bb13 1192
4d9b86e1 1193 if (!reason.empty ())
3d6e9d23
TT
1194 throw_error (ex.error, "warning: %s\n%s", reason.c_str (),
1195 ex.what ());
7ae1a6a6 1196 else
3d6e9d23 1197 throw_error (ex.error, "%s", ex.what ());
87b0bb13 1198 }
d6b0e80f 1199
af990527
PA
1200 /* The ptrace base target adds the main thread with (pid,0,0)
1201 format. Decorate it with lwp info. */
e99b03dc
TT
1202 ptid = ptid_t (inferior_ptid.pid (),
1203 inferior_ptid.pid (),
fd79271b 1204 0);
5b6d1e4f 1205 thread_change_ptid (linux_target, inferior_ptid, ptid);
af990527 1206
9f0bdab8 1207 /* Add the initial process as the first LWP to the list. */
26cb8b7c 1208 lp = add_initial_lwp (ptid);
a0ef4274 1209
22827c51 1210 status = linux_nat_post_attach_wait (lp->ptid, &lp->signalled);
dacc9cb2
PP
1211 if (!WIFSTOPPED (status))
1212 {
1213 if (WIFEXITED (status))
1214 {
1215 int exit_code = WEXITSTATUS (status);
1216
223ffa71 1217 target_terminal::ours ();
bc1e6c81 1218 target_mourn_inferior (inferior_ptid);
dacc9cb2
PP
1219 if (exit_code == 0)
1220 error (_("Unable to attach: program exited normally."));
1221 else
1222 error (_("Unable to attach: program exited with code %d."),
1223 exit_code);
1224 }
1225 else if (WIFSIGNALED (status))
1226 {
2ea28649 1227 enum gdb_signal signo;
dacc9cb2 1228
223ffa71 1229 target_terminal::ours ();
bc1e6c81 1230 target_mourn_inferior (inferior_ptid);
dacc9cb2 1231
2ea28649 1232 signo = gdb_signal_from_host (WTERMSIG (status));
dacc9cb2
PP
1233 error (_("Unable to attach: program terminated with signal "
1234 "%s, %s."),
2ea28649
PA
1235 gdb_signal_to_name (signo),
1236 gdb_signal_to_string (signo));
dacc9cb2
PP
1237 }
1238
1239 internal_error (__FILE__, __LINE__,
1240 _("unexpected status %d for PID %ld"),
e38504b3 1241 status, (long) ptid.lwp ());
dacc9cb2
PP
1242 }
1243
a0ef4274 1244 lp->stopped = 1;
9f0bdab8 1245
a0ef4274 1246 /* Save the wait status to report later. */
d6b0e80f 1247 lp->resumed = 1;
9327494e
SM
1248 linux_nat_debug_printf ("waitpid %ld, saving status %s",
1249 (long) lp->ptid.pid (), status_to_str (status));
710151dd 1250
7feb7d06
PA
1251 lp->status = status;
1252
8784d563
PA
1253 /* We must attach to every LWP. If /proc is mounted, use that to
1254 find them now. The inferior may be using raw clone instead of
1255 using pthreads. But even if it is using pthreads, thread_db
1256 walks structures in the inferior's address space to find the list
1257 of threads/LWPs, and those structures may well be corrupted.
1258 Note that once thread_db is loaded, we'll still use it to list
1259 threads and associate pthread info with each LWP. */
e99b03dc 1260 linux_proc_attach_tgid_threads (lp->ptid.pid (),
8784d563
PA
1261 attach_proc_task_lwp_callback);
1262
7feb7d06 1263 if (target_can_async_p ())
6a3753b3 1264 target_async (1);
d6b0e80f
AC
1265}
1266
ced2dffb
PA
1267/* Get pending signal of THREAD as a host signal number, for detaching
1268 purposes. This is the signal the thread last stopped for, which we
1269 need to deliver to the thread when detaching, otherwise, it'd be
1270 suppressed/lost. */
1271
a0ef4274 1272static int
ced2dffb 1273get_detach_signal (struct lwp_info *lp)
a0ef4274 1274{
a493e3e2 1275 enum gdb_signal signo = GDB_SIGNAL_0;
ca2163eb
PA
1276
1277 /* If we paused threads momentarily, we may have stored pending
1278 events in lp->status or lp->waitstatus (see stop_wait_callback),
1279 and GDB core hasn't seen any signal for those threads.
1280 Otherwise, the last signal reported to the core is found in the
1281 thread object's stop_signal.
1282
1283 There's a corner case that isn't handled here at present. Only
1284 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1285 stop_signal make sense as a real signal to pass to the inferior.
1286 Some catchpoint related events, like
1287 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
a493e3e2 1288 to GDB_SIGNAL_SIGTRAP when the catchpoint triggers. But,
ca2163eb
PA
1289 those traps are debug API (ptrace in our case) related and
1290 induced; the inferior wouldn't see them if it wasn't being
1291 traced. Hence, we should never pass them to the inferior, even
1292 when set to pass state. Since this corner case isn't handled by
1293 infrun.c when proceeding with a signal, for consistency, neither
1294 do we handle it here (or elsewhere in the file we check for
1295 signal pass state). Normally SIGTRAP isn't set to pass state, so
1296 this is really a corner case. */
1297
1298 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
a493e3e2 1299 signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal. */
ca2163eb 1300 else if (lp->status)
2ea28649 1301 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
00431a78 1302 else
ca2163eb 1303 {
5b6d1e4f 1304 struct thread_info *tp = find_thread_ptid (linux_target, lp->ptid);
e0881a8e 1305
00431a78 1306 if (target_is_non_stop_p () && !tp->executing)
ca2163eb 1307 {
00431a78
PA
1308 if (tp->suspend.waitstatus_pending_p)
1309 signo = tp->suspend.waitstatus.value.sig;
1310 else
1311 signo = tp->suspend.stop_signal;
1312 }
1313 else if (!target_is_non_stop_p ())
1314 {
00431a78 1315 ptid_t last_ptid;
5b6d1e4f 1316 process_stratum_target *last_target;
00431a78 1317
5b6d1e4f 1318 get_last_target_status (&last_target, &last_ptid, nullptr);
e0881a8e 1319
5b6d1e4f
PA
1320 if (last_target == linux_target
1321 && lp->ptid.lwp () == last_ptid.lwp ())
00431a78 1322 signo = tp->suspend.stop_signal;
4c28f408 1323 }
ca2163eb 1324 }
4c28f408 1325
a493e3e2 1326 if (signo == GDB_SIGNAL_0)
ca2163eb 1327 {
9327494e
SM
1328 linux_nat_debug_printf ("lwp %s has no pending signal",
1329 target_pid_to_str (lp->ptid).c_str ());
ca2163eb
PA
1330 }
1331 else if (!signal_pass_state (signo))
1332 {
9327494e
SM
1333 linux_nat_debug_printf
1334 ("lwp %s had signal %s but it is in no pass state",
1335 target_pid_to_str (lp->ptid).c_str (), gdb_signal_to_string (signo));
a0ef4274 1336 }
a0ef4274 1337 else
4c28f408 1338 {
9327494e
SM
1339 linux_nat_debug_printf ("lwp %s has pending signal %s",
1340 target_pid_to_str (lp->ptid).c_str (),
1341 gdb_signal_to_string (signo));
ced2dffb
PA
1342
1343 return gdb_signal_to_host (signo);
4c28f408 1344 }
a0ef4274
DJ
1345
1346 return 0;
1347}
1348
ced2dffb
PA
1349/* Detach from LP. If SIGNO_P is non-NULL, then it points to the
1350 signal number that should be passed to the LWP when detaching.
1351 Otherwise pass any pending signal the LWP may have, if any. */
1352
1353static void
1354detach_one_lwp (struct lwp_info *lp, int *signo_p)
d6b0e80f 1355{
e38504b3 1356 int lwpid = lp->ptid.lwp ();
ced2dffb
PA
1357 int signo;
1358
d6b0e80f
AC
1359 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1360
9327494e
SM
1361 if (lp->status != 0)
1362 linux_nat_debug_printf ("Pending %s for %s on detach.",
1363 strsignal (WSTOPSIG (lp->status)),
1364 target_pid_to_str (lp->ptid).c_str ());
d6b0e80f 1365
a0ef4274
DJ
1366 /* If there is a pending SIGSTOP, get rid of it. */
1367 if (lp->signalled)
d6b0e80f 1368 {
9327494e
SM
1369 linux_nat_debug_printf ("Sending SIGCONT to %s",
1370 target_pid_to_str (lp->ptid).c_str ());
d6b0e80f 1371
ced2dffb 1372 kill_lwp (lwpid, SIGCONT);
d6b0e80f 1373 lp->signalled = 0;
d6b0e80f
AC
1374 }
1375
ced2dffb 1376 if (signo_p == NULL)
d6b0e80f 1377 {
a0ef4274 1378 /* Pass on any pending signal for this LWP. */
ced2dffb
PA
1379 signo = get_detach_signal (lp);
1380 }
1381 else
1382 signo = *signo_p;
a0ef4274 1383
ced2dffb
PA
1384 /* Preparing to resume may try to write registers, and fail if the
1385 lwp is zombie. If that happens, ignore the error. We'll handle
1386 it below, when detach fails with ESRCH. */
a70b8144 1387 try
ced2dffb 1388 {
135340af 1389 linux_target->low_prepare_to_resume (lp);
ced2dffb 1390 }
230d2906 1391 catch (const gdb_exception_error &ex)
ced2dffb
PA
1392 {
1393 if (!check_ptrace_stopped_lwp_gone (lp))
eedc3f4f 1394 throw;
ced2dffb 1395 }
d6b0e80f 1396
ced2dffb
PA
1397 if (ptrace (PTRACE_DETACH, lwpid, 0, signo) < 0)
1398 {
1399 int save_errno = errno;
1400
1401 /* We know the thread exists, so ESRCH must mean the lwp is
1402 zombie. This can happen if one of the already-detached
1403 threads exits the whole thread group. In that case we're
1404 still attached, and must reap the lwp. */
1405 if (save_errno == ESRCH)
1406 {
1407 int ret, status;
d6b0e80f 1408
ced2dffb
PA
1409 ret = my_waitpid (lwpid, &status, __WALL);
1410 if (ret == -1)
1411 {
1412 warning (_("Couldn't reap LWP %d while detaching: %s"),
6d91ce9a 1413 lwpid, safe_strerror (errno));
ced2dffb
PA
1414 }
1415 else if (!WIFEXITED (status) && !WIFSIGNALED (status))
1416 {
1417 warning (_("Reaping LWP %d while detaching "
1418 "returned unexpected status 0x%x"),
1419 lwpid, status);
1420 }
1421 }
1422 else
1423 {
a068643d
TT
1424 error (_("Can't detach %s: %s"),
1425 target_pid_to_str (lp->ptid).c_str (),
ced2dffb
PA
1426 safe_strerror (save_errno));
1427 }
d6b0e80f 1428 }
9327494e
SM
1429 else
1430 linux_nat_debug_printf ("PTRACE_DETACH (%s, %s, 0) (OK)",
1431 target_pid_to_str (lp->ptid).c_str (),
1432 strsignal (signo));
ced2dffb
PA
1433
1434 delete_lwp (lp->ptid);
1435}
d6b0e80f 1436
ced2dffb 1437static int
d3a70e03 1438detach_callback (struct lwp_info *lp)
ced2dffb
PA
1439{
1440 /* We don't actually detach from the thread group leader just yet.
1441 If the thread group exits, we must reap the zombie clone lwps
1442 before we're able to reap the leader. */
e38504b3 1443 if (lp->ptid.lwp () != lp->ptid.pid ())
ced2dffb 1444 detach_one_lwp (lp, NULL);
d6b0e80f
AC
1445 return 0;
1446}
1447
f6ac5f3d
PA
1448void
1449linux_nat_target::detach (inferior *inf, int from_tty)
d6b0e80f 1450{
d90e17a7 1451 struct lwp_info *main_lwp;
bc09b0c1 1452 int pid = inf->pid;
a0ef4274 1453
ae5e0686
MK
1454 /* Don't unregister from the event loop, as there may be other
1455 inferiors running. */
b84876c2 1456
4c28f408 1457 /* Stop all threads before detaching. ptrace requires that the
30baf67b 1458 thread is stopped to successfully detach. */
d3a70e03 1459 iterate_over_lwps (ptid_t (pid), stop_callback);
4c28f408
PA
1460 /* ... and wait until all of them have reported back that
1461 they're no longer running. */
d3a70e03 1462 iterate_over_lwps (ptid_t (pid), stop_wait_callback);
4c28f408 1463
d3a70e03 1464 iterate_over_lwps (ptid_t (pid), detach_callback);
d6b0e80f
AC
1465
1466 /* Only the initial process should be left right now. */
bc09b0c1 1467 gdb_assert (num_lwps (pid) == 1);
d90e17a7 1468
f2907e49 1469 main_lwp = find_lwp_pid (ptid_t (pid));
d6b0e80f 1470
7a7d3353
PA
1471 if (forks_exist_p ())
1472 {
1473 /* Multi-fork case. The current inferior_ptid is being detached
1474 from, but there are other viable forks to debug. Detach from
1475 the current fork, and context-switch to the first
1476 available. */
6bd6f3b6 1477 linux_fork_detach (from_tty);
7a7d3353
PA
1478 }
1479 else
ced2dffb 1480 {
ced2dffb
PA
1481 target_announce_detach (from_tty);
1482
6bd6f3b6
SM
1483 /* Pass on any pending signal for the last LWP. */
1484 int signo = get_detach_signal (main_lwp);
ced2dffb
PA
1485
1486 detach_one_lwp (main_lwp, &signo);
1487
f6ac5f3d 1488 detach_success (inf);
ced2dffb 1489 }
d6b0e80f
AC
1490}
1491
8a99810d
PA
1492/* Resume execution of the inferior process. If STEP is nonzero,
1493 single-step it. If SIGNAL is nonzero, give it that signal. */
1494
1495static void
23f238d3
PA
1496linux_resume_one_lwp_throw (struct lwp_info *lp, int step,
1497 enum gdb_signal signo)
8a99810d 1498{
8a99810d 1499 lp->step = step;
9c02b525
PA
1500
1501 /* stop_pc doubles as the PC the LWP had when it was last resumed.
1502 We only presently need that if the LWP is stepped though (to
1503 handle the case of stepping a breakpoint instruction). */
1504 if (step)
1505 {
5b6d1e4f 1506 struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid);
9c02b525
PA
1507
1508 lp->stop_pc = regcache_read_pc (regcache);
1509 }
1510 else
1511 lp->stop_pc = 0;
1512
135340af 1513 linux_target->low_prepare_to_resume (lp);
f6ac5f3d 1514 linux_target->low_resume (lp->ptid, step, signo);
23f238d3
PA
1515
1516 /* Successfully resumed. Clear state that no longer makes sense,
1517 and mark the LWP as running. Must not do this before resuming
1518 otherwise if that fails other code will be confused. E.g., we'd
1519 later try to stop the LWP and hang forever waiting for a stop
1520 status. Note that we must not throw after this is cleared,
1521 otherwise handle_zombie_lwp_error would get confused. */
8a99810d 1522 lp->stopped = 0;
1ad3de98 1523 lp->core = -1;
23f238d3 1524 lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
5b6d1e4f 1525 registers_changed_ptid (linux_target, lp->ptid);
8a99810d
PA
1526}
1527
23f238d3
PA
1528/* Called when we try to resume a stopped LWP and that errors out. If
1529 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
1530 or about to become), discard the error, clear any pending status
1531 the LWP may have, and return true (we'll collect the exit status
1532 soon enough). Otherwise, return false. */
1533
1534static int
1535check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
1536{
1537 /* If we get an error after resuming the LWP successfully, we'd
1538 confuse !T state for the LWP being gone. */
1539 gdb_assert (lp->stopped);
1540
1541 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
1542 because even if ptrace failed with ESRCH, the tracee may be "not
1543 yet fully dead", but already refusing ptrace requests. In that
1544 case the tracee has 'R (Running)' state for a little bit
1545 (observed in Linux 3.18). See also the note on ESRCH in the
1546 ptrace(2) man page. Instead, check whether the LWP has any state
1547 other than ptrace-stopped. */
1548
1549 /* Don't assume anything if /proc/PID/status can't be read. */
e38504b3 1550 if (linux_proc_pid_is_trace_stopped_nowarn (lp->ptid.lwp ()) == 0)
23f238d3
PA
1551 {
1552 lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
1553 lp->status = 0;
1554 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
1555 return 1;
1556 }
1557 return 0;
1558}
1559
1560/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
1561 disappears while we try to resume it. */
1562
1563static void
1564linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1565{
a70b8144 1566 try
23f238d3
PA
1567 {
1568 linux_resume_one_lwp_throw (lp, step, signo);
1569 }
230d2906 1570 catch (const gdb_exception_error &ex)
23f238d3
PA
1571 {
1572 if (!check_ptrace_stopped_lwp_gone (lp))
eedc3f4f 1573 throw;
23f238d3 1574 }
23f238d3
PA
1575}
1576
d6b0e80f
AC
1577/* Resume LP. */
1578
25289eb2 1579static void
e5ef252a 1580resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
d6b0e80f 1581{
25289eb2 1582 if (lp->stopped)
6c95b8df 1583 {
5b6d1e4f 1584 struct inferior *inf = find_inferior_ptid (linux_target, lp->ptid);
25289eb2
PA
1585
1586 if (inf->vfork_child != NULL)
1587 {
9327494e
SM
1588 linux_nat_debug_printf ("Not resuming %s (vfork parent)",
1589 target_pid_to_str (lp->ptid).c_str ());
25289eb2 1590 }
8a99810d 1591 else if (!lwp_status_pending_p (lp))
25289eb2 1592 {
9327494e
SM
1593 linux_nat_debug_printf ("Resuming sibling %s, %s, %s",
1594 target_pid_to_str (lp->ptid).c_str (),
1595 (signo != GDB_SIGNAL_0
1596 ? strsignal (gdb_signal_to_host (signo))
1597 : "0"),
1598 step ? "step" : "resume");
25289eb2 1599
8a99810d 1600 linux_resume_one_lwp (lp, step, signo);
25289eb2
PA
1601 }
1602 else
1603 {
9327494e
SM
1604 linux_nat_debug_printf ("Not resuming sibling %s (has pending)",
1605 target_pid_to_str (lp->ptid).c_str ());
25289eb2 1606 }
6c95b8df 1607 }
25289eb2 1608 else
9327494e 1609 linux_nat_debug_printf ("Not resuming sibling %s (not stopped)",
a068643d 1610 target_pid_to_str (lp->ptid).c_str ());
25289eb2 1611}
d6b0e80f 1612
8817a6f2
PA
1613/* Callback for iterate_over_lwps. If LWP is EXCEPT, do nothing.
1614 Resume LWP with the last stop signal, if it is in pass state. */
e5ef252a 1615
25289eb2 1616static int
d3a70e03 1617linux_nat_resume_callback (struct lwp_info *lp, struct lwp_info *except)
25289eb2 1618{
e5ef252a
PA
1619 enum gdb_signal signo = GDB_SIGNAL_0;
1620
8817a6f2
PA
1621 if (lp == except)
1622 return 0;
1623
e5ef252a
PA
1624 if (lp->stopped)
1625 {
1626 struct thread_info *thread;
1627
5b6d1e4f 1628 thread = find_thread_ptid (linux_target, lp->ptid);
e5ef252a
PA
1629 if (thread != NULL)
1630 {
70509625 1631 signo = thread->suspend.stop_signal;
e5ef252a
PA
1632 thread->suspend.stop_signal = GDB_SIGNAL_0;
1633 }
1634 }
1635
1636 resume_lwp (lp, 0, signo);
d6b0e80f
AC
1637 return 0;
1638}
1639
1640static int
d3a70e03 1641resume_clear_callback (struct lwp_info *lp)
d6b0e80f
AC
1642{
1643 lp->resumed = 0;
25289eb2 1644 lp->last_resume_kind = resume_stop;
d6b0e80f
AC
1645 return 0;
1646}
1647
1648static int
d3a70e03 1649resume_set_callback (struct lwp_info *lp)
d6b0e80f
AC
1650{
1651 lp->resumed = 1;
25289eb2 1652 lp->last_resume_kind = resume_continue;
d6b0e80f
AC
1653 return 0;
1654}
1655
f6ac5f3d
PA
1656void
1657linux_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
d6b0e80f
AC
1658{
1659 struct lwp_info *lp;
d90e17a7 1660 int resume_many;
d6b0e80f 1661
9327494e
SM
1662 linux_nat_debug_printf ("Preparing to %s %s, %s, inferior_ptid %s",
1663 step ? "step" : "resume",
1664 target_pid_to_str (ptid).c_str (),
1665 (signo != GDB_SIGNAL_0
1666 ? strsignal (gdb_signal_to_host (signo)) : "0"),
1667 target_pid_to_str (inferior_ptid).c_str ());
76f50ad1 1668
d6b0e80f 1669 /* A specific PTID means `step only this process id'. */
d7e15655 1670 resume_many = (minus_one_ptid == ptid
0e998d96 1671 || ptid.is_pid ());
4c28f408 1672
7da6a5b9
LM
1673 /* Mark the lwps we're resuming as resumed and update their
1674 last_resume_kind to resume_continue. */
d3a70e03 1675 iterate_over_lwps (ptid, resume_set_callback);
d6b0e80f 1676
d90e17a7
PA
1677 /* See if it's the current inferior that should be handled
1678 specially. */
1679 if (resume_many)
1680 lp = find_lwp_pid (inferior_ptid);
1681 else
1682 lp = find_lwp_pid (ptid);
9f0bdab8 1683 gdb_assert (lp != NULL);
d6b0e80f 1684
9f0bdab8 1685 /* Remember if we're stepping. */
25289eb2 1686 lp->last_resume_kind = step ? resume_step : resume_continue;
d6b0e80f 1687
9f0bdab8
DJ
1688 /* If we have a pending wait status for this thread, there is no
1689 point in resuming the process. But first make sure that
1690 linux_nat_wait won't preemptively handle the event - we
1691 should never take this short-circuit if we are going to
1692 leave LP running, since we have skipped resuming all the
1693 other threads. This bit of code needs to be synchronized
1694 with linux_nat_wait. */
76f50ad1 1695
9f0bdab8
DJ
1696 if (lp->status && WIFSTOPPED (lp->status))
1697 {
2455069d
UW
1698 if (!lp->step
1699 && WSTOPSIG (lp->status)
1700 && sigismember (&pass_mask, WSTOPSIG (lp->status)))
d6b0e80f 1701 {
9327494e
SM
1702 linux_nat_debug_printf
1703 ("Not short circuiting for ignored status 0x%x", lp->status);
9f0bdab8 1704
d6b0e80f
AC
1705 /* FIXME: What should we do if we are supposed to continue
1706 this thread with a signal? */
a493e3e2 1707 gdb_assert (signo == GDB_SIGNAL_0);
2ea28649 1708 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
9f0bdab8
DJ
1709 lp->status = 0;
1710 }
1711 }
76f50ad1 1712
8a99810d 1713 if (lwp_status_pending_p (lp))
9f0bdab8
DJ
1714 {
1715 /* FIXME: What should we do if we are supposed to continue
1716 this thread with a signal? */
a493e3e2 1717 gdb_assert (signo == GDB_SIGNAL_0);
76f50ad1 1718
9327494e
SM
1719 linux_nat_debug_printf ("Short circuiting for status 0x%x",
1720 lp->status);
d6b0e80f 1721
7feb7d06
PA
1722 if (target_can_async_p ())
1723 {
6a3753b3 1724 target_async (1);
7feb7d06
PA
1725 /* Tell the event loop we have something to process. */
1726 async_file_mark ();
1727 }
9f0bdab8 1728 return;
d6b0e80f
AC
1729 }
1730
d90e17a7 1731 if (resume_many)
d3a70e03
TT
1732 iterate_over_lwps (ptid, [=] (struct lwp_info *info)
1733 {
1734 return linux_nat_resume_callback (info, lp);
1735 });
d90e17a7 1736
9327494e
SM
1737 linux_nat_debug_printf ("%s %s, %s (resume event thread)",
1738 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1739 target_pid_to_str (lp->ptid).c_str (),
1740 (signo != GDB_SIGNAL_0
1741 ? strsignal (gdb_signal_to_host (signo)) : "0"));
b84876c2 1742
2bf6fb9d
PA
1743 linux_resume_one_lwp (lp, step, signo);
1744
b84876c2 1745 if (target_can_async_p ())
6a3753b3 1746 target_async (1);
d6b0e80f
AC
1747}
1748
c5f62d5f 1749/* Send a signal to an LWP. */
d6b0e80f
AC
1750
1751static int
1752kill_lwp (int lwpid, int signo)
1753{
4a6ed09b 1754 int ret;
d6b0e80f 1755
4a6ed09b
PA
1756 errno = 0;
1757 ret = syscall (__NR_tkill, lwpid, signo);
1758 if (errno == ENOSYS)
1759 {
1760 /* If tkill fails, then we are not using nptl threads, a
1761 configuration we no longer support. */
1762 perror_with_name (("tkill"));
1763 }
1764 return ret;
d6b0e80f
AC
1765}
1766
ca2163eb
PA
1767/* Handle a GNU/Linux syscall trap wait response. If we see a syscall
1768 event, check if the core is interested in it: if not, ignore the
1769 event, and keep waiting; otherwise, we need to toggle the LWP's
1770 syscall entry/exit status, since the ptrace event itself doesn't
1771 indicate it, and report the trap to higher layers. */
1772
1773static int
1774linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
1775{
1776 struct target_waitstatus *ourstatus = &lp->waitstatus;
1777 struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
5b6d1e4f 1778 thread_info *thread = find_thread_ptid (linux_target, lp->ptid);
00431a78 1779 int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, thread);
ca2163eb
PA
1780
1781 if (stopping)
1782 {
1783 /* If we're stopping threads, there's a SIGSTOP pending, which
1784 makes it so that the LWP reports an immediate syscall return,
1785 followed by the SIGSTOP. Skip seeing that "return" using
1786 PTRACE_CONT directly, and let stop_wait_callback collect the
1787 SIGSTOP. Later when the thread is resumed, a new syscall
1788 entry event. If we didn't do this (and returned 0), we'd
1789 leave a syscall entry pending, and our caller, by using
1790 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1791 itself. Later, when the user re-resumes this LWP, we'd see
1792 another syscall entry event and we'd mistake it for a return.
1793
1794 If stop_wait_callback didn't force the SIGSTOP out of the LWP
1795 (leaving immediately with LWP->signalled set, without issuing
1796 a PTRACE_CONT), it would still be problematic to leave this
1797 syscall enter pending, as later when the thread is resumed,
1798 it would then see the same syscall exit mentioned above,
1799 followed by the delayed SIGSTOP, while the syscall didn't
1800 actually get to execute. It seems it would be even more
1801 confusing to the user. */
1802
9327494e
SM
1803 linux_nat_debug_printf
1804 ("ignoring syscall %d for LWP %ld (stopping threads), resuming with "
1805 "PTRACE_CONT for SIGSTOP", syscall_number, lp->ptid.lwp ());
ca2163eb
PA
1806
1807 lp->syscall_state = TARGET_WAITKIND_IGNORE;
e38504b3 1808 ptrace (PTRACE_CONT, lp->ptid.lwp (), 0, 0);
8817a6f2 1809 lp->stopped = 0;
ca2163eb
PA
1810 return 1;
1811 }
1812
bfd09d20
JS
1813 /* Always update the entry/return state, even if this particular
1814 syscall isn't interesting to the core now. In async mode,
1815 the user could install a new catchpoint for this syscall
1816 between syscall enter/return, and we'll need to know to
1817 report a syscall return if that happens. */
1818 lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1819 ? TARGET_WAITKIND_SYSCALL_RETURN
1820 : TARGET_WAITKIND_SYSCALL_ENTRY);
1821
ca2163eb
PA
1822 if (catch_syscall_enabled ())
1823 {
ca2163eb
PA
1824 if (catching_syscall_number (syscall_number))
1825 {
1826 /* Alright, an event to report. */
1827 ourstatus->kind = lp->syscall_state;
1828 ourstatus->value.syscall_number = syscall_number;
1829
9327494e
SM
1830 linux_nat_debug_printf
1831 ("stopping for %s of syscall %d for LWP %ld",
1832 (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1833 ? "entry" : "return"), syscall_number, lp->ptid.lwp ());
1834
ca2163eb
PA
1835 return 0;
1836 }
1837
9327494e
SM
1838 linux_nat_debug_printf
1839 ("ignoring %s of syscall %d for LWP %ld",
1840 (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1841 ? "entry" : "return"), syscall_number, lp->ptid.lwp ());
ca2163eb
PA
1842 }
1843 else
1844 {
1845 /* If we had been syscall tracing, and hence used PT_SYSCALL
1846 before on this LWP, it could happen that the user removes all
1847 syscall catchpoints before we get to process this event.
1848 There are two noteworthy issues here:
1849
1850 - When stopped at a syscall entry event, resuming with
1851 PT_STEP still resumes executing the syscall and reports a
1852 syscall return.
1853
1854 - Only PT_SYSCALL catches syscall enters. If we last
1855 single-stepped this thread, then this event can't be a
1856 syscall enter. If we last single-stepped this thread, this
1857 has to be a syscall exit.
1858
1859 The points above mean that the next resume, be it PT_STEP or
1860 PT_CONTINUE, can not trigger a syscall trace event. */
9327494e
SM
1861 linux_nat_debug_printf
1862 ("caught syscall event with no syscall catchpoints. %d for LWP %ld, "
1863 "ignoring", syscall_number, lp->ptid.lwp ());
ca2163eb
PA
1864 lp->syscall_state = TARGET_WAITKIND_IGNORE;
1865 }
1866
1867 /* The core isn't interested in this event. For efficiency, avoid
1868 stopping all threads only to have the core resume them all again.
1869 Since we're not stopping threads, if we're still syscall tracing
1870 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1871 subsequent syscall. Simply resume using the inf-ptrace layer,
1872 which knows when to use PT_SYSCALL or PT_CONTINUE. */
1873
8a99810d 1874 linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
ca2163eb
PA
1875 return 1;
1876}
1877
3d799a95
DJ
1878/* Handle a GNU/Linux extended wait response. If we see a clone
1879 event, we need to add the new LWP to our list (and not report the
1880 trap to higher layers). This function returns non-zero if the
1881 event should be ignored and we should wait again. If STOPPING is
1882 true, the new LWP remains stopped, otherwise it is continued. */
d6b0e80f
AC
1883
1884static int
4dd63d48 1885linux_handle_extended_wait (struct lwp_info *lp, int status)
d6b0e80f 1886{
e38504b3 1887 int pid = lp->ptid.lwp ();
3d799a95 1888 struct target_waitstatus *ourstatus = &lp->waitstatus;
89a5711c 1889 int event = linux_ptrace_get_extended_event (status);
d6b0e80f 1890
bfd09d20
JS
1891 /* All extended events we currently use are mid-syscall. Only
1892 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
1893 you have to be using PTRACE_SEIZE to get that. */
1894 lp->syscall_state = TARGET_WAITKIND_SYSCALL_ENTRY;
1895
3d799a95
DJ
1896 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1897 || event == PTRACE_EVENT_CLONE)
d6b0e80f 1898 {
3d799a95
DJ
1899 unsigned long new_pid;
1900 int ret;
1901
1902 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
6fc19103 1903
3d799a95
DJ
1904 /* If we haven't already seen the new PID stop, wait for it now. */
1905 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1906 {
1907 /* The new child has a pending SIGSTOP. We can't affect it until it
1908 hits the SIGSTOP, but we're already attached. */
4a6ed09b 1909 ret = my_waitpid (new_pid, &status, __WALL);
3d799a95
DJ
1910 if (ret == -1)
1911 perror_with_name (_("waiting for new child"));
1912 else if (ret != new_pid)
1913 internal_error (__FILE__, __LINE__,
1914 _("wait returned unexpected PID %d"), ret);
1915 else if (!WIFSTOPPED (status))
1916 internal_error (__FILE__, __LINE__,
1917 _("wait returned unexpected status 0x%x"), status);
1918 }
1919
fd79271b 1920 ourstatus->value.related_pid = ptid_t (new_pid, new_pid, 0);
3d799a95 1921
26cb8b7c
PA
1922 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
1923 {
1924 /* The arch-specific native code may need to know about new
1925 forks even if those end up never mapped to an
1926 inferior. */
135340af 1927 linux_target->low_new_fork (lp, new_pid);
26cb8b7c 1928 }
1310c1b0
PFC
1929 else if (event == PTRACE_EVENT_CLONE)
1930 {
1931 linux_target->low_new_clone (lp, new_pid);
1932 }
26cb8b7c 1933
2277426b 1934 if (event == PTRACE_EVENT_FORK
e99b03dc 1935 && linux_fork_checkpointing_p (lp->ptid.pid ()))
2277426b 1936 {
2277426b
PA
1937 /* Handle checkpointing by linux-fork.c here as a special
1938 case. We don't want the follow-fork-mode or 'catch fork'
1939 to interfere with this. */
1940
1941 /* This won't actually modify the breakpoint list, but will
1942 physically remove the breakpoints from the child. */
fd79271b 1943 detach_breakpoints (ptid_t (new_pid, new_pid, 0));
2277426b
PA
1944
1945 /* Retain child fork in ptrace (stopped) state. */
14571dad
MS
1946 if (!find_fork_pid (new_pid))
1947 add_fork (new_pid);
2277426b
PA
1948
1949 /* Report as spurious, so that infrun doesn't want to follow
1950 this fork. We're actually doing an infcall in
1951 linux-fork.c. */
1952 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
2277426b
PA
1953
1954 /* Report the stop to the core. */
1955 return 0;
1956 }
1957
3d799a95
DJ
1958 if (event == PTRACE_EVENT_FORK)
1959 ourstatus->kind = TARGET_WAITKIND_FORKED;
1960 else if (event == PTRACE_EVENT_VFORK)
1961 ourstatus->kind = TARGET_WAITKIND_VFORKED;
4dd63d48 1962 else if (event == PTRACE_EVENT_CLONE)
3d799a95 1963 {
78768c4a
JK
1964 struct lwp_info *new_lp;
1965
3d799a95 1966 ourstatus->kind = TARGET_WAITKIND_IGNORE;
78768c4a 1967
9327494e
SM
1968 linux_nat_debug_printf
1969 ("Got clone event from LWP %d, new child is LWP %ld", pid, new_pid);
3c4d7e12 1970
e99b03dc 1971 new_lp = add_lwp (ptid_t (lp->ptid.pid (), new_pid, 0));
4c28f408 1972 new_lp->stopped = 1;
4dd63d48 1973 new_lp->resumed = 1;
d6b0e80f 1974
2db9a427
PA
1975 /* If the thread_db layer is active, let it record the user
1976 level thread id and status, and add the thread to GDB's
1977 list. */
1978 if (!thread_db_notice_clone (lp->ptid, new_lp->ptid))
3d799a95 1979 {
2db9a427
PA
1980 /* The process is not using thread_db. Add the LWP to
1981 GDB's list. */
e38504b3 1982 target_post_attach (new_lp->ptid.lwp ());
5b6d1e4f 1983 add_thread (linux_target, new_lp->ptid);
2db9a427 1984 }
4c28f408 1985
2ee52aa4 1986 /* Even if we're stopping the thread for some reason
4dd63d48
PA
1987 internal to this module, from the perspective of infrun
1988 and the user/frontend, this new thread is running until
1989 it next reports a stop. */
719546c4
SM
1990 set_running (linux_target, new_lp->ptid, true);
1991 set_executing (linux_target, new_lp->ptid, true);
4c28f408 1992
4dd63d48 1993 if (WSTOPSIG (status) != SIGSTOP)
79395f92 1994 {
4dd63d48
PA
1995 /* This can happen if someone starts sending signals to
1996 the new thread before it gets a chance to run, which
1997 have a lower number than SIGSTOP (e.g. SIGUSR1).
1998 This is an unlikely case, and harder to handle for
1999 fork / vfork than for clone, so we do not try - but
2000 we handle it for clone events here. */
2001
2002 new_lp->signalled = 1;
2003
79395f92
PA
2004 /* We created NEW_LP so it cannot yet contain STATUS. */
2005 gdb_assert (new_lp->status == 0);
2006
2007 /* Save the wait status to report later. */
9327494e
SM
2008 linux_nat_debug_printf
2009 ("waitpid of new LWP %ld, saving status %s",
2010 (long) new_lp->ptid.lwp (), status_to_str (status));
79395f92
PA
2011 new_lp->status = status;
2012 }
aa01bd36
PA
2013 else if (report_thread_events)
2014 {
2015 new_lp->waitstatus.kind = TARGET_WAITKIND_THREAD_CREATED;
2016 new_lp->status = status;
2017 }
79395f92 2018
3d799a95
DJ
2019 return 1;
2020 }
2021
2022 return 0;
d6b0e80f
AC
2023 }
2024
3d799a95
DJ
2025 if (event == PTRACE_EVENT_EXEC)
2026 {
9327494e 2027 linux_nat_debug_printf ("Got exec event from LWP %ld", lp->ptid.lwp ());
a75724bc 2028
3d799a95
DJ
2029 ourstatus->kind = TARGET_WAITKIND_EXECD;
2030 ourstatus->value.execd_pathname
f6ac5f3d 2031 = xstrdup (linux_proc_pid_to_exec_file (pid));
3d799a95 2032
8af756ef
PA
2033 /* The thread that execed must have been resumed, but, when a
2034 thread execs, it changes its tid to the tgid, and the old
2035 tgid thread might have not been resumed. */
2036 lp->resumed = 1;
6c95b8df
PA
2037 return 0;
2038 }
2039
2040 if (event == PTRACE_EVENT_VFORK_DONE)
2041 {
2042 if (current_inferior ()->waiting_for_vfork_done)
3d799a95 2043 {
9327494e
SM
2044 linux_nat_debug_printf
2045 ("Got expected PTRACE_EVENT_VFORK_DONE from LWP %ld: stopping",
2046 lp->ptid.lwp ());
3d799a95 2047
6c95b8df
PA
2048 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
2049 return 0;
3d799a95
DJ
2050 }
2051
9327494e
SM
2052 linux_nat_debug_printf
2053 ("Got PTRACE_EVENT_VFORK_DONE from LWP %ld: ignoring", lp->ptid.lwp ());
2054
6c95b8df 2055 return 1;
3d799a95
DJ
2056 }
2057
2058 internal_error (__FILE__, __LINE__,
2059 _("unknown ptrace event %d"), event);
d6b0e80f
AC
2060}
2061
9c3a5d93
PA
2062/* Suspend waiting for a signal. We're mostly interested in
2063 SIGCHLD/SIGINT. */
2064
2065static void
2066wait_for_signal ()
2067{
9327494e 2068 linux_nat_debug_printf ("about to sigsuspend");
9c3a5d93
PA
2069 sigsuspend (&suspend_mask);
2070
2071 /* If the quit flag is set, it means that the user pressed Ctrl-C
2072 and we're debugging a process that is running on a separate
2073 terminal, so we must forward the Ctrl-C to the inferior. (If the
2074 inferior is sharing GDB's terminal, then the Ctrl-C reaches the
2075 inferior directly.) We must do this here because functions that
2076 need to block waiting for a signal loop forever until there's an
2077 event to report before returning back to the event loop. */
2078 if (!target_terminal::is_ours ())
2079 {
2080 if (check_quit_flag ())
2081 target_pass_ctrlc ();
2082 }
2083}
2084
d6b0e80f
AC
2085/* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2086 exited. */
2087
2088static int
2089wait_lwp (struct lwp_info *lp)
2090{
2091 pid_t pid;
432b4d03 2092 int status = 0;
d6b0e80f 2093 int thread_dead = 0;
432b4d03 2094 sigset_t prev_mask;
d6b0e80f
AC
2095
2096 gdb_assert (!lp->stopped);
2097 gdb_assert (lp->status == 0);
2098
432b4d03
JK
2099 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2100 block_child_signals (&prev_mask);
2101
2102 for (;;)
d6b0e80f 2103 {
e38504b3 2104 pid = my_waitpid (lp->ptid.lwp (), &status, __WALL | WNOHANG);
a9f4bb21
PA
2105 if (pid == -1 && errno == ECHILD)
2106 {
2107 /* The thread has previously exited. We need to delete it
4a6ed09b
PA
2108 now because if this was a non-leader thread execing, we
2109 won't get an exit event. See comments on exec events at
2110 the top of the file. */
a9f4bb21 2111 thread_dead = 1;
9327494e
SM
2112 linux_nat_debug_printf ("%s vanished.",
2113 target_pid_to_str (lp->ptid).c_str ());
a9f4bb21 2114 }
432b4d03
JK
2115 if (pid != 0)
2116 break;
2117
2118 /* Bugs 10970, 12702.
2119 Thread group leader may have exited in which case we'll lock up in
2120 waitpid if there are other threads, even if they are all zombies too.
2121 Basically, we're not supposed to use waitpid this way.
4a6ed09b
PA
2122 tkill(pid,0) cannot be used here as it gets ESRCH for both
2123 for zombie and running processes.
432b4d03
JK
2124
2125 As a workaround, check if we're waiting for the thread group leader and
2126 if it's a zombie, and avoid calling waitpid if it is.
2127
2128 This is racy, what if the tgl becomes a zombie right after we check?
2129 Therefore always use WNOHANG with sigsuspend - it is equivalent to
5f572dec 2130 waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
432b4d03 2131
e38504b3
TT
2132 if (lp->ptid.pid () == lp->ptid.lwp ()
2133 && linux_proc_pid_is_zombie (lp->ptid.lwp ()))
d6b0e80f 2134 {
d6b0e80f 2135 thread_dead = 1;
9327494e
SM
2136 linux_nat_debug_printf ("Thread group leader %s vanished.",
2137 target_pid_to_str (lp->ptid).c_str ());
432b4d03 2138 break;
d6b0e80f 2139 }
432b4d03
JK
2140
2141 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2142 get invoked despite our caller had them intentionally blocked by
2143 block_child_signals. This is sensitive only to the loop of
2144 linux_nat_wait_1 and there if we get called my_waitpid gets called
2145 again before it gets to sigsuspend so we can safely let the handlers
2146 get executed here. */
9c3a5d93 2147 wait_for_signal ();
432b4d03
JK
2148 }
2149
2150 restore_child_signals_mask (&prev_mask);
2151
d6b0e80f
AC
2152 if (!thread_dead)
2153 {
e38504b3 2154 gdb_assert (pid == lp->ptid.lwp ());
d6b0e80f 2155
9327494e 2156 linux_nat_debug_printf ("waitpid %s received %s",
a068643d 2157 target_pid_to_str (lp->ptid).c_str (),
d6b0e80f 2158 status_to_str (status));
d6b0e80f 2159
a9f4bb21
PA
2160 /* Check if the thread has exited. */
2161 if (WIFEXITED (status) || WIFSIGNALED (status))
2162 {
aa01bd36 2163 if (report_thread_events
e38504b3 2164 || lp->ptid.pid () == lp->ptid.lwp ())
69dde7dc 2165 {
9327494e 2166 linux_nat_debug_printf ("LWP %d exited.", lp->ptid.pid ());
69dde7dc 2167
aa01bd36 2168 /* If this is the leader exiting, it means the whole
69dde7dc
PA
2169 process is gone. Store the status to report to the
2170 core. Store it in lp->waitstatus, because lp->status
2171 would be ambiguous (W_EXITCODE(0,0) == 0). */
2172 store_waitstatus (&lp->waitstatus, status);
2173 return 0;
2174 }
2175
a9f4bb21 2176 thread_dead = 1;
9327494e
SM
2177 linux_nat_debug_printf ("%s exited.",
2178 target_pid_to_str (lp->ptid).c_str ());
a9f4bb21 2179 }
d6b0e80f
AC
2180 }
2181
2182 if (thread_dead)
2183 {
e26af52f 2184 exit_lwp (lp);
d6b0e80f
AC
2185 return 0;
2186 }
2187
2188 gdb_assert (WIFSTOPPED (status));
8817a6f2 2189 lp->stopped = 1;
d6b0e80f 2190
8784d563
PA
2191 if (lp->must_set_ptrace_flags)
2192 {
5b6d1e4f 2193 inferior *inf = find_inferior_pid (linux_target, lp->ptid.pid ());
de0d863e 2194 int options = linux_nat_ptrace_options (inf->attach_flag);
8784d563 2195
e38504b3 2196 linux_enable_event_reporting (lp->ptid.lwp (), options);
8784d563
PA
2197 lp->must_set_ptrace_flags = 0;
2198 }
2199
ca2163eb
PA
2200 /* Handle GNU/Linux's syscall SIGTRAPs. */
2201 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2202 {
2203 /* No longer need the sysgood bit. The ptrace event ends up
2204 recorded in lp->waitstatus if we care for it. We can carry
2205 on handling the event like a regular SIGTRAP from here
2206 on. */
2207 status = W_STOPCODE (SIGTRAP);
2208 if (linux_handle_syscall_trap (lp, 1))
2209 return wait_lwp (lp);
2210 }
bfd09d20
JS
2211 else
2212 {
2213 /* Almost all other ptrace-stops are known to be outside of system
2214 calls, with further exceptions in linux_handle_extended_wait. */
2215 lp->syscall_state = TARGET_WAITKIND_IGNORE;
2216 }
ca2163eb 2217
d6b0e80f 2218 /* Handle GNU/Linux's extended waitstatus for trace events. */
89a5711c
DB
2219 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
2220 && linux_is_extended_waitstatus (status))
d6b0e80f 2221 {
9327494e 2222 linux_nat_debug_printf ("Handling extended status 0x%06x", status);
4dd63d48 2223 linux_handle_extended_wait (lp, status);
20ba1ce6 2224 return 0;
d6b0e80f
AC
2225 }
2226
2227 return status;
2228}
2229
2230/* Send a SIGSTOP to LP. */
2231
2232static int
d3a70e03 2233stop_callback (struct lwp_info *lp)
d6b0e80f
AC
2234{
2235 if (!lp->stopped && !lp->signalled)
2236 {
2237 int ret;
2238
9327494e 2239 linux_nat_debug_printf ("kill %s **<SIGSTOP>**",
a068643d 2240 target_pid_to_str (lp->ptid).c_str ());
9327494e 2241
d6b0e80f 2242 errno = 0;
e38504b3 2243 ret = kill_lwp (lp->ptid.lwp (), SIGSTOP);
9327494e 2244 linux_nat_debug_printf ("lwp kill %d %s", ret,
d6b0e80f 2245 errno ? safe_strerror (errno) : "ERRNO-OK");
d6b0e80f
AC
2246
2247 lp->signalled = 1;
2248 gdb_assert (lp->status == 0);
2249 }
2250
2251 return 0;
2252}
2253
7b50312a
PA
2254/* Request a stop on LWP. */
2255
2256void
2257linux_stop_lwp (struct lwp_info *lwp)
2258{
d3a70e03 2259 stop_callback (lwp);
7b50312a
PA
2260}
2261
2db9a427
PA
2262/* See linux-nat.h */
2263
2264void
2265linux_stop_and_wait_all_lwps (void)
2266{
2267 /* Stop all LWP's ... */
d3a70e03 2268 iterate_over_lwps (minus_one_ptid, stop_callback);
2db9a427
PA
2269
2270 /* ... and wait until all of them have reported back that
2271 they're no longer running. */
d3a70e03 2272 iterate_over_lwps (minus_one_ptid, stop_wait_callback);
2db9a427
PA
2273}
2274
2275/* See linux-nat.h */
2276
2277void
2278linux_unstop_all_lwps (void)
2279{
2280 iterate_over_lwps (minus_one_ptid,
d3a70e03
TT
2281 [] (struct lwp_info *info)
2282 {
2283 return resume_stopped_resumed_lwps (info, minus_one_ptid);
2284 });
2db9a427
PA
2285}
2286
57380f4e 2287/* Return non-zero if LWP PID has a pending SIGINT. */
d6b0e80f
AC
2288
2289static int
57380f4e
DJ
2290linux_nat_has_pending_sigint (int pid)
2291{
2292 sigset_t pending, blocked, ignored;
57380f4e
DJ
2293
2294 linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2295
2296 if (sigismember (&pending, SIGINT)
2297 && !sigismember (&ignored, SIGINT))
2298 return 1;
2299
2300 return 0;
2301}
2302
2303/* Set a flag in LP indicating that we should ignore its next SIGINT. */
2304
2305static int
d3a70e03 2306set_ignore_sigint (struct lwp_info *lp)
d6b0e80f 2307{
57380f4e
DJ
2308 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2309 flag to consume the next one. */
2310 if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2311 && WSTOPSIG (lp->status) == SIGINT)
2312 lp->status = 0;
2313 else
2314 lp->ignore_sigint = 1;
2315
2316 return 0;
2317}
2318
2319/* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2320 This function is called after we know the LWP has stopped; if the LWP
2321 stopped before the expected SIGINT was delivered, then it will never have
2322 arrived. Also, if the signal was delivered to a shared queue and consumed
2323 by a different thread, it will never be delivered to this LWP. */
d6b0e80f 2324
57380f4e
DJ
2325static void
2326maybe_clear_ignore_sigint (struct lwp_info *lp)
2327{
2328 if (!lp->ignore_sigint)
2329 return;
2330
e38504b3 2331 if (!linux_nat_has_pending_sigint (lp->ptid.lwp ()))
57380f4e 2332 {
9327494e
SM
2333 linux_nat_debug_printf ("Clearing bogus flag for %s",
2334 target_pid_to_str (lp->ptid).c_str ());
57380f4e
DJ
2335 lp->ignore_sigint = 0;
2336 }
2337}
2338
ebec9a0f
PA
2339/* Fetch the possible triggered data watchpoint info and store it in
2340 LP.
2341
2342 On some archs, like x86, that use debug registers to set
2343 watchpoints, it's possible that the way to know which watched
2344 address trapped, is to check the register that is used to select
2345 which address to watch. Problem is, between setting the watchpoint
2346 and reading back which data address trapped, the user may change
2347 the set of watchpoints, and, as a consequence, GDB changes the
2348 debug registers in the inferior. To avoid reading back a stale
2349 stopped-data-address when that happens, we cache in LP the fact
2350 that a watchpoint trapped, and the corresponding data address, as
2351 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2352 registers meanwhile, we have the cached data we can rely on. */
2353
9c02b525
PA
2354static int
2355check_stopped_by_watchpoint (struct lwp_info *lp)
ebec9a0f 2356{
2989a365 2357 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
ebec9a0f
PA
2358 inferior_ptid = lp->ptid;
2359
f6ac5f3d 2360 if (linux_target->low_stopped_by_watchpoint ())
ebec9a0f 2361 {
15c66dd6 2362 lp->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
f6ac5f3d
PA
2363 lp->stopped_data_address_p
2364 = linux_target->low_stopped_data_address (&lp->stopped_data_address);
ebec9a0f
PA
2365 }
2366
15c66dd6 2367 return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
9c02b525
PA
2368}
2369
9c02b525 2370/* Returns true if the LWP had stopped for a watchpoint. */
ebec9a0f 2371
57810aa7 2372bool
f6ac5f3d 2373linux_nat_target::stopped_by_watchpoint ()
ebec9a0f
PA
2374{
2375 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2376
2377 gdb_assert (lp != NULL);
2378
15c66dd6 2379 return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
ebec9a0f
PA
2380}
2381
57810aa7 2382bool
f6ac5f3d 2383linux_nat_target::stopped_data_address (CORE_ADDR *addr_p)
ebec9a0f
PA
2384{
2385 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2386
2387 gdb_assert (lp != NULL);
2388
2389 *addr_p = lp->stopped_data_address;
2390
2391 return lp->stopped_data_address_p;
2392}
2393
26ab7092
JK
2394/* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2395
135340af
PA
2396bool
2397linux_nat_target::low_status_is_event (int status)
26ab7092
JK
2398{
2399 return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2400}
2401
57380f4e
DJ
2402/* Wait until LP is stopped. */
2403
2404static int
d3a70e03 2405stop_wait_callback (struct lwp_info *lp)
57380f4e 2406{
5b6d1e4f 2407 inferior *inf = find_inferior_ptid (linux_target, lp->ptid);
6c95b8df
PA
2408
2409 /* If this is a vfork parent, bail out, it is not going to report
2410 any SIGSTOP until the vfork is done with. */
2411 if (inf->vfork_child != NULL)
2412 return 0;
2413
d6b0e80f
AC
2414 if (!lp->stopped)
2415 {
2416 int status;
2417
2418 status = wait_lwp (lp);
2419 if (status == 0)
2420 return 0;
2421
57380f4e
DJ
2422 if (lp->ignore_sigint && WIFSTOPPED (status)
2423 && WSTOPSIG (status) == SIGINT)
d6b0e80f 2424 {
57380f4e 2425 lp->ignore_sigint = 0;
d6b0e80f
AC
2426
2427 errno = 0;
e38504b3 2428 ptrace (PTRACE_CONT, lp->ptid.lwp (), 0, 0);
8817a6f2 2429 lp->stopped = 0;
9327494e
SM
2430 linux_nat_debug_printf
2431 ("PTRACE_CONT %s, 0, 0 (%s) (discarding SIGINT)",
2432 target_pid_to_str (lp->ptid).c_str (),
2433 errno ? safe_strerror (errno) : "OK");
d6b0e80f 2434
d3a70e03 2435 return stop_wait_callback (lp);
d6b0e80f
AC
2436 }
2437
57380f4e
DJ
2438 maybe_clear_ignore_sigint (lp);
2439
d6b0e80f
AC
2440 if (WSTOPSIG (status) != SIGSTOP)
2441 {
e5ef252a 2442 /* The thread was stopped with a signal other than SIGSTOP. */
7feb7d06 2443
9327494e
SM
2444 linux_nat_debug_printf ("Pending event %s in %s",
2445 status_to_str ((int) status),
2446 target_pid_to_str (lp->ptid).c_str ());
e5ef252a
PA
2447
2448 /* Save the sigtrap event. */
2449 lp->status = status;
e5ef252a 2450 gdb_assert (lp->signalled);
e7ad2f14 2451 save_stop_reason (lp);
d6b0e80f
AC
2452 }
2453 else
2454 {
7010835a 2455 /* We caught the SIGSTOP that we intended to catch. */
e5ef252a 2456
9327494e
SM
2457 linux_nat_debug_printf ("Expected SIGSTOP caught for %s.",
2458 target_pid_to_str (lp->ptid).c_str ());
e5ef252a 2459
d6b0e80f 2460 lp->signalled = 0;
7010835a
AB
2461
2462 /* If we are waiting for this stop so we can report the thread
2463 stopped then we need to record this status. Otherwise, we can
2464 now discard this stop event. */
2465 if (lp->last_resume_kind == resume_stop)
2466 {
2467 lp->status = status;
2468 save_stop_reason (lp);
2469 }
d6b0e80f
AC
2470 }
2471 }
2472
2473 return 0;
2474}
2475
9c02b525
PA
2476/* Return non-zero if LP has a wait status pending. Discard the
2477 pending event and resume the LWP if the event that originally
2478 caused the stop became uninteresting. */
d6b0e80f
AC
2479
2480static int
d3a70e03 2481status_callback (struct lwp_info *lp)
d6b0e80f
AC
2482{
2483 /* Only report a pending wait status if we pretend that this has
2484 indeed been resumed. */
ca2163eb
PA
2485 if (!lp->resumed)
2486 return 0;
2487
eb54c8bf
PA
2488 if (!lwp_status_pending_p (lp))
2489 return 0;
2490
15c66dd6
PA
2491 if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
2492 || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
9c02b525 2493 {
5b6d1e4f 2494 struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid);
9c02b525
PA
2495 CORE_ADDR pc;
2496 int discard = 0;
2497
9c02b525
PA
2498 pc = regcache_read_pc (regcache);
2499
2500 if (pc != lp->stop_pc)
2501 {
9327494e
SM
2502 linux_nat_debug_printf ("PC of %s changed. was=%s, now=%s",
2503 target_pid_to_str (lp->ptid).c_str (),
2504 paddress (target_gdbarch (), lp->stop_pc),
2505 paddress (target_gdbarch (), pc));
9c02b525
PA
2506 discard = 1;
2507 }
faf09f01
PA
2508
2509#if !USE_SIGTRAP_SIGINFO
a01bda52 2510 else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
9c02b525 2511 {
9327494e
SM
2512 linux_nat_debug_printf ("previous breakpoint of %s, at %s gone",
2513 target_pid_to_str (lp->ptid).c_str (),
2514 paddress (target_gdbarch (), lp->stop_pc));
9c02b525
PA
2515
2516 discard = 1;
2517 }
faf09f01 2518#endif
9c02b525
PA
2519
2520 if (discard)
2521 {
9327494e
SM
2522 linux_nat_debug_printf ("pending event of %s cancelled.",
2523 target_pid_to_str (lp->ptid).c_str ());
9c02b525
PA
2524
2525 lp->status = 0;
2526 linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
2527 return 0;
2528 }
9c02b525
PA
2529 }
2530
eb54c8bf 2531 return 1;
d6b0e80f
AC
2532}
2533
d6b0e80f
AC
2534/* Count the LWP's that have had events. */
2535
2536static int
d3a70e03 2537count_events_callback (struct lwp_info *lp, int *count)
d6b0e80f 2538{
d6b0e80f
AC
2539 gdb_assert (count != NULL);
2540
9c02b525
PA
2541 /* Select only resumed LWPs that have an event pending. */
2542 if (lp->resumed && lwp_status_pending_p (lp))
d6b0e80f
AC
2543 (*count)++;
2544
2545 return 0;
2546}
2547
2548/* Select the LWP (if any) that is currently being single-stepped. */
2549
2550static int
d3a70e03 2551select_singlestep_lwp_callback (struct lwp_info *lp)
d6b0e80f 2552{
25289eb2
PA
2553 if (lp->last_resume_kind == resume_step
2554 && lp->status != 0)
d6b0e80f
AC
2555 return 1;
2556 else
2557 return 0;
2558}
2559
8a99810d
PA
2560/* Returns true if LP has a status pending. */
2561
2562static int
2563lwp_status_pending_p (struct lwp_info *lp)
2564{
2565 /* We check for lp->waitstatus in addition to lp->status, because we
2566 can have pending process exits recorded in lp->status and
2567 W_EXITCODE(0,0) happens to be 0. */
2568 return lp->status != 0 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE;
2569}
2570
b90fc188 2571/* Select the Nth LWP that has had an event. */
d6b0e80f
AC
2572
2573static int
d3a70e03 2574select_event_lwp_callback (struct lwp_info *lp, int *selector)
d6b0e80f 2575{
d6b0e80f
AC
2576 gdb_assert (selector != NULL);
2577
9c02b525
PA
2578 /* Select only resumed LWPs that have an event pending. */
2579 if (lp->resumed && lwp_status_pending_p (lp))
d6b0e80f
AC
2580 if ((*selector)-- == 0)
2581 return 1;
2582
2583 return 0;
2584}
2585
e7ad2f14
PA
2586/* Called when the LWP stopped for a signal/trap. If it stopped for a
2587 trap check what caused it (breakpoint, watchpoint, trace, etc.),
2588 and save the result in the LWP's stop_reason field. If it stopped
2589 for a breakpoint, decrement the PC if necessary on the lwp's
2590 architecture. */
9c02b525 2591
e7ad2f14
PA
2592static void
2593save_stop_reason (struct lwp_info *lp)
710151dd 2594{
e7ad2f14
PA
2595 struct regcache *regcache;
2596 struct gdbarch *gdbarch;
515630c5 2597 CORE_ADDR pc;
9c02b525 2598 CORE_ADDR sw_bp_pc;
faf09f01
PA
2599#if USE_SIGTRAP_SIGINFO
2600 siginfo_t siginfo;
2601#endif
9c02b525 2602
e7ad2f14
PA
2603 gdb_assert (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON);
2604 gdb_assert (lp->status != 0);
2605
135340af 2606 if (!linux_target->low_status_is_event (lp->status))
e7ad2f14
PA
2607 return;
2608
5b6d1e4f 2609 regcache = get_thread_regcache (linux_target, lp->ptid);
ac7936df 2610 gdbarch = regcache->arch ();
e7ad2f14 2611
9c02b525 2612 pc = regcache_read_pc (regcache);
527a273a 2613 sw_bp_pc = pc - gdbarch_decr_pc_after_break (gdbarch);
515630c5 2614
faf09f01
PA
2615#if USE_SIGTRAP_SIGINFO
2616 if (linux_nat_get_siginfo (lp->ptid, &siginfo))
2617 {
2618 if (siginfo.si_signo == SIGTRAP)
2619 {
e7ad2f14
PA
2620 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code)
2621 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
faf09f01 2622 {
e7ad2f14
PA
2623 /* The si_code is ambiguous on this arch -- check debug
2624 registers. */
2625 if (!check_stopped_by_watchpoint (lp))
2626 lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
2627 }
2628 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code))
2629 {
2630 /* If we determine the LWP stopped for a SW breakpoint,
2631 trust it. Particularly don't check watchpoint
7da6a5b9 2632 registers, because, at least on s390, we'd find
e7ad2f14
PA
2633 stopped-by-watchpoint as long as there's a watchpoint
2634 set. */
faf09f01 2635 lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
faf09f01 2636 }
e7ad2f14 2637 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
faf09f01 2638 {
e7ad2f14
PA
2639 /* This can indicate either a hardware breakpoint or
2640 hardware watchpoint. Check debug registers. */
2641 if (!check_stopped_by_watchpoint (lp))
2642 lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
faf09f01 2643 }
2bf6fb9d
PA
2644 else if (siginfo.si_code == TRAP_TRACE)
2645 {
9327494e
SM
2646 linux_nat_debug_printf ("%s stopped by trace",
2647 target_pid_to_str (lp->ptid).c_str ());
e7ad2f14
PA
2648
2649 /* We may have single stepped an instruction that
2650 triggered a watchpoint. In that case, on some
2651 architectures (such as x86), instead of TRAP_HWBKPT,
2652 si_code indicates TRAP_TRACE, and we need to check
2653 the debug registers separately. */
2654 check_stopped_by_watchpoint (lp);
2bf6fb9d 2655 }
faf09f01
PA
2656 }
2657 }
2658#else
9c02b525 2659 if ((!lp->step || lp->stop_pc == sw_bp_pc)
a01bda52 2660 && software_breakpoint_inserted_here_p (regcache->aspace (),
9c02b525 2661 sw_bp_pc))
710151dd 2662 {
9c02b525
PA
2663 /* The LWP was either continued, or stepped a software
2664 breakpoint instruction. */
e7ad2f14
PA
2665 lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
2666 }
2667
a01bda52 2668 if (hardware_breakpoint_inserted_here_p (regcache->aspace (), pc))
e7ad2f14
PA
2669 lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
2670
2671 if (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON)
2672 check_stopped_by_watchpoint (lp);
2673#endif
2674
2675 if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
2676 {
9327494e
SM
2677 linux_nat_debug_printf ("%s stopped by software breakpoint",
2678 target_pid_to_str (lp->ptid).c_str ());
710151dd
PA
2679
2680 /* Back up the PC if necessary. */
9c02b525
PA
2681 if (pc != sw_bp_pc)
2682 regcache_write_pc (regcache, sw_bp_pc);
515630c5 2683
e7ad2f14
PA
2684 /* Update this so we record the correct stop PC below. */
2685 pc = sw_bp_pc;
710151dd 2686 }
e7ad2f14 2687 else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
9c02b525 2688 {
9327494e
SM
2689 linux_nat_debug_printf ("%s stopped by hardware breakpoint",
2690 target_pid_to_str (lp->ptid).c_str ());
e7ad2f14
PA
2691 }
2692 else if (lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
2693 {
9327494e
SM
2694 linux_nat_debug_printf ("%s stopped by hardware watchpoint",
2695 target_pid_to_str (lp->ptid).c_str ());
9c02b525 2696 }
d6b0e80f 2697
e7ad2f14 2698 lp->stop_pc = pc;
d6b0e80f
AC
2699}
2700
faf09f01
PA
2701
2702/* Returns true if the LWP had stopped for a software breakpoint. */
2703
57810aa7 2704bool
f6ac5f3d 2705linux_nat_target::stopped_by_sw_breakpoint ()
faf09f01
PA
2706{
2707 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2708
2709 gdb_assert (lp != NULL);
2710
2711 return lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
2712}
2713
2714/* Implement the supports_stopped_by_sw_breakpoint method. */
2715
57810aa7 2716bool
f6ac5f3d 2717linux_nat_target::supports_stopped_by_sw_breakpoint ()
faf09f01
PA
2718{
2719 return USE_SIGTRAP_SIGINFO;
2720}
2721
2722/* Returns true if the LWP had stopped for a hardware
2723 breakpoint/watchpoint. */
2724
57810aa7 2725bool
f6ac5f3d 2726linux_nat_target::stopped_by_hw_breakpoint ()
faf09f01
PA
2727{
2728 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2729
2730 gdb_assert (lp != NULL);
2731
2732 return lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
2733}
2734
2735/* Implement the supports_stopped_by_hw_breakpoint method. */
2736
57810aa7 2737bool
f6ac5f3d 2738linux_nat_target::supports_stopped_by_hw_breakpoint ()
faf09f01
PA
2739{
2740 return USE_SIGTRAP_SIGINFO;
2741}
2742
d6b0e80f
AC
2743/* Select one LWP out of those that have events pending. */
2744
2745static void
d90e17a7 2746select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
d6b0e80f
AC
2747{
2748 int num_events = 0;
2749 int random_selector;
9c02b525 2750 struct lwp_info *event_lp = NULL;
d6b0e80f 2751
ac264b3b 2752 /* Record the wait status for the original LWP. */
d6b0e80f
AC
2753 (*orig_lp)->status = *status;
2754
9c02b525
PA
2755 /* In all-stop, give preference to the LWP that is being
2756 single-stepped. There will be at most one, and it will be the
2757 LWP that the core is most interested in. If we didn't do this,
2758 then we'd have to handle pending step SIGTRAPs somehow in case
2759 the core later continues the previously-stepped thread, as
2760 otherwise we'd report the pending SIGTRAP then, and the core, not
2761 having stepped the thread, wouldn't understand what the trap was
2762 for, and therefore would report it to the user as a random
2763 signal. */
fbea99ea 2764 if (!target_is_non_stop_p ())
d6b0e80f 2765 {
d3a70e03 2766 event_lp = iterate_over_lwps (filter, select_singlestep_lwp_callback);
9c02b525
PA
2767 if (event_lp != NULL)
2768 {
9327494e
SM
2769 linux_nat_debug_printf ("Select single-step %s",
2770 target_pid_to_str (event_lp->ptid).c_str ());
9c02b525 2771 }
d6b0e80f 2772 }
9c02b525
PA
2773
2774 if (event_lp == NULL)
d6b0e80f 2775 {
9c02b525 2776 /* Pick one at random, out of those which have had events. */
d6b0e80f 2777
9c02b525 2778 /* First see how many events we have. */
d3a70e03
TT
2779 iterate_over_lwps (filter,
2780 [&] (struct lwp_info *info)
2781 {
2782 return count_events_callback (info, &num_events);
2783 });
8bf3b159 2784 gdb_assert (num_events > 0);
d6b0e80f 2785
9c02b525
PA
2786 /* Now randomly pick a LWP out of those that have had
2787 events. */
d6b0e80f
AC
2788 random_selector = (int)
2789 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2790
9327494e
SM
2791 if (num_events > 1)
2792 linux_nat_debug_printf ("Found %d events, selecting #%d",
2793 num_events, random_selector);
d6b0e80f 2794
d3a70e03
TT
2795 event_lp
2796 = (iterate_over_lwps
2797 (filter,
2798 [&] (struct lwp_info *info)
2799 {
2800 return select_event_lwp_callback (info,
2801 &random_selector);
2802 }));
d6b0e80f
AC
2803 }
2804
2805 if (event_lp != NULL)
2806 {
2807 /* Switch the event LWP. */
2808 *orig_lp = event_lp;
2809 *status = event_lp->status;
2810 }
2811
2812 /* Flush the wait status for the event LWP. */
2813 (*orig_lp)->status = 0;
2814}
2815
2816/* Return non-zero if LP has been resumed. */
2817
2818static int
d3a70e03 2819resumed_callback (struct lwp_info *lp)
d6b0e80f
AC
2820{
2821 return lp->resumed;
2822}
2823
02f3fc28 2824/* Check if we should go on and pass this event to common code.
7da6a5b9 2825 Return the affected lwp if we should, or NULL otherwise. */
12d9289a 2826
02f3fc28 2827static struct lwp_info *
9c02b525 2828linux_nat_filter_event (int lwpid, int status)
02f3fc28
PA
2829{
2830 struct lwp_info *lp;
89a5711c 2831 int event = linux_ptrace_get_extended_event (status);
02f3fc28 2832
f2907e49 2833 lp = find_lwp_pid (ptid_t (lwpid));
02f3fc28
PA
2834
2835 /* Check for stop events reported by a process we didn't already
2836 know about - anything not already in our LWP list.
2837
2838 If we're expecting to receive stopped processes after
2839 fork, vfork, and clone events, then we'll just add the
2840 new one to our list and go back to waiting for the event
2841 to be reported - the stopped process might be returned
0e5bf2a8
PA
2842 from waitpid before or after the event is.
2843
2844 But note the case of a non-leader thread exec'ing after the
2845 leader having exited, and gone from our lists. The non-leader
2846 thread changes its tid to the tgid. */
2847
2848 if (WIFSTOPPED (status) && lp == NULL
89a5711c 2849 && (WSTOPSIG (status) == SIGTRAP && event == PTRACE_EVENT_EXEC))
0e5bf2a8
PA
2850 {
2851 /* A multi-thread exec after we had seen the leader exiting. */
9327494e 2852 linux_nat_debug_printf ("Re-adding thread group leader LWP %d.", lwpid);
0e5bf2a8 2853
fd79271b 2854 lp = add_lwp (ptid_t (lwpid, lwpid, 0));
0e5bf2a8
PA
2855 lp->stopped = 1;
2856 lp->resumed = 1;
5b6d1e4f 2857 add_thread (linux_target, lp->ptid);
0e5bf2a8
PA
2858 }
2859
02f3fc28
PA
2860 if (WIFSTOPPED (status) && !lp)
2861 {
9327494e
SM
2862 linux_nat_debug_printf ("saving LWP %ld status %s in stopped_pids list",
2863 (long) lwpid, status_to_str (status));
84636d28 2864 add_to_pid_list (&stopped_pids, lwpid, status);
02f3fc28
PA
2865 return NULL;
2866 }
2867
2868 /* Make sure we don't report an event for the exit of an LWP not in
1777feb0 2869 our list, i.e. not part of the current process. This can happen
fd62cb89 2870 if we detach from a program we originally forked and then it
02f3fc28
PA
2871 exits. */
2872 if (!WIFSTOPPED (status) && !lp)
2873 return NULL;
2874
8817a6f2
PA
2875 /* This LWP is stopped now. (And if dead, this prevents it from
2876 ever being continued.) */
2877 lp->stopped = 1;
2878
8784d563
PA
2879 if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
2880 {
5b6d1e4f 2881 inferior *inf = find_inferior_pid (linux_target, lp->ptid.pid ());
de0d863e 2882 int options = linux_nat_ptrace_options (inf->attach_flag);
8784d563 2883
e38504b3 2884 linux_enable_event_reporting (lp->ptid.lwp (), options);
8784d563
PA
2885 lp->must_set_ptrace_flags = 0;
2886 }
2887
ca2163eb
PA
2888 /* Handle GNU/Linux's syscall SIGTRAPs. */
2889 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2890 {
2891 /* No longer need the sysgood bit. The ptrace event ends up
2892 recorded in lp->waitstatus if we care for it. We can carry
2893 on handling the event like a regular SIGTRAP from here
2894 on. */
2895 status = W_STOPCODE (SIGTRAP);
2896 if (linux_handle_syscall_trap (lp, 0))
2897 return NULL;
2898 }
bfd09d20
JS
2899 else
2900 {
2901 /* Almost all other ptrace-stops are known to be outside of system
2902 calls, with further exceptions in linux_handle_extended_wait. */
2903 lp->syscall_state = TARGET_WAITKIND_IGNORE;
2904 }
02f3fc28 2905
ca2163eb 2906 /* Handle GNU/Linux's extended waitstatus for trace events. */
89a5711c
DB
2907 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
2908 && linux_is_extended_waitstatus (status))
02f3fc28 2909 {
9327494e
SM
2910 linux_nat_debug_printf ("Handling extended status 0x%06x", status);
2911
4dd63d48 2912 if (linux_handle_extended_wait (lp, status))
02f3fc28
PA
2913 return NULL;
2914 }
2915
2916 /* Check if the thread has exited. */
9c02b525
PA
2917 if (WIFEXITED (status) || WIFSIGNALED (status))
2918 {
aa01bd36 2919 if (!report_thread_events
e99b03dc 2920 && num_lwps (lp->ptid.pid ()) > 1)
02f3fc28 2921 {
9327494e
SM
2922 linux_nat_debug_printf ("%s exited.",
2923 target_pid_to_str (lp->ptid).c_str ());
9c02b525 2924
4a6ed09b
PA
2925 /* If there is at least one more LWP, then the exit signal
2926 was not the end of the debugged application and should be
2927 ignored. */
2928 exit_lwp (lp);
2929 return NULL;
02f3fc28
PA
2930 }
2931
77598427
PA
2932 /* Note that even if the leader was ptrace-stopped, it can still
2933 exit, if e.g., some other thread brings down the whole
2934 process (calls `exit'). So don't assert that the lwp is
2935 resumed. */
9327494e
SM
2936 linux_nat_debug_printf ("LWP %ld exited (resumed=%d)",
2937 lp->ptid.lwp (), lp->resumed);
02f3fc28 2938
9c02b525
PA
2939 /* Dead LWP's aren't expected to reported a pending sigstop. */
2940 lp->signalled = 0;
2941
2942 /* Store the pending event in the waitstatus, because
2943 W_EXITCODE(0,0) == 0. */
2944 store_waitstatus (&lp->waitstatus, status);
2945 return lp;
02f3fc28
PA
2946 }
2947
02f3fc28
PA
2948 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2949 an attempt to stop an LWP. */
2950 if (lp->signalled
2951 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
2952 {
02f3fc28
PA
2953 lp->signalled = 0;
2954
2bf6fb9d 2955 if (lp->last_resume_kind == resume_stop)
25289eb2 2956 {
9327494e
SM
2957 linux_nat_debug_printf ("resume_stop SIGSTOP caught for %s.",
2958 target_pid_to_str (lp->ptid).c_str ());
2bf6fb9d
PA
2959 }
2960 else
2961 {
2962 /* This is a delayed SIGSTOP. Filter out the event. */
02f3fc28 2963
9327494e
SM
2964 linux_nat_debug_printf
2965 ("%s %s, 0, 0 (discard delayed SIGSTOP)",
2966 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2967 target_pid_to_str (lp->ptid).c_str ());
02f3fc28 2968
2bf6fb9d 2969 linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
25289eb2 2970 gdb_assert (lp->resumed);
25289eb2
PA
2971 return NULL;
2972 }
02f3fc28
PA
2973 }
2974
57380f4e
DJ
2975 /* Make sure we don't report a SIGINT that we have already displayed
2976 for another thread. */
2977 if (lp->ignore_sigint
2978 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
2979 {
9327494e
SM
2980 linux_nat_debug_printf ("Delayed SIGINT caught for %s.",
2981 target_pid_to_str (lp->ptid).c_str ());
57380f4e
DJ
2982
2983 /* This is a delayed SIGINT. */
2984 lp->ignore_sigint = 0;
2985
8a99810d 2986 linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
9327494e
SM
2987 linux_nat_debug_printf ("%s %s, 0, 0 (discard SIGINT)",
2988 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2989 target_pid_to_str (lp->ptid).c_str ());
57380f4e
DJ
2990 gdb_assert (lp->resumed);
2991
2992 /* Discard the event. */
2993 return NULL;
2994 }
2995
9c02b525
PA
2996 /* Don't report signals that GDB isn't interested in, such as
2997 signals that are neither printed nor stopped upon. Stopping all
7da6a5b9 2998 threads can be a bit time-consuming, so if we want decent
9c02b525
PA
2999 performance with heavily multi-threaded programs, especially when
3000 they're using a high frequency timer, we'd better avoid it if we
3001 can. */
3002 if (WIFSTOPPED (status))
3003 {
3004 enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
3005
fbea99ea 3006 if (!target_is_non_stop_p ())
9c02b525
PA
3007 {
3008 /* Only do the below in all-stop, as we currently use SIGSTOP
3009 to implement target_stop (see linux_nat_stop) in
3010 non-stop. */
3011 if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
3012 {
3013 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3014 forwarded to the entire process group, that is, all LWPs
3015 will receive it - unless they're using CLONE_THREAD to
3016 share signals. Since we only want to report it once, we
3017 mark it as ignored for all LWPs except this one. */
d3a70e03 3018 iterate_over_lwps (ptid_t (lp->ptid.pid ()), set_ignore_sigint);
9c02b525
PA
3019 lp->ignore_sigint = 0;
3020 }
3021 else
3022 maybe_clear_ignore_sigint (lp);
3023 }
3024
3025 /* When using hardware single-step, we need to report every signal.
c9587f88 3026 Otherwise, signals in pass_mask may be short-circuited
d8c06f22
AB
3027 except signals that might be caused by a breakpoint, or SIGSTOP
3028 if we sent the SIGSTOP and are waiting for it to arrive. */
9c02b525 3029 if (!lp->step
c9587f88 3030 && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status))
d8c06f22 3031 && (WSTOPSIG (status) != SIGSTOP
5b6d1e4f 3032 || !find_thread_ptid (linux_target, lp->ptid)->stop_requested)
c9587f88 3033 && !linux_wstatus_maybe_breakpoint (status))
9c02b525
PA
3034 {
3035 linux_resume_one_lwp (lp, lp->step, signo);
9327494e
SM
3036 linux_nat_debug_printf
3037 ("%s %s, %s (preempt 'handle')",
3038 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3039 target_pid_to_str (lp->ptid).c_str (),
3040 (signo != GDB_SIGNAL_0
3041 ? strsignal (gdb_signal_to_host (signo)) : "0"));
9c02b525
PA
3042 return NULL;
3043 }
3044 }
3045
02f3fc28
PA
3046 /* An interesting event. */
3047 gdb_assert (lp);
ca2163eb 3048 lp->status = status;
e7ad2f14 3049 save_stop_reason (lp);
02f3fc28
PA
3050 return lp;
3051}
3052
0e5bf2a8
PA
3053/* Detect zombie thread group leaders, and "exit" them. We can't reap
3054 their exits until all other threads in the group have exited. */
3055
3056static void
3057check_zombie_leaders (void)
3058{
08036331 3059 for (inferior *inf : all_inferiors ())
0e5bf2a8
PA
3060 {
3061 struct lwp_info *leader_lp;
3062
3063 if (inf->pid == 0)
3064 continue;
3065
f2907e49 3066 leader_lp = find_lwp_pid (ptid_t (inf->pid));
0e5bf2a8
PA
3067 if (leader_lp != NULL
3068 /* Check if there are other threads in the group, as we may
3069 have raced with the inferior simply exiting. */
3070 && num_lwps (inf->pid) > 1
5f572dec 3071 && linux_proc_pid_is_zombie (inf->pid))
0e5bf2a8 3072 {
9327494e
SM
3073 linux_nat_debug_printf ("Thread group leader %d zombie "
3074 "(it exited, or another thread execd).",
3075 inf->pid);
0e5bf2a8
PA
3076
3077 /* A leader zombie can mean one of two things:
3078
3079 - It exited, and there's an exit status pending
3080 available, or only the leader exited (not the whole
3081 program). In the latter case, we can't waitpid the
3082 leader's exit status until all other threads are gone.
3083
3084 - There are 3 or more threads in the group, and a thread
4a6ed09b
PA
3085 other than the leader exec'd. See comments on exec
3086 events at the top of the file. We could try
0e5bf2a8
PA
3087 distinguishing the exit and exec cases, by waiting once
3088 more, and seeing if something comes out, but it doesn't
3089 sound useful. The previous leader _does_ go away, and
3090 we'll re-add the new one once we see the exec event
3091 (which is just the same as what would happen if the
3092 previous leader did exit voluntarily before some other
3093 thread execs). */
3094
9327494e 3095 linux_nat_debug_printf ("Thread group leader %d vanished.", inf->pid);
0e5bf2a8
PA
3096 exit_lwp (leader_lp);
3097 }
3098 }
3099}
3100
aa01bd36
PA
3101/* Convenience function that is called when the kernel reports an exit
3102 event. This decides whether to report the event to GDB as a
3103 process exit event, a thread exit event, or to suppress the
3104 event. */
3105
3106static ptid_t
3107filter_exit_event (struct lwp_info *event_child,
3108 struct target_waitstatus *ourstatus)
3109{
3110 ptid_t ptid = event_child->ptid;
3111
e99b03dc 3112 if (num_lwps (ptid.pid ()) > 1)
aa01bd36
PA
3113 {
3114 if (report_thread_events)
3115 ourstatus->kind = TARGET_WAITKIND_THREAD_EXITED;
3116 else
3117 ourstatus->kind = TARGET_WAITKIND_IGNORE;
3118
3119 exit_lwp (event_child);
3120 }
3121
3122 return ptid;
3123}
3124
d6b0e80f 3125static ptid_t
f6ac5f3d 3126linux_nat_wait_1 (ptid_t ptid, struct target_waitstatus *ourstatus,
b60cea74 3127 target_wait_flags target_options)
d6b0e80f 3128{
fc9b8e47 3129 sigset_t prev_mask;
4b60df3d 3130 enum resume_kind last_resume_kind;
12d9289a 3131 struct lwp_info *lp;
12d9289a 3132 int status;
d6b0e80f 3133
9327494e 3134 linux_nat_debug_printf ("enter");
b84876c2 3135
f973ed9c
DJ
3136 /* The first time we get here after starting a new inferior, we may
3137 not have added it to the LWP list yet - this is the earliest
3138 moment at which we know its PID. */
677c92fe 3139 if (ptid.is_pid () && find_lwp_pid (ptid) == nullptr)
f973ed9c 3140 {
677c92fe 3141 ptid_t lwp_ptid (ptid.pid (), ptid.pid ());
27c9d204 3142
677c92fe
SM
3143 /* Upgrade the main thread's ptid. */
3144 thread_change_ptid (linux_target, ptid, lwp_ptid);
3145 lp = add_initial_lwp (lwp_ptid);
f973ed9c
DJ
3146 lp->resumed = 1;
3147 }
3148
12696c10 3149 /* Make sure SIGCHLD is blocked until the sigsuspend below. */
7feb7d06 3150 block_child_signals (&prev_mask);
d6b0e80f 3151
d6b0e80f 3152 /* First check if there is a LWP with a wait status pending. */
d3a70e03 3153 lp = iterate_over_lwps (ptid, status_callback);
8a99810d 3154 if (lp != NULL)
d6b0e80f 3155 {
9327494e
SM
3156 linux_nat_debug_printf ("Using pending wait status %s for %s.",
3157 status_to_str (lp->status),
3158 target_pid_to_str (lp->ptid).c_str ());
d6b0e80f
AC
3159 }
3160
9c02b525
PA
3161 /* But if we don't find a pending event, we'll have to wait. Always
3162 pull all events out of the kernel. We'll randomly select an
3163 event LWP out of all that have events, to prevent starvation. */
7feb7d06 3164
d90e17a7 3165 while (lp == NULL)
d6b0e80f
AC
3166 {
3167 pid_t lwpid;
3168
0e5bf2a8
PA
3169 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3170 quirks:
3171
3172 - If the thread group leader exits while other threads in the
3173 thread group still exist, waitpid(TGID, ...) hangs. That
3174 waitpid won't return an exit status until the other threads
85102364 3175 in the group are reaped.
0e5bf2a8
PA
3176
3177 - When a non-leader thread execs, that thread just vanishes
3178 without reporting an exit (so we'd hang if we waited for it
3179 explicitly in that case). The exec event is reported to
3180 the TGID pid. */
3181
3182 errno = 0;
4a6ed09b 3183 lwpid = my_waitpid (-1, &status, __WALL | WNOHANG);
0e5bf2a8 3184
9327494e
SM
3185 linux_nat_debug_printf ("waitpid(-1, ...) returned %d, %s",
3186 lwpid,
3187 errno ? safe_strerror (errno) : "ERRNO-OK");
b84876c2 3188
d6b0e80f
AC
3189 if (lwpid > 0)
3190 {
9327494e 3191 linux_nat_debug_printf ("waitpid %ld received %s",
d6b0e80f 3192 (long) lwpid, status_to_str (status));
d6b0e80f 3193
9c02b525 3194 linux_nat_filter_event (lwpid, status);
0e5bf2a8
PA
3195 /* Retry until nothing comes out of waitpid. A single
3196 SIGCHLD can indicate more than one child stopped. */
3197 continue;
d6b0e80f
AC
3198 }
3199
20ba1ce6
PA
3200 /* Now that we've pulled all events out of the kernel, resume
3201 LWPs that don't have an interesting event to report. */
3202 iterate_over_lwps (minus_one_ptid,
d3a70e03
TT
3203 [] (struct lwp_info *info)
3204 {
3205 return resume_stopped_resumed_lwps (info, minus_one_ptid);
3206 });
20ba1ce6
PA
3207
3208 /* ... and find an LWP with a status to report to the core, if
3209 any. */
d3a70e03 3210 lp = iterate_over_lwps (ptid, status_callback);
9c02b525
PA
3211 if (lp != NULL)
3212 break;
3213
0e5bf2a8
PA
3214 /* Check for zombie thread group leaders. Those can't be reaped
3215 until all other threads in the thread group are. */
3216 check_zombie_leaders ();
d6b0e80f 3217
0e5bf2a8
PA
3218 /* If there are no resumed children left, bail. We'd be stuck
3219 forever in the sigsuspend call below otherwise. */
d3a70e03 3220 if (iterate_over_lwps (ptid, resumed_callback) == NULL)
0e5bf2a8 3221 {
9327494e 3222 linux_nat_debug_printf ("exit (no resumed LWP)");
b84876c2 3223
0e5bf2a8 3224 ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
b84876c2 3225
0e5bf2a8
PA
3226 restore_child_signals_mask (&prev_mask);
3227 return minus_one_ptid;
d6b0e80f 3228 }
28736962 3229
0e5bf2a8
PA
3230 /* No interesting event to report to the core. */
3231
3232 if (target_options & TARGET_WNOHANG)
3233 {
9327494e 3234 linux_nat_debug_printf ("exit (ignore)");
28736962 3235
0e5bf2a8 3236 ourstatus->kind = TARGET_WAITKIND_IGNORE;
28736962
PA
3237 restore_child_signals_mask (&prev_mask);
3238 return minus_one_ptid;
3239 }
d6b0e80f
AC
3240
3241 /* We shouldn't end up here unless we want to try again. */
d90e17a7 3242 gdb_assert (lp == NULL);
0e5bf2a8
PA
3243
3244 /* Block until we get an event reported with SIGCHLD. */
9c3a5d93 3245 wait_for_signal ();
d6b0e80f
AC
3246 }
3247
d6b0e80f
AC
3248 gdb_assert (lp);
3249
ca2163eb
PA
3250 status = lp->status;
3251 lp->status = 0;
3252
fbea99ea 3253 if (!target_is_non_stop_p ())
4c28f408
PA
3254 {
3255 /* Now stop all other LWP's ... */
d3a70e03 3256 iterate_over_lwps (minus_one_ptid, stop_callback);
4c28f408
PA
3257
3258 /* ... and wait until all of them have reported back that
3259 they're no longer running. */
d3a70e03 3260 iterate_over_lwps (minus_one_ptid, stop_wait_callback);
9c02b525
PA
3261 }
3262
3263 /* If we're not waiting for a specific LWP, choose an event LWP from
3264 among those that have had events. Giving equal priority to all
3265 LWPs that have had events helps prevent starvation. */
d7e15655 3266 if (ptid == minus_one_ptid || ptid.is_pid ())
9c02b525
PA
3267 select_event_lwp (ptid, &lp, &status);
3268
3269 gdb_assert (lp != NULL);
3270
3271 /* Now that we've selected our final event LWP, un-adjust its PC if
faf09f01
PA
3272 it was a software breakpoint, and we can't reliably support the
3273 "stopped by software breakpoint" stop reason. */
3274 if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3275 && !USE_SIGTRAP_SIGINFO)
9c02b525 3276 {
5b6d1e4f 3277 struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid);
ac7936df 3278 struct gdbarch *gdbarch = regcache->arch ();
527a273a 3279 int decr_pc = gdbarch_decr_pc_after_break (gdbarch);
4c28f408 3280
9c02b525
PA
3281 if (decr_pc != 0)
3282 {
3283 CORE_ADDR pc;
d6b0e80f 3284
9c02b525
PA
3285 pc = regcache_read_pc (regcache);
3286 regcache_write_pc (regcache, pc + decr_pc);
3287 }
3288 }
e3e9f5a2 3289
9c02b525
PA
3290 /* We'll need this to determine whether to report a SIGSTOP as
3291 GDB_SIGNAL_0. Need to take a copy because resume_clear_callback
3292 clears it. */
3293 last_resume_kind = lp->last_resume_kind;
4b60df3d 3294
fbea99ea 3295 if (!target_is_non_stop_p ())
9c02b525 3296 {
e3e9f5a2
PA
3297 /* In all-stop, from the core's perspective, all LWPs are now
3298 stopped until a new resume action is sent over. */
d3a70e03 3299 iterate_over_lwps (minus_one_ptid, resume_clear_callback);
e3e9f5a2
PA
3300 }
3301 else
25289eb2 3302 {
d3a70e03 3303 resume_clear_callback (lp);
25289eb2 3304 }
d6b0e80f 3305
135340af 3306 if (linux_target->low_status_is_event (status))
d6b0e80f 3307 {
9327494e
SM
3308 linux_nat_debug_printf ("trap ptid is %s.",
3309 target_pid_to_str (lp->ptid).c_str ());
d6b0e80f 3310 }
d6b0e80f
AC
3311
3312 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3313 {
3314 *ourstatus = lp->waitstatus;
3315 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3316 }
3317 else
3318 store_waitstatus (ourstatus, status);
3319
9327494e 3320 linux_nat_debug_printf ("exit");
b84876c2 3321
7feb7d06 3322 restore_child_signals_mask (&prev_mask);
1e225492 3323
4b60df3d 3324 if (last_resume_kind == resume_stop
25289eb2
PA
3325 && ourstatus->kind == TARGET_WAITKIND_STOPPED
3326 && WSTOPSIG (status) == SIGSTOP)
3327 {
3328 /* A thread that has been requested to stop by GDB with
3329 target_stop, and it stopped cleanly, so report as SIG0. The
3330 use of SIGSTOP is an implementation detail. */
a493e3e2 3331 ourstatus->value.sig = GDB_SIGNAL_0;
25289eb2
PA
3332 }
3333
1e225492
JK
3334 if (ourstatus->kind == TARGET_WAITKIND_EXITED
3335 || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
3336 lp->core = -1;
3337 else
2e794194 3338 lp->core = linux_common_core_of_thread (lp->ptid);
1e225492 3339
aa01bd36
PA
3340 if (ourstatus->kind == TARGET_WAITKIND_EXITED)
3341 return filter_exit_event (lp, ourstatus);
3342
f973ed9c 3343 return lp->ptid;
d6b0e80f
AC
3344}
3345
e3e9f5a2
PA
3346/* Resume LWPs that are currently stopped without any pending status
3347 to report, but are resumed from the core's perspective. */
3348
3349static int
d3a70e03 3350resume_stopped_resumed_lwps (struct lwp_info *lp, const ptid_t wait_ptid)
e3e9f5a2 3351{
4dd63d48
PA
3352 if (!lp->stopped)
3353 {
9327494e
SM
3354 linux_nat_debug_printf ("NOT resuming LWP %s, not stopped",
3355 target_pid_to_str (lp->ptid).c_str ());
4dd63d48
PA
3356 }
3357 else if (!lp->resumed)
3358 {
9327494e
SM
3359 linux_nat_debug_printf ("NOT resuming LWP %s, not resumed",
3360 target_pid_to_str (lp->ptid).c_str ());
4dd63d48
PA
3361 }
3362 else if (lwp_status_pending_p (lp))
3363 {
9327494e
SM
3364 linux_nat_debug_printf ("NOT resuming LWP %s, has pending status",
3365 target_pid_to_str (lp->ptid).c_str ());
4dd63d48
PA
3366 }
3367 else
e3e9f5a2 3368 {
5b6d1e4f 3369 struct regcache *regcache = get_thread_regcache (linux_target, lp->ptid);
ac7936df 3370 struct gdbarch *gdbarch = regcache->arch ();
336060f3 3371
a70b8144 3372 try
e3e9f5a2 3373 {
23f238d3
PA
3374 CORE_ADDR pc = regcache_read_pc (regcache);
3375 int leave_stopped = 0;
e3e9f5a2 3376
23f238d3
PA
3377 /* Don't bother if there's a breakpoint at PC that we'd hit
3378 immediately, and we're not waiting for this LWP. */
d3a70e03 3379 if (!lp->ptid.matches (wait_ptid))
23f238d3 3380 {
a01bda52 3381 if (breakpoint_inserted_here_p (regcache->aspace (), pc))
23f238d3
PA
3382 leave_stopped = 1;
3383 }
e3e9f5a2 3384
23f238d3
PA
3385 if (!leave_stopped)
3386 {
9327494e
SM
3387 linux_nat_debug_printf
3388 ("resuming stopped-resumed LWP %s at %s: step=%d",
3389 target_pid_to_str (lp->ptid).c_str (), paddress (gdbarch, pc),
3390 lp->step);
23f238d3
PA
3391
3392 linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0);
3393 }
3394 }
230d2906 3395 catch (const gdb_exception_error &ex)
23f238d3
PA
3396 {
3397 if (!check_ptrace_stopped_lwp_gone (lp))
eedc3f4f 3398 throw;
23f238d3 3399 }
e3e9f5a2
PA
3400 }
3401
3402 return 0;
3403}
3404
f6ac5f3d
PA
3405ptid_t
3406linux_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
b60cea74 3407 target_wait_flags target_options)
7feb7d06
PA
3408{
3409 ptid_t event_ptid;
3410
9327494e
SM
3411 linux_nat_debug_printf ("[%s], [%s]", target_pid_to_str (ptid).c_str (),
3412 target_options_to_string (target_options).c_str ());
7feb7d06
PA
3413
3414 /* Flush the async file first. */
d9d41e78 3415 if (target_is_async_p ())
7feb7d06
PA
3416 async_file_flush ();
3417
e3e9f5a2
PA
3418 /* Resume LWPs that are currently stopped without any pending status
3419 to report, but are resumed from the core's perspective. LWPs get
3420 in this state if we find them stopping at a time we're not
3421 interested in reporting the event (target_wait on a
3422 specific_process, for example, see linux_nat_wait_1), and
3423 meanwhile the event became uninteresting. Don't bother resuming
3424 LWPs we're not going to wait for if they'd stop immediately. */
fbea99ea 3425 if (target_is_non_stop_p ())
d3a70e03
TT
3426 iterate_over_lwps (minus_one_ptid,
3427 [=] (struct lwp_info *info)
3428 {
3429 return resume_stopped_resumed_lwps (info, ptid);
3430 });
e3e9f5a2 3431
f6ac5f3d 3432 event_ptid = linux_nat_wait_1 (ptid, ourstatus, target_options);
7feb7d06
PA
3433
3434 /* If we requested any event, and something came out, assume there
3435 may be more. If we requested a specific lwp or process, also
3436 assume there may be more. */
d9d41e78 3437 if (target_is_async_p ()
6953d224
PA
3438 && ((ourstatus->kind != TARGET_WAITKIND_IGNORE
3439 && ourstatus->kind != TARGET_WAITKIND_NO_RESUMED)
d7e15655 3440 || ptid != minus_one_ptid))
7feb7d06
PA
3441 async_file_mark ();
3442
7feb7d06
PA
3443 return event_ptid;
3444}
3445
1d2736d4
PA
3446/* Kill one LWP. */
3447
3448static void
3449kill_one_lwp (pid_t pid)
d6b0e80f 3450{
ed731959
JK
3451 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
3452
3453 errno = 0;
1d2736d4 3454 kill_lwp (pid, SIGKILL);
9327494e 3455
ed731959 3456 if (debug_linux_nat)
57745c90
PA
3457 {
3458 int save_errno = errno;
3459
9327494e
SM
3460 linux_nat_debug_printf
3461 ("kill (SIGKILL) %ld, 0, 0 (%s)", (long) pid,
3462 save_errno != 0 ? safe_strerror (save_errno) : "OK");
57745c90 3463 }
ed731959
JK
3464
3465 /* Some kernels ignore even SIGKILL for processes under ptrace. */
3466
d6b0e80f 3467 errno = 0;
1d2736d4 3468 ptrace (PTRACE_KILL, pid, 0, 0);
d6b0e80f 3469 if (debug_linux_nat)
57745c90
PA
3470 {
3471 int save_errno = errno;
3472
9327494e
SM
3473 linux_nat_debug_printf
3474 ("PTRACE_KILL %ld, 0, 0 (%s)", (long) pid,
3475 save_errno ? safe_strerror (save_errno) : "OK");
57745c90 3476 }
d6b0e80f
AC
3477}
3478
1d2736d4
PA
3479/* Wait for an LWP to die. */
3480
3481static void
3482kill_wait_one_lwp (pid_t pid)
d6b0e80f 3483{
1d2736d4 3484 pid_t res;
d6b0e80f
AC
3485
3486 /* We must make sure that there are no pending events (delayed
3487 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3488 program doesn't interfere with any following debugging session. */
3489
d6b0e80f
AC
3490 do
3491 {
1d2736d4
PA
3492 res = my_waitpid (pid, NULL, __WALL);
3493 if (res != (pid_t) -1)
d6b0e80f 3494 {
9327494e
SM
3495 linux_nat_debug_printf ("wait %ld received unknown.", (long) pid);
3496
4a6ed09b
PA
3497 /* The Linux kernel sometimes fails to kill a thread
3498 completely after PTRACE_KILL; that goes from the stop
3499 point in do_fork out to the one in get_signal_to_deliver
3500 and waits again. So kill it again. */
1d2736d4 3501 kill_one_lwp (pid);
d6b0e80f
AC
3502 }
3503 }
1d2736d4
PA
3504 while (res == pid);
3505
3506 gdb_assert (res == -1 && errno == ECHILD);
3507}
3508
3509/* Callback for iterate_over_lwps. */
d6b0e80f 3510
1d2736d4 3511static int
d3a70e03 3512kill_callback (struct lwp_info *lp)
1d2736d4 3513{
e38504b3 3514 kill_one_lwp (lp->ptid.lwp ());
d6b0e80f
AC
3515 return 0;
3516}
3517
1d2736d4
PA
3518/* Callback for iterate_over_lwps. */
3519
3520static int
d3a70e03 3521kill_wait_callback (struct lwp_info *lp)
1d2736d4 3522{
e38504b3 3523 kill_wait_one_lwp (lp->ptid.lwp ());
1d2736d4
PA
3524 return 0;
3525}
3526
3527/* Kill the fork children of any threads of inferior INF that are
3528 stopped at a fork event. */
3529
3530static void
3531kill_unfollowed_fork_children (struct inferior *inf)
3532{
08036331
PA
3533 for (thread_info *thread : inf->non_exited_threads ())
3534 {
3535 struct target_waitstatus *ws = &thread->pending_follow;
1d2736d4 3536
08036331
PA
3537 if (ws->kind == TARGET_WAITKIND_FORKED
3538 || ws->kind == TARGET_WAITKIND_VFORKED)
3539 {
3540 ptid_t child_ptid = ws->value.related_pid;
3541 int child_pid = child_ptid.pid ();
3542 int child_lwp = child_ptid.lwp ();
3543
3544 kill_one_lwp (child_lwp);
3545 kill_wait_one_lwp (child_lwp);
3546
3547 /* Let the arch-specific native code know this process is
3548 gone. */
3549 linux_target->low_forget_process (child_pid);
3550 }
3551 }
1d2736d4
PA
3552}
3553
f6ac5f3d
PA
3554void
3555linux_nat_target::kill ()
d6b0e80f 3556{
f973ed9c
DJ
3557 /* If we're stopped while forking and we haven't followed yet,
3558 kill the other task. We need to do this first because the
3559 parent will be sleeping if this is a vfork. */
1d2736d4 3560 kill_unfollowed_fork_children (current_inferior ());
f973ed9c
DJ
3561
3562 if (forks_exist_p ())
7feb7d06 3563 linux_fork_killall ();
f973ed9c
DJ
3564 else
3565 {
e99b03dc 3566 ptid_t ptid = ptid_t (inferior_ptid.pid ());
e0881a8e 3567
4c28f408 3568 /* Stop all threads before killing them, since ptrace requires
30baf67b 3569 that the thread is stopped to successfully PTRACE_KILL. */
d3a70e03 3570 iterate_over_lwps (ptid, stop_callback);
4c28f408
PA
3571 /* ... and wait until all of them have reported back that
3572 they're no longer running. */
d3a70e03 3573 iterate_over_lwps (ptid, stop_wait_callback);
4c28f408 3574
f973ed9c 3575 /* Kill all LWP's ... */
d3a70e03 3576 iterate_over_lwps (ptid, kill_callback);
f973ed9c
DJ
3577
3578 /* ... and wait until we've flushed all events. */
d3a70e03 3579 iterate_over_lwps (ptid, kill_wait_callback);
f973ed9c
DJ
3580 }
3581
bc1e6c81 3582 target_mourn_inferior (inferior_ptid);
d6b0e80f
AC
3583}
3584
f6ac5f3d
PA
3585void
3586linux_nat_target::mourn_inferior ()
d6b0e80f 3587{
e99b03dc 3588 int pid = inferior_ptid.pid ();
26cb8b7c
PA
3589
3590 purge_lwp_list (pid);
d6b0e80f 3591
f973ed9c 3592 if (! forks_exist_p ())
d90e17a7 3593 /* Normal case, no other forks available. */
f6ac5f3d 3594 inf_ptrace_target::mourn_inferior ();
f973ed9c
DJ
3595 else
3596 /* Multi-fork case. The current inferior_ptid has exited, but
3597 there are other viable forks to debug. Delete the exiting
3598 one and context-switch to the first available. */
3599 linux_fork_mourn_inferior ();
26cb8b7c
PA
3600
3601 /* Let the arch-specific native code know this process is gone. */
135340af 3602 linux_target->low_forget_process (pid);
d6b0e80f
AC
3603}
3604
5b009018
PA
3605/* Convert a native/host siginfo object, into/from the siginfo in the
3606 layout of the inferiors' architecture. */
3607
3608static void
a5362b9a 3609siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
5b009018 3610{
135340af
PA
3611 /* If the low target didn't do anything, then just do a straight
3612 memcpy. */
3613 if (!linux_target->low_siginfo_fixup (siginfo, inf_siginfo, direction))
5b009018
PA
3614 {
3615 if (direction == 1)
a5362b9a 3616 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
5b009018 3617 else
a5362b9a 3618 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
5b009018
PA
3619 }
3620}
3621
9b409511 3622static enum target_xfer_status
f6ac5f3d 3623linux_xfer_siginfo (enum target_object object,
dda83cd7 3624 const char *annex, gdb_byte *readbuf,
9b409511
YQ
3625 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3626 ULONGEST *xfered_len)
4aa995e1 3627{
4aa995e1 3628 int pid;
a5362b9a
TS
3629 siginfo_t siginfo;
3630 gdb_byte inf_siginfo[sizeof (siginfo_t)];
4aa995e1
PA
3631
3632 gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
3633 gdb_assert (readbuf || writebuf);
3634
e38504b3 3635 pid = inferior_ptid.lwp ();
4aa995e1 3636 if (pid == 0)
e99b03dc 3637 pid = inferior_ptid.pid ();
4aa995e1
PA
3638
3639 if (offset > sizeof (siginfo))
2ed4b548 3640 return TARGET_XFER_E_IO;
4aa995e1
PA
3641
3642 errno = 0;
3643 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3644 if (errno != 0)
2ed4b548 3645 return TARGET_XFER_E_IO;
4aa995e1 3646
5b009018
PA
3647 /* When GDB is built as a 64-bit application, ptrace writes into
3648 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3649 inferior with a 64-bit GDB should look the same as debugging it
3650 with a 32-bit GDB, we need to convert it. GDB core always sees
3651 the converted layout, so any read/write will have to be done
3652 post-conversion. */
3653 siginfo_fixup (&siginfo, inf_siginfo, 0);
3654
4aa995e1
PA
3655 if (offset + len > sizeof (siginfo))
3656 len = sizeof (siginfo) - offset;
3657
3658 if (readbuf != NULL)
5b009018 3659 memcpy (readbuf, inf_siginfo + offset, len);
4aa995e1
PA
3660 else
3661 {
5b009018
PA
3662 memcpy (inf_siginfo + offset, writebuf, len);
3663
3664 /* Convert back to ptrace layout before flushing it out. */
3665 siginfo_fixup (&siginfo, inf_siginfo, 1);
3666
4aa995e1
PA
3667 errno = 0;
3668 ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3669 if (errno != 0)
2ed4b548 3670 return TARGET_XFER_E_IO;
4aa995e1
PA
3671 }
3672
9b409511
YQ
3673 *xfered_len = len;
3674 return TARGET_XFER_OK;
4aa995e1
PA
3675}
3676
9b409511 3677static enum target_xfer_status
f6ac5f3d
PA
3678linux_nat_xfer_osdata (enum target_object object,
3679 const char *annex, gdb_byte *readbuf,
3680 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3681 ULONGEST *xfered_len);
3682
f6ac5f3d
PA
3683static enum target_xfer_status
3684linux_proc_xfer_partial (enum target_object object,
3685 const char *annex, gdb_byte *readbuf,
3686 const gdb_byte *writebuf,
3687 ULONGEST offset, LONGEST len, ULONGEST *xfered_len);
3688
3689enum target_xfer_status
3690linux_nat_target::xfer_partial (enum target_object object,
3691 const char *annex, gdb_byte *readbuf,
3692 const gdb_byte *writebuf,
3693 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
d6b0e80f 3694{
9b409511 3695 enum target_xfer_status xfer;
d6b0e80f 3696
4aa995e1 3697 if (object == TARGET_OBJECT_SIGNAL_INFO)
f6ac5f3d 3698 return linux_xfer_siginfo (object, annex, readbuf, writebuf,
9b409511 3699 offset, len, xfered_len);
4aa995e1 3700
c35b1492
PA
3701 /* The target is connected but no live inferior is selected. Pass
3702 this request down to a lower stratum (e.g., the executable
3703 file). */
d7e15655 3704 if (object == TARGET_OBJECT_MEMORY && inferior_ptid == null_ptid)
9b409511 3705 return TARGET_XFER_EOF;
c35b1492 3706
f6ac5f3d
PA
3707 if (object == TARGET_OBJECT_AUXV)
3708 return memory_xfer_auxv (this, object, annex, readbuf, writebuf,
3709 offset, len, xfered_len);
3710
3711 if (object == TARGET_OBJECT_OSDATA)
3712 return linux_nat_xfer_osdata (object, annex, readbuf, writebuf,
3713 offset, len, xfered_len);
d6b0e80f 3714
f6ac5f3d
PA
3715 /* GDB calculates all addresses in the largest possible address
3716 width.
3717 The address width must be masked before its final use - either by
3718 linux_proc_xfer_partial or inf_ptrace_target::xfer_partial.
3719
3720 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
3721
3722 if (object == TARGET_OBJECT_MEMORY)
3723 {
3724 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
3725
3726 if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
3727 offset &= ((ULONGEST) 1 << addr_bit) - 1;
3728 }
3729
3730 xfer = linux_proc_xfer_partial (object, annex, readbuf, writebuf,
3731 offset, len, xfered_len);
3732 if (xfer != TARGET_XFER_EOF)
3733 return xfer;
3734
3735 return inf_ptrace_target::xfer_partial (object, annex, readbuf, writebuf,
3736 offset, len, xfered_len);
d6b0e80f
AC
3737}
3738
57810aa7 3739bool
f6ac5f3d 3740linux_nat_target::thread_alive (ptid_t ptid)
28439f5e 3741{
4a6ed09b
PA
3742 /* As long as a PTID is in lwp list, consider it alive. */
3743 return find_lwp_pid (ptid) != NULL;
28439f5e
PA
3744}
3745
8a06aea7
PA
3746/* Implement the to_update_thread_list target method for this
3747 target. */
3748
f6ac5f3d
PA
3749void
3750linux_nat_target::update_thread_list ()
8a06aea7 3751{
a6904d5a
PA
3752 struct lwp_info *lwp;
3753
4a6ed09b
PA
3754 /* We add/delete threads from the list as clone/exit events are
3755 processed, so just try deleting exited threads still in the
3756 thread list. */
3757 delete_exited_threads ();
a6904d5a
PA
3758
3759 /* Update the processor core that each lwp/thread was last seen
3760 running on. */
3761 ALL_LWPS (lwp)
1ad3de98
PA
3762 {
3763 /* Avoid accessing /proc if the thread hasn't run since we last
3764 time we fetched the thread's core. Accessing /proc becomes
3765 noticeably expensive when we have thousands of LWPs. */
3766 if (lwp->core == -1)
3767 lwp->core = linux_common_core_of_thread (lwp->ptid);
3768 }
8a06aea7
PA
3769}
3770
a068643d 3771std::string
f6ac5f3d 3772linux_nat_target::pid_to_str (ptid_t ptid)
d6b0e80f 3773{
15a9e13e 3774 if (ptid.lwp_p ()
e38504b3 3775 && (ptid.pid () != ptid.lwp ()
e99b03dc 3776 || num_lwps (ptid.pid ()) > 1))
a068643d 3777 return string_printf ("LWP %ld", ptid.lwp ());
d6b0e80f
AC
3778
3779 return normal_pid_to_str (ptid);
3780}
3781
f6ac5f3d
PA
3782const char *
3783linux_nat_target::thread_name (struct thread_info *thr)
4694da01 3784{
79efa585 3785 return linux_proc_tid_get_name (thr->ptid);
4694da01
TT
3786}
3787
dba24537
AC
3788/* Accepts an integer PID; Returns a string representing a file that
3789 can be opened to get the symbols for the child process. */
3790
f6ac5f3d
PA
3791char *
3792linux_nat_target::pid_to_exec_file (int pid)
dba24537 3793{
e0d86d2c 3794 return linux_proc_pid_to_exec_file (pid);
dba24537
AC
3795}
3796
a379284a
AA
3797/* Implement the to_xfer_partial target method using /proc/<pid>/mem.
3798 Because we can use a single read/write call, this can be much more
3799 efficient than banging away at PTRACE_PEEKTEXT. */
10d6c8cd 3800
9b409511 3801static enum target_xfer_status
f6ac5f3d 3802linux_proc_xfer_partial (enum target_object object,
10d6c8cd
DJ
3803 const char *annex, gdb_byte *readbuf,
3804 const gdb_byte *writebuf,
9b409511 3805 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
dba24537 3806{
10d6c8cd
DJ
3807 LONGEST ret;
3808 int fd;
dba24537
AC
3809 char filename[64];
3810
a379284a 3811 if (object != TARGET_OBJECT_MEMORY)
f486487f 3812 return TARGET_XFER_EOF;
dba24537
AC
3813
3814 /* Don't bother for one word. */
3815 if (len < 3 * sizeof (long))
9b409511 3816 return TARGET_XFER_EOF;
dba24537
AC
3817
3818 /* We could keep this file open and cache it - possibly one per
3819 thread. That requires some juggling, but is even faster. */
b67aeab0 3820 xsnprintf (filename, sizeof filename, "/proc/%ld/mem",
e38504b3 3821 inferior_ptid.lwp ());
a379284a
AA
3822 fd = gdb_open_cloexec (filename, ((readbuf ? O_RDONLY : O_WRONLY)
3823 | O_LARGEFILE), 0);
dba24537 3824 if (fd == -1)
9b409511 3825 return TARGET_XFER_EOF;
dba24537 3826
a379284a
AA
3827 /* Use pread64/pwrite64 if available, since they save a syscall and can
3828 handle 64-bit offsets even on 32-bit platforms (for instance, SPARC
3829 debugging a SPARC64 application). */
dba24537 3830#ifdef HAVE_PREAD64
a379284a
AA
3831 ret = (readbuf ? pread64 (fd, readbuf, len, offset)
3832 : pwrite64 (fd, writebuf, len, offset));
dba24537 3833#else
a379284a
AA
3834 ret = lseek (fd, offset, SEEK_SET);
3835 if (ret != -1)
3836 ret = (readbuf ? read (fd, readbuf, len)
3837 : write (fd, writebuf, len));
dba24537 3838#endif
dba24537
AC
3839
3840 close (fd);
9b409511 3841
a379284a 3842 if (ret == -1 || ret == 0)
9b409511
YQ
3843 return TARGET_XFER_EOF;
3844 else
3845 {
3846 *xfered_len = ret;
3847 return TARGET_XFER_OK;
3848 }
dba24537
AC
3849}
3850
efcbbd14 3851
dba24537
AC
3852/* Parse LINE as a signal set and add its set bits to SIGS. */
3853
3854static void
3855add_line_to_sigset (const char *line, sigset_t *sigs)
3856{
3857 int len = strlen (line) - 1;
3858 const char *p;
3859 int signum;
3860
3861 if (line[len] != '\n')
8a3fe4f8 3862 error (_("Could not parse signal set: %s"), line);
dba24537
AC
3863
3864 p = line;
3865 signum = len * 4;
3866 while (len-- > 0)
3867 {
3868 int digit;
3869
3870 if (*p >= '0' && *p <= '9')
3871 digit = *p - '0';
3872 else if (*p >= 'a' && *p <= 'f')
3873 digit = *p - 'a' + 10;
3874 else
8a3fe4f8 3875 error (_("Could not parse signal set: %s"), line);
dba24537
AC
3876
3877 signum -= 4;
3878
3879 if (digit & 1)
3880 sigaddset (sigs, signum + 1);
3881 if (digit & 2)
3882 sigaddset (sigs, signum + 2);
3883 if (digit & 4)
3884 sigaddset (sigs, signum + 3);
3885 if (digit & 8)
3886 sigaddset (sigs, signum + 4);
3887
3888 p++;
3889 }
3890}
3891
3892/* Find process PID's pending signals from /proc/pid/status and set
3893 SIGS to match. */
3894
3895void
3e43a32a
MS
3896linux_proc_pending_signals (int pid, sigset_t *pending,
3897 sigset_t *blocked, sigset_t *ignored)
dba24537 3898{
d8d2a3ee 3899 char buffer[PATH_MAX], fname[PATH_MAX];
dba24537
AC
3900
3901 sigemptyset (pending);
3902 sigemptyset (blocked);
3903 sigemptyset (ignored);
cde33bf1 3904 xsnprintf (fname, sizeof fname, "/proc/%d/status", pid);
d419f42d 3905 gdb_file_up procfile = gdb_fopen_cloexec (fname, "r");
dba24537 3906 if (procfile == NULL)
8a3fe4f8 3907 error (_("Could not open %s"), fname);
dba24537 3908
d419f42d 3909 while (fgets (buffer, PATH_MAX, procfile.get ()) != NULL)
dba24537
AC
3910 {
3911 /* Normal queued signals are on the SigPnd line in the status
3912 file. However, 2.6 kernels also have a "shared" pending
3913 queue for delivering signals to a thread group, so check for
3914 a ShdPnd line also.
3915
3916 Unfortunately some Red Hat kernels include the shared pending
3917 queue but not the ShdPnd status field. */
3918
61012eef 3919 if (startswith (buffer, "SigPnd:\t"))
dba24537 3920 add_line_to_sigset (buffer + 8, pending);
61012eef 3921 else if (startswith (buffer, "ShdPnd:\t"))
dba24537 3922 add_line_to_sigset (buffer + 8, pending);
61012eef 3923 else if (startswith (buffer, "SigBlk:\t"))
dba24537 3924 add_line_to_sigset (buffer + 8, blocked);
61012eef 3925 else if (startswith (buffer, "SigIgn:\t"))
dba24537
AC
3926 add_line_to_sigset (buffer + 8, ignored);
3927 }
dba24537
AC
3928}
3929
9b409511 3930static enum target_xfer_status
f6ac5f3d 3931linux_nat_xfer_osdata (enum target_object object,
e0881a8e 3932 const char *annex, gdb_byte *readbuf,
9b409511
YQ
3933 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3934 ULONGEST *xfered_len)
07e059b5 3935{
07e059b5
VP
3936 gdb_assert (object == TARGET_OBJECT_OSDATA);
3937
9b409511
YQ
3938 *xfered_len = linux_common_xfer_osdata (annex, readbuf, offset, len);
3939 if (*xfered_len == 0)
3940 return TARGET_XFER_EOF;
3941 else
3942 return TARGET_XFER_OK;
07e059b5
VP
3943}
3944
f6ac5f3d
PA
3945std::vector<static_tracepoint_marker>
3946linux_nat_target::static_tracepoint_markers_by_strid (const char *strid)
5808517f
YQ
3947{
3948 char s[IPA_CMD_BUF_SIZE];
e99b03dc 3949 int pid = inferior_ptid.pid ();
5d9310c4 3950 std::vector<static_tracepoint_marker> markers;
256642e8 3951 const char *p = s;
fd79271b 3952 ptid_t ptid = ptid_t (pid, 0, 0);
5d9310c4 3953 static_tracepoint_marker marker;
5808517f
YQ
3954
3955 /* Pause all */
3956 target_stop (ptid);
3957
3958 memcpy (s, "qTfSTM", sizeof ("qTfSTM"));
3959 s[sizeof ("qTfSTM")] = 0;
3960
42476b70 3961 agent_run_command (pid, s, strlen (s) + 1);
5808517f 3962
1db93f14
TT
3963 /* Unpause all. */
3964 SCOPE_EXIT { target_continue_no_signal (ptid); };
5808517f
YQ
3965
3966 while (*p++ == 'm')
3967 {
5808517f
YQ
3968 do
3969 {
5d9310c4 3970 parse_static_tracepoint_marker_definition (p, &p, &marker);
5808517f 3971
5d9310c4
SM
3972 if (strid == NULL || marker.str_id == strid)
3973 markers.push_back (std::move (marker));
5808517f
YQ
3974 }
3975 while (*p++ == ','); /* comma-separated list */
3976
3977 memcpy (s, "qTsSTM", sizeof ("qTsSTM"));
3978 s[sizeof ("qTsSTM")] = 0;
42476b70 3979 agent_run_command (pid, s, strlen (s) + 1);
5808517f
YQ
3980 p = s;
3981 }
3982
5808517f
YQ
3983 return markers;
3984}
3985
b84876c2
PA
3986/* target_is_async_p implementation. */
3987
57810aa7 3988bool
f6ac5f3d 3989linux_nat_target::is_async_p ()
b84876c2 3990{
198297aa 3991 return linux_is_async_p ();
b84876c2
PA
3992}
3993
3994/* target_can_async_p implementation. */
3995
57810aa7 3996bool
f6ac5f3d 3997linux_nat_target::can_async_p ()
b84876c2 3998{
fde1b17d
SM
3999 /* We're always async, unless the user explicitly prevented it with the
4000 "maint set target-async" command. */
3dd5b83d 4001 return target_async_permitted;
b84876c2
PA
4002}
4003
57810aa7 4004bool
f6ac5f3d 4005linux_nat_target::supports_non_stop ()
9908b566 4006{
f80c8ec4 4007 return true;
9908b566
VP
4008}
4009
fbea99ea
PA
4010/* to_always_non_stop_p implementation. */
4011
57810aa7 4012bool
f6ac5f3d 4013linux_nat_target::always_non_stop_p ()
fbea99ea 4014{
f80c8ec4 4015 return true;
fbea99ea
PA
4016}
4017
57810aa7 4018bool
f6ac5f3d 4019linux_nat_target::supports_multi_process ()
d90e17a7 4020{
aee91db3 4021 return true;
d90e17a7
PA
4022}
4023
57810aa7 4024bool
f6ac5f3d 4025linux_nat_target::supports_disable_randomization ()
03583c20
UW
4026{
4027#ifdef HAVE_PERSONALITY
f80c8ec4 4028 return true;
03583c20 4029#else
f80c8ec4 4030 return false;
03583c20
UW
4031#endif
4032}
4033
7feb7d06
PA
4034/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4035 so we notice when any child changes state, and notify the
4036 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4037 above to wait for the arrival of a SIGCHLD. */
4038
b84876c2 4039static void
7feb7d06 4040sigchld_handler (int signo)
b84876c2 4041{
7feb7d06
PA
4042 int old_errno = errno;
4043
01124a23 4044 if (debug_linux_nat)
da5bd37e 4045 gdb_stdlog->write_async_safe ("sigchld\n", sizeof ("sigchld\n") - 1);
7feb7d06
PA
4046
4047 if (signo == SIGCHLD
4048 && linux_nat_event_pipe[0] != -1)
4049 async_file_mark (); /* Let the event loop know that there are
4050 events to handle. */
4051
4052 errno = old_errno;
4053}
4054
4055/* Callback registered with the target events file descriptor. */
4056
4057static void
4058handle_target_event (int error, gdb_client_data client_data)
4059{
b1a35af2 4060 inferior_event_handler (INF_REG_EVENT);
7feb7d06
PA
4061}
4062
4063/* Create/destroy the target events pipe. Returns previous state. */
4064
4065static int
4066linux_async_pipe (int enable)
4067{
198297aa 4068 int previous = linux_is_async_p ();
7feb7d06
PA
4069
4070 if (previous != enable)
4071 {
4072 sigset_t prev_mask;
4073
12696c10
PA
4074 /* Block child signals while we create/destroy the pipe, as
4075 their handler writes to it. */
7feb7d06
PA
4076 block_child_signals (&prev_mask);
4077
4078 if (enable)
4079 {
614c279d 4080 if (gdb_pipe_cloexec (linux_nat_event_pipe) == -1)
7feb7d06
PA
4081 internal_error (__FILE__, __LINE__,
4082 "creating event pipe failed.");
4083
4084 fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
4085 fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
4086 }
4087 else
4088 {
4089 close (linux_nat_event_pipe[0]);
4090 close (linux_nat_event_pipe[1]);
4091 linux_nat_event_pipe[0] = -1;
4092 linux_nat_event_pipe[1] = -1;
4093 }
4094
4095 restore_child_signals_mask (&prev_mask);
4096 }
4097
4098 return previous;
b84876c2
PA
4099}
4100
5b6d1e4f
PA
4101int
4102linux_nat_target::async_wait_fd ()
4103{
4104 return linux_nat_event_pipe[0];
4105}
4106
b84876c2
PA
4107/* target_async implementation. */
4108
f6ac5f3d
PA
4109void
4110linux_nat_target::async (int enable)
b84876c2 4111{
6a3753b3 4112 if (enable)
b84876c2 4113 {
7feb7d06
PA
4114 if (!linux_async_pipe (1))
4115 {
4116 add_file_handler (linux_nat_event_pipe[0],
2554f6f5
SM
4117 handle_target_event, NULL,
4118 "linux-nat");
7feb7d06
PA
4119 /* There may be pending events to handle. Tell the event loop
4120 to poll them. */
4121 async_file_mark ();
4122 }
b84876c2
PA
4123 }
4124 else
4125 {
b84876c2 4126 delete_file_handler (linux_nat_event_pipe[0]);
7feb7d06 4127 linux_async_pipe (0);
b84876c2
PA
4128 }
4129 return;
4130}
4131
a493e3e2 4132/* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
252fbfc8
PA
4133 event came out. */
4134
4c28f408 4135static int
d3a70e03 4136linux_nat_stop_lwp (struct lwp_info *lwp)
4c28f408 4137{
d90e17a7 4138 if (!lwp->stopped)
252fbfc8 4139 {
9327494e
SM
4140 linux_nat_debug_printf ("running -> suspending %s",
4141 target_pid_to_str (lwp->ptid).c_str ());
252fbfc8 4142
252fbfc8 4143
25289eb2
PA
4144 if (lwp->last_resume_kind == resume_stop)
4145 {
9327494e
SM
4146 linux_nat_debug_printf ("already stopping LWP %ld at GDB's request",
4147 lwp->ptid.lwp ());
25289eb2
PA
4148 return 0;
4149 }
252fbfc8 4150
d3a70e03 4151 stop_callback (lwp);
25289eb2 4152 lwp->last_resume_kind = resume_stop;
d90e17a7
PA
4153 }
4154 else
4155 {
4156 /* Already known to be stopped; do nothing. */
252fbfc8 4157
d90e17a7
PA
4158 if (debug_linux_nat)
4159 {
5b6d1e4f 4160 if (find_thread_ptid (linux_target, lwp->ptid)->stop_requested)
9327494e
SM
4161 linux_nat_debug_printf ("already stopped/stop_requested %s",
4162 target_pid_to_str (lwp->ptid).c_str ());
d90e17a7 4163 else
9327494e
SM
4164 linux_nat_debug_printf ("already stopped/no stop_requested yet %s",
4165 target_pid_to_str (lwp->ptid).c_str ());
252fbfc8
PA
4166 }
4167 }
4c28f408
PA
4168 return 0;
4169}
4170
f6ac5f3d
PA
4171void
4172linux_nat_target::stop (ptid_t ptid)
4c28f408 4173{
d3a70e03 4174 iterate_over_lwps (ptid, linux_nat_stop_lwp);
bfedc46a
PA
4175}
4176
f6ac5f3d
PA
4177void
4178linux_nat_target::close ()
d90e17a7
PA
4179{
4180 /* Unregister from the event loop. */
f6ac5f3d
PA
4181 if (is_async_p ())
4182 async (0);
d90e17a7 4183
f6ac5f3d 4184 inf_ptrace_target::close ();
d90e17a7
PA
4185}
4186
c0694254
PA
4187/* When requests are passed down from the linux-nat layer to the
4188 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4189 used. The address space pointer is stored in the inferior object,
4190 but the common code that is passed such ptid can't tell whether
4191 lwpid is a "main" process id or not (it assumes so). We reverse
4192 look up the "main" process id from the lwp here. */
4193
f6ac5f3d
PA
4194struct address_space *
4195linux_nat_target::thread_address_space (ptid_t ptid)
c0694254
PA
4196{
4197 struct lwp_info *lwp;
4198 struct inferior *inf;
4199 int pid;
4200
e38504b3 4201 if (ptid.lwp () == 0)
c0694254
PA
4202 {
4203 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
4204 tgid. */
4205 lwp = find_lwp_pid (ptid);
e99b03dc 4206 pid = lwp->ptid.pid ();
c0694254
PA
4207 }
4208 else
4209 {
4210 /* A (pid,lwpid,0) ptid. */
e99b03dc 4211 pid = ptid.pid ();
c0694254
PA
4212 }
4213
5b6d1e4f 4214 inf = find_inferior_pid (this, pid);
c0694254
PA
4215 gdb_assert (inf != NULL);
4216 return inf->aspace;
4217}
4218
dc146f7c
VP
4219/* Return the cached value of the processor core for thread PTID. */
4220
f6ac5f3d
PA
4221int
4222linux_nat_target::core_of_thread (ptid_t ptid)
dc146f7c
VP
4223{
4224 struct lwp_info *info = find_lwp_pid (ptid);
e0881a8e 4225
dc146f7c
VP
4226 if (info)
4227 return info->core;
4228 return -1;
4229}
4230
7a6a1731
GB
4231/* Implementation of to_filesystem_is_local. */
4232
57810aa7 4233bool
f6ac5f3d 4234linux_nat_target::filesystem_is_local ()
7a6a1731
GB
4235{
4236 struct inferior *inf = current_inferior ();
4237
4238 if (inf->fake_pid_p || inf->pid == 0)
57810aa7 4239 return true;
7a6a1731
GB
4240
4241 return linux_ns_same (inf->pid, LINUX_NS_MNT);
4242}
4243
4244/* Convert the INF argument passed to a to_fileio_* method
4245 to a process ID suitable for passing to its corresponding
4246 linux_mntns_* function. If INF is non-NULL then the
4247 caller is requesting the filesystem seen by INF. If INF
4248 is NULL then the caller is requesting the filesystem seen
4249 by the GDB. We fall back to GDB's filesystem in the case
4250 that INF is non-NULL but its PID is unknown. */
4251
4252static pid_t
4253linux_nat_fileio_pid_of (struct inferior *inf)
4254{
4255 if (inf == NULL || inf->fake_pid_p || inf->pid == 0)
4256 return getpid ();
4257 else
4258 return inf->pid;
4259}
4260
4261/* Implementation of to_fileio_open. */
4262
f6ac5f3d
PA
4263int
4264linux_nat_target::fileio_open (struct inferior *inf, const char *filename,
4265 int flags, int mode, int warn_if_slow,
4266 int *target_errno)
7a6a1731
GB
4267{
4268 int nat_flags;
4269 mode_t nat_mode;
4270 int fd;
4271
4272 if (fileio_to_host_openflags (flags, &nat_flags) == -1
4273 || fileio_to_host_mode (mode, &nat_mode) == -1)
4274 {
4275 *target_errno = FILEIO_EINVAL;
4276 return -1;
4277 }
4278
4279 fd = linux_mntns_open_cloexec (linux_nat_fileio_pid_of (inf),
4280 filename, nat_flags, nat_mode);
4281 if (fd == -1)
4282 *target_errno = host_to_fileio_error (errno);
4283
4284 return fd;
4285}
4286
4287/* Implementation of to_fileio_readlink. */
4288
f6ac5f3d
PA
4289gdb::optional<std::string>
4290linux_nat_target::fileio_readlink (struct inferior *inf, const char *filename,
4291 int *target_errno)
7a6a1731
GB
4292{
4293 char buf[PATH_MAX];
4294 int len;
7a6a1731
GB
4295
4296 len = linux_mntns_readlink (linux_nat_fileio_pid_of (inf),
4297 filename, buf, sizeof (buf));
4298 if (len < 0)
4299 {
4300 *target_errno = host_to_fileio_error (errno);
e0d3522b 4301 return {};
7a6a1731
GB
4302 }
4303
e0d3522b 4304 return std::string (buf, len);
7a6a1731
GB
4305}
4306
4307/* Implementation of to_fileio_unlink. */
4308
f6ac5f3d
PA
4309int
4310linux_nat_target::fileio_unlink (struct inferior *inf, const char *filename,
4311 int *target_errno)
7a6a1731
GB
4312{
4313 int ret;
4314
4315 ret = linux_mntns_unlink (linux_nat_fileio_pid_of (inf),
4316 filename);
4317 if (ret == -1)
4318 *target_errno = host_to_fileio_error (errno);
4319
4320 return ret;
4321}
4322
aa01bd36
PA
4323/* Implementation of the to_thread_events method. */
4324
f6ac5f3d
PA
4325void
4326linux_nat_target::thread_events (int enable)
aa01bd36
PA
4327{
4328 report_thread_events = enable;
4329}
4330
f6ac5f3d
PA
4331linux_nat_target::linux_nat_target ()
4332{
f973ed9c
DJ
4333 /* We don't change the stratum; this target will sit at
4334 process_stratum and thread_db will set at thread_stratum. This
4335 is a little strange, since this is a multi-threaded-capable
4336 target, but we want to be on the stack below thread_db, and we
4337 also want to be used for single-threaded processes. */
f973ed9c
DJ
4338}
4339
f865ee35
JK
4340/* See linux-nat.h. */
4341
4342int
4343linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo)
9f0bdab8 4344{
da559b09 4345 int pid;
9f0bdab8 4346
e38504b3 4347 pid = ptid.lwp ();
da559b09 4348 if (pid == 0)
e99b03dc 4349 pid = ptid.pid ();
f865ee35 4350
da559b09
JK
4351 errno = 0;
4352 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo);
4353 if (errno != 0)
4354 {
4355 memset (siginfo, 0, sizeof (*siginfo));
4356 return 0;
4357 }
f865ee35 4358 return 1;
9f0bdab8
DJ
4359}
4360
7b669087
GB
4361/* See nat/linux-nat.h. */
4362
4363ptid_t
4364current_lwp_ptid (void)
4365{
15a9e13e 4366 gdb_assert (inferior_ptid.lwp_p ());
7b669087
GB
4367 return inferior_ptid;
4368}
4369
6c265988 4370void _initialize_linux_nat ();
d6b0e80f 4371void
6c265988 4372_initialize_linux_nat ()
d6b0e80f 4373{
ccce17b0
YQ
4374 add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance,
4375 &debug_linux_nat, _("\
b84876c2
PA
4376Set debugging of GNU/Linux lwp module."), _("\
4377Show debugging of GNU/Linux lwp module."), _("\
4378Enables printf debugging output."),
ccce17b0
YQ
4379 NULL,
4380 show_debug_linux_nat,
4381 &setdebuglist, &showdebuglist);
b84876c2 4382
7a6a1731
GB
4383 add_setshow_boolean_cmd ("linux-namespaces", class_maintenance,
4384 &debug_linux_namespaces, _("\
4385Set debugging of GNU/Linux namespaces module."), _("\
4386Show debugging of GNU/Linux namespaces module."), _("\
4387Enables printf debugging output."),
4388 NULL,
4389 NULL,
4390 &setdebuglist, &showdebuglist);
4391
7feb7d06
PA
4392 /* Install a SIGCHLD handler. */
4393 sigchld_action.sa_handler = sigchld_handler;
4394 sigemptyset (&sigchld_action.sa_mask);
4395 sigchld_action.sa_flags = SA_RESTART;
b84876c2
PA
4396
4397 /* Make it the default. */
7feb7d06 4398 sigaction (SIGCHLD, &sigchld_action, NULL);
d6b0e80f
AC
4399
4400 /* Make sure we don't block SIGCHLD during a sigsuspend. */
21987b9c 4401 gdb_sigmask (SIG_SETMASK, NULL, &suspend_mask);
d6b0e80f
AC
4402 sigdelset (&suspend_mask, SIGCHLD);
4403
7feb7d06 4404 sigemptyset (&blocked_mask);
774113b0
PA
4405
4406 lwp_lwpid_htab_create ();
d6b0e80f
AC
4407}
4408\f
4409
4410/* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4411 the GNU/Linux Threads library and therefore doesn't really belong
4412 here. */
4413
d6b0e80f
AC
4414/* Return the set of signals used by the threads library in *SET. */
4415
4416void
4417lin_thread_get_thread_signals (sigset_t *set)
4418{
d6b0e80f
AC
4419 sigemptyset (set);
4420
4a6ed09b
PA
4421 /* NPTL reserves the first two RT signals, but does not provide any
4422 way for the debugger to query the signal numbers - fortunately
4423 they don't change. */
4424 sigaddset (set, __SIGRTMIN);
4425 sigaddset (set, __SIGRTMIN + 1);
d6b0e80f 4426}
This page took 1.983538 seconds and 4 git commands to generate.