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