]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/gdbserver/linux-low.c
daily update
[thirdparty/binutils-gdb.git] / gdb / gdbserver / linux-low.c
CommitLineData
da6d8c04 1/* Low level interface to ptrace, for the remote server for GDB.
0b302171 2 Copyright (C) 1995-1996, 1998-2012 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"
d26e3629 21#include "linux-osdata.h"
58b4daa5 22#include "agent.h"
da6d8c04 23
58caa3dc 24#include <sys/wait.h>
da6d8c04
DJ
25#include <stdio.h>
26#include <sys/param.h>
da6d8c04 27#include <sys/ptrace.h>
af96c192 28#include "linux-ptrace.h"
e3deef73 29#include "linux-procfs.h"
da6d8c04
DJ
30#include <signal.h>
31#include <sys/ioctl.h>
32#include <fcntl.h>
d07c63e7 33#include <string.h>
0a30fbc4
DJ
34#include <stdlib.h>
35#include <unistd.h>
fa6a77dc 36#include <errno.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>
efcbbd14
UW
43#include <sys/stat.h>
44#include <sys/vfs.h>
1570b33e 45#include <sys/uio.h>
957f3f49
DE
46#ifndef ELFMAG0
47/* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
48 then ELFMAG0 will have been defined. If it didn't get included by
49 gdb_proc_service.h then including it will likely introduce a duplicate
50 definition of elf_fpregset_t. */
51#include <elf.h>
52#endif
efcbbd14
UW
53
54#ifndef SPUFS_MAGIC
55#define SPUFS_MAGIC 0x23c9b64e
56#endif
da6d8c04 57
03583c20
UW
58#ifdef HAVE_PERSONALITY
59# include <sys/personality.h>
60# if !HAVE_DECL_ADDR_NO_RANDOMIZE
61# define ADDR_NO_RANDOMIZE 0x0040000
62# endif
63#endif
64
fd462a61
DJ
65#ifndef O_LARGEFILE
66#define O_LARGEFILE 0
67#endif
68
ec8ebe72
DE
69#ifndef W_STOPCODE
70#define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
71#endif
72
1a981360
PA
73/* This is the kernel's hard limit. Not to be confused with
74 SIGRTMIN. */
75#ifndef __SIGRTMIN
76#define __SIGRTMIN 32
77#endif
78
42c81e2a
DJ
79#ifdef __UCLIBC__
80#if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
23512c01
MGD
81/* PTRACE_TEXT_ADDR and friends. */
82#include <asm/ptrace.h>
42c81e2a
DJ
83#define HAS_NOMMU
84#endif
85#endif
86
8365dcf5
TJB
87#ifndef HAVE_ELF32_AUXV_T
88/* Copied from glibc's elf.h. */
89typedef struct
90{
91 uint32_t a_type; /* Entry type */
92 union
93 {
94 uint32_t a_val; /* Integer value */
95 /* We use to have pointer elements added here. We cannot do that,
96 though, since it does not work when using 32-bit definitions
97 on 64-bit platforms and vice versa. */
98 } a_un;
99} Elf32_auxv_t;
100#endif
101
102#ifndef HAVE_ELF64_AUXV_T
103/* Copied from glibc's elf.h. */
104typedef struct
105{
106 uint64_t a_type; /* Entry type */
107 union
108 {
109 uint64_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} Elf64_auxv_t;
115#endif
116
24a09b5f
DJ
117/* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
118 representation of the thread ID.
611cb4a5 119
54a0b537 120 ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
95954743
PA
121 the same as the LWP ID.
122
123 ``all_processes'' is keyed by the "overall process ID", which
124 GNU/Linux calls tgid, "thread group ID". */
0d62e5e8 125
54a0b537 126struct inferior_list all_lwps;
0d62e5e8 127
05044653
PA
128/* A list of all unknown processes which receive stop signals. Some
129 other process will presumably claim each of these as forked
130 children momentarily. */
24a09b5f 131
05044653
PA
132struct simple_pid_list
133{
134 /* The process ID. */
135 int pid;
136
137 /* The status as reported by waitpid. */
138 int status;
139
140 /* Next in chain. */
141 struct simple_pid_list *next;
142};
143struct simple_pid_list *stopped_pids;
144
145/* Trivial list manipulation functions to keep track of a list of new
146 stopped processes. */
147
148static void
149add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
150{
151 struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
152
153 new_pid->pid = pid;
154 new_pid->status = status;
155 new_pid->next = *listp;
156 *listp = new_pid;
157}
158
159static int
160pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
161{
162 struct simple_pid_list **p;
163
164 for (p = listp; *p != NULL; p = &(*p)->next)
165 if ((*p)->pid == pid)
166 {
167 struct simple_pid_list *next = (*p)->next;
168
169 *statusp = (*p)->status;
170 xfree (*p);
171 *p = next;
172 return 1;
173 }
174 return 0;
175}
24a09b5f 176
bde24c0a
PA
177enum stopping_threads_kind
178 {
179 /* Not stopping threads presently. */
180 NOT_STOPPING_THREADS,
181
182 /* Stopping threads. */
183 STOPPING_THREADS,
184
185 /* Stopping and suspending threads. */
186 STOPPING_AND_SUSPENDING_THREADS
187 };
188
189/* This is set while stop_all_lwps is in effect. */
190enum stopping_threads_kind stopping_threads = NOT_STOPPING_THREADS;
0d62e5e8
DJ
191
192/* FIXME make into a target method? */
24a09b5f 193int using_threads = 1;
24a09b5f 194
fa593d66
PA
195/* True if we're presently stabilizing threads (moving them out of
196 jump pads). */
197static int stabilizing_threads;
198
95954743
PA
199/* This flag is true iff we've just created or attached to our first
200 inferior but it has not stopped yet. As soon as it does, we need
201 to call the low target's arch_setup callback. Doing this only on
202 the first inferior avoids reinializing the architecture on every
203 inferior, and avoids messing with the register caches of the
204 already running inferiors. NOTE: this assumes all inferiors under
205 control of gdbserver have the same architecture. */
d61ddec4
UW
206static int new_inferior;
207
2acc282a 208static void linux_resume_one_lwp (struct lwp_info *lwp,
54a0b537 209 int step, int signal, siginfo_t *info);
2bd7c093 210static void linux_resume (struct thread_resume *resume_info, size_t n);
7984d532
PA
211static void stop_all_lwps (int suspend, struct lwp_info *except);
212static void unstop_all_lwps (int unsuspend, struct lwp_info *except);
95954743 213static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
95954743 214static void *add_lwp (ptid_t ptid);
c35fafde 215static int linux_stopped_by_watchpoint (void);
95954743 216static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
d50171e4 217static void proceed_all_lwps (void);
d50171e4
PA
218static int finish_step_over (struct lwp_info *lwp);
219static CORE_ADDR get_stop_pc (struct lwp_info *lwp);
220static int kill_lwp (unsigned long lwpid, int signo);
1e7fc18c 221static void linux_enable_event_reporting (int pid);
d50171e4
PA
222
223/* True if the low target can hardware single-step. Such targets
224 don't need a BREAKPOINT_REINSERT_ADDR callback. */
225
226static int
227can_hardware_single_step (void)
228{
229 return (the_low_target.breakpoint_reinsert_addr == NULL);
230}
231
232/* True if the low target supports memory breakpoints. If so, we'll
233 have a GET_PC implementation. */
234
235static int
236supports_breakpoints (void)
237{
238 return (the_low_target.get_pc != NULL);
239}
0d62e5e8 240
fa593d66
PA
241/* Returns true if this target can support fast tracepoints. This
242 does not mean that the in-process agent has been loaded in the
243 inferior. */
244
245static int
246supports_fast_tracepoints (void)
247{
248 return the_low_target.install_fast_tracepoint_jump_pad != NULL;
249}
250
0d62e5e8
DJ
251struct pending_signals
252{
253 int signal;
32ca6d61 254 siginfo_t info;
0d62e5e8
DJ
255 struct pending_signals *prev;
256};
611cb4a5 257
58caa3dc 258#ifdef HAVE_LINUX_REGSETS
52fa2412
UW
259static char *disabled_regsets;
260static int num_regsets;
58caa3dc
DJ
261#endif
262
bd99dc85
PA
263/* The read/write ends of the pipe registered as waitable file in the
264 event loop. */
265static int linux_event_pipe[2] = { -1, -1 };
266
267/* True if we're currently in async mode. */
268#define target_is_async_p() (linux_event_pipe[0] != -1)
269
02fc4de7 270static void send_sigstop (struct lwp_info *lwp);
bd99dc85
PA
271static void wait_for_sigstop (struct inferior_list_entry *entry);
272
d0722149
DE
273/* Return non-zero if HEADER is a 64-bit ELF file. */
274
275static int
214d508e 276elf_64_header_p (const Elf64_Ehdr *header, unsigned int *machine)
d0722149 277{
214d508e
L
278 if (header->e_ident[EI_MAG0] == ELFMAG0
279 && header->e_ident[EI_MAG1] == ELFMAG1
280 && header->e_ident[EI_MAG2] == ELFMAG2
281 && header->e_ident[EI_MAG3] == ELFMAG3)
282 {
283 *machine = header->e_machine;
284 return header->e_ident[EI_CLASS] == ELFCLASS64;
285
286 }
287 *machine = EM_NONE;
288 return -1;
d0722149
DE
289}
290
291/* Return non-zero if FILE is a 64-bit ELF file,
292 zero if the file is not a 64-bit ELF file,
293 and -1 if the file is not accessible or doesn't exist. */
294
be07f1a2 295static int
214d508e 296elf_64_file_p (const char *file, unsigned int *machine)
d0722149 297{
957f3f49 298 Elf64_Ehdr header;
d0722149
DE
299 int fd;
300
301 fd = open (file, O_RDONLY);
302 if (fd < 0)
303 return -1;
304
305 if (read (fd, &header, sizeof (header)) != sizeof (header))
306 {
307 close (fd);
308 return 0;
309 }
310 close (fd);
311
214d508e 312 return elf_64_header_p (&header, machine);
d0722149
DE
313}
314
be07f1a2
PA
315/* Accepts an integer PID; Returns true if the executable PID is
316 running is a 64-bit ELF file.. */
317
318int
214d508e 319linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine)
be07f1a2
PA
320{
321 char file[MAXPATHLEN];
322
323 sprintf (file, "/proc/%d/exe", pid);
214d508e 324 return elf_64_file_p (file, machine);
be07f1a2
PA
325}
326
bd99dc85
PA
327static void
328delete_lwp (struct lwp_info *lwp)
329{
330 remove_thread (get_lwp_thread (lwp));
331 remove_inferior (&all_lwps, &lwp->head);
aa5ca48f 332 free (lwp->arch_private);
bd99dc85
PA
333 free (lwp);
334}
335
95954743
PA
336/* Add a process to the common process list, and set its private
337 data. */
338
339static struct process_info *
340linux_add_process (int pid, int attached)
341{
342 struct process_info *proc;
343
344 /* Is this the first process? If so, then set the arch. */
345 if (all_processes.head == NULL)
346 new_inferior = 1;
347
348 proc = add_process (pid, attached);
349 proc->private = xcalloc (1, sizeof (*proc->private));
350
aa5ca48f
DE
351 if (the_low_target.new_process != NULL)
352 proc->private->arch_private = the_low_target.new_process ();
353
95954743
PA
354 return proc;
355}
356
07d4f67e
DE
357/* Wrapper function for waitpid which handles EINTR, and emulates
358 __WALL for systems where that is not available. */
359
360static int
361my_waitpid (int pid, int *status, int flags)
362{
363 int ret, out_errno;
364
365 if (debug_threads)
366 fprintf (stderr, "my_waitpid (%d, 0x%x)\n", pid, flags);
367
368 if (flags & __WALL)
369 {
370 sigset_t block_mask, org_mask, wake_mask;
371 int wnohang;
372
373 wnohang = (flags & WNOHANG) != 0;
374 flags &= ~(__WALL | __WCLONE);
375 flags |= WNOHANG;
376
377 /* Block all signals while here. This avoids knowing about
378 LinuxThread's signals. */
379 sigfillset (&block_mask);
380 sigprocmask (SIG_BLOCK, &block_mask, &org_mask);
381
382 /* ... except during the sigsuspend below. */
383 sigemptyset (&wake_mask);
384
385 while (1)
386 {
387 /* Since all signals are blocked, there's no need to check
388 for EINTR here. */
389 ret = waitpid (pid, status, flags);
390 out_errno = errno;
391
392 if (ret == -1 && out_errno != ECHILD)
393 break;
394 else if (ret > 0)
395 break;
396
397 if (flags & __WCLONE)
398 {
399 /* We've tried both flavors now. If WNOHANG is set,
400 there's nothing else to do, just bail out. */
401 if (wnohang)
402 break;
403
404 if (debug_threads)
405 fprintf (stderr, "blocking\n");
406
407 /* Block waiting for signals. */
408 sigsuspend (&wake_mask);
409 }
410
411 flags ^= __WCLONE;
412 }
413
414 sigprocmask (SIG_SETMASK, &org_mask, NULL);
415 }
416 else
417 {
418 do
419 ret = waitpid (pid, status, flags);
420 while (ret == -1 && errno == EINTR);
421 out_errno = errno;
422 }
423
424 if (debug_threads)
425 fprintf (stderr, "my_waitpid (%d, 0x%x): status(%x), %d\n",
426 pid, flags, status ? *status : -1, ret);
427
428 errno = out_errno;
429 return ret;
430}
431
bd99dc85
PA
432/* Handle a GNU/Linux extended wait response. If we see a clone
433 event, we need to add the new LWP to our list (and not report the
434 trap to higher layers). */
0d62e5e8 435
24a09b5f 436static void
54a0b537 437handle_extended_wait (struct lwp_info *event_child, int wstat)
24a09b5f
DJ
438{
439 int event = wstat >> 16;
54a0b537 440 struct lwp_info *new_lwp;
24a09b5f
DJ
441
442 if (event == PTRACE_EVENT_CLONE)
443 {
95954743 444 ptid_t ptid;
24a09b5f 445 unsigned long new_pid;
05044653 446 int ret, status;
24a09b5f 447
bd99dc85 448 ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), 0, &new_pid);
24a09b5f
DJ
449
450 /* If we haven't already seen the new PID stop, wait for it now. */
05044653 451 if (!pull_pid_from_list (&stopped_pids, new_pid, &status))
24a09b5f
DJ
452 {
453 /* The new child has a pending SIGSTOP. We can't affect it until it
454 hits the SIGSTOP, but we're already attached. */
455
97438e3f 456 ret = my_waitpid (new_pid, &status, __WALL);
24a09b5f
DJ
457
458 if (ret == -1)
459 perror_with_name ("waiting for new child");
460 else if (ret != new_pid)
461 warning ("wait returned unexpected PID %d", ret);
da5898ce 462 else if (!WIFSTOPPED (status))
24a09b5f
DJ
463 warning ("wait returned unexpected status 0x%x", status);
464 }
465
1e7fc18c 466 linux_enable_event_reporting (new_pid);
24a09b5f 467
95954743
PA
468 ptid = ptid_build (pid_of (event_child), new_pid, 0);
469 new_lwp = (struct lwp_info *) add_lwp (ptid);
470 add_thread (ptid, new_lwp);
24a09b5f 471
e27d73f6
DE
472 /* Either we're going to immediately resume the new thread
473 or leave it stopped. linux_resume_one_lwp is a nop if it
474 thinks the thread is currently running, so set this first
475 before calling linux_resume_one_lwp. */
476 new_lwp->stopped = 1;
477
bde24c0a
PA
478 /* If we're suspending all threads, leave this one suspended
479 too. */
480 if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS)
481 new_lwp->suspended = 1;
482
da5898ce
DJ
483 /* Normally we will get the pending SIGSTOP. But in some cases
484 we might get another signal delivered to the group first.
f21cc1a2 485 If we do get another signal, be sure not to lose it. */
da5898ce
DJ
486 if (WSTOPSIG (status) == SIGSTOP)
487 {
bde24c0a 488 if (stopping_threads != NOT_STOPPING_THREADS)
d50171e4
PA
489 new_lwp->stop_pc = get_stop_pc (new_lwp);
490 else
e27d73f6 491 linux_resume_one_lwp (new_lwp, 0, 0, NULL);
da5898ce 492 }
24a09b5f 493 else
da5898ce 494 {
54a0b537 495 new_lwp->stop_expected = 1;
d50171e4 496
bde24c0a 497 if (stopping_threads != NOT_STOPPING_THREADS)
da5898ce 498 {
d50171e4 499 new_lwp->stop_pc = get_stop_pc (new_lwp);
54a0b537
PA
500 new_lwp->status_pending_p = 1;
501 new_lwp->status_pending = status;
da5898ce
DJ
502 }
503 else
504 /* Pass the signal on. This is what GDB does - except
505 shouldn't we really report it instead? */
e27d73f6 506 linux_resume_one_lwp (new_lwp, 0, WSTOPSIG (status), NULL);
da5898ce 507 }
24a09b5f
DJ
508
509 /* Always resume the current thread. If we are stopping
510 threads, it will have a pending SIGSTOP; we may as well
511 collect it now. */
2acc282a 512 linux_resume_one_lwp (event_child, event_child->stepping, 0, NULL);
24a09b5f
DJ
513 }
514}
515
d50171e4
PA
516/* Return the PC as read from the regcache of LWP, without any
517 adjustment. */
518
519static CORE_ADDR
520get_pc (struct lwp_info *lwp)
521{
522 struct thread_info *saved_inferior;
523 struct regcache *regcache;
524 CORE_ADDR pc;
525
526 if (the_low_target.get_pc == NULL)
527 return 0;
528
529 saved_inferior = current_inferior;
530 current_inferior = get_lwp_thread (lwp);
531
532 regcache = get_thread_regcache (current_inferior, 1);
533 pc = (*the_low_target.get_pc) (regcache);
534
535 if (debug_threads)
536 fprintf (stderr, "pc is 0x%lx\n", (long) pc);
537
538 current_inferior = saved_inferior;
539 return pc;
540}
541
542/* This function should only be called if LWP got a SIGTRAP.
0d62e5e8
DJ
543 The SIGTRAP could mean several things.
544
545 On i386, where decr_pc_after_break is non-zero:
546 If we were single-stepping this process using PTRACE_SINGLESTEP,
547 we will get only the one SIGTRAP (even if the instruction we
548 stepped over was a breakpoint). The value of $eip will be the
549 next instruction.
550 If we continue the process using PTRACE_CONT, we will get a
551 SIGTRAP when we hit a breakpoint. The value of $eip will be
552 the instruction after the breakpoint (i.e. needs to be
553 decremented). If we report the SIGTRAP to GDB, we must also
554 report the undecremented PC. If we cancel the SIGTRAP, we
555 must resume at the decremented PC.
556
557 (Presumably, not yet tested) On a non-decr_pc_after_break machine
558 with hardware or kernel single-step:
559 If we single-step over a breakpoint instruction, our PC will
560 point at the following instruction. If we continue and hit a
561 breakpoint instruction, our PC will point at the breakpoint
562 instruction. */
563
564static CORE_ADDR
d50171e4 565get_stop_pc (struct lwp_info *lwp)
0d62e5e8 566{
d50171e4
PA
567 CORE_ADDR stop_pc;
568
569 if (the_low_target.get_pc == NULL)
570 return 0;
0d62e5e8 571
d50171e4
PA
572 stop_pc = get_pc (lwp);
573
bdabb078
PA
574 if (WSTOPSIG (lwp->last_status) == SIGTRAP
575 && !lwp->stepping
576 && !lwp->stopped_by_watchpoint
577 && lwp->last_status >> 16 == 0)
47c0c975
DE
578 stop_pc -= the_low_target.decr_pc_after_break;
579
580 if (debug_threads)
581 fprintf (stderr, "stop pc is 0x%lx\n", (long) stop_pc);
582
583 return stop_pc;
0d62e5e8 584}
ce3a066d 585
0d62e5e8 586static void *
95954743 587add_lwp (ptid_t ptid)
611cb4a5 588{
54a0b537 589 struct lwp_info *lwp;
0d62e5e8 590
54a0b537
PA
591 lwp = (struct lwp_info *) xmalloc (sizeof (*lwp));
592 memset (lwp, 0, sizeof (*lwp));
0d62e5e8 593
95954743 594 lwp->head.id = ptid;
0d62e5e8 595
aa5ca48f
DE
596 if (the_low_target.new_thread != NULL)
597 lwp->arch_private = the_low_target.new_thread ();
598
54a0b537 599 add_inferior_to_list (&all_lwps, &lwp->head);
0d62e5e8 600
54a0b537 601 return lwp;
0d62e5e8 602}
611cb4a5 603
da6d8c04
DJ
604/* Start an inferior process and returns its pid.
605 ALLARGS is a vector of program-name and args. */
606
ce3a066d
DJ
607static int
608linux_create_inferior (char *program, char **allargs)
da6d8c04 609{
03583c20
UW
610#ifdef HAVE_PERSONALITY
611 int personality_orig = 0, personality_set = 0;
612#endif
a6dbe5df 613 struct lwp_info *new_lwp;
da6d8c04 614 int pid;
95954743 615 ptid_t ptid;
da6d8c04 616
03583c20
UW
617#ifdef HAVE_PERSONALITY
618 if (disable_randomization)
619 {
620 errno = 0;
621 personality_orig = personality (0xffffffff);
622 if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
623 {
624 personality_set = 1;
625 personality (personality_orig | ADDR_NO_RANDOMIZE);
626 }
627 if (errno != 0 || (personality_set
628 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
629 warning ("Error disabling address space randomization: %s",
630 strerror (errno));
631 }
632#endif
633
42c81e2a 634#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437
NS
635 pid = vfork ();
636#else
da6d8c04 637 pid = fork ();
52fb6437 638#endif
da6d8c04
DJ
639 if (pid < 0)
640 perror_with_name ("fork");
641
642 if (pid == 0)
643 {
644 ptrace (PTRACE_TRACEME, 0, 0, 0);
645
1a981360 646#ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
254787d4 647 signal (__SIGRTMIN + 1, SIG_DFL);
60c3d7b0 648#endif
0d62e5e8 649
a9fa9f7d
DJ
650 setpgid (0, 0);
651
e0f9f062
DE
652 /* If gdbserver is connected to gdb via stdio, redirect the inferior's
653 stdout to stderr so that inferior i/o doesn't corrupt the connection.
654 Also, redirect stdin to /dev/null. */
655 if (remote_connection_is_stdio ())
656 {
657 close (0);
658 open ("/dev/null", O_RDONLY);
659 dup2 (2, 1);
3e52c33d
JK
660 if (write (2, "stdin/stdout redirected\n",
661 sizeof ("stdin/stdout redirected\n") - 1) < 0)
662 /* Errors ignored. */;
e0f9f062
DE
663 }
664
2b876972
DJ
665 execv (program, allargs);
666 if (errno == ENOENT)
667 execvp (program, allargs);
da6d8c04
DJ
668
669 fprintf (stderr, "Cannot exec %s: %s.\n", program,
d07c63e7 670 strerror (errno));
da6d8c04
DJ
671 fflush (stderr);
672 _exit (0177);
673 }
674
03583c20
UW
675#ifdef HAVE_PERSONALITY
676 if (personality_set)
677 {
678 errno = 0;
679 personality (personality_orig);
680 if (errno != 0)
681 warning ("Error restoring address space randomization: %s",
682 strerror (errno));
683 }
684#endif
685
95954743
PA
686 linux_add_process (pid, 0);
687
688 ptid = ptid_build (pid, pid, 0);
689 new_lwp = add_lwp (ptid);
690 add_thread (ptid, new_lwp);
a6dbe5df 691 new_lwp->must_set_ptrace_flags = 1;
611cb4a5 692
a9fa9f7d 693 return pid;
da6d8c04
DJ
694}
695
696/* Attach to an inferior process. */
697
95954743
PA
698static void
699linux_attach_lwp_1 (unsigned long lwpid, int initial)
da6d8c04 700{
95954743 701 ptid_t ptid;
54a0b537 702 struct lwp_info *new_lwp;
611cb4a5 703
95954743 704 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) != 0)
da6d8c04 705 {
87b0bb13
JK
706 struct buffer buffer;
707
95954743 708 if (!initial)
2d717e4f
DJ
709 {
710 /* If we fail to attach to an LWP, just warn. */
95954743 711 fprintf (stderr, "Cannot attach to lwp %ld: %s (%d)\n", lwpid,
2d717e4f
DJ
712 strerror (errno), errno);
713 fflush (stderr);
714 return;
715 }
5f572dec
JK
716
717 /* If we fail to attach to a process, report an error. */
87b0bb13
JK
718 buffer_init (&buffer);
719 linux_ptrace_attach_warnings (lwpid, &buffer);
720 buffer_grow_str0 (&buffer, "");
721 error ("%sCannot attach to lwp %ld: %s (%d)", buffer_finish (&buffer),
722 lwpid, strerror (errno), errno);
da6d8c04
DJ
723 }
724
95954743 725 if (initial)
e3deef73
LM
726 /* If lwp is the tgid, we handle adding existing threads later.
727 Otherwise we just add lwp without bothering about any other
728 threads. */
95954743
PA
729 ptid = ptid_build (lwpid, lwpid, 0);
730 else
731 {
732 /* Note that extracting the pid from the current inferior is
733 safe, since we're always called in the context of the same
734 process as this new thread. */
735 int pid = pid_of (get_thread_lwp (current_inferior));
736 ptid = ptid_build (pid, lwpid, 0);
737 }
24a09b5f 738
95954743
PA
739 new_lwp = (struct lwp_info *) add_lwp (ptid);
740 add_thread (ptid, new_lwp);
0d62e5e8 741
a6dbe5df
PA
742 /* We need to wait for SIGSTOP before being able to make the next
743 ptrace call on this LWP. */
744 new_lwp->must_set_ptrace_flags = 1;
745
644cebc9 746 if (linux_proc_pid_is_stopped (lwpid))
c14d7ab2
PA
747 {
748 if (debug_threads)
749 fprintf (stderr,
750 "Attached to a stopped process\n");
751
752 /* The process is definitely stopped. It is in a job control
753 stop, unless the kernel predates the TASK_STOPPED /
754 TASK_TRACED distinction, in which case it might be in a
755 ptrace stop. Make sure it is in a ptrace stop; from there we
756 can kill it, signal it, et cetera.
757
758 First make sure there is a pending SIGSTOP. Since we are
759 already attached, the process can not transition from stopped
760 to running without a PTRACE_CONT; so we know this signal will
761 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
762 probably already in the queue (unless this kernel is old
763 enough to use TASK_STOPPED for ptrace stops); but since
764 SIGSTOP is not an RT signal, it can only be queued once. */
765 kill_lwp (lwpid, SIGSTOP);
766
767 /* Finally, resume the stopped process. This will deliver the
768 SIGSTOP (or a higher priority signal, just like normal
769 PTRACE_ATTACH), which we'll catch later on. */
770 ptrace (PTRACE_CONT, lwpid, 0, 0);
771 }
772
0d62e5e8 773 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
0e21c1ec
DE
774 brings it to a halt.
775
776 There are several cases to consider here:
777
778 1) gdbserver has already attached to the process and is being notified
1b3f6016 779 of a new thread that is being created.
d50171e4
PA
780 In this case we should ignore that SIGSTOP and resume the
781 process. This is handled below by setting stop_expected = 1,
8336d594 782 and the fact that add_thread sets last_resume_kind ==
d50171e4 783 resume_continue.
0e21c1ec
DE
784
785 2) This is the first thread (the process thread), and we're attaching
1b3f6016
PA
786 to it via attach_inferior.
787 In this case we want the process thread to stop.
d50171e4
PA
788 This is handled by having linux_attach set last_resume_kind ==
789 resume_stop after we return.
e3deef73
LM
790
791 If the pid we are attaching to is also the tgid, we attach to and
792 stop all the existing threads. Otherwise, we attach to pid and
793 ignore any other threads in the same group as this pid.
0e21c1ec
DE
794
795 3) GDB is connecting to gdbserver and is requesting an enumeration of all
1b3f6016
PA
796 existing threads.
797 In this case we want the thread to stop.
798 FIXME: This case is currently not properly handled.
799 We should wait for the SIGSTOP but don't. Things work apparently
800 because enough time passes between when we ptrace (ATTACH) and when
801 gdb makes the next ptrace call on the thread.
0d62e5e8
DJ
802
803 On the other hand, if we are currently trying to stop all threads, we
804 should treat the new thread as if we had sent it a SIGSTOP. This works
54a0b537 805 because we are guaranteed that the add_lwp call above added us to the
0e21c1ec
DE
806 end of the list, and so the new thread has not yet reached
807 wait_for_sigstop (but will). */
d50171e4 808 new_lwp->stop_expected = 1;
0d62e5e8
DJ
809}
810
95954743
PA
811void
812linux_attach_lwp (unsigned long lwpid)
813{
814 linux_attach_lwp_1 (lwpid, 0);
815}
816
e3deef73
LM
817/* Attach to PID. If PID is the tgid, attach to it and all
818 of its threads. */
819
0d62e5e8 820int
a1928bad 821linux_attach (unsigned long pid)
0d62e5e8 822{
e3deef73
LM
823 /* Attach to PID. We will check for other threads
824 soon. */
95954743 825 linux_attach_lwp_1 (pid, 1);
95954743 826 linux_add_process (pid, 1);
0d62e5e8 827
bd99dc85
PA
828 if (!non_stop)
829 {
8336d594
PA
830 struct thread_info *thread;
831
832 /* Don't ignore the initial SIGSTOP if we just attached to this
833 process. It will be collected by wait shortly. */
834 thread = find_thread_ptid (ptid_build (pid, pid, 0));
835 thread->last_resume_kind = resume_stop;
bd99dc85 836 }
0d62e5e8 837
e3deef73
LM
838 if (linux_proc_get_tgid (pid) == pid)
839 {
840 DIR *dir;
841 char pathname[128];
842
843 sprintf (pathname, "/proc/%ld/task", pid);
844
845 dir = opendir (pathname);
846
847 if (!dir)
848 {
849 fprintf (stderr, "Could not open /proc/%ld/task.\n", pid);
850 fflush (stderr);
851 }
852 else
853 {
854 /* At this point we attached to the tgid. Scan the task for
855 existing threads. */
856 unsigned long lwp;
857 int new_threads_found;
858 int iterations = 0;
859 struct dirent *dp;
860
861 while (iterations < 2)
862 {
863 new_threads_found = 0;
864 /* Add all the other threads. While we go through the
865 threads, new threads may be spawned. Cycle through
866 the list of threads until we have done two iterations without
867 finding new threads. */
868 while ((dp = readdir (dir)) != NULL)
869 {
870 /* Fetch one lwp. */
871 lwp = strtoul (dp->d_name, NULL, 10);
872
873 /* Is this a new thread? */
874 if (lwp
875 && find_thread_ptid (ptid_build (pid, lwp, 0)) == NULL)
876 {
877 linux_attach_lwp_1 (lwp, 0);
878 new_threads_found++;
879
880 if (debug_threads)
881 fprintf (stderr, "\
882Found and attached to new lwp %ld\n", lwp);
883 }
884 }
885
886 if (!new_threads_found)
887 iterations++;
888 else
889 iterations = 0;
890
891 rewinddir (dir);
892 }
893 closedir (dir);
894 }
895 }
896
95954743
PA
897 return 0;
898}
899
900struct counter
901{
902 int pid;
903 int count;
904};
905
906static int
907second_thread_of_pid_p (struct inferior_list_entry *entry, void *args)
908{
909 struct counter *counter = args;
910
911 if (ptid_get_pid (entry->id) == counter->pid)
912 {
913 if (++counter->count > 1)
914 return 1;
915 }
d61ddec4 916
da6d8c04
DJ
917 return 0;
918}
919
95954743
PA
920static int
921last_thread_of_process_p (struct thread_info *thread)
922{
923 ptid_t ptid = ((struct inferior_list_entry *)thread)->id;
924 int pid = ptid_get_pid (ptid);
925 struct counter counter = { pid , 0 };
da6d8c04 926
95954743
PA
927 return (find_inferior (&all_threads,
928 second_thread_of_pid_p, &counter) == NULL);
929}
930
da84f473
PA
931/* Kill LWP. */
932
933static void
934linux_kill_one_lwp (struct lwp_info *lwp)
935{
936 int pid = lwpid_of (lwp);
937
938 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
939 there is no signal context, and ptrace(PTRACE_KILL) (or
940 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
941 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
942 alternative is to kill with SIGKILL. We only need one SIGKILL
943 per process, not one for each thread. But since we still support
944 linuxthreads, and we also support debugging programs using raw
945 clone without CLONE_THREAD, we send one for each thread. For
946 years, we used PTRACE_KILL only, so we're being a bit paranoid
947 about some old kernels where PTRACE_KILL might work better
948 (dubious if there are any such, but that's why it's paranoia), so
949 we try SIGKILL first, PTRACE_KILL second, and so we're fine
950 everywhere. */
951
952 errno = 0;
953 kill (pid, SIGKILL);
954 if (debug_threads)
955 fprintf (stderr,
956 "LKL: kill (SIGKILL) %s, 0, 0 (%s)\n",
957 target_pid_to_str (ptid_of (lwp)),
958 errno ? strerror (errno) : "OK");
959
960 errno = 0;
961 ptrace (PTRACE_KILL, pid, 0, 0);
962 if (debug_threads)
963 fprintf (stderr,
964 "LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
965 target_pid_to_str (ptid_of (lwp)),
966 errno ? strerror (errno) : "OK");
967}
968
969/* Callback for `find_inferior'. Kills an lwp of a given process,
970 except the leader. */
95954743
PA
971
972static int
da84f473 973kill_one_lwp_callback (struct inferior_list_entry *entry, void *args)
da6d8c04 974{
0d62e5e8 975 struct thread_info *thread = (struct thread_info *) entry;
54a0b537 976 struct lwp_info *lwp = get_thread_lwp (thread);
0d62e5e8 977 int wstat;
95954743
PA
978 int pid = * (int *) args;
979
980 if (ptid_get_pid (entry->id) != pid)
981 return 0;
0d62e5e8 982
fd500816
DJ
983 /* We avoid killing the first thread here, because of a Linux kernel (at
984 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
985 the children get a chance to be reaped, it will remain a zombie
986 forever. */
95954743 987
12b42a12 988 if (lwpid_of (lwp) == pid)
95954743
PA
989 {
990 if (debug_threads)
991 fprintf (stderr, "lkop: is last of process %s\n",
992 target_pid_to_str (entry->id));
993 return 0;
994 }
fd500816 995
0d62e5e8
DJ
996 do
997 {
da84f473 998 linux_kill_one_lwp (lwp);
0d62e5e8
DJ
999
1000 /* Make sure it died. The loop is most likely unnecessary. */
95954743 1001 pid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
bd99dc85 1002 } while (pid > 0 && WIFSTOPPED (wstat));
95954743
PA
1003
1004 return 0;
da6d8c04
DJ
1005}
1006
95954743
PA
1007static int
1008linux_kill (int pid)
0d62e5e8 1009{
95954743 1010 struct process_info *process;
54a0b537 1011 struct lwp_info *lwp;
fd500816 1012 int wstat;
95954743 1013 int lwpid;
fd500816 1014
95954743
PA
1015 process = find_process_pid (pid);
1016 if (process == NULL)
1017 return -1;
9d606399 1018
f9e39928
PA
1019 /* If we're killing a running inferior, make sure it is stopped
1020 first, as PTRACE_KILL will not work otherwise. */
7984d532 1021 stop_all_lwps (0, NULL);
f9e39928 1022
da84f473 1023 find_inferior (&all_threads, kill_one_lwp_callback , &pid);
fd500816 1024
54a0b537 1025 /* See the comment in linux_kill_one_lwp. We did not kill the first
fd500816 1026 thread in the list, so do so now. */
95954743 1027 lwp = find_lwp_pid (pid_to_ptid (pid));
bd99dc85 1028
784867a5 1029 if (lwp == NULL)
fd500816 1030 {
784867a5
JK
1031 if (debug_threads)
1032 fprintf (stderr, "lk_1: cannot find lwp %ld, for pid: %d\n",
1033 lwpid_of (lwp), pid);
1034 }
1035 else
1036 {
1037 if (debug_threads)
1038 fprintf (stderr, "lk_1: killing lwp %ld, for pid: %d\n",
1039 lwpid_of (lwp), pid);
fd500816 1040
784867a5
JK
1041 do
1042 {
da84f473 1043 linux_kill_one_lwp (lwp);
784867a5
JK
1044
1045 /* Make sure it died. The loop is most likely unnecessary. */
1046 lwpid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
1047 } while (lwpid > 0 && WIFSTOPPED (wstat));
1048 }
2d717e4f 1049
8336d594 1050 the_target->mourn (process);
f9e39928
PA
1051
1052 /* Since we presently can only stop all lwps of all processes, we
1053 need to unstop lwps of other processes. */
7984d532 1054 unstop_all_lwps (0, NULL);
95954743 1055 return 0;
0d62e5e8
DJ
1056}
1057
9b224c5e
PA
1058/* Get pending signal of THREAD, for detaching purposes. This is the
1059 signal the thread last stopped for, which we need to deliver to the
1060 thread when detaching, otherwise, it'd be suppressed/lost. */
1061
1062static int
1063get_detach_signal (struct thread_info *thread)
1064{
a493e3e2 1065 enum gdb_signal signo = GDB_SIGNAL_0;
9b224c5e
PA
1066 int status;
1067 struct lwp_info *lp = get_thread_lwp (thread);
1068
1069 if (lp->status_pending_p)
1070 status = lp->status_pending;
1071 else
1072 {
1073 /* If the thread had been suspended by gdbserver, and it stopped
1074 cleanly, then it'll have stopped with SIGSTOP. But we don't
1075 want to deliver that SIGSTOP. */
1076 if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
a493e3e2 1077 || thread->last_status.value.sig == GDB_SIGNAL_0)
9b224c5e
PA
1078 return 0;
1079
1080 /* Otherwise, we may need to deliver the signal we
1081 intercepted. */
1082 status = lp->last_status;
1083 }
1084
1085 if (!WIFSTOPPED (status))
1086 {
1087 if (debug_threads)
1088 fprintf (stderr,
1089 "GPS: lwp %s hasn't stopped: no pending signal\n",
1090 target_pid_to_str (ptid_of (lp)));
1091 return 0;
1092 }
1093
1094 /* Extended wait statuses aren't real SIGTRAPs. */
1095 if (WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
1096 {
1097 if (debug_threads)
1098 fprintf (stderr,
1099 "GPS: lwp %s had stopped with extended "
1100 "status: no pending signal\n",
1101 target_pid_to_str (ptid_of (lp)));
1102 return 0;
1103 }
1104
2ea28649 1105 signo = gdb_signal_from_host (WSTOPSIG (status));
9b224c5e
PA
1106
1107 if (program_signals_p && !program_signals[signo])
1108 {
1109 if (debug_threads)
1110 fprintf (stderr,
1111 "GPS: lwp %s had signal %s, but it is in nopass state\n",
1112 target_pid_to_str (ptid_of (lp)),
2ea28649 1113 gdb_signal_to_string (signo));
9b224c5e
PA
1114 return 0;
1115 }
1116 else if (!program_signals_p
1117 /* If we have no way to know which signals GDB does not
1118 want to have passed to the program, assume
1119 SIGTRAP/SIGINT, which is GDB's default. */
a493e3e2 1120 && (signo == GDB_SIGNAL_TRAP || signo == GDB_SIGNAL_INT))
9b224c5e
PA
1121 {
1122 if (debug_threads)
1123 fprintf (stderr,
1124 "GPS: lwp %s had signal %s, "
1125 "but we don't know if we should pass it. Default to not.\n",
1126 target_pid_to_str (ptid_of (lp)),
2ea28649 1127 gdb_signal_to_string (signo));
9b224c5e
PA
1128 return 0;
1129 }
1130 else
1131 {
1132 if (debug_threads)
1133 fprintf (stderr,
1134 "GPS: lwp %s has pending signal %s: delivering it.\n",
1135 target_pid_to_str (ptid_of (lp)),
2ea28649 1136 gdb_signal_to_string (signo));
9b224c5e
PA
1137
1138 return WSTOPSIG (status);
1139 }
1140}
1141
95954743
PA
1142static int
1143linux_detach_one_lwp (struct inferior_list_entry *entry, void *args)
6ad8ae5c
DJ
1144{
1145 struct thread_info *thread = (struct thread_info *) entry;
54a0b537 1146 struct lwp_info *lwp = get_thread_lwp (thread);
95954743 1147 int pid = * (int *) args;
9b224c5e 1148 int sig;
95954743
PA
1149
1150 if (ptid_get_pid (entry->id) != pid)
1151 return 0;
6ad8ae5c 1152
9b224c5e 1153 /* If there is a pending SIGSTOP, get rid of it. */
54a0b537 1154 if (lwp->stop_expected)
ae13219e 1155 {
9b224c5e
PA
1156 if (debug_threads)
1157 fprintf (stderr,
1158 "Sending SIGCONT to %s\n",
1159 target_pid_to_str (ptid_of (lwp)));
1160
1161 kill_lwp (lwpid_of (lwp), SIGCONT);
54a0b537 1162 lwp->stop_expected = 0;
ae13219e
DJ
1163 }
1164
1165 /* Flush any pending changes to the process's registers. */
1166 regcache_invalidate_one ((struct inferior_list_entry *)
54a0b537 1167 get_lwp_thread (lwp));
ae13219e 1168
9b224c5e
PA
1169 /* Pass on any pending signal for this thread. */
1170 sig = get_detach_signal (thread);
1171
ae13219e 1172 /* Finally, let it resume. */
82bfbe7e
PA
1173 if (the_low_target.prepare_to_resume != NULL)
1174 the_low_target.prepare_to_resume (lwp);
f15f9948
TJB
1175 if (ptrace (PTRACE_DETACH, lwpid_of (lwp), 0,
1176 (PTRACE_ARG4_TYPE) (long) sig) < 0)
9b224c5e
PA
1177 error (_("Can't detach %s: %s"),
1178 target_pid_to_str (ptid_of (lwp)),
1179 strerror (errno));
bd99dc85
PA
1180
1181 delete_lwp (lwp);
95954743 1182 return 0;
6ad8ae5c
DJ
1183}
1184
95954743
PA
1185static int
1186linux_detach (int pid)
1187{
1188 struct process_info *process;
1189
1190 process = find_process_pid (pid);
1191 if (process == NULL)
1192 return -1;
1193
f9e39928
PA
1194 /* Stop all threads before detaching. First, ptrace requires that
1195 the thread is stopped to sucessfully detach. Second, thread_db
1196 may need to uninstall thread event breakpoints from memory, which
1197 only works with a stopped process anyway. */
7984d532 1198 stop_all_lwps (0, NULL);
f9e39928 1199
ca5c370d 1200#ifdef USE_THREAD_DB
8336d594 1201 thread_db_detach (process);
ca5c370d
PA
1202#endif
1203
fa593d66
PA
1204 /* Stabilize threads (move out of jump pads). */
1205 stabilize_threads ();
1206
95954743 1207 find_inferior (&all_threads, linux_detach_one_lwp, &pid);
8336d594
PA
1208
1209 the_target->mourn (process);
f9e39928
PA
1210
1211 /* Since we presently can only stop all lwps of all processes, we
1212 need to unstop lwps of other processes. */
7984d532 1213 unstop_all_lwps (0, NULL);
f9e39928
PA
1214 return 0;
1215}
1216
1217/* Remove all LWPs that belong to process PROC from the lwp list. */
1218
1219static int
1220delete_lwp_callback (struct inferior_list_entry *entry, void *proc)
1221{
1222 struct lwp_info *lwp = (struct lwp_info *) entry;
1223 struct process_info *process = proc;
1224
1225 if (pid_of (lwp) == pid_of (process))
1226 delete_lwp (lwp);
1227
dd6953e1 1228 return 0;
6ad8ae5c
DJ
1229}
1230
8336d594
PA
1231static void
1232linux_mourn (struct process_info *process)
1233{
1234 struct process_info_private *priv;
1235
1236#ifdef USE_THREAD_DB
1237 thread_db_mourn (process);
1238#endif
1239
f9e39928
PA
1240 find_inferior (&all_lwps, delete_lwp_callback, process);
1241
8336d594
PA
1242 /* Freeing all private data. */
1243 priv = process->private;
1244 free (priv->arch_private);
1245 free (priv);
1246 process->private = NULL;
505106cd
PA
1247
1248 remove_process (process);
8336d594
PA
1249}
1250
444d6139 1251static void
95954743 1252linux_join (int pid)
444d6139 1253{
444d6139
PA
1254 int status, ret;
1255
1256 do {
95954743 1257 ret = my_waitpid (pid, &status, 0);
444d6139
PA
1258 if (WIFEXITED (status) || WIFSIGNALED (status))
1259 break;
1260 } while (ret != -1 || errno != ECHILD);
1261}
1262
6ad8ae5c 1263/* Return nonzero if the given thread is still alive. */
0d62e5e8 1264static int
95954743 1265linux_thread_alive (ptid_t ptid)
0d62e5e8 1266{
95954743
PA
1267 struct lwp_info *lwp = find_lwp_pid (ptid);
1268
1269 /* We assume we always know if a thread exits. If a whole process
1270 exited but we still haven't been able to report it to GDB, we'll
1271 hold on to the last lwp of the dead process. */
1272 if (lwp != NULL)
1273 return !lwp->dead;
0d62e5e8
DJ
1274 else
1275 return 0;
1276}
1277
6bf5e0ba 1278/* Return 1 if this lwp has an interesting status pending. */
611cb4a5 1279static int
d50171e4 1280status_pending_p_callback (struct inferior_list_entry *entry, void *arg)
0d62e5e8 1281{
54a0b537 1282 struct lwp_info *lwp = (struct lwp_info *) entry;
95954743 1283 ptid_t ptid = * (ptid_t *) arg;
7984d532 1284 struct thread_info *thread;
95954743
PA
1285
1286 /* Check if we're only interested in events from a specific process
1287 or its lwps. */
1288 if (!ptid_equal (minus_one_ptid, ptid)
1289 && ptid_get_pid (ptid) != ptid_get_pid (lwp->head.id))
1290 return 0;
0d62e5e8 1291
d50171e4
PA
1292 thread = get_lwp_thread (lwp);
1293
1294 /* If we got a `vCont;t', but we haven't reported a stop yet, do
1295 report any status pending the LWP may have. */
8336d594 1296 if (thread->last_resume_kind == resume_stop
7984d532 1297 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
d50171e4 1298 return 0;
0d62e5e8 1299
d50171e4 1300 return lwp->status_pending_p;
0d62e5e8
DJ
1301}
1302
95954743
PA
1303static int
1304same_lwp (struct inferior_list_entry *entry, void *data)
1305{
1306 ptid_t ptid = *(ptid_t *) data;
1307 int lwp;
1308
1309 if (ptid_get_lwp (ptid) != 0)
1310 lwp = ptid_get_lwp (ptid);
1311 else
1312 lwp = ptid_get_pid (ptid);
1313
1314 if (ptid_get_lwp (entry->id) == lwp)
1315 return 1;
1316
1317 return 0;
1318}
1319
1320struct lwp_info *
1321find_lwp_pid (ptid_t ptid)
1322{
1323 return (struct lwp_info*) find_inferior (&all_lwps, same_lwp, &ptid);
1324}
1325
bd99dc85 1326static struct lwp_info *
95954743 1327linux_wait_for_lwp (ptid_t ptid, int *wstatp, int options)
611cb4a5 1328{
0d62e5e8 1329 int ret;
95954743 1330 int to_wait_for = -1;
bd99dc85 1331 struct lwp_info *child = NULL;
0d62e5e8 1332
bd99dc85 1333 if (debug_threads)
95954743
PA
1334 fprintf (stderr, "linux_wait_for_lwp: %s\n", target_pid_to_str (ptid));
1335
1336 if (ptid_equal (ptid, minus_one_ptid))
1337 to_wait_for = -1; /* any child */
1338 else
1339 to_wait_for = ptid_get_lwp (ptid); /* this lwp only */
0d62e5e8 1340
bd99dc85 1341 options |= __WALL;
0d62e5e8 1342
bd99dc85 1343retry:
0d62e5e8 1344
bd99dc85
PA
1345 ret = my_waitpid (to_wait_for, wstatp, options);
1346 if (ret == 0 || (ret == -1 && errno == ECHILD && (options & WNOHANG)))
1347 return NULL;
1348 else if (ret == -1)
1349 perror_with_name ("waitpid");
0d62e5e8
DJ
1350
1351 if (debug_threads
1352 && (!WIFSTOPPED (*wstatp)
1353 || (WSTOPSIG (*wstatp) != 32
1354 && WSTOPSIG (*wstatp) != 33)))
1355 fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
1356
95954743 1357 child = find_lwp_pid (pid_to_ptid (ret));
0d62e5e8 1358
24a09b5f
DJ
1359 /* If we didn't find a process, one of two things presumably happened:
1360 - A process we started and then detached from has exited. Ignore it.
1361 - A process we are controlling has forked and the new child's stop
1362 was reported to us by the kernel. Save its PID. */
bd99dc85 1363 if (child == NULL && WIFSTOPPED (*wstatp))
24a09b5f 1364 {
05044653 1365 add_to_pid_list (&stopped_pids, ret, *wstatp);
24a09b5f
DJ
1366 goto retry;
1367 }
bd99dc85 1368 else if (child == NULL)
24a09b5f
DJ
1369 goto retry;
1370
bd99dc85 1371 child->stopped = 1;
0d62e5e8 1372
bd99dc85 1373 child->last_status = *wstatp;
32ca6d61 1374
d61ddec4
UW
1375 /* Architecture-specific setup after inferior is running.
1376 This needs to happen after we have attached to the inferior
1377 and it is stopped for the first time, but before we access
1378 any inferior registers. */
1379 if (new_inferior)
1380 {
1381 the_low_target.arch_setup ();
52fa2412
UW
1382#ifdef HAVE_LINUX_REGSETS
1383 memset (disabled_regsets, 0, num_regsets);
1384#endif
d61ddec4
UW
1385 new_inferior = 0;
1386 }
1387
c3adc08c
PA
1388 /* Fetch the possibly triggered data watchpoint info and store it in
1389 CHILD.
1390
1391 On some archs, like x86, that use debug registers to set
1392 watchpoints, it's possible that the way to know which watched
1393 address trapped, is to check the register that is used to select
1394 which address to watch. Problem is, between setting the
1395 watchpoint and reading back which data address trapped, the user
1396 may change the set of watchpoints, and, as a consequence, GDB
1397 changes the debug registers in the inferior. To avoid reading
1398 back a stale stopped-data-address when that happens, we cache in
1399 LP the fact that a watchpoint trapped, and the corresponding data
1400 address, as soon as we see CHILD stop with a SIGTRAP. If GDB
1401 changes the debug registers meanwhile, we have the cached data we
1402 can rely on. */
1403
1404 if (WIFSTOPPED (*wstatp) && WSTOPSIG (*wstatp) == SIGTRAP)
1405 {
1406 if (the_low_target.stopped_by_watchpoint == NULL)
1407 {
1408 child->stopped_by_watchpoint = 0;
1409 }
1410 else
1411 {
1412 struct thread_info *saved_inferior;
1413
1414 saved_inferior = current_inferior;
1415 current_inferior = get_lwp_thread (child);
1416
1417 child->stopped_by_watchpoint
1418 = the_low_target.stopped_by_watchpoint ();
1419
1420 if (child->stopped_by_watchpoint)
1421 {
1422 if (the_low_target.stopped_data_address != NULL)
1423 child->stopped_data_address
1424 = the_low_target.stopped_data_address ();
1425 else
1426 child->stopped_data_address = 0;
1427 }
1428
1429 current_inferior = saved_inferior;
1430 }
1431 }
1432
d50171e4
PA
1433 /* Store the STOP_PC, with adjustment applied. This depends on the
1434 architecture being defined already (so that CHILD has a valid
1435 regcache), and on LAST_STATUS being set (to check for SIGTRAP or
1436 not). */
1437 if (WIFSTOPPED (*wstatp))
1438 child->stop_pc = get_stop_pc (child);
1439
0d62e5e8 1440 if (debug_threads
47c0c975
DE
1441 && WIFSTOPPED (*wstatp)
1442 && the_low_target.get_pc != NULL)
0d62e5e8 1443 {
896c7fbb 1444 struct thread_info *saved_inferior = current_inferior;
bce522a2 1445 struct regcache *regcache;
47c0c975
DE
1446 CORE_ADDR pc;
1447
d50171e4 1448 current_inferior = get_lwp_thread (child);
bce522a2 1449 regcache = get_thread_regcache (current_inferior, 1);
442ea881 1450 pc = (*the_low_target.get_pc) (regcache);
47c0c975 1451 fprintf (stderr, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc);
896c7fbb 1452 current_inferior = saved_inferior;
0d62e5e8 1453 }
bd99dc85
PA
1454
1455 return child;
0d62e5e8 1456}
611cb4a5 1457
219f2f23
PA
1458/* This function should only be called if the LWP got a SIGTRAP.
1459
1460 Handle any tracepoint steps or hits. Return true if a tracepoint
1461 event was handled, 0 otherwise. */
1462
1463static int
1464handle_tracepoints (struct lwp_info *lwp)
1465{
1466 struct thread_info *tinfo = get_lwp_thread (lwp);
1467 int tpoint_related_event = 0;
1468
7984d532
PA
1469 /* If this tracepoint hit causes a tracing stop, we'll immediately
1470 uninsert tracepoints. To do this, we temporarily pause all
1471 threads, unpatch away, and then unpause threads. We need to make
1472 sure the unpausing doesn't resume LWP too. */
1473 lwp->suspended++;
1474
219f2f23
PA
1475 /* And we need to be sure that any all-threads-stopping doesn't try
1476 to move threads out of the jump pads, as it could deadlock the
1477 inferior (LWP could be in the jump pad, maybe even holding the
1478 lock.) */
1479
1480 /* Do any necessary step collect actions. */
1481 tpoint_related_event |= tracepoint_finished_step (tinfo, lwp->stop_pc);
1482
fa593d66
PA
1483 tpoint_related_event |= handle_tracepoint_bkpts (tinfo, lwp->stop_pc);
1484
219f2f23
PA
1485 /* See if we just hit a tracepoint and do its main collect
1486 actions. */
1487 tpoint_related_event |= tracepoint_was_hit (tinfo, lwp->stop_pc);
1488
7984d532
PA
1489 lwp->suspended--;
1490
1491 gdb_assert (lwp->suspended == 0);
fa593d66 1492 gdb_assert (!stabilizing_threads || lwp->collecting_fast_tracepoint);
7984d532 1493
219f2f23
PA
1494 if (tpoint_related_event)
1495 {
1496 if (debug_threads)
1497 fprintf (stderr, "got a tracepoint event\n");
1498 return 1;
1499 }
1500
1501 return 0;
1502}
1503
fa593d66
PA
1504/* Convenience wrapper. Returns true if LWP is presently collecting a
1505 fast tracepoint. */
1506
1507static int
1508linux_fast_tracepoint_collecting (struct lwp_info *lwp,
1509 struct fast_tpoint_collect_status *status)
1510{
1511 CORE_ADDR thread_area;
1512
1513 if (the_low_target.get_thread_area == NULL)
1514 return 0;
1515
1516 /* Get the thread area address. This is used to recognize which
1517 thread is which when tracing with the in-process agent library.
1518 We don't read anything from the address, and treat it as opaque;
1519 it's the address itself that we assume is unique per-thread. */
1520 if ((*the_low_target.get_thread_area) (lwpid_of (lwp), &thread_area) == -1)
1521 return 0;
1522
1523 return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status);
1524}
1525
1526/* The reason we resume in the caller, is because we want to be able
1527 to pass lwp->status_pending as WSTAT, and we need to clear
1528 status_pending_p before resuming, otherwise, linux_resume_one_lwp
1529 refuses to resume. */
1530
1531static int
1532maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
1533{
1534 struct thread_info *saved_inferior;
1535
1536 saved_inferior = current_inferior;
1537 current_inferior = get_lwp_thread (lwp);
1538
1539 if ((wstat == NULL
1540 || (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
1541 && supports_fast_tracepoints ()
58b4daa5 1542 && agent_loaded_p ())
fa593d66
PA
1543 {
1544 struct fast_tpoint_collect_status status;
1545 int r;
1546
1547 if (debug_threads)
1548 fprintf (stderr, "\
1549Checking whether LWP %ld needs to move out of the jump pad.\n",
1550 lwpid_of (lwp));
1551
1552 r = linux_fast_tracepoint_collecting (lwp, &status);
1553
1554 if (wstat == NULL
1555 || (WSTOPSIG (*wstat) != SIGILL
1556 && WSTOPSIG (*wstat) != SIGFPE
1557 && WSTOPSIG (*wstat) != SIGSEGV
1558 && WSTOPSIG (*wstat) != SIGBUS))
1559 {
1560 lwp->collecting_fast_tracepoint = r;
1561
1562 if (r != 0)
1563 {
1564 if (r == 1 && lwp->exit_jump_pad_bkpt == NULL)
1565 {
1566 /* Haven't executed the original instruction yet.
1567 Set breakpoint there, and wait till it's hit,
1568 then single-step until exiting the jump pad. */
1569 lwp->exit_jump_pad_bkpt
1570 = set_breakpoint_at (status.adjusted_insn_addr, NULL);
1571 }
1572
1573 if (debug_threads)
1574 fprintf (stderr, "\
1575Checking whether LWP %ld needs to move out of the jump pad...it does\n",
1576 lwpid_of (lwp));
0cccb683 1577 current_inferior = saved_inferior;
fa593d66
PA
1578
1579 return 1;
1580 }
1581 }
1582 else
1583 {
1584 /* If we get a synchronous signal while collecting, *and*
1585 while executing the (relocated) original instruction,
1586 reset the PC to point at the tpoint address, before
1587 reporting to GDB. Otherwise, it's an IPA lib bug: just
1588 report the signal to GDB, and pray for the best. */
1589
1590 lwp->collecting_fast_tracepoint = 0;
1591
1592 if (r != 0
1593 && (status.adjusted_insn_addr <= lwp->stop_pc
1594 && lwp->stop_pc < status.adjusted_insn_addr_end))
1595 {
1596 siginfo_t info;
1597 struct regcache *regcache;
1598
1599 /* The si_addr on a few signals references the address
1600 of the faulting instruction. Adjust that as
1601 well. */
1602 if ((WSTOPSIG (*wstat) == SIGILL
1603 || WSTOPSIG (*wstat) == SIGFPE
1604 || WSTOPSIG (*wstat) == SIGBUS
1605 || WSTOPSIG (*wstat) == SIGSEGV)
1606 && ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &info) == 0
1607 /* Final check just to make sure we don't clobber
1608 the siginfo of non-kernel-sent signals. */
1609 && (uintptr_t) info.si_addr == lwp->stop_pc)
1610 {
1611 info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
1612 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &info);
1613 }
1614
1615 regcache = get_thread_regcache (get_lwp_thread (lwp), 1);
1616 (*the_low_target.set_pc) (regcache, status.tpoint_addr);
1617 lwp->stop_pc = status.tpoint_addr;
1618
1619 /* Cancel any fast tracepoint lock this thread was
1620 holding. */
1621 force_unlock_trace_buffer ();
1622 }
1623
1624 if (lwp->exit_jump_pad_bkpt != NULL)
1625 {
1626 if (debug_threads)
1627 fprintf (stderr,
1628 "Cancelling fast exit-jump-pad: removing bkpt. "
1629 "stopping all threads momentarily.\n");
1630
1631 stop_all_lwps (1, lwp);
1632 cancel_breakpoints ();
1633
1634 delete_breakpoint (lwp->exit_jump_pad_bkpt);
1635 lwp->exit_jump_pad_bkpt = NULL;
1636
1637 unstop_all_lwps (1, lwp);
1638
1639 gdb_assert (lwp->suspended >= 0);
1640 }
1641 }
1642 }
1643
1644 if (debug_threads)
1645 fprintf (stderr, "\
1646Checking whether LWP %ld needs to move out of the jump pad...no\n",
1647 lwpid_of (lwp));
0cccb683
YQ
1648
1649 current_inferior = saved_inferior;
fa593d66
PA
1650 return 0;
1651}
1652
1653/* Enqueue one signal in the "signals to report later when out of the
1654 jump pad" list. */
1655
1656static void
1657enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
1658{
1659 struct pending_signals *p_sig;
1660
1661 if (debug_threads)
1662 fprintf (stderr, "\
1663Deferring signal %d for LWP %ld.\n", WSTOPSIG (*wstat), lwpid_of (lwp));
1664
1665 if (debug_threads)
1666 {
1667 struct pending_signals *sig;
1668
1669 for (sig = lwp->pending_signals_to_report;
1670 sig != NULL;
1671 sig = sig->prev)
1672 fprintf (stderr,
1673 " Already queued %d\n",
1674 sig->signal);
1675
1676 fprintf (stderr, " (no more currently queued signals)\n");
1677 }
1678
1a981360
PA
1679 /* Don't enqueue non-RT signals if they are already in the deferred
1680 queue. (SIGSTOP being the easiest signal to see ending up here
1681 twice) */
1682 if (WSTOPSIG (*wstat) < __SIGRTMIN)
1683 {
1684 struct pending_signals *sig;
1685
1686 for (sig = lwp->pending_signals_to_report;
1687 sig != NULL;
1688 sig = sig->prev)
1689 {
1690 if (sig->signal == WSTOPSIG (*wstat))
1691 {
1692 if (debug_threads)
1693 fprintf (stderr,
1694 "Not requeuing already queued non-RT signal %d"
1695 " for LWP %ld\n",
1696 sig->signal,
1697 lwpid_of (lwp));
1698 return;
1699 }
1700 }
1701 }
1702
fa593d66
PA
1703 p_sig = xmalloc (sizeof (*p_sig));
1704 p_sig->prev = lwp->pending_signals_to_report;
1705 p_sig->signal = WSTOPSIG (*wstat);
1706 memset (&p_sig->info, 0, sizeof (siginfo_t));
1707 ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
1708
1709 lwp->pending_signals_to_report = p_sig;
1710}
1711
1712/* Dequeue one signal from the "signals to report later when out of
1713 the jump pad" list. */
1714
1715static int
1716dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
1717{
1718 if (lwp->pending_signals_to_report != NULL)
1719 {
1720 struct pending_signals **p_sig;
1721
1722 p_sig = &lwp->pending_signals_to_report;
1723 while ((*p_sig)->prev != NULL)
1724 p_sig = &(*p_sig)->prev;
1725
1726 *wstat = W_STOPCODE ((*p_sig)->signal);
1727 if ((*p_sig)->info.si_signo != 0)
1728 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
1729 free (*p_sig);
1730 *p_sig = NULL;
1731
1732 if (debug_threads)
1733 fprintf (stderr, "Reporting deferred signal %d for LWP %ld.\n",
1734 WSTOPSIG (*wstat), lwpid_of (lwp));
1735
1736 if (debug_threads)
1737 {
1738 struct pending_signals *sig;
1739
1740 for (sig = lwp->pending_signals_to_report;
1741 sig != NULL;
1742 sig = sig->prev)
1743 fprintf (stderr,
1744 " Still queued %d\n",
1745 sig->signal);
1746
1747 fprintf (stderr, " (no more queued signals)\n");
1748 }
1749
1750 return 1;
1751 }
1752
1753 return 0;
1754}
1755
d50171e4
PA
1756/* Arrange for a breakpoint to be hit again later. We don't keep the
1757 SIGTRAP status and don't forward the SIGTRAP signal to the LWP. We
1758 will handle the current event, eventually we will resume this LWP,
1759 and this breakpoint will trap again. */
1760
1761static int
1762cancel_breakpoint (struct lwp_info *lwp)
1763{
1764 struct thread_info *saved_inferior;
d50171e4
PA
1765
1766 /* There's nothing to do if we don't support breakpoints. */
1767 if (!supports_breakpoints ())
1768 return 0;
1769
d50171e4
PA
1770 /* breakpoint_at reads from current inferior. */
1771 saved_inferior = current_inferior;
1772 current_inferior = get_lwp_thread (lwp);
1773
1774 if ((*the_low_target.breakpoint_at) (lwp->stop_pc))
1775 {
1776 if (debug_threads)
1777 fprintf (stderr,
1778 "CB: Push back breakpoint for %s\n",
fc7238bb 1779 target_pid_to_str (ptid_of (lwp)));
d50171e4
PA
1780
1781 /* Back up the PC if necessary. */
1782 if (the_low_target.decr_pc_after_break)
1783 {
1784 struct regcache *regcache
fc7238bb 1785 = get_thread_regcache (current_inferior, 1);
d50171e4
PA
1786 (*the_low_target.set_pc) (regcache, lwp->stop_pc);
1787 }
1788
1789 current_inferior = saved_inferior;
1790 return 1;
1791 }
1792 else
1793 {
1794 if (debug_threads)
1795 fprintf (stderr,
1796 "CB: No breakpoint found at %s for [%s]\n",
1797 paddress (lwp->stop_pc),
fc7238bb 1798 target_pid_to_str (ptid_of (lwp)));
d50171e4
PA
1799 }
1800
1801 current_inferior = saved_inferior;
1802 return 0;
1803}
1804
1805/* When the event-loop is doing a step-over, this points at the thread
1806 being stepped. */
1807ptid_t step_over_bkpt;
1808
bd99dc85
PA
1809/* Wait for an event from child PID. If PID is -1, wait for any
1810 child. Store the stop status through the status pointer WSTAT.
1811 OPTIONS is passed to the waitpid call. Return 0 if no child stop
1812 event was found and OPTIONS contains WNOHANG. Return the PID of
1813 the stopped child otherwise. */
1814
0d62e5e8 1815static int
d8301ad1 1816linux_wait_for_event (ptid_t ptid, int *wstat, int options)
0d62e5e8 1817{
d50171e4 1818 struct lwp_info *event_child, *requested_child;
d8301ad1 1819 ptid_t wait_ptid;
d50171e4 1820
d50171e4
PA
1821 event_child = NULL;
1822 requested_child = NULL;
0d62e5e8 1823
95954743 1824 /* Check for a lwp with a pending status. */
bd99dc85 1825
e825046f 1826 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
0d62e5e8 1827 {
54a0b537 1828 event_child = (struct lwp_info *)
d50171e4 1829 find_inferior (&all_lwps, status_pending_p_callback, &ptid);
0d62e5e8 1830 if (debug_threads && event_child)
bd99dc85 1831 fprintf (stderr, "Got a pending child %ld\n", lwpid_of (event_child));
0d62e5e8
DJ
1832 }
1833 else
1834 {
95954743 1835 requested_child = find_lwp_pid (ptid);
d50171e4 1836
bde24c0a 1837 if (stopping_threads == NOT_STOPPING_THREADS
fa593d66
PA
1838 && requested_child->status_pending_p
1839 && requested_child->collecting_fast_tracepoint)
1840 {
1841 enqueue_one_deferred_signal (requested_child,
1842 &requested_child->status_pending);
1843 requested_child->status_pending_p = 0;
1844 requested_child->status_pending = 0;
1845 linux_resume_one_lwp (requested_child, 0, 0, NULL);
1846 }
1847
1848 if (requested_child->suspended
1849 && requested_child->status_pending_p)
1850 fatal ("requesting an event out of a suspended child?");
1851
d50171e4 1852 if (requested_child->status_pending_p)
bd99dc85 1853 event_child = requested_child;
0d62e5e8 1854 }
611cb4a5 1855
0d62e5e8
DJ
1856 if (event_child != NULL)
1857 {
bd99dc85
PA
1858 if (debug_threads)
1859 fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
1860 lwpid_of (event_child), event_child->status_pending);
1861 *wstat = event_child->status_pending;
1862 event_child->status_pending_p = 0;
1863 event_child->status_pending = 0;
1864 current_inferior = get_lwp_thread (event_child);
1865 return lwpid_of (event_child);
0d62e5e8
DJ
1866 }
1867
d8301ad1
JK
1868 if (ptid_is_pid (ptid))
1869 {
1870 /* A request to wait for a specific tgid. This is not possible
1871 with waitpid, so instead, we wait for any child, and leave
1872 children we're not interested in right now with a pending
1873 status to report later. */
1874 wait_ptid = minus_one_ptid;
1875 }
1876 else
1877 wait_ptid = ptid;
1878
0d62e5e8
DJ
1879 /* We only enter this loop if no process has a pending wait status. Thus
1880 any action taken in response to a wait status inside this loop is
1881 responding as soon as we detect the status, not after any pending
1882 events. */
1883 while (1)
1884 {
d8301ad1 1885 event_child = linux_wait_for_lwp (wait_ptid, wstat, options);
0d62e5e8 1886
bd99dc85 1887 if ((options & WNOHANG) && event_child == NULL)
d50171e4
PA
1888 {
1889 if (debug_threads)
1890 fprintf (stderr, "WNOHANG set, no event found\n");
1891 return 0;
1892 }
0d62e5e8
DJ
1893
1894 if (event_child == NULL)
1895 error ("event from unknown child");
611cb4a5 1896
d8301ad1
JK
1897 if (ptid_is_pid (ptid)
1898 && ptid_get_pid (ptid) != ptid_get_pid (ptid_of (event_child)))
1899 {
1900 if (! WIFSTOPPED (*wstat))
1901 mark_lwp_dead (event_child, *wstat);
1902 else
1903 {
1904 event_child->status_pending_p = 1;
1905 event_child->status_pending = *wstat;
1906 }
1907 continue;
1908 }
1909
bd99dc85 1910 current_inferior = get_lwp_thread (event_child);
0d62e5e8 1911
89be2091 1912 /* Check for thread exit. */
bd99dc85 1913 if (! WIFSTOPPED (*wstat))
0d62e5e8 1914 {
89be2091 1915 if (debug_threads)
95954743 1916 fprintf (stderr, "LWP %ld exiting\n", lwpid_of (event_child));
89be2091
DJ
1917
1918 /* If the last thread is exiting, just return. */
95954743 1919 if (last_thread_of_process_p (current_inferior))
bd99dc85
PA
1920 {
1921 if (debug_threads)
95954743
PA
1922 fprintf (stderr, "LWP %ld is last lwp of process\n",
1923 lwpid_of (event_child));
bd99dc85
PA
1924 return lwpid_of (event_child);
1925 }
89be2091 1926
bd99dc85
PA
1927 if (!non_stop)
1928 {
1929 current_inferior = (struct thread_info *) all_threads.head;
1930 if (debug_threads)
1931 fprintf (stderr, "Current inferior is now %ld\n",
1932 lwpid_of (get_thread_lwp (current_inferior)));
1933 }
1934 else
1935 {
1936 current_inferior = NULL;
1937 if (debug_threads)
1938 fprintf (stderr, "Current inferior is now <NULL>\n");
1939 }
89be2091
DJ
1940
1941 /* If we were waiting for this particular child to do something...
1942 well, it did something. */
bd99dc85 1943 if (requested_child != NULL)
d50171e4
PA
1944 {
1945 int lwpid = lwpid_of (event_child);
1946
1947 /* Cancel the step-over operation --- the thread that
1948 started it is gone. */
1949 if (finish_step_over (event_child))
7984d532 1950 unstop_all_lwps (1, event_child);
d50171e4
PA
1951 delete_lwp (event_child);
1952 return lwpid;
1953 }
1954
1955 delete_lwp (event_child);
89be2091
DJ
1956
1957 /* Wait for a more interesting event. */
1958 continue;
1959 }
1960
a6dbe5df
PA
1961 if (event_child->must_set_ptrace_flags)
1962 {
1e7fc18c 1963 linux_enable_event_reporting (lwpid_of (event_child));
a6dbe5df
PA
1964 event_child->must_set_ptrace_flags = 0;
1965 }
1966
bd99dc85
PA
1967 if (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) == SIGTRAP
1968 && *wstat >> 16 != 0)
24a09b5f 1969 {
bd99dc85 1970 handle_extended_wait (event_child, *wstat);
24a09b5f
DJ
1971 continue;
1972 }
1973
d50171e4
PA
1974 if (WIFSTOPPED (*wstat)
1975 && WSTOPSIG (*wstat) == SIGSTOP
1976 && event_child->stop_expected)
1977 {
1978 int should_stop;
1979
1980 if (debug_threads)
1981 fprintf (stderr, "Expected stop.\n");
1982 event_child->stop_expected = 0;
1983
8336d594 1984 should_stop = (current_inferior->last_resume_kind == resume_stop
bde24c0a 1985 || stopping_threads != NOT_STOPPING_THREADS);
d50171e4
PA
1986
1987 if (!should_stop)
1988 {
1989 linux_resume_one_lwp (event_child,
1990 event_child->stepping, 0, NULL);
1991 continue;
1992 }
1993 }
1994
bd99dc85 1995 return lwpid_of (event_child);
611cb4a5 1996 }
0d62e5e8 1997
611cb4a5
DJ
1998 /* NOTREACHED */
1999 return 0;
2000}
2001
6bf5e0ba
PA
2002/* Count the LWP's that have had events. */
2003
2004static int
2005count_events_callback (struct inferior_list_entry *entry, void *data)
2006{
2007 struct lwp_info *lp = (struct lwp_info *) entry;
8336d594 2008 struct thread_info *thread = get_lwp_thread (lp);
6bf5e0ba
PA
2009 int *count = data;
2010
2011 gdb_assert (count != NULL);
2012
2013 /* Count only resumed LWPs that have a SIGTRAP event pending that
2014 should be reported to GDB. */
8336d594
PA
2015 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
2016 && thread->last_resume_kind != resume_stop
6bf5e0ba
PA
2017 && lp->status_pending_p
2018 && WIFSTOPPED (lp->status_pending)
2019 && WSTOPSIG (lp->status_pending) == SIGTRAP
2020 && !breakpoint_inserted_here (lp->stop_pc))
2021 (*count)++;
2022
2023 return 0;
2024}
2025
2026/* Select the LWP (if any) that is currently being single-stepped. */
2027
2028static int
2029select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data)
2030{
2031 struct lwp_info *lp = (struct lwp_info *) entry;
8336d594 2032 struct thread_info *thread = get_lwp_thread (lp);
6bf5e0ba 2033
8336d594
PA
2034 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
2035 && thread->last_resume_kind == resume_step
6bf5e0ba
PA
2036 && lp->status_pending_p)
2037 return 1;
2038 else
2039 return 0;
2040}
2041
2042/* Select the Nth LWP that has had a SIGTRAP event that should be
2043 reported to GDB. */
2044
2045static int
2046select_event_lwp_callback (struct inferior_list_entry *entry, void *data)
2047{
2048 struct lwp_info *lp = (struct lwp_info *) entry;
8336d594 2049 struct thread_info *thread = get_lwp_thread (lp);
6bf5e0ba
PA
2050 int *selector = data;
2051
2052 gdb_assert (selector != NULL);
2053
2054 /* Select only resumed LWPs that have a SIGTRAP event pending. */
8336d594
PA
2055 if (thread->last_resume_kind != resume_stop
2056 && thread->last_status.kind == TARGET_WAITKIND_IGNORE
6bf5e0ba
PA
2057 && lp->status_pending_p
2058 && WIFSTOPPED (lp->status_pending)
2059 && WSTOPSIG (lp->status_pending) == SIGTRAP
2060 && !breakpoint_inserted_here (lp->stop_pc))
2061 if ((*selector)-- == 0)
2062 return 1;
2063
2064 return 0;
2065}
2066
2067static int
2068cancel_breakpoints_callback (struct inferior_list_entry *entry, void *data)
2069{
2070 struct lwp_info *lp = (struct lwp_info *) entry;
8336d594 2071 struct thread_info *thread = get_lwp_thread (lp);
6bf5e0ba
PA
2072 struct lwp_info *event_lp = data;
2073
2074 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2075 if (lp == event_lp)
2076 return 0;
2077
2078 /* If a LWP other than the LWP that we're reporting an event for has
2079 hit a GDB breakpoint (as opposed to some random trap signal),
2080 then just arrange for it to hit it again later. We don't keep
2081 the SIGTRAP status and don't forward the SIGTRAP signal to the
2082 LWP. We will handle the current event, eventually we will resume
2083 all LWPs, and this one will get its breakpoint trap again.
2084
2085 If we do not do this, then we run the risk that the user will
2086 delete or disable the breakpoint, but the LWP will have already
2087 tripped on it. */
2088
8336d594
PA
2089 if (thread->last_resume_kind != resume_stop
2090 && thread->last_status.kind == TARGET_WAITKIND_IGNORE
6bf5e0ba
PA
2091 && lp->status_pending_p
2092 && WIFSTOPPED (lp->status_pending)
2093 && WSTOPSIG (lp->status_pending) == SIGTRAP
bdabb078
PA
2094 && !lp->stepping
2095 && !lp->stopped_by_watchpoint
6bf5e0ba
PA
2096 && cancel_breakpoint (lp))
2097 /* Throw away the SIGTRAP. */
2098 lp->status_pending_p = 0;
2099
2100 return 0;
2101}
2102
7984d532
PA
2103static void
2104linux_cancel_breakpoints (void)
2105{
2106 find_inferior (&all_lwps, cancel_breakpoints_callback, NULL);
2107}
2108
6bf5e0ba
PA
2109/* Select one LWP out of those that have events pending. */
2110
2111static void
2112select_event_lwp (struct lwp_info **orig_lp)
2113{
2114 int num_events = 0;
2115 int random_selector;
2116 struct lwp_info *event_lp;
2117
2118 /* Give preference to any LWP that is being single-stepped. */
2119 event_lp
2120 = (struct lwp_info *) find_inferior (&all_lwps,
2121 select_singlestep_lwp_callback, NULL);
2122 if (event_lp != NULL)
2123 {
2124 if (debug_threads)
2125 fprintf (stderr,
2126 "SEL: Select single-step %s\n",
2127 target_pid_to_str (ptid_of (event_lp)));
2128 }
2129 else
2130 {
2131 /* No single-stepping LWP. Select one at random, out of those
2132 which have had SIGTRAP events. */
2133
2134 /* First see how many SIGTRAP events we have. */
2135 find_inferior (&all_lwps, count_events_callback, &num_events);
2136
2137 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2138 random_selector = (int)
2139 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2140
2141 if (debug_threads && num_events > 1)
2142 fprintf (stderr,
2143 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2144 num_events, random_selector);
2145
2146 event_lp = (struct lwp_info *) find_inferior (&all_lwps,
2147 select_event_lwp_callback,
2148 &random_selector);
2149 }
2150
2151 if (event_lp != NULL)
2152 {
2153 /* Switch the event LWP. */
2154 *orig_lp = event_lp;
2155 }
2156}
2157
7984d532
PA
2158/* Decrement the suspend count of an LWP. */
2159
2160static int
2161unsuspend_one_lwp (struct inferior_list_entry *entry, void *except)
2162{
2163 struct lwp_info *lwp = (struct lwp_info *) entry;
2164
2165 /* Ignore EXCEPT. */
2166 if (lwp == except)
2167 return 0;
2168
2169 lwp->suspended--;
2170
2171 gdb_assert (lwp->suspended >= 0);
2172 return 0;
2173}
2174
2175/* Decrement the suspend count of all LWPs, except EXCEPT, if non
2176 NULL. */
2177
2178static void
2179unsuspend_all_lwps (struct lwp_info *except)
2180{
2181 find_inferior (&all_lwps, unsuspend_one_lwp, except);
2182}
2183
fa593d66
PA
2184static void move_out_of_jump_pad_callback (struct inferior_list_entry *entry);
2185static int stuck_in_jump_pad_callback (struct inferior_list_entry *entry,
2186 void *data);
2187static int lwp_running (struct inferior_list_entry *entry, void *data);
2188static ptid_t linux_wait_1 (ptid_t ptid,
2189 struct target_waitstatus *ourstatus,
2190 int target_options);
2191
2192/* Stabilize threads (move out of jump pads).
2193
2194 If a thread is midway collecting a fast tracepoint, we need to
2195 finish the collection and move it out of the jump pad before
2196 reporting the signal.
2197
2198 This avoids recursion while collecting (when a signal arrives
2199 midway, and the signal handler itself collects), which would trash
2200 the trace buffer. In case the user set a breakpoint in a signal
2201 handler, this avoids the backtrace showing the jump pad, etc..
2202 Most importantly, there are certain things we can't do safely if
2203 threads are stopped in a jump pad (or in its callee's). For
2204 example:
2205
2206 - starting a new trace run. A thread still collecting the
2207 previous run, could trash the trace buffer when resumed. The trace
2208 buffer control structures would have been reset but the thread had
2209 no way to tell. The thread could even midway memcpy'ing to the
2210 buffer, which would mean that when resumed, it would clobber the
2211 trace buffer that had been set for a new run.
2212
2213 - we can't rewrite/reuse the jump pads for new tracepoints
2214 safely. Say you do tstart while a thread is stopped midway while
2215 collecting. When the thread is later resumed, it finishes the
2216 collection, and returns to the jump pad, to execute the original
2217 instruction that was under the tracepoint jump at the time the
2218 older run had been started. If the jump pad had been rewritten
2219 since for something else in the new run, the thread would now
2220 execute the wrong / random instructions. */
2221
2222static void
2223linux_stabilize_threads (void)
2224{
2225 struct thread_info *save_inferior;
2226 struct lwp_info *lwp_stuck;
2227
2228 lwp_stuck
2229 = (struct lwp_info *) find_inferior (&all_lwps,
2230 stuck_in_jump_pad_callback, NULL);
2231 if (lwp_stuck != NULL)
2232 {
b4d51a55
PA
2233 if (debug_threads)
2234 fprintf (stderr, "can't stabilize, LWP %ld is stuck in jump pad\n",
2235 lwpid_of (lwp_stuck));
fa593d66
PA
2236 return;
2237 }
2238
2239 save_inferior = current_inferior;
2240
2241 stabilizing_threads = 1;
2242
2243 /* Kick 'em all. */
2244 for_each_inferior (&all_lwps, move_out_of_jump_pad_callback);
2245
2246 /* Loop until all are stopped out of the jump pads. */
2247 while (find_inferior (&all_lwps, lwp_running, NULL) != NULL)
2248 {
2249 struct target_waitstatus ourstatus;
2250 struct lwp_info *lwp;
fa593d66
PA
2251 int wstat;
2252
2253 /* Note that we go through the full wait even loop. While
2254 moving threads out of jump pad, we need to be able to step
2255 over internal breakpoints and such. */
32fcada3 2256 linux_wait_1 (minus_one_ptid, &ourstatus, 0);
fa593d66
PA
2257
2258 if (ourstatus.kind == TARGET_WAITKIND_STOPPED)
2259 {
2260 lwp = get_thread_lwp (current_inferior);
2261
2262 /* Lock it. */
2263 lwp->suspended++;
2264
a493e3e2 2265 if (ourstatus.value.sig != GDB_SIGNAL_0
fa593d66
PA
2266 || current_inferior->last_resume_kind == resume_stop)
2267 {
2ea28649 2268 wstat = W_STOPCODE (gdb_signal_to_host (ourstatus.value.sig));
fa593d66
PA
2269 enqueue_one_deferred_signal (lwp, &wstat);
2270 }
2271 }
2272 }
2273
2274 find_inferior (&all_lwps, unsuspend_one_lwp, NULL);
2275
2276 stabilizing_threads = 0;
2277
2278 current_inferior = save_inferior;
2279
b4d51a55 2280 if (debug_threads)
fa593d66 2281 {
b4d51a55
PA
2282 lwp_stuck
2283 = (struct lwp_info *) find_inferior (&all_lwps,
2284 stuck_in_jump_pad_callback, NULL);
2285 if (lwp_stuck != NULL)
fa593d66
PA
2286 fprintf (stderr, "couldn't stabilize, LWP %ld got stuck in jump pad\n",
2287 lwpid_of (lwp_stuck));
2288 }
2289}
2290
0d62e5e8 2291/* Wait for process, returns status. */
da6d8c04 2292
95954743
PA
2293static ptid_t
2294linux_wait_1 (ptid_t ptid,
2295 struct target_waitstatus *ourstatus, int target_options)
da6d8c04 2296{
e5f1222d 2297 int w;
fc7238bb 2298 struct lwp_info *event_child;
bd99dc85 2299 int options;
bd99dc85 2300 int pid;
6bf5e0ba
PA
2301 int step_over_finished;
2302 int bp_explains_trap;
2303 int maybe_internal_trap;
2304 int report_to_gdb;
219f2f23 2305 int trace_event;
bd99dc85
PA
2306
2307 /* Translate generic target options into linux options. */
2308 options = __WALL;
2309 if (target_options & TARGET_WNOHANG)
2310 options |= WNOHANG;
0d62e5e8
DJ
2311
2312retry:
fa593d66
PA
2313 bp_explains_trap = 0;
2314 trace_event = 0;
bd99dc85
PA
2315 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2316
0d62e5e8
DJ
2317 /* If we were only supposed to resume one thread, only wait for
2318 that thread - if it's still alive. If it died, however - which
2319 can happen if we're coming from the thread death case below -
2320 then we need to make sure we restart the other threads. We could
2321 pick a thread at random or restart all; restarting all is less
2322 arbitrary. */
95954743
PA
2323 if (!non_stop
2324 && !ptid_equal (cont_thread, null_ptid)
2325 && !ptid_equal (cont_thread, minus_one_ptid))
0d62e5e8 2326 {
fc7238bb
PA
2327 struct thread_info *thread;
2328
bd99dc85
PA
2329 thread = (struct thread_info *) find_inferior_id (&all_threads,
2330 cont_thread);
0d62e5e8
DJ
2331
2332 /* No stepping, no signal - unless one is pending already, of course. */
bd99dc85 2333 if (thread == NULL)
64386c31
DJ
2334 {
2335 struct thread_resume resume_info;
95954743 2336 resume_info.thread = minus_one_ptid;
bd99dc85
PA
2337 resume_info.kind = resume_continue;
2338 resume_info.sig = 0;
2bd7c093 2339 linux_resume (&resume_info, 1);
64386c31 2340 }
bd99dc85 2341 else
95954743 2342 ptid = cont_thread;
0d62e5e8 2343 }
da6d8c04 2344
6bf5e0ba
PA
2345 if (ptid_equal (step_over_bkpt, null_ptid))
2346 pid = linux_wait_for_event (ptid, &w, options);
2347 else
2348 {
2349 if (debug_threads)
2350 fprintf (stderr, "step_over_bkpt set [%s], doing a blocking wait\n",
2351 target_pid_to_str (step_over_bkpt));
2352 pid = linux_wait_for_event (step_over_bkpt, &w, options & ~WNOHANG);
2353 }
2354
bd99dc85 2355 if (pid == 0) /* only if TARGET_WNOHANG */
95954743 2356 return null_ptid;
bd99dc85 2357
6bf5e0ba 2358 event_child = get_thread_lwp (current_inferior);
da6d8c04 2359
0d62e5e8
DJ
2360 /* If we are waiting for a particular child, and it exited,
2361 linux_wait_for_event will return its exit status. Similarly if
2362 the last child exited. If this is not the last child, however,
2363 do not report it as exited until there is a 'thread exited' response
2364 available in the remote protocol. Instead, just wait for another event.
2365 This should be safe, because if the thread crashed we will already
2366 have reported the termination signal to GDB; that should stop any
2367 in-progress stepping operations, etc.
2368
2369 Report the exit status of the last thread to exit. This matches
2370 LinuxThreads' behavior. */
2371
95954743 2372 if (last_thread_of_process_p (current_inferior))
da6d8c04 2373 {
bd99dc85 2374 if (WIFEXITED (w) || WIFSIGNALED (w))
0d62e5e8 2375 {
bd99dc85
PA
2376 if (WIFEXITED (w))
2377 {
2378 ourstatus->kind = TARGET_WAITKIND_EXITED;
2379 ourstatus->value.integer = WEXITSTATUS (w);
2380
2381 if (debug_threads)
493e2a69
MS
2382 fprintf (stderr,
2383 "\nChild exited with retcode = %x \n",
2384 WEXITSTATUS (w));
bd99dc85
PA
2385 }
2386 else
2387 {
2388 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2ea28649 2389 ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
bd99dc85
PA
2390
2391 if (debug_threads)
493e2a69
MS
2392 fprintf (stderr,
2393 "\nChild terminated with signal = %x \n",
2394 WTERMSIG (w));
bd99dc85
PA
2395
2396 }
5b1c542e 2397
3e4c1235 2398 return ptid_of (event_child);
0d62e5e8 2399 }
da6d8c04 2400 }
0d62e5e8 2401 else
da6d8c04 2402 {
0d62e5e8
DJ
2403 if (!WIFSTOPPED (w))
2404 goto retry;
da6d8c04
DJ
2405 }
2406
6bf5e0ba
PA
2407 /* If this event was not handled before, and is not a SIGTRAP, we
2408 report it. SIGILL and SIGSEGV are also treated as traps in case
2409 a breakpoint is inserted at the current PC. If this target does
2410 not support internal breakpoints at all, we also report the
2411 SIGTRAP without further processing; it's of no concern to us. */
2412 maybe_internal_trap
2413 = (supports_breakpoints ()
2414 && (WSTOPSIG (w) == SIGTRAP
2415 || ((WSTOPSIG (w) == SIGILL
2416 || WSTOPSIG (w) == SIGSEGV)
2417 && (*the_low_target.breakpoint_at) (event_child->stop_pc))));
2418
2419 if (maybe_internal_trap)
2420 {
2421 /* Handle anything that requires bookkeeping before deciding to
2422 report the event or continue waiting. */
2423
2424 /* First check if we can explain the SIGTRAP with an internal
2425 breakpoint, or if we should possibly report the event to GDB.
2426 Do this before anything that may remove or insert a
2427 breakpoint. */
2428 bp_explains_trap = breakpoint_inserted_here (event_child->stop_pc);
2429
2430 /* We have a SIGTRAP, possibly a step-over dance has just
2431 finished. If so, tweak the state machine accordingly,
2432 reinsert breakpoints and delete any reinsert (software
2433 single-step) breakpoints. */
2434 step_over_finished = finish_step_over (event_child);
2435
2436 /* Now invoke the callbacks of any internal breakpoints there. */
2437 check_breakpoints (event_child->stop_pc);
2438
219f2f23
PA
2439 /* Handle tracepoint data collecting. This may overflow the
2440 trace buffer, and cause a tracing stop, removing
2441 breakpoints. */
2442 trace_event = handle_tracepoints (event_child);
2443
6bf5e0ba
PA
2444 if (bp_explains_trap)
2445 {
2446 /* If we stepped or ran into an internal breakpoint, we've
2447 already handled it. So next time we resume (from this
2448 PC), we should step over it. */
2449 if (debug_threads)
2450 fprintf (stderr, "Hit a gdbserver breakpoint.\n");
2451
8b07ae33
PA
2452 if (breakpoint_here (event_child->stop_pc))
2453 event_child->need_step_over = 1;
6bf5e0ba
PA
2454 }
2455 }
2456 else
2457 {
2458 /* We have some other signal, possibly a step-over dance was in
2459 progress, and it should be cancelled too. */
2460 step_over_finished = finish_step_over (event_child);
fa593d66
PA
2461 }
2462
2463 /* We have all the data we need. Either report the event to GDB, or
2464 resume threads and keep waiting for more. */
2465
2466 /* If we're collecting a fast tracepoint, finish the collection and
2467 move out of the jump pad before delivering a signal. See
2468 linux_stabilize_threads. */
2469
2470 if (WIFSTOPPED (w)
2471 && WSTOPSIG (w) != SIGTRAP
2472 && supports_fast_tracepoints ()
58b4daa5 2473 && agent_loaded_p ())
fa593d66
PA
2474 {
2475 if (debug_threads)
2476 fprintf (stderr,
2477 "Got signal %d for LWP %ld. Check if we need "
2478 "to defer or adjust it.\n",
2479 WSTOPSIG (w), lwpid_of (event_child));
2480
2481 /* Allow debugging the jump pad itself. */
2482 if (current_inferior->last_resume_kind != resume_step
2483 && maybe_move_out_of_jump_pad (event_child, &w))
2484 {
2485 enqueue_one_deferred_signal (event_child, &w);
2486
2487 if (debug_threads)
2488 fprintf (stderr,
2489 "Signal %d for LWP %ld deferred (in jump pad)\n",
2490 WSTOPSIG (w), lwpid_of (event_child));
2491
2492 linux_resume_one_lwp (event_child, 0, 0, NULL);
2493 goto retry;
2494 }
2495 }
219f2f23 2496
fa593d66
PA
2497 if (event_child->collecting_fast_tracepoint)
2498 {
2499 if (debug_threads)
2500 fprintf (stderr, "\
2501LWP %ld was trying to move out of the jump pad (%d). \
2502Check if we're already there.\n",
2503 lwpid_of (event_child),
2504 event_child->collecting_fast_tracepoint);
2505
2506 trace_event = 1;
2507
2508 event_child->collecting_fast_tracepoint
2509 = linux_fast_tracepoint_collecting (event_child, NULL);
2510
2511 if (event_child->collecting_fast_tracepoint != 1)
2512 {
2513 /* No longer need this breakpoint. */
2514 if (event_child->exit_jump_pad_bkpt != NULL)
2515 {
2516 if (debug_threads)
2517 fprintf (stderr,
2518 "No longer need exit-jump-pad bkpt; removing it."
2519 "stopping all threads momentarily.\n");
2520
2521 /* Other running threads could hit this breakpoint.
2522 We don't handle moribund locations like GDB does,
2523 instead we always pause all threads when removing
2524 breakpoints, so that any step-over or
2525 decr_pc_after_break adjustment is always taken
2526 care of while the breakpoint is still
2527 inserted. */
2528 stop_all_lwps (1, event_child);
2529 cancel_breakpoints ();
2530
2531 delete_breakpoint (event_child->exit_jump_pad_bkpt);
2532 event_child->exit_jump_pad_bkpt = NULL;
2533
2534 unstop_all_lwps (1, event_child);
2535
2536 gdb_assert (event_child->suspended >= 0);
2537 }
2538 }
2539
2540 if (event_child->collecting_fast_tracepoint == 0)
2541 {
2542 if (debug_threads)
2543 fprintf (stderr,
2544 "fast tracepoint finished "
2545 "collecting successfully.\n");
2546
2547 /* We may have a deferred signal to report. */
2548 if (dequeue_one_deferred_signal (event_child, &w))
2549 {
2550 if (debug_threads)
2551 fprintf (stderr, "dequeued one signal.\n");
2552 }
3c11dd79 2553 else
fa593d66 2554 {
3c11dd79
PA
2555 if (debug_threads)
2556 fprintf (stderr, "no deferred signals.\n");
fa593d66
PA
2557
2558 if (stabilizing_threads)
2559 {
2560 ourstatus->kind = TARGET_WAITKIND_STOPPED;
a493e3e2 2561 ourstatus->value.sig = GDB_SIGNAL_0;
fa593d66
PA
2562 return ptid_of (event_child);
2563 }
2564 }
2565 }
6bf5e0ba
PA
2566 }
2567
e471f25b
PA
2568 /* Check whether GDB would be interested in this event. */
2569
2570 /* If GDB is not interested in this signal, don't stop other
2571 threads, and don't report it to GDB. Just resume the inferior
2572 right away. We do this for threading-related signals as well as
2573 any that GDB specifically requested we ignore. But never ignore
2574 SIGSTOP if we sent it ourselves, and do not ignore signals when
2575 stepping - they may require special handling to skip the signal
2576 handler. */
2577 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
2578 thread library? */
2579 if (WIFSTOPPED (w)
2580 && current_inferior->last_resume_kind != resume_step
2581 && (
1a981360 2582#if defined (USE_THREAD_DB) && !defined (__ANDROID__)
e471f25b
PA
2583 (current_process ()->private->thread_db != NULL
2584 && (WSTOPSIG (w) == __SIGRTMIN
2585 || WSTOPSIG (w) == __SIGRTMIN + 1))
2586 ||
2587#endif
2ea28649 2588 (pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
e471f25b
PA
2589 && !(WSTOPSIG (w) == SIGSTOP
2590 && current_inferior->last_resume_kind == resume_stop))))
2591 {
2592 siginfo_t info, *info_p;
2593
2594 if (debug_threads)
2595 fprintf (stderr, "Ignored signal %d for LWP %ld.\n",
2596 WSTOPSIG (w), lwpid_of (event_child));
2597
2598 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child), 0, &info) == 0)
2599 info_p = &info;
2600 else
2601 info_p = NULL;
2602 linux_resume_one_lwp (event_child, event_child->stepping,
2603 WSTOPSIG (w), info_p);
2604 goto retry;
2605 }
2606
2607 /* If GDB wanted this thread to single step, we always want to
2608 report the SIGTRAP, and let GDB handle it. Watchpoints should
2609 always be reported. So should signals we can't explain. A
2610 SIGTRAP we can't explain could be a GDB breakpoint --- we may or
2611 not support Z0 breakpoints. If we do, we're be able to handle
2612 GDB breakpoints on top of internal breakpoints, by handling the
2613 internal breakpoint and still reporting the event to GDB. If we
2614 don't, we're out of luck, GDB won't see the breakpoint hit. */
6bf5e0ba 2615 report_to_gdb = (!maybe_internal_trap
8336d594 2616 || current_inferior->last_resume_kind == resume_step
6bf5e0ba 2617 || event_child->stopped_by_watchpoint
493e2a69
MS
2618 || (!step_over_finished
2619 && !bp_explains_trap && !trace_event)
9f3a5c85
LM
2620 || (gdb_breakpoint_here (event_child->stop_pc)
2621 && gdb_condition_true_at_breakpoint (event_child->stop_pc)));
6bf5e0ba
PA
2622
2623 /* We found no reason GDB would want us to stop. We either hit one
2624 of our own breakpoints, or finished an internal step GDB
2625 shouldn't know about. */
2626 if (!report_to_gdb)
2627 {
2628 if (debug_threads)
2629 {
2630 if (bp_explains_trap)
2631 fprintf (stderr, "Hit a gdbserver breakpoint.\n");
2632 if (step_over_finished)
2633 fprintf (stderr, "Step-over finished.\n");
219f2f23
PA
2634 if (trace_event)
2635 fprintf (stderr, "Tracepoint event.\n");
6bf5e0ba
PA
2636 }
2637
2638 /* We're not reporting this breakpoint to GDB, so apply the
2639 decr_pc_after_break adjustment to the inferior's regcache
2640 ourselves. */
2641
2642 if (the_low_target.set_pc != NULL)
2643 {
2644 struct regcache *regcache
2645 = get_thread_regcache (get_lwp_thread (event_child), 1);
2646 (*the_low_target.set_pc) (regcache, event_child->stop_pc);
2647 }
2648
7984d532
PA
2649 /* We may have finished stepping over a breakpoint. If so,
2650 we've stopped and suspended all LWPs momentarily except the
2651 stepping one. This is where we resume them all again. We're
2652 going to keep waiting, so use proceed, which handles stepping
2653 over the next breakpoint. */
6bf5e0ba
PA
2654 if (debug_threads)
2655 fprintf (stderr, "proceeding all threads.\n");
7984d532
PA
2656
2657 if (step_over_finished)
2658 unsuspend_all_lwps (event_child);
2659
6bf5e0ba
PA
2660 proceed_all_lwps ();
2661 goto retry;
2662 }
2663
2664 if (debug_threads)
2665 {
8336d594 2666 if (current_inferior->last_resume_kind == resume_step)
6bf5e0ba
PA
2667 fprintf (stderr, "GDB wanted to single-step, reporting event.\n");
2668 if (event_child->stopped_by_watchpoint)
2669 fprintf (stderr, "Stopped by watchpoint.\n");
8b07ae33
PA
2670 if (gdb_breakpoint_here (event_child->stop_pc))
2671 fprintf (stderr, "Stopped by GDB breakpoint.\n");
6bf5e0ba
PA
2672 if (debug_threads)
2673 fprintf (stderr, "Hit a non-gdbserver trap event.\n");
2674 }
2675
2676 /* Alright, we're going to report a stop. */
2677
fa593d66 2678 if (!non_stop && !stabilizing_threads)
6bf5e0ba
PA
2679 {
2680 /* In all-stop, stop all threads. */
7984d532 2681 stop_all_lwps (0, NULL);
6bf5e0ba
PA
2682
2683 /* If we're not waiting for a specific LWP, choose an event LWP
2684 from among those that have had events. Giving equal priority
2685 to all LWPs that have had events helps prevent
2686 starvation. */
2687 if (ptid_equal (ptid, minus_one_ptid))
2688 {
2689 event_child->status_pending_p = 1;
2690 event_child->status_pending = w;
2691
2692 select_event_lwp (&event_child);
2693
2694 event_child->status_pending_p = 0;
2695 w = event_child->status_pending;
2696 }
2697
2698 /* Now that we've selected our final event LWP, cancel any
2699 breakpoints in other LWPs that have hit a GDB breakpoint.
2700 See the comment in cancel_breakpoints_callback to find out
2701 why. */
2702 find_inferior (&all_lwps, cancel_breakpoints_callback, event_child);
fa593d66 2703
c03e6ccc
YQ
2704 /* If we were going a step-over, all other threads but the stepping one
2705 had been paused in start_step_over, with their suspend counts
2706 incremented. We don't want to do a full unstop/unpause, because we're
2707 in all-stop mode (so we want threads stopped), but we still need to
2708 unsuspend the other threads, to decrement their `suspended' count
2709 back. */
2710 if (step_over_finished)
2711 unsuspend_all_lwps (event_child);
2712
fa593d66
PA
2713 /* Stabilize threads (move out of jump pads). */
2714 stabilize_threads ();
6bf5e0ba
PA
2715 }
2716 else
2717 {
2718 /* If we just finished a step-over, then all threads had been
2719 momentarily paused. In all-stop, that's fine, we want
2720 threads stopped by now anyway. In non-stop, we need to
2721 re-resume threads that GDB wanted to be running. */
2722 if (step_over_finished)
7984d532 2723 unstop_all_lwps (1, event_child);
6bf5e0ba
PA
2724 }
2725
5b1c542e 2726 ourstatus->kind = TARGET_WAITKIND_STOPPED;
5b1c542e 2727
8336d594
PA
2728 if (current_inferior->last_resume_kind == resume_stop
2729 && WSTOPSIG (w) == SIGSTOP)
bd99dc85
PA
2730 {
2731 /* A thread that has been requested to stop by GDB with vCont;t,
2732 and it stopped cleanly, so report as SIG0. The use of
2733 SIGSTOP is an implementation detail. */
a493e3e2 2734 ourstatus->value.sig = GDB_SIGNAL_0;
bd99dc85 2735 }
8336d594
PA
2736 else if (current_inferior->last_resume_kind == resume_stop
2737 && WSTOPSIG (w) != SIGSTOP)
bd99dc85
PA
2738 {
2739 /* A thread that has been requested to stop by GDB with vCont;t,
d50171e4 2740 but, it stopped for other reasons. */
2ea28649 2741 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
bd99dc85
PA
2742 }
2743 else
2744 {
2ea28649 2745 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
bd99dc85
PA
2746 }
2747
d50171e4
PA
2748 gdb_assert (ptid_equal (step_over_bkpt, null_ptid));
2749
bd99dc85 2750 if (debug_threads)
95954743 2751 fprintf (stderr, "linux_wait ret = %s, %d, %d\n",
6bf5e0ba 2752 target_pid_to_str (ptid_of (event_child)),
bd99dc85
PA
2753 ourstatus->kind,
2754 ourstatus->value.sig);
2755
6bf5e0ba 2756 return ptid_of (event_child);
bd99dc85
PA
2757}
2758
2759/* Get rid of any pending event in the pipe. */
2760static void
2761async_file_flush (void)
2762{
2763 int ret;
2764 char buf;
2765
2766 do
2767 ret = read (linux_event_pipe[0], &buf, 1);
2768 while (ret >= 0 || (ret == -1 && errno == EINTR));
2769}
2770
2771/* Put something in the pipe, so the event loop wakes up. */
2772static void
2773async_file_mark (void)
2774{
2775 int ret;
2776
2777 async_file_flush ();
2778
2779 do
2780 ret = write (linux_event_pipe[1], "+", 1);
2781 while (ret == 0 || (ret == -1 && errno == EINTR));
2782
2783 /* Ignore EAGAIN. If the pipe is full, the event loop will already
2784 be awakened anyway. */
2785}
2786
95954743
PA
2787static ptid_t
2788linux_wait (ptid_t ptid,
2789 struct target_waitstatus *ourstatus, int target_options)
bd99dc85 2790{
95954743 2791 ptid_t event_ptid;
bd99dc85
PA
2792
2793 if (debug_threads)
95954743 2794 fprintf (stderr, "linux_wait: [%s]\n", target_pid_to_str (ptid));
bd99dc85
PA
2795
2796 /* Flush the async file first. */
2797 if (target_is_async_p ())
2798 async_file_flush ();
2799
95954743 2800 event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
bd99dc85
PA
2801
2802 /* If at least one stop was reported, there may be more. A single
2803 SIGCHLD can signal more than one child stop. */
2804 if (target_is_async_p ()
2805 && (target_options & TARGET_WNOHANG) != 0
95954743 2806 && !ptid_equal (event_ptid, null_ptid))
bd99dc85
PA
2807 async_file_mark ();
2808
2809 return event_ptid;
da6d8c04
DJ
2810}
2811
c5f62d5f 2812/* Send a signal to an LWP. */
fd500816
DJ
2813
2814static int
a1928bad 2815kill_lwp (unsigned long lwpid, int signo)
fd500816 2816{
c5f62d5f
DE
2817 /* Use tkill, if possible, in case we are using nptl threads. If tkill
2818 fails, then we are not using nptl threads and we should be using kill. */
fd500816 2819
c5f62d5f
DE
2820#ifdef __NR_tkill
2821 {
2822 static int tkill_failed;
fd500816 2823
c5f62d5f
DE
2824 if (!tkill_failed)
2825 {
2826 int ret;
2827
2828 errno = 0;
2829 ret = syscall (__NR_tkill, lwpid, signo);
2830 if (errno != ENOSYS)
2831 return ret;
2832 tkill_failed = 1;
2833 }
2834 }
fd500816
DJ
2835#endif
2836
2837 return kill (lwpid, signo);
2838}
2839
964e4306
PA
2840void
2841linux_stop_lwp (struct lwp_info *lwp)
2842{
2843 send_sigstop (lwp);
2844}
2845
0d62e5e8 2846static void
02fc4de7 2847send_sigstop (struct lwp_info *lwp)
0d62e5e8 2848{
bd99dc85 2849 int pid;
0d62e5e8 2850
bd99dc85
PA
2851 pid = lwpid_of (lwp);
2852
0d62e5e8
DJ
2853 /* If we already have a pending stop signal for this process, don't
2854 send another. */
54a0b537 2855 if (lwp->stop_expected)
0d62e5e8 2856 {
ae13219e 2857 if (debug_threads)
bd99dc85 2858 fprintf (stderr, "Have pending sigstop for lwp %d\n", pid);
ae13219e 2859
0d62e5e8
DJ
2860 return;
2861 }
2862
2863 if (debug_threads)
bd99dc85 2864 fprintf (stderr, "Sending sigstop to lwp %d\n", pid);
0d62e5e8 2865
d50171e4 2866 lwp->stop_expected = 1;
bd99dc85 2867 kill_lwp (pid, SIGSTOP);
0d62e5e8
DJ
2868}
2869
7984d532
PA
2870static int
2871send_sigstop_callback (struct inferior_list_entry *entry, void *except)
02fc4de7
PA
2872{
2873 struct lwp_info *lwp = (struct lwp_info *) entry;
2874
7984d532
PA
2875 /* Ignore EXCEPT. */
2876 if (lwp == except)
2877 return 0;
2878
02fc4de7 2879 if (lwp->stopped)
7984d532 2880 return 0;
02fc4de7
PA
2881
2882 send_sigstop (lwp);
7984d532
PA
2883 return 0;
2884}
2885
2886/* Increment the suspend count of an LWP, and stop it, if not stopped
2887 yet. */
2888static int
2889suspend_and_send_sigstop_callback (struct inferior_list_entry *entry,
2890 void *except)
2891{
2892 struct lwp_info *lwp = (struct lwp_info *) entry;
2893
2894 /* Ignore EXCEPT. */
2895 if (lwp == except)
2896 return 0;
2897
2898 lwp->suspended++;
2899
2900 return send_sigstop_callback (entry, except);
02fc4de7
PA
2901}
2902
95954743
PA
2903static void
2904mark_lwp_dead (struct lwp_info *lwp, int wstat)
2905{
2906 /* It's dead, really. */
2907 lwp->dead = 1;
2908
2909 /* Store the exit status for later. */
2910 lwp->status_pending_p = 1;
2911 lwp->status_pending = wstat;
2912
95954743
PA
2913 /* Prevent trying to stop it. */
2914 lwp->stopped = 1;
2915
2916 /* No further stops are expected from a dead lwp. */
2917 lwp->stop_expected = 0;
2918}
2919
0d62e5e8
DJ
2920static void
2921wait_for_sigstop (struct inferior_list_entry *entry)
2922{
54a0b537 2923 struct lwp_info *lwp = (struct lwp_info *) entry;
bd99dc85 2924 struct thread_info *saved_inferior;
a1928bad 2925 int wstat;
95954743
PA
2926 ptid_t saved_tid;
2927 ptid_t ptid;
d50171e4 2928 int pid;
0d62e5e8 2929
54a0b537 2930 if (lwp->stopped)
d50171e4
PA
2931 {
2932 if (debug_threads)
2933 fprintf (stderr, "wait_for_sigstop: LWP %ld already stopped\n",
2934 lwpid_of (lwp));
2935 return;
2936 }
0d62e5e8
DJ
2937
2938 saved_inferior = current_inferior;
bd99dc85
PA
2939 if (saved_inferior != NULL)
2940 saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
2941 else
95954743 2942 saved_tid = null_ptid; /* avoid bogus unused warning */
bd99dc85 2943
95954743 2944 ptid = lwp->head.id;
bd99dc85 2945
d50171e4
PA
2946 if (debug_threads)
2947 fprintf (stderr, "wait_for_sigstop: pulling one event\n");
2948
2949 pid = linux_wait_for_event (ptid, &wstat, __WALL);
0d62e5e8
DJ
2950
2951 /* If we stopped with a non-SIGSTOP signal, save it for later
2952 and record the pending SIGSTOP. If the process exited, just
2953 return. */
d50171e4 2954 if (WIFSTOPPED (wstat))
0d62e5e8
DJ
2955 {
2956 if (debug_threads)
d50171e4
PA
2957 fprintf (stderr, "LWP %ld stopped with signal %d\n",
2958 lwpid_of (lwp), WSTOPSIG (wstat));
c35fafde 2959
d50171e4 2960 if (WSTOPSIG (wstat) != SIGSTOP)
c35fafde
PA
2961 {
2962 if (debug_threads)
d50171e4
PA
2963 fprintf (stderr, "LWP %ld stopped with non-sigstop status %06x\n",
2964 lwpid_of (lwp), wstat);
2965
c35fafde
PA
2966 lwp->status_pending_p = 1;
2967 lwp->status_pending = wstat;
2968 }
0d62e5e8 2969 }
d50171e4 2970 else
95954743
PA
2971 {
2972 if (debug_threads)
d50171e4 2973 fprintf (stderr, "Process %d exited while stopping LWPs\n", pid);
95954743 2974
d50171e4
PA
2975 lwp = find_lwp_pid (pid_to_ptid (pid));
2976 if (lwp)
2977 {
2978 /* Leave this status pending for the next time we're able to
2979 report it. In the mean time, we'll report this lwp as
2980 dead to GDB, so GDB doesn't try to read registers and
2981 memory from it. This can only happen if this was the
2982 last thread of the process; otherwise, PID is removed
2983 from the thread tables before linux_wait_for_event
2984 returns. */
2985 mark_lwp_dead (lwp, wstat);
2986 }
95954743 2987 }
0d62e5e8 2988
bd99dc85 2989 if (saved_inferior == NULL || linux_thread_alive (saved_tid))
0d62e5e8
DJ
2990 current_inferior = saved_inferior;
2991 else
2992 {
2993 if (debug_threads)
2994 fprintf (stderr, "Previously current thread died.\n");
2995
bd99dc85
PA
2996 if (non_stop)
2997 {
2998 /* We can't change the current inferior behind GDB's back,
2999 otherwise, a subsequent command may apply to the wrong
3000 process. */
3001 current_inferior = NULL;
3002 }
3003 else
3004 {
3005 /* Set a valid thread as current. */
3006 set_desired_inferior (0);
3007 }
0d62e5e8
DJ
3008 }
3009}
3010
fa593d66
PA
3011/* Returns true if LWP ENTRY is stopped in a jump pad, and we can't
3012 move it out, because we need to report the stop event to GDB. For
3013 example, if the user puts a breakpoint in the jump pad, it's
3014 because she wants to debug it. */
3015
3016static int
3017stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data)
3018{
3019 struct lwp_info *lwp = (struct lwp_info *) entry;
3020 struct thread_info *thread = get_lwp_thread (lwp);
3021
3022 gdb_assert (lwp->suspended == 0);
3023 gdb_assert (lwp->stopped);
3024
3025 /* Allow debugging the jump pad, gdb_collect, etc.. */
3026 return (supports_fast_tracepoints ()
58b4daa5 3027 && agent_loaded_p ()
fa593d66
PA
3028 && (gdb_breakpoint_here (lwp->stop_pc)
3029 || lwp->stopped_by_watchpoint
3030 || thread->last_resume_kind == resume_step)
3031 && linux_fast_tracepoint_collecting (lwp, NULL));
3032}
3033
3034static void
3035move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
3036{
3037 struct lwp_info *lwp = (struct lwp_info *) entry;
3038 struct thread_info *thread = get_lwp_thread (lwp);
3039 int *wstat;
3040
3041 gdb_assert (lwp->suspended == 0);
3042 gdb_assert (lwp->stopped);
3043
3044 wstat = lwp->status_pending_p ? &lwp->status_pending : NULL;
3045
3046 /* Allow debugging the jump pad, gdb_collect, etc. */
3047 if (!gdb_breakpoint_here (lwp->stop_pc)
3048 && !lwp->stopped_by_watchpoint
3049 && thread->last_resume_kind != resume_step
3050 && maybe_move_out_of_jump_pad (lwp, wstat))
3051 {
3052 if (debug_threads)
3053 fprintf (stderr,
3054 "LWP %ld needs stabilizing (in jump pad)\n",
3055 lwpid_of (lwp));
3056
3057 if (wstat)
3058 {
3059 lwp->status_pending_p = 0;
3060 enqueue_one_deferred_signal (lwp, wstat);
3061
3062 if (debug_threads)
3063 fprintf (stderr,
3064 "Signal %d for LWP %ld deferred "
3065 "(in jump pad)\n",
3066 WSTOPSIG (*wstat), lwpid_of (lwp));
3067 }
3068
3069 linux_resume_one_lwp (lwp, 0, 0, NULL);
3070 }
3071 else
3072 lwp->suspended++;
3073}
3074
3075static int
3076lwp_running (struct inferior_list_entry *entry, void *data)
3077{
3078 struct lwp_info *lwp = (struct lwp_info *) entry;
3079
3080 if (lwp->dead)
3081 return 0;
3082 if (lwp->stopped)
3083 return 0;
3084 return 1;
3085}
3086
7984d532
PA
3087/* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
3088 If SUSPEND, then also increase the suspend count of every LWP,
3089 except EXCEPT. */
3090
0d62e5e8 3091static void
7984d532 3092stop_all_lwps (int suspend, struct lwp_info *except)
0d62e5e8 3093{
bde24c0a
PA
3094 /* Should not be called recursively. */
3095 gdb_assert (stopping_threads == NOT_STOPPING_THREADS);
3096
3097 stopping_threads = (suspend
3098 ? STOPPING_AND_SUSPENDING_THREADS
3099 : STOPPING_THREADS);
7984d532
PA
3100
3101 if (suspend)
3102 find_inferior (&all_lwps, suspend_and_send_sigstop_callback, except);
3103 else
3104 find_inferior (&all_lwps, send_sigstop_callback, except);
54a0b537 3105 for_each_inferior (&all_lwps, wait_for_sigstop);
bde24c0a 3106 stopping_threads = NOT_STOPPING_THREADS;
0d62e5e8
DJ
3107}
3108
da6d8c04
DJ
3109/* Resume execution of the inferior process.
3110 If STEP is nonzero, single-step it.
3111 If SIGNAL is nonzero, give it that signal. */
3112
ce3a066d 3113static void
2acc282a 3114linux_resume_one_lwp (struct lwp_info *lwp,
54a0b537 3115 int step, int signal, siginfo_t *info)
da6d8c04 3116{
0d62e5e8 3117 struct thread_info *saved_inferior;
fa593d66 3118 int fast_tp_collecting;
0d62e5e8 3119
54a0b537 3120 if (lwp->stopped == 0)
0d62e5e8
DJ
3121 return;
3122
fa593d66
PA
3123 fast_tp_collecting = lwp->collecting_fast_tracepoint;
3124
3125 gdb_assert (!stabilizing_threads || fast_tp_collecting);
3126
219f2f23
PA
3127 /* Cancel actions that rely on GDB not changing the PC (e.g., the
3128 user used the "jump" command, or "set $pc = foo"). */
3129 if (lwp->stop_pc != get_pc (lwp))
3130 {
3131 /* Collecting 'while-stepping' actions doesn't make sense
3132 anymore. */
3133 release_while_stepping_state_list (get_lwp_thread (lwp));
3134 }
3135
0d62e5e8
DJ
3136 /* If we have pending signals or status, and a new signal, enqueue the
3137 signal. Also enqueue the signal if we are waiting to reinsert a
3138 breakpoint; it will be picked up again below. */
3139 if (signal != 0
fa593d66
PA
3140 && (lwp->status_pending_p
3141 || lwp->pending_signals != NULL
3142 || lwp->bp_reinsert != 0
3143 || fast_tp_collecting))
0d62e5e8
DJ
3144 {
3145 struct pending_signals *p_sig;
bca929d3 3146 p_sig = xmalloc (sizeof (*p_sig));
54a0b537 3147 p_sig->prev = lwp->pending_signals;
0d62e5e8 3148 p_sig->signal = signal;
32ca6d61
DJ
3149 if (info == NULL)
3150 memset (&p_sig->info, 0, sizeof (siginfo_t));
3151 else
3152 memcpy (&p_sig->info, info, sizeof (siginfo_t));
54a0b537 3153 lwp->pending_signals = p_sig;
0d62e5e8
DJ
3154 }
3155
d50171e4
PA
3156 if (lwp->status_pending_p)
3157 {
3158 if (debug_threads)
3159 fprintf (stderr, "Not resuming lwp %ld (%s, signal %d, stop %s);"
3160 " has pending status\n",
3161 lwpid_of (lwp), step ? "step" : "continue", signal,
3162 lwp->stop_expected ? "expected" : "not expected");
3163 return;
3164 }
0d62e5e8
DJ
3165
3166 saved_inferior = current_inferior;
54a0b537 3167 current_inferior = get_lwp_thread (lwp);
0d62e5e8
DJ
3168
3169 if (debug_threads)
1b3f6016 3170 fprintf (stderr, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
bd99dc85 3171 lwpid_of (lwp), step ? "step" : "continue", signal,
54a0b537 3172 lwp->stop_expected ? "expected" : "not expected");
0d62e5e8
DJ
3173
3174 /* This bit needs some thinking about. If we get a signal that
3175 we must report while a single-step reinsert is still pending,
3176 we often end up resuming the thread. It might be better to
3177 (ew) allow a stack of pending events; then we could be sure that
3178 the reinsert happened right away and not lose any signals.
3179
3180 Making this stack would also shrink the window in which breakpoints are
54a0b537 3181 uninserted (see comment in linux_wait_for_lwp) but not enough for
0d62e5e8
DJ
3182 complete correctness, so it won't solve that problem. It may be
3183 worthwhile just to solve this one, however. */
54a0b537 3184 if (lwp->bp_reinsert != 0)
0d62e5e8
DJ
3185 {
3186 if (debug_threads)
d50171e4
PA
3187 fprintf (stderr, " pending reinsert at 0x%s\n",
3188 paddress (lwp->bp_reinsert));
3189
3190 if (lwp->bp_reinsert != 0 && can_hardware_single_step ())
3191 {
fa593d66
PA
3192 if (fast_tp_collecting == 0)
3193 {
3194 if (step == 0)
3195 fprintf (stderr, "BAD - reinserting but not stepping.\n");
3196 if (lwp->suspended)
3197 fprintf (stderr, "BAD - reinserting and suspended(%d).\n",
3198 lwp->suspended);
3199 }
d50171e4
PA
3200
3201 step = 1;
3202 }
0d62e5e8
DJ
3203
3204 /* Postpone any pending signal. It was enqueued above. */
3205 signal = 0;
3206 }
3207
fa593d66
PA
3208 if (fast_tp_collecting == 1)
3209 {
3210 if (debug_threads)
3211 fprintf (stderr, "\
3212lwp %ld wants to get out of fast tracepoint jump pad (exit-jump-pad-bkpt)\n",
3213 lwpid_of (lwp));
3214
3215 /* Postpone any pending signal. It was enqueued above. */
3216 signal = 0;
3217 }
3218 else if (fast_tp_collecting == 2)
3219 {
3220 if (debug_threads)
3221 fprintf (stderr, "\
3222lwp %ld wants to get out of fast tracepoint jump pad single-stepping\n",
3223 lwpid_of (lwp));
3224
3225 if (can_hardware_single_step ())
3226 step = 1;
3227 else
3228 fatal ("moving out of jump pad single-stepping"
3229 " not implemented on this target");
3230
3231 /* Postpone any pending signal. It was enqueued above. */
3232 signal = 0;
3233 }
3234
219f2f23
PA
3235 /* If we have while-stepping actions in this thread set it stepping.
3236 If we have a signal to deliver, it may or may not be set to
3237 SIG_IGN, we don't know. Assume so, and allow collecting
3238 while-stepping into a signal handler. A possible smart thing to
3239 do would be to set an internal breakpoint at the signal return
3240 address, continue, and carry on catching this while-stepping
3241 action only when that breakpoint is hit. A future
3242 enhancement. */
3243 if (get_lwp_thread (lwp)->while_stepping != NULL
3244 && can_hardware_single_step ())
3245 {
3246 if (debug_threads)
3247 fprintf (stderr,
3248 "lwp %ld has a while-stepping action -> forcing step.\n",
3249 lwpid_of (lwp));
3250 step = 1;
3251 }
3252
aa691b87 3253 if (debug_threads && the_low_target.get_pc != NULL)
0d62e5e8 3254 {
442ea881
PA
3255 struct regcache *regcache = get_thread_regcache (current_inferior, 1);
3256 CORE_ADDR pc = (*the_low_target.get_pc) (regcache);
47c0c975 3257 fprintf (stderr, " resuming from pc 0x%lx\n", (long) pc);
0d62e5e8
DJ
3258 }
3259
fa593d66
PA
3260 /* If we have pending signals, consume one unless we are trying to
3261 reinsert a breakpoint or we're trying to finish a fast tracepoint
3262 collect. */
3263 if (lwp->pending_signals != NULL
3264 && lwp->bp_reinsert == 0
3265 && fast_tp_collecting == 0)
0d62e5e8
DJ
3266 {
3267 struct pending_signals **p_sig;
3268
54a0b537 3269 p_sig = &lwp->pending_signals;
0d62e5e8
DJ
3270 while ((*p_sig)->prev != NULL)
3271 p_sig = &(*p_sig)->prev;
3272
3273 signal = (*p_sig)->signal;
32ca6d61 3274 if ((*p_sig)->info.si_signo != 0)
bd99dc85 3275 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
32ca6d61 3276
0d62e5e8
DJ
3277 free (*p_sig);
3278 *p_sig = NULL;
3279 }
3280
aa5ca48f
DE
3281 if (the_low_target.prepare_to_resume != NULL)
3282 the_low_target.prepare_to_resume (lwp);
3283
0d62e5e8 3284 regcache_invalidate_one ((struct inferior_list_entry *)
54a0b537 3285 get_lwp_thread (lwp));
da6d8c04 3286 errno = 0;
54a0b537 3287 lwp->stopped = 0;
c3adc08c 3288 lwp->stopped_by_watchpoint = 0;
54a0b537 3289 lwp->stepping = step;
14ce3065
DE
3290 ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp), 0,
3291 /* Coerce to a uintptr_t first to avoid potential gcc warning
3292 of coercing an 8 byte integer to a 4 byte pointer. */
3293 (PTRACE_ARG4_TYPE) (uintptr_t) signal);
0d62e5e8
DJ
3294
3295 current_inferior = saved_inferior;
da6d8c04 3296 if (errno)
3221518c
UW
3297 {
3298 /* ESRCH from ptrace either means that the thread was already
3299 running (an error) or that it is gone (a race condition). If
3300 it's gone, we will get a notification the next time we wait,
3301 so we can ignore the error. We could differentiate these
3302 two, but it's tricky without waiting; the thread still exists
3303 as a zombie, so sending it signal 0 would succeed. So just
3304 ignore ESRCH. */
3305 if (errno == ESRCH)
3306 return;
3307
3308 perror_with_name ("ptrace");
3309 }
da6d8c04
DJ
3310}
3311
2bd7c093
PA
3312struct thread_resume_array
3313{
3314 struct thread_resume *resume;
3315 size_t n;
3316};
64386c31
DJ
3317
3318/* This function is called once per thread. We look up the thread
5544ad89
DJ
3319 in RESUME_PTR, and mark the thread with a pointer to the appropriate
3320 resume request.
3321
3322 This algorithm is O(threads * resume elements), but resume elements
3323 is small (and will remain small at least until GDB supports thread
3324 suspension). */
2bd7c093
PA
3325static int
3326linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
0d62e5e8 3327{
54a0b537 3328 struct lwp_info *lwp;
64386c31 3329 struct thread_info *thread;
5544ad89 3330 int ndx;
2bd7c093 3331 struct thread_resume_array *r;
64386c31
DJ
3332
3333 thread = (struct thread_info *) entry;
54a0b537 3334 lwp = get_thread_lwp (thread);
2bd7c093 3335 r = arg;
64386c31 3336
2bd7c093 3337 for (ndx = 0; ndx < r->n; ndx++)
95954743
PA
3338 {
3339 ptid_t ptid = r->resume[ndx].thread;
3340 if (ptid_equal (ptid, minus_one_ptid)
3341 || ptid_equal (ptid, entry->id)
3342 || (ptid_is_pid (ptid)
3343 && (ptid_get_pid (ptid) == pid_of (lwp)))
3344 || (ptid_get_lwp (ptid) == -1
3345 && (ptid_get_pid (ptid) == pid_of (lwp))))
3346 {
d50171e4 3347 if (r->resume[ndx].kind == resume_stop
8336d594 3348 && thread->last_resume_kind == resume_stop)
d50171e4
PA
3349 {
3350 if (debug_threads)
3351 fprintf (stderr, "already %s LWP %ld at GDB's request\n",
3352 thread->last_status.kind == TARGET_WAITKIND_STOPPED
3353 ? "stopped"
3354 : "stopping",
3355 lwpid_of (lwp));
3356
3357 continue;
3358 }
3359
95954743 3360 lwp->resume = &r->resume[ndx];
8336d594 3361 thread->last_resume_kind = lwp->resume->kind;
fa593d66
PA
3362
3363 /* If we had a deferred signal to report, dequeue one now.
3364 This can happen if LWP gets more than one signal while
3365 trying to get out of a jump pad. */
3366 if (lwp->stopped
3367 && !lwp->status_pending_p
3368 && dequeue_one_deferred_signal (lwp, &lwp->status_pending))
3369 {
3370 lwp->status_pending_p = 1;
3371
3372 if (debug_threads)
3373 fprintf (stderr,
3374 "Dequeueing deferred signal %d for LWP %ld, "
3375 "leaving status pending.\n",
3376 WSTOPSIG (lwp->status_pending), lwpid_of (lwp));
3377 }
3378
95954743
PA
3379 return 0;
3380 }
3381 }
2bd7c093
PA
3382
3383 /* No resume action for this thread. */
3384 lwp->resume = NULL;
64386c31 3385
2bd7c093 3386 return 0;
5544ad89
DJ
3387}
3388
5544ad89 3389
bd99dc85
PA
3390/* Set *FLAG_P if this lwp has an interesting status pending. */
3391static int
3392resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
5544ad89 3393{
bd99dc85 3394 struct lwp_info *lwp = (struct lwp_info *) entry;
5544ad89 3395
bd99dc85
PA
3396 /* LWPs which will not be resumed are not interesting, because
3397 we might not wait for them next time through linux_wait. */
2bd7c093 3398 if (lwp->resume == NULL)
bd99dc85 3399 return 0;
64386c31 3400
bd99dc85 3401 if (lwp->status_pending_p)
d50171e4
PA
3402 * (int *) flag_p = 1;
3403
3404 return 0;
3405}
3406
3407/* Return 1 if this lwp that GDB wants running is stopped at an
3408 internal breakpoint that we need to step over. It assumes that any
3409 required STOP_PC adjustment has already been propagated to the
3410 inferior's regcache. */
3411
3412static int
3413need_step_over_p (struct inferior_list_entry *entry, void *dummy)
3414{
3415 struct lwp_info *lwp = (struct lwp_info *) entry;
8336d594 3416 struct thread_info *thread;
d50171e4
PA
3417 struct thread_info *saved_inferior;
3418 CORE_ADDR pc;
3419
3420 /* LWPs which will not be resumed are not interesting, because we
3421 might not wait for them next time through linux_wait. */
3422
3423 if (!lwp->stopped)
3424 {
3425 if (debug_threads)
3426 fprintf (stderr,
3427 "Need step over [LWP %ld]? Ignoring, not stopped\n",
3428 lwpid_of (lwp));
3429 return 0;
3430 }
3431
8336d594
PA
3432 thread = get_lwp_thread (lwp);
3433
3434 if (thread->last_resume_kind == resume_stop)
d50171e4
PA
3435 {
3436 if (debug_threads)
3437 fprintf (stderr,
3438 "Need step over [LWP %ld]? Ignoring, should remain stopped\n",
3439 lwpid_of (lwp));
3440 return 0;
3441 }
3442
7984d532
PA
3443 gdb_assert (lwp->suspended >= 0);
3444
3445 if (lwp->suspended)
3446 {
3447 if (debug_threads)
3448 fprintf (stderr,
3449 "Need step over [LWP %ld]? Ignoring, suspended\n",
3450 lwpid_of (lwp));
3451 return 0;
3452 }
3453
d50171e4
PA
3454 if (!lwp->need_step_over)
3455 {
3456 if (debug_threads)
3457 fprintf (stderr,
3458 "Need step over [LWP %ld]? No\n", lwpid_of (lwp));
3459 }
5544ad89 3460
bd99dc85 3461 if (lwp->status_pending_p)
d50171e4
PA
3462 {
3463 if (debug_threads)
3464 fprintf (stderr,
3465 "Need step over [LWP %ld]? Ignoring, has pending status.\n",
3466 lwpid_of (lwp));
3467 return 0;
3468 }
3469
3470 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
3471 or we have. */
3472 pc = get_pc (lwp);
3473
3474 /* If the PC has changed since we stopped, then don't do anything,
3475 and let the breakpoint/tracepoint be hit. This happens if, for
3476 instance, GDB handled the decr_pc_after_break subtraction itself,
3477 GDB is OOL stepping this thread, or the user has issued a "jump"
3478 command, or poked thread's registers herself. */
3479 if (pc != lwp->stop_pc)
3480 {
3481 if (debug_threads)
3482 fprintf (stderr,
3483 "Need step over [LWP %ld]? Cancelling, PC was changed. "
3484 "Old stop_pc was 0x%s, PC is now 0x%s\n",
3485 lwpid_of (lwp), paddress (lwp->stop_pc), paddress (pc));
3486
3487 lwp->need_step_over = 0;
3488 return 0;
3489 }
3490
3491 saved_inferior = current_inferior;
8336d594 3492 current_inferior = thread;
d50171e4 3493
8b07ae33 3494 /* We can only step over breakpoints we know about. */
fa593d66 3495 if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
d50171e4 3496 {
8b07ae33 3497 /* Don't step over a breakpoint that GDB expects to hit
9f3a5c85
LM
3498 though. If the condition is being evaluated on the target's side
3499 and it evaluate to false, step over this breakpoint as well. */
3500 if (gdb_breakpoint_here (pc)
3501 && gdb_condition_true_at_breakpoint (pc))
8b07ae33
PA
3502 {
3503 if (debug_threads)
3504 fprintf (stderr,
3505 "Need step over [LWP %ld]? yes, but found"
3506 " GDB breakpoint at 0x%s; skipping step over\n",
3507 lwpid_of (lwp), paddress (pc));
d50171e4 3508
8b07ae33
PA
3509 current_inferior = saved_inferior;
3510 return 0;
3511 }
3512 else
3513 {
3514 if (debug_threads)
3515 fprintf (stderr,
493e2a69
MS
3516 "Need step over [LWP %ld]? yes, "
3517 "found breakpoint at 0x%s\n",
8b07ae33 3518 lwpid_of (lwp), paddress (pc));
d50171e4 3519
8b07ae33
PA
3520 /* We've found an lwp that needs stepping over --- return 1 so
3521 that find_inferior stops looking. */
3522 current_inferior = saved_inferior;
3523
3524 /* If the step over is cancelled, this is set again. */
3525 lwp->need_step_over = 0;
3526 return 1;
3527 }
d50171e4
PA
3528 }
3529
3530 current_inferior = saved_inferior;
3531
3532 if (debug_threads)
3533 fprintf (stderr,
3534 "Need step over [LWP %ld]? No, no breakpoint found at 0x%s\n",
3535 lwpid_of (lwp), paddress (pc));
c6ecbae5 3536
bd99dc85 3537 return 0;
5544ad89
DJ
3538}
3539
d50171e4
PA
3540/* Start a step-over operation on LWP. When LWP stopped at a
3541 breakpoint, to make progress, we need to remove the breakpoint out
3542 of the way. If we let other threads run while we do that, they may
3543 pass by the breakpoint location and miss hitting it. To avoid
3544 that, a step-over momentarily stops all threads while LWP is
3545 single-stepped while the breakpoint is temporarily uninserted from
3546 the inferior. When the single-step finishes, we reinsert the
3547 breakpoint, and let all threads that are supposed to be running,
3548 run again.
3549
3550 On targets that don't support hardware single-step, we don't
3551 currently support full software single-stepping. Instead, we only
3552 support stepping over the thread event breakpoint, by asking the
3553 low target where to place a reinsert breakpoint. Since this
3554 routine assumes the breakpoint being stepped over is a thread event
3555 breakpoint, it usually assumes the return address of the current
3556 function is a good enough place to set the reinsert breakpoint. */
3557
3558static int
3559start_step_over (struct lwp_info *lwp)
3560{
3561 struct thread_info *saved_inferior;
3562 CORE_ADDR pc;
3563 int step;
3564
3565 if (debug_threads)
3566 fprintf (stderr,
3567 "Starting step-over on LWP %ld. Stopping all threads\n",
3568 lwpid_of (lwp));
3569
7984d532
PA
3570 stop_all_lwps (1, lwp);
3571 gdb_assert (lwp->suspended == 0);
d50171e4
PA
3572
3573 if (debug_threads)
3574 fprintf (stderr, "Done stopping all threads for step-over.\n");
3575
3576 /* Note, we should always reach here with an already adjusted PC,
3577 either by GDB (if we're resuming due to GDB's request), or by our
3578 caller, if we just finished handling an internal breakpoint GDB
3579 shouldn't care about. */
3580 pc = get_pc (lwp);
3581
3582 saved_inferior = current_inferior;
3583 current_inferior = get_lwp_thread (lwp);
3584
3585 lwp->bp_reinsert = pc;
3586 uninsert_breakpoints_at (pc);
fa593d66 3587 uninsert_fast_tracepoint_jumps_at (pc);
d50171e4
PA
3588
3589 if (can_hardware_single_step ())
3590 {
3591 step = 1;
3592 }
3593 else
3594 {
3595 CORE_ADDR raddr = (*the_low_target.breakpoint_reinsert_addr) ();
3596 set_reinsert_breakpoint (raddr);
3597 step = 0;
3598 }
3599
3600 current_inferior = saved_inferior;
3601
3602 linux_resume_one_lwp (lwp, step, 0, NULL);
3603
3604 /* Require next event from this LWP. */
3605 step_over_bkpt = lwp->head.id;
3606 return 1;
3607}
3608
3609/* Finish a step-over. Reinsert the breakpoint we had uninserted in
3610 start_step_over, if still there, and delete any reinsert
3611 breakpoints we've set, on non hardware single-step targets. */
3612
3613static int
3614finish_step_over (struct lwp_info *lwp)
3615{
3616 if (lwp->bp_reinsert != 0)
3617 {
3618 if (debug_threads)
3619 fprintf (stderr, "Finished step over.\n");
3620
3621 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
3622 may be no breakpoint to reinsert there by now. */
3623 reinsert_breakpoints_at (lwp->bp_reinsert);
fa593d66 3624 reinsert_fast_tracepoint_jumps_at (lwp->bp_reinsert);
d50171e4
PA
3625
3626 lwp->bp_reinsert = 0;
3627
3628 /* Delete any software-single-step reinsert breakpoints. No
3629 longer needed. We don't have to worry about other threads
3630 hitting this trap, and later not being able to explain it,
3631 because we were stepping over a breakpoint, and we hold all
3632 threads but LWP stopped while doing that. */
3633 if (!can_hardware_single_step ())
3634 delete_reinsert_breakpoints ();
3635
3636 step_over_bkpt = null_ptid;
3637 return 1;
3638 }
3639 else
3640 return 0;
3641}
3642
5544ad89
DJ
3643/* This function is called once per thread. We check the thread's resume
3644 request, which will tell us whether to resume, step, or leave the thread
bd99dc85 3645 stopped; and what signal, if any, it should be sent.
5544ad89 3646
bd99dc85
PA
3647 For threads which we aren't explicitly told otherwise, we preserve
3648 the stepping flag; this is used for stepping over gdbserver-placed
3649 breakpoints.
3650
3651 If pending_flags was set in any thread, we queue any needed
3652 signals, since we won't actually resume. We already have a pending
3653 event to report, so we don't need to preserve any step requests;
3654 they should be re-issued if necessary. */
3655
3656static int
3657linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
5544ad89 3658{
54a0b537 3659 struct lwp_info *lwp;
5544ad89 3660 struct thread_info *thread;
bd99dc85 3661 int step;
d50171e4
PA
3662 int leave_all_stopped = * (int *) arg;
3663 int leave_pending;
5544ad89
DJ
3664
3665 thread = (struct thread_info *) entry;
54a0b537 3666 lwp = get_thread_lwp (thread);
5544ad89 3667
2bd7c093 3668 if (lwp->resume == NULL)
bd99dc85 3669 return 0;
5544ad89 3670
bd99dc85 3671 if (lwp->resume->kind == resume_stop)
5544ad89 3672 {
bd99dc85 3673 if (debug_threads)
d50171e4 3674 fprintf (stderr, "resume_stop request for LWP %ld\n", lwpid_of (lwp));
bd99dc85
PA
3675
3676 if (!lwp->stopped)
3677 {
3678 if (debug_threads)
d50171e4 3679 fprintf (stderr, "stopping LWP %ld\n", lwpid_of (lwp));
bd99dc85 3680
d50171e4
PA
3681 /* Stop the thread, and wait for the event asynchronously,
3682 through the event loop. */
02fc4de7 3683 send_sigstop (lwp);
bd99dc85
PA
3684 }
3685 else
3686 {
3687 if (debug_threads)
d50171e4
PA
3688 fprintf (stderr, "already stopped LWP %ld\n",
3689 lwpid_of (lwp));
3690
3691 /* The LWP may have been stopped in an internal event that
3692 was not meant to be notified back to GDB (e.g., gdbserver
3693 breakpoint), so we should be reporting a stop event in
3694 this case too. */
3695
3696 /* If the thread already has a pending SIGSTOP, this is a
3697 no-op. Otherwise, something later will presumably resume
3698 the thread and this will cause it to cancel any pending
3699 operation, due to last_resume_kind == resume_stop. If
3700 the thread already has a pending status to report, we
3701 will still report it the next time we wait - see
3702 status_pending_p_callback. */
1a981360
PA
3703
3704 /* If we already have a pending signal to report, then
3705 there's no need to queue a SIGSTOP, as this means we're
3706 midway through moving the LWP out of the jumppad, and we
3707 will report the pending signal as soon as that is
3708 finished. */
3709 if (lwp->pending_signals_to_report == NULL)
3710 send_sigstop (lwp);
bd99dc85 3711 }
32ca6d61 3712
bd99dc85
PA
3713 /* For stop requests, we're done. */
3714 lwp->resume = NULL;
fc7238bb 3715 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
bd99dc85 3716 return 0;
5544ad89
DJ
3717 }
3718
bd99dc85
PA
3719 /* If this thread which is about to be resumed has a pending status,
3720 then don't resume any threads - we can just report the pending
3721 status. Make sure to queue any signals that would otherwise be
3722 sent. In all-stop mode, we do this decision based on if *any*
d50171e4
PA
3723 thread has a pending status. If there's a thread that needs the
3724 step-over-breakpoint dance, then don't resume any other thread
3725 but that particular one. */
3726 leave_pending = (lwp->status_pending_p || leave_all_stopped);
5544ad89 3727
d50171e4 3728 if (!leave_pending)
bd99dc85
PA
3729 {
3730 if (debug_threads)
3731 fprintf (stderr, "resuming LWP %ld\n", lwpid_of (lwp));
5544ad89 3732
d50171e4 3733 step = (lwp->resume->kind == resume_step);
2acc282a 3734 linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL);
bd99dc85
PA
3735 }
3736 else
3737 {
3738 if (debug_threads)
3739 fprintf (stderr, "leaving LWP %ld stopped\n", lwpid_of (lwp));
5544ad89 3740
bd99dc85
PA
3741 /* If we have a new signal, enqueue the signal. */
3742 if (lwp->resume->sig != 0)
3743 {
3744 struct pending_signals *p_sig;
3745 p_sig = xmalloc (sizeof (*p_sig));
3746 p_sig->prev = lwp->pending_signals;
3747 p_sig->signal = lwp->resume->sig;
3748 memset (&p_sig->info, 0, sizeof (siginfo_t));
3749
3750 /* If this is the same signal we were previously stopped by,
3751 make sure to queue its siginfo. We can ignore the return
3752 value of ptrace; if it fails, we'll skip
3753 PTRACE_SETSIGINFO. */
3754 if (WIFSTOPPED (lwp->last_status)
3755 && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
3756 ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
3757
3758 lwp->pending_signals = p_sig;
3759 }
3760 }
5544ad89 3761
fc7238bb 3762 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
bd99dc85 3763 lwp->resume = NULL;
5544ad89 3764 return 0;
0d62e5e8
DJ
3765}
3766
3767static void
2bd7c093 3768linux_resume (struct thread_resume *resume_info, size_t n)
0d62e5e8 3769{
2bd7c093 3770 struct thread_resume_array array = { resume_info, n };
d50171e4
PA
3771 struct lwp_info *need_step_over = NULL;
3772 int any_pending;
3773 int leave_all_stopped;
c6ecbae5 3774
2bd7c093 3775 find_inferior (&all_threads, linux_set_resume_request, &array);
5544ad89 3776
d50171e4
PA
3777 /* If there is a thread which would otherwise be resumed, which has
3778 a pending status, then don't resume any threads - we can just
3779 report the pending status. Make sure to queue any signals that
3780 would otherwise be sent. In non-stop mode, we'll apply this
3781 logic to each thread individually. We consume all pending events
3782 before considering to start a step-over (in all-stop). */
3783 any_pending = 0;
bd99dc85 3784 if (!non_stop)
d50171e4
PA
3785 find_inferior (&all_lwps, resume_status_pending_p, &any_pending);
3786
3787 /* If there is a thread which would otherwise be resumed, which is
3788 stopped at a breakpoint that needs stepping over, then don't
3789 resume any threads - have it step over the breakpoint with all
3790 other threads stopped, then resume all threads again. Make sure
3791 to queue any signals that would otherwise be delivered or
3792 queued. */
3793 if (!any_pending && supports_breakpoints ())
3794 need_step_over
3795 = (struct lwp_info *) find_inferior (&all_lwps,
3796 need_step_over_p, NULL);
3797
3798 leave_all_stopped = (need_step_over != NULL || any_pending);
3799
3800 if (debug_threads)
3801 {
3802 if (need_step_over != NULL)
3803 fprintf (stderr, "Not resuming all, need step over\n");
3804 else if (any_pending)
3805 fprintf (stderr,
3806 "Not resuming, all-stop and found "
3807 "an LWP with pending status\n");
3808 else
3809 fprintf (stderr, "Resuming, no pending status or step over needed\n");
3810 }
3811
3812 /* Even if we're leaving threads stopped, queue all signals we'd
3813 otherwise deliver. */
3814 find_inferior (&all_threads, linux_resume_one_thread, &leave_all_stopped);
3815
3816 if (need_step_over)
3817 start_step_over (need_step_over);
3818}
3819
3820/* This function is called once per thread. We check the thread's
3821 last resume request, which will tell us whether to resume, step, or
3822 leave the thread stopped. Any signal the client requested to be
3823 delivered has already been enqueued at this point.
3824
3825 If any thread that GDB wants running is stopped at an internal
3826 breakpoint that needs stepping over, we start a step-over operation
3827 on that particular thread, and leave all others stopped. */
3828
7984d532
PA
3829static int
3830proceed_one_lwp (struct inferior_list_entry *entry, void *except)
d50171e4 3831{
7984d532 3832 struct lwp_info *lwp = (struct lwp_info *) entry;
8336d594 3833 struct thread_info *thread;
d50171e4
PA
3834 int step;
3835
7984d532
PA
3836 if (lwp == except)
3837 return 0;
d50171e4
PA
3838
3839 if (debug_threads)
3840 fprintf (stderr,
3841 "proceed_one_lwp: lwp %ld\n", lwpid_of (lwp));
3842
3843 if (!lwp->stopped)
3844 {
3845 if (debug_threads)
3846 fprintf (stderr, " LWP %ld already running\n", lwpid_of (lwp));
7984d532 3847 return 0;
d50171e4
PA
3848 }
3849
8336d594
PA
3850 thread = get_lwp_thread (lwp);
3851
02fc4de7
PA
3852 if (thread->last_resume_kind == resume_stop
3853 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
d50171e4
PA
3854 {
3855 if (debug_threads)
02fc4de7
PA
3856 fprintf (stderr, " client wants LWP to remain %ld stopped\n",
3857 lwpid_of (lwp));
7984d532 3858 return 0;
d50171e4
PA
3859 }
3860
3861 if (lwp->status_pending_p)
3862 {
3863 if (debug_threads)
3864 fprintf (stderr, " LWP %ld has pending status, leaving stopped\n",
3865 lwpid_of (lwp));
7984d532 3866 return 0;
d50171e4
PA
3867 }
3868
7984d532
PA
3869 gdb_assert (lwp->suspended >= 0);
3870
d50171e4
PA
3871 if (lwp->suspended)
3872 {
3873 if (debug_threads)
3874 fprintf (stderr, " LWP %ld is suspended\n", lwpid_of (lwp));
7984d532 3875 return 0;
d50171e4
PA
3876 }
3877
1a981360
PA
3878 if (thread->last_resume_kind == resume_stop
3879 && lwp->pending_signals_to_report == NULL
3880 && lwp->collecting_fast_tracepoint == 0)
02fc4de7
PA
3881 {
3882 /* We haven't reported this LWP as stopped yet (otherwise, the
3883 last_status.kind check above would catch it, and we wouldn't
3884 reach here. This LWP may have been momentarily paused by a
3885 stop_all_lwps call while handling for example, another LWP's
3886 step-over. In that case, the pending expected SIGSTOP signal
3887 that was queued at vCont;t handling time will have already
3888 been consumed by wait_for_sigstop, and so we need to requeue
3889 another one here. Note that if the LWP already has a SIGSTOP
3890 pending, this is a no-op. */
3891
3892 if (debug_threads)
3893 fprintf (stderr,
3894 "Client wants LWP %ld to stop. "
3895 "Making sure it has a SIGSTOP pending\n",
3896 lwpid_of (lwp));
3897
3898 send_sigstop (lwp);
3899 }
3900
8336d594 3901 step = thread->last_resume_kind == resume_step;
d50171e4 3902 linux_resume_one_lwp (lwp, step, 0, NULL);
7984d532
PA
3903 return 0;
3904}
3905
3906static int
3907unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except)
3908{
3909 struct lwp_info *lwp = (struct lwp_info *) entry;
3910
3911 if (lwp == except)
3912 return 0;
3913
3914 lwp->suspended--;
3915 gdb_assert (lwp->suspended >= 0);
3916
3917 return proceed_one_lwp (entry, except);
d50171e4
PA
3918}
3919
3920/* When we finish a step-over, set threads running again. If there's
3921 another thread that may need a step-over, now's the time to start
3922 it. Eventually, we'll move all threads past their breakpoints. */
3923
3924static void
3925proceed_all_lwps (void)
3926{
3927 struct lwp_info *need_step_over;
3928
3929 /* If there is a thread which would otherwise be resumed, which is
3930 stopped at a breakpoint that needs stepping over, then don't
3931 resume any threads - have it step over the breakpoint with all
3932 other threads stopped, then resume all threads again. */
3933
3934 if (supports_breakpoints ())
3935 {
3936 need_step_over
3937 = (struct lwp_info *) find_inferior (&all_lwps,
3938 need_step_over_p, NULL);
3939
3940 if (need_step_over != NULL)
3941 {
3942 if (debug_threads)
3943 fprintf (stderr, "proceed_all_lwps: found "
3944 "thread %ld needing a step-over\n",
3945 lwpid_of (need_step_over));
3946
3947 start_step_over (need_step_over);
3948 return;
3949 }
3950 }
5544ad89 3951
d50171e4
PA
3952 if (debug_threads)
3953 fprintf (stderr, "Proceeding, no step-over needed\n");
3954
7984d532 3955 find_inferior (&all_lwps, proceed_one_lwp, NULL);
d50171e4
PA
3956}
3957
3958/* Stopped LWPs that the client wanted to be running, that don't have
3959 pending statuses, are set to run again, except for EXCEPT, if not
3960 NULL. This undoes a stop_all_lwps call. */
3961
3962static void
7984d532 3963unstop_all_lwps (int unsuspend, struct lwp_info *except)
d50171e4 3964{
5544ad89
DJ
3965 if (debug_threads)
3966 {
d50171e4
PA
3967 if (except)
3968 fprintf (stderr,
3969 "unstopping all lwps, except=(LWP %ld)\n", lwpid_of (except));
5544ad89 3970 else
d50171e4
PA
3971 fprintf (stderr,
3972 "unstopping all lwps\n");
5544ad89
DJ
3973 }
3974
7984d532
PA
3975 if (unsuspend)
3976 find_inferior (&all_lwps, unsuspend_and_proceed_one_lwp, except);
3977 else
3978 find_inferior (&all_lwps, proceed_one_lwp, except);
0d62e5e8
DJ
3979}
3980
58caa3dc
DJ
3981
3982#ifdef HAVE_LINUX_REGSETS
3983
1faeff08
MR
3984#define use_linux_regsets 1
3985
58caa3dc 3986static int
442ea881 3987regsets_fetch_inferior_registers (struct regcache *regcache)
58caa3dc
DJ
3988{
3989 struct regset_info *regset;
e9d25b98 3990 int saw_general_regs = 0;
95954743 3991 int pid;
1570b33e 3992 struct iovec iov;
58caa3dc
DJ
3993
3994 regset = target_regsets;
3995
95954743 3996 pid = lwpid_of (get_thread_lwp (current_inferior));
58caa3dc
DJ
3997 while (regset->size >= 0)
3998 {
1570b33e
L
3999 void *buf, *data;
4000 int nt_type, res;
58caa3dc 4001
52fa2412 4002 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
58caa3dc
DJ
4003 {
4004 regset ++;
4005 continue;
4006 }
4007
bca929d3 4008 buf = xmalloc (regset->size);
1570b33e
L
4009
4010 nt_type = regset->nt_type;
4011 if (nt_type)
4012 {
4013 iov.iov_base = buf;
4014 iov.iov_len = regset->size;
4015 data = (void *) &iov;
4016 }
4017 else
4018 data = buf;
4019
dfb64f85 4020#ifndef __sparc__
f15f9948
TJB
4021 res = ptrace (regset->get_request, pid,
4022 (PTRACE_ARG3_TYPE) (long) nt_type, data);
dfb64f85 4023#else
1570b33e 4024 res = ptrace (regset->get_request, pid, data, nt_type);
dfb64f85 4025#endif
58caa3dc
DJ
4026 if (res < 0)
4027 {
4028 if (errno == EIO)
4029 {
52fa2412
UW
4030 /* If we get EIO on a regset, do not try it again for
4031 this process. */
4032 disabled_regsets[regset - target_regsets] = 1;
fdeb2a12 4033 free (buf);
52fa2412 4034 continue;
58caa3dc
DJ
4035 }
4036 else
4037 {
0d62e5e8 4038 char s[256];
95954743
PA
4039 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
4040 pid);
0d62e5e8 4041 perror (s);
58caa3dc
DJ
4042 }
4043 }
e9d25b98
DJ
4044 else if (regset->type == GENERAL_REGS)
4045 saw_general_regs = 1;
442ea881 4046 regset->store_function (regcache, buf);
58caa3dc 4047 regset ++;
fdeb2a12 4048 free (buf);
58caa3dc 4049 }
e9d25b98
DJ
4050 if (saw_general_regs)
4051 return 0;
4052 else
4053 return 1;
58caa3dc
DJ
4054}
4055
4056static int
442ea881 4057regsets_store_inferior_registers (struct regcache *regcache)
58caa3dc
DJ
4058{
4059 struct regset_info *regset;
e9d25b98 4060 int saw_general_regs = 0;
95954743 4061 int pid;
1570b33e 4062 struct iovec iov;
58caa3dc
DJ
4063
4064 regset = target_regsets;
4065
95954743 4066 pid = lwpid_of (get_thread_lwp (current_inferior));
58caa3dc
DJ
4067 while (regset->size >= 0)
4068 {
1570b33e
L
4069 void *buf, *data;
4070 int nt_type, res;
58caa3dc 4071
52fa2412 4072 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
58caa3dc
DJ
4073 {
4074 regset ++;
4075 continue;
4076 }
4077
bca929d3 4078 buf = xmalloc (regset->size);
545587ee
DJ
4079
4080 /* First fill the buffer with the current register set contents,
4081 in case there are any items in the kernel's regset that are
4082 not in gdbserver's regcache. */
1570b33e
L
4083
4084 nt_type = regset->nt_type;
4085 if (nt_type)
4086 {
4087 iov.iov_base = buf;
4088 iov.iov_len = regset->size;
4089 data = (void *) &iov;
4090 }
4091 else
4092 data = buf;
4093
dfb64f85 4094#ifndef __sparc__
f15f9948
TJB
4095 res = ptrace (regset->get_request, pid,
4096 (PTRACE_ARG3_TYPE) (long) nt_type, data);
dfb64f85 4097#else
689cc2ae 4098 res = ptrace (regset->get_request, pid, data, nt_type);
dfb64f85 4099#endif
545587ee
DJ
4100
4101 if (res == 0)
4102 {
4103 /* Then overlay our cached registers on that. */
442ea881 4104 regset->fill_function (regcache, buf);
545587ee
DJ
4105
4106 /* Only now do we write the register set. */
dfb64f85 4107#ifndef __sparc__
f15f9948
TJB
4108 res = ptrace (regset->set_request, pid,
4109 (PTRACE_ARG3_TYPE) (long) nt_type, data);
dfb64f85 4110#else
1570b33e 4111 res = ptrace (regset->set_request, pid, data, nt_type);
dfb64f85 4112#endif
545587ee
DJ
4113 }
4114
58caa3dc
DJ
4115 if (res < 0)
4116 {
4117 if (errno == EIO)
4118 {
52fa2412
UW
4119 /* If we get EIO on a regset, do not try it again for
4120 this process. */
4121 disabled_regsets[regset - target_regsets] = 1;
fdeb2a12 4122 free (buf);
52fa2412 4123 continue;
58caa3dc 4124 }
3221518c
UW
4125 else if (errno == ESRCH)
4126 {
1b3f6016
PA
4127 /* At this point, ESRCH should mean the process is
4128 already gone, in which case we simply ignore attempts
4129 to change its registers. See also the related
4130 comment in linux_resume_one_lwp. */
fdeb2a12 4131 free (buf);
3221518c
UW
4132 return 0;
4133 }
58caa3dc
DJ
4134 else
4135 {
ce3a066d 4136 perror ("Warning: ptrace(regsets_store_inferior_registers)");
58caa3dc
DJ
4137 }
4138 }
e9d25b98
DJ
4139 else if (regset->type == GENERAL_REGS)
4140 saw_general_regs = 1;
58caa3dc 4141 regset ++;
09ec9b38 4142 free (buf);
58caa3dc 4143 }
e9d25b98
DJ
4144 if (saw_general_regs)
4145 return 0;
4146 else
4147 return 1;
58caa3dc
DJ
4148}
4149
1faeff08 4150#else /* !HAVE_LINUX_REGSETS */
58caa3dc 4151
1faeff08
MR
4152#define use_linux_regsets 0
4153#define regsets_fetch_inferior_registers(regcache) 1
4154#define regsets_store_inferior_registers(regcache) 1
58caa3dc 4155
58caa3dc 4156#endif
1faeff08
MR
4157
4158/* Return 1 if register REGNO is supported by one of the regset ptrace
4159 calls or 0 if it has to be transferred individually. */
4160
4161static int
4162linux_register_in_regsets (int regno)
4163{
4164 unsigned char mask = 1 << (regno % 8);
4165 size_t index = regno / 8;
4166
4167 return (use_linux_regsets
4168 && (the_low_target.regset_bitmap == NULL
4169 || (the_low_target.regset_bitmap[index] & mask) != 0));
4170}
4171
58caa3dc 4172#ifdef HAVE_LINUX_USRREGS
1faeff08
MR
4173
4174int
4175register_addr (int regnum)
4176{
4177 int addr;
4178
4179 if (regnum < 0 || regnum >= the_low_target.num_regs)
4180 error ("Invalid register number %d.", regnum);
4181
4182 addr = the_low_target.regmap[regnum];
4183
4184 return addr;
4185}
4186
4187/* Fetch one register. */
4188static void
4189fetch_register (struct regcache *regcache, int regno)
4190{
4191 CORE_ADDR regaddr;
4192 int i, size;
4193 char *buf;
4194 int pid;
4195
4196 if (regno >= the_low_target.num_regs)
4197 return;
4198 if ((*the_low_target.cannot_fetch_register) (regno))
4199 return;
4200
4201 regaddr = register_addr (regno);
4202 if (regaddr == -1)
4203 return;
4204
4205 size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
4206 & -sizeof (PTRACE_XFER_TYPE));
4207 buf = alloca (size);
4208
4209 pid = lwpid_of (get_thread_lwp (current_inferior));
4210 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
4211 {
4212 errno = 0;
4213 *(PTRACE_XFER_TYPE *) (buf + i) =
4214 ptrace (PTRACE_PEEKUSER, pid,
4215 /* Coerce to a uintptr_t first to avoid potential gcc warning
4216 of coercing an 8 byte integer to a 4 byte pointer. */
4217 (PTRACE_ARG3_TYPE) (uintptr_t) regaddr, 0);
4218 regaddr += sizeof (PTRACE_XFER_TYPE);
4219 if (errno != 0)
4220 error ("reading register %d: %s", regno, strerror (errno));
4221 }
4222
4223 if (the_low_target.supply_ptrace_register)
4224 the_low_target.supply_ptrace_register (regcache, regno, buf);
4225 else
4226 supply_register (regcache, regno, buf);
4227}
4228
4229/* Store one register. */
4230static void
4231store_register (struct regcache *regcache, int regno)
4232{
4233 CORE_ADDR regaddr;
4234 int i, size;
4235 char *buf;
4236 int pid;
4237
4238 if (regno >= the_low_target.num_regs)
4239 return;
4240 if ((*the_low_target.cannot_store_register) (regno))
4241 return;
4242
4243 regaddr = register_addr (regno);
4244 if (regaddr == -1)
4245 return;
4246
4247 size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
4248 & -sizeof (PTRACE_XFER_TYPE));
4249 buf = alloca (size);
4250 memset (buf, 0, size);
4251
4252 if (the_low_target.collect_ptrace_register)
4253 the_low_target.collect_ptrace_register (regcache, regno, buf);
4254 else
4255 collect_register (regcache, regno, buf);
4256
4257 pid = lwpid_of (get_thread_lwp (current_inferior));
4258 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
4259 {
4260 errno = 0;
4261 ptrace (PTRACE_POKEUSER, pid,
4262 /* Coerce to a uintptr_t first to avoid potential gcc warning
4263 about coercing an 8 byte integer to a 4 byte pointer. */
4264 (PTRACE_ARG3_TYPE) (uintptr_t) regaddr,
4265 (PTRACE_ARG4_TYPE) *(PTRACE_XFER_TYPE *) (buf + i));
4266 if (errno != 0)
4267 {
4268 /* At this point, ESRCH should mean the process is
4269 already gone, in which case we simply ignore attempts
4270 to change its registers. See also the related
4271 comment in linux_resume_one_lwp. */
4272 if (errno == ESRCH)
4273 return;
4274
4275 if ((*the_low_target.cannot_store_register) (regno) == 0)
4276 error ("writing register %d: %s", regno, strerror (errno));
4277 }
4278 regaddr += sizeof (PTRACE_XFER_TYPE);
4279 }
4280}
4281
4282/* Fetch all registers, or just one, from the child process.
4283 If REGNO is -1, do this for all registers, skipping any that are
4284 assumed to have been retrieved by regsets_fetch_inferior_registers,
4285 unless ALL is non-zero.
4286 Otherwise, REGNO specifies which register (so we can save time). */
4287static void
4288usr_fetch_inferior_registers (struct regcache *regcache, int regno, int all)
4289{
4290 if (regno == -1)
4291 {
4292 for (regno = 0; regno < the_low_target.num_regs; regno++)
4293 if (all || !linux_register_in_regsets (regno))
4294 fetch_register (regcache, regno);
4295 }
4296 else
4297 fetch_register (regcache, regno);
4298}
4299
4300/* Store our register values back into the inferior.
4301 If REGNO is -1, do this for all registers, skipping any that are
4302 assumed to have been saved by regsets_store_inferior_registers,
4303 unless ALL is non-zero.
4304 Otherwise, REGNO specifies which register (so we can save time). */
4305static void
4306usr_store_inferior_registers (struct regcache *regcache, int regno, int all)
4307{
4308 if (regno == -1)
4309 {
4310 for (regno = 0; regno < the_low_target.num_regs; regno++)
4311 if (all || !linux_register_in_regsets (regno))
4312 store_register (regcache, regno);
4313 }
4314 else
4315 store_register (regcache, regno);
4316}
4317
4318#else /* !HAVE_LINUX_USRREGS */
4319
4320#define usr_fetch_inferior_registers(regcache, regno, all) do {} while (0)
4321#define usr_store_inferior_registers(regcache, regno, all) do {} while (0)
4322
58caa3dc 4323#endif
1faeff08
MR
4324
4325
4326void
4327linux_fetch_registers (struct regcache *regcache, int regno)
4328{
4329 int use_regsets;
4330 int all = 0;
4331
4332 if (regno == -1)
4333 {
c14dfd32
PA
4334 if (the_low_target.fetch_register != NULL)
4335 for (regno = 0; regno < the_low_target.num_regs; regno++)
4336 (*the_low_target.fetch_register) (regcache, regno);
4337
1faeff08 4338 all = regsets_fetch_inferior_registers (regcache);
c14dfd32 4339 usr_fetch_inferior_registers (regcache, -1, all);
1faeff08
MR
4340 }
4341 else
4342 {
c14dfd32
PA
4343 if (the_low_target.fetch_register != NULL
4344 && (*the_low_target.fetch_register) (regcache, regno))
4345 return;
4346
1faeff08
MR
4347 use_regsets = linux_register_in_regsets (regno);
4348 if (use_regsets)
4349 all = regsets_fetch_inferior_registers (regcache);
4350 if (!use_regsets || all)
4351 usr_fetch_inferior_registers (regcache, regno, 1);
4352 }
58caa3dc
DJ
4353}
4354
4355void
442ea881 4356linux_store_registers (struct regcache *regcache, int regno)
58caa3dc 4357{
1faeff08
MR
4358 int use_regsets;
4359 int all = 0;
4360
4361 if (regno == -1)
4362 {
4363 all = regsets_store_inferior_registers (regcache);
4364 usr_store_inferior_registers (regcache, regno, all);
4365 }
4366 else
4367 {
4368 use_regsets = linux_register_in_regsets (regno);
4369 if (use_regsets)
4370 all = regsets_store_inferior_registers (regcache);
4371 if (!use_regsets || all)
4372 usr_store_inferior_registers (regcache, regno, 1);
4373 }
58caa3dc
DJ
4374}
4375
da6d8c04 4376
da6d8c04
DJ
4377/* Copy LEN bytes from inferior's memory starting at MEMADDR
4378 to debugger memory starting at MYADDR. */
4379
c3e735a6 4380static int
f450004a 4381linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
da6d8c04 4382{
4934b29e
MR
4383 int pid = lwpid_of (get_thread_lwp (current_inferior));
4384 register PTRACE_XFER_TYPE *buffer;
4385 register CORE_ADDR addr;
4386 register int count;
4387 char filename[64];
da6d8c04 4388 register int i;
4934b29e 4389 int ret;
fd462a61 4390 int fd;
fd462a61
DJ
4391
4392 /* Try using /proc. Don't bother for one word. */
4393 if (len >= 3 * sizeof (long))
4394 {
4934b29e
MR
4395 int bytes;
4396
fd462a61
DJ
4397 /* We could keep this file open and cache it - possibly one per
4398 thread. That requires some juggling, but is even faster. */
95954743 4399 sprintf (filename, "/proc/%d/mem", pid);
fd462a61
DJ
4400 fd = open (filename, O_RDONLY | O_LARGEFILE);
4401 if (fd == -1)
4402 goto no_proc;
4403
4404 /* If pread64 is available, use it. It's faster if the kernel
4405 supports it (only one syscall), and it's 64-bit safe even on
4406 32-bit platforms (for instance, SPARC debugging a SPARC64
4407 application). */
4408#ifdef HAVE_PREAD64
4934b29e 4409 bytes = pread64 (fd, myaddr, len, memaddr);
fd462a61 4410#else
4934b29e
MR
4411 bytes = -1;
4412 if (lseek (fd, memaddr, SEEK_SET) != -1)
4413 bytes = read (fd, myaddr, len);
fd462a61 4414#endif
fd462a61
DJ
4415
4416 close (fd);
4934b29e
MR
4417 if (bytes == len)
4418 return 0;
4419
4420 /* Some data was read, we'll try to get the rest with ptrace. */
4421 if (bytes > 0)
4422 {
4423 memaddr += bytes;
4424 myaddr += bytes;
4425 len -= bytes;
4426 }
fd462a61 4427 }
da6d8c04 4428
fd462a61 4429 no_proc:
4934b29e
MR
4430 /* Round starting address down to longword boundary. */
4431 addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
4432 /* Round ending address up; get number of longwords that makes. */
4433 count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
4434 / sizeof (PTRACE_XFER_TYPE));
4435 /* Allocate buffer of that many longwords. */
4436 buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
4437
da6d8c04 4438 /* Read all the longwords */
4934b29e 4439 errno = 0;
da6d8c04
DJ
4440 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
4441 {
14ce3065
DE
4442 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
4443 about coercing an 8 byte integer to a 4 byte pointer. */
4444 buffer[i] = ptrace (PTRACE_PEEKTEXT, pid,
4445 (PTRACE_ARG3_TYPE) (uintptr_t) addr, 0);
c3e735a6 4446 if (errno)
4934b29e 4447 break;
da6d8c04 4448 }
4934b29e 4449 ret = errno;
da6d8c04
DJ
4450
4451 /* Copy appropriate bytes out of the buffer. */
8d409d16
MR
4452 if (i > 0)
4453 {
4454 i *= sizeof (PTRACE_XFER_TYPE);
4455 i -= memaddr & (sizeof (PTRACE_XFER_TYPE) - 1);
4456 memcpy (myaddr,
4457 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
4458 i < len ? i : len);
4459 }
c3e735a6 4460
4934b29e 4461 return ret;
da6d8c04
DJ
4462}
4463
93ae6fdc
PA
4464/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
4465 memory at MEMADDR. On failure (cannot write to the inferior)
da6d8c04
DJ
4466 returns the value of errno. */
4467
ce3a066d 4468static int
f450004a 4469linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
da6d8c04
DJ
4470{
4471 register int i;
4472 /* Round starting address down to longword boundary. */
4473 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
4474 /* Round ending address up; get number of longwords that makes. */
4475 register int count
493e2a69
MS
4476 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
4477 / sizeof (PTRACE_XFER_TYPE);
4478
da6d8c04 4479 /* Allocate buffer of that many longwords. */
493e2a69
MS
4480 register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *)
4481 alloca (count * sizeof (PTRACE_XFER_TYPE));
4482
95954743 4483 int pid = lwpid_of (get_thread_lwp (current_inferior));
da6d8c04 4484
0d62e5e8
DJ
4485 if (debug_threads)
4486 {
58d6951d
DJ
4487 /* Dump up to four bytes. */
4488 unsigned int val = * (unsigned int *) myaddr;
4489 if (len == 1)
4490 val = val & 0xff;
4491 else if (len == 2)
4492 val = val & 0xffff;
4493 else if (len == 3)
4494 val = val & 0xffffff;
4495 fprintf (stderr, "Writing %0*x to 0x%08lx\n", 2 * ((len < 4) ? len : 4),
4496 val, (long)memaddr);
0d62e5e8
DJ
4497 }
4498
da6d8c04
DJ
4499 /* Fill start and end extra bytes of buffer with existing memory data. */
4500
93ae6fdc 4501 errno = 0;
14ce3065
DE
4502 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
4503 about coercing an 8 byte integer to a 4 byte pointer. */
4504 buffer[0] = ptrace (PTRACE_PEEKTEXT, pid,
4505 (PTRACE_ARG3_TYPE) (uintptr_t) addr, 0);
93ae6fdc
PA
4506 if (errno)
4507 return errno;
da6d8c04
DJ
4508
4509 if (count > 1)
4510 {
93ae6fdc 4511 errno = 0;
da6d8c04 4512 buffer[count - 1]
95954743 4513 = ptrace (PTRACE_PEEKTEXT, pid,
14ce3065
DE
4514 /* Coerce to a uintptr_t first to avoid potential gcc warning
4515 about coercing an 8 byte integer to a 4 byte pointer. */
4516 (PTRACE_ARG3_TYPE) (uintptr_t) (addr + (count - 1)
4517 * sizeof (PTRACE_XFER_TYPE)),
d844cde6 4518 0);
93ae6fdc
PA
4519 if (errno)
4520 return errno;
da6d8c04
DJ
4521 }
4522
93ae6fdc 4523 /* Copy data to be written over corresponding part of buffer. */
da6d8c04 4524
493e2a69
MS
4525 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
4526 myaddr, len);
da6d8c04
DJ
4527
4528 /* Write the entire buffer. */
4529
4530 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
4531 {
4532 errno = 0;
14ce3065
DE
4533 ptrace (PTRACE_POKETEXT, pid,
4534 /* Coerce to a uintptr_t first to avoid potential gcc warning
4535 about coercing an 8 byte integer to a 4 byte pointer. */
4536 (PTRACE_ARG3_TYPE) (uintptr_t) addr,
4537 (PTRACE_ARG4_TYPE) buffer[i]);
da6d8c04
DJ
4538 if (errno)
4539 return errno;
4540 }
4541
4542 return 0;
4543}
2f2893d9 4544
6076632b 4545/* Non-zero if the kernel supports PTRACE_O_TRACEFORK. */
24a09b5f
DJ
4546static int linux_supports_tracefork_flag;
4547
1e7fc18c
PA
4548static void
4549linux_enable_event_reporting (int pid)
4550{
4551 if (!linux_supports_tracefork_flag)
4552 return;
4553
4554 ptrace (PTRACE_SETOPTIONS, pid, 0, (PTRACE_ARG4_TYPE) PTRACE_O_TRACECLONE);
4555}
4556
51c2684e 4557/* Helper functions for linux_test_for_tracefork, called via clone (). */
24a09b5f 4558
51c2684e
DJ
4559static int
4560linux_tracefork_grandchild (void *arg)
4561{
4562 _exit (0);
4563}
4564
7407e2de
AS
4565#define STACK_SIZE 4096
4566
51c2684e
DJ
4567static int
4568linux_tracefork_child (void *arg)
24a09b5f
DJ
4569{
4570 ptrace (PTRACE_TRACEME, 0, 0, 0);
4571 kill (getpid (), SIGSTOP);
e4b7f41c
JK
4572
4573#if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
4574
4575 if (fork () == 0)
4576 linux_tracefork_grandchild (NULL);
4577
4578#else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4579
7407e2de
AS
4580#ifdef __ia64__
4581 __clone2 (linux_tracefork_grandchild, arg, STACK_SIZE,
4582 CLONE_VM | SIGCHLD, NULL);
4583#else
a1f2ce7d 4584 clone (linux_tracefork_grandchild, (char *) arg + STACK_SIZE,
7407e2de
AS
4585 CLONE_VM | SIGCHLD, NULL);
4586#endif
e4b7f41c
JK
4587
4588#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4589
24a09b5f
DJ
4590 _exit (0);
4591}
4592
24a09b5f
DJ
4593/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
4594 sure that we can enable the option, and that it had the desired
4595 effect. */
4596
4597static void
4598linux_test_for_tracefork (void)
4599{
4600 int child_pid, ret, status;
4601 long second_pid;
e4b7f41c 4602#if defined(__UCLIBC__) && defined(HAS_NOMMU)
bca929d3 4603 char *stack = xmalloc (STACK_SIZE * 4);
e4b7f41c 4604#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
24a09b5f
DJ
4605
4606 linux_supports_tracefork_flag = 0;
4607
e4b7f41c
JK
4608#if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
4609
4610 child_pid = fork ();
4611 if (child_pid == 0)
4612 linux_tracefork_child (NULL);
4613
4614#else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4615
51c2684e 4616 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
7407e2de
AS
4617#ifdef __ia64__
4618 child_pid = __clone2 (linux_tracefork_child, stack, STACK_SIZE,
4619 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
e4b7f41c 4620#else /* !__ia64__ */
7407e2de
AS
4621 child_pid = clone (linux_tracefork_child, stack + STACK_SIZE,
4622 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
e4b7f41c
JK
4623#endif /* !__ia64__ */
4624
4625#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4626
24a09b5f 4627 if (child_pid == -1)
51c2684e 4628 perror_with_name ("clone");
24a09b5f
DJ
4629
4630 ret = my_waitpid (child_pid, &status, 0);
4631 if (ret == -1)
4632 perror_with_name ("waitpid");
4633 else if (ret != child_pid)
4634 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
4635 if (! WIFSTOPPED (status))
4636 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
4637
14ce3065
DE
4638 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
4639 (PTRACE_ARG4_TYPE) PTRACE_O_TRACEFORK);
24a09b5f
DJ
4640 if (ret != 0)
4641 {
4642 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
4643 if (ret != 0)
4644 {
4645 warning ("linux_test_for_tracefork: failed to kill child");
4646 return;
4647 }
4648
4649 ret = my_waitpid (child_pid, &status, 0);
4650 if (ret != child_pid)
4651 warning ("linux_test_for_tracefork: failed to wait for killed child");
4652 else if (!WIFSIGNALED (status))
4653 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
4654 "killed child", status);
4655
4656 return;
4657 }
4658
4659 ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
4660 if (ret != 0)
4661 warning ("linux_test_for_tracefork: failed to resume child");
4662
4663 ret = my_waitpid (child_pid, &status, 0);
4664
4665 if (ret == child_pid && WIFSTOPPED (status)
4666 && status >> 16 == PTRACE_EVENT_FORK)
4667 {
4668 second_pid = 0;
4669 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
4670 if (ret == 0 && second_pid != 0)
4671 {
4672 int second_status;
4673
4674 linux_supports_tracefork_flag = 1;
4675 my_waitpid (second_pid, &second_status, 0);
4676 ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
4677 if (ret != 0)
4678 warning ("linux_test_for_tracefork: failed to kill second child");
4679 my_waitpid (second_pid, &status, 0);
4680 }
4681 }
4682 else
4683 warning ("linux_test_for_tracefork: unexpected result from waitpid "
4684 "(%d, status 0x%x)", ret, status);
4685
4686 do
4687 {
4688 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
4689 if (ret != 0)
4690 warning ("linux_test_for_tracefork: failed to kill child");
4691 my_waitpid (child_pid, &status, 0);
4692 }
4693 while (WIFSTOPPED (status));
51c2684e 4694
e4b7f41c 4695#if defined(__UCLIBC__) && defined(HAS_NOMMU)
51c2684e 4696 free (stack);
e4b7f41c 4697#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
24a09b5f
DJ
4698}
4699
4700
2f2893d9
DJ
4701static void
4702linux_look_up_symbols (void)
4703{
0d62e5e8 4704#ifdef USE_THREAD_DB
95954743
PA
4705 struct process_info *proc = current_process ();
4706
cdbfd419 4707 if (proc->private->thread_db != NULL)
0d62e5e8
DJ
4708 return;
4709
6076632b
DE
4710 /* If the kernel supports tracing forks then it also supports tracing
4711 clones, and then we don't need to use the magic thread event breakpoint
4712 to learn about threads. */
cdbfd419 4713 thread_db_init (!linux_supports_tracefork_flag);
0d62e5e8
DJ
4714#endif
4715}
4716
e5379b03 4717static void
ef57601b 4718linux_request_interrupt (void)
e5379b03 4719{
a1928bad 4720 extern unsigned long signal_pid;
e5379b03 4721
95954743
PA
4722 if (!ptid_equal (cont_thread, null_ptid)
4723 && !ptid_equal (cont_thread, minus_one_ptid))
e5379b03 4724 {
54a0b537 4725 struct lwp_info *lwp;
bd99dc85 4726 int lwpid;
e5379b03 4727
54a0b537 4728 lwp = get_thread_lwp (current_inferior);
bd99dc85
PA
4729 lwpid = lwpid_of (lwp);
4730 kill_lwp (lwpid, SIGINT);
e5379b03
DJ
4731 }
4732 else
ef57601b 4733 kill_lwp (signal_pid, SIGINT);
e5379b03
DJ
4734}
4735
aa691b87
RM
4736/* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
4737 to debugger memory starting at MYADDR. */
4738
4739static int
f450004a 4740linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len)
aa691b87
RM
4741{
4742 char filename[PATH_MAX];
4743 int fd, n;
95954743 4744 int pid = lwpid_of (get_thread_lwp (current_inferior));
aa691b87 4745
6cebaf6e 4746 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
aa691b87
RM
4747
4748 fd = open (filename, O_RDONLY);
4749 if (fd < 0)
4750 return -1;
4751
4752 if (offset != (CORE_ADDR) 0
4753 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4754 n = -1;
4755 else
4756 n = read (fd, myaddr, len);
4757
4758 close (fd);
4759
4760 return n;
4761}
4762
d993e290
PA
4763/* These breakpoint and watchpoint related wrapper functions simply
4764 pass on the function call if the target has registered a
4765 corresponding function. */
e013ee27
OF
4766
4767static int
d993e290 4768linux_insert_point (char type, CORE_ADDR addr, int len)
e013ee27 4769{
d993e290
PA
4770 if (the_low_target.insert_point != NULL)
4771 return the_low_target.insert_point (type, addr, len);
e013ee27
OF
4772 else
4773 /* Unsupported (see target.h). */
4774 return 1;
4775}
4776
4777static int
d993e290 4778linux_remove_point (char type, CORE_ADDR addr, int len)
e013ee27 4779{
d993e290
PA
4780 if (the_low_target.remove_point != NULL)
4781 return the_low_target.remove_point (type, addr, len);
e013ee27
OF
4782 else
4783 /* Unsupported (see target.h). */
4784 return 1;
4785}
4786
4787static int
4788linux_stopped_by_watchpoint (void)
4789{
c3adc08c
PA
4790 struct lwp_info *lwp = get_thread_lwp (current_inferior);
4791
4792 return lwp->stopped_by_watchpoint;
e013ee27
OF
4793}
4794
4795static CORE_ADDR
4796linux_stopped_data_address (void)
4797{
c3adc08c
PA
4798 struct lwp_info *lwp = get_thread_lwp (current_inferior);
4799
4800 return lwp->stopped_data_address;
e013ee27
OF
4801}
4802
42c81e2a 4803#if defined(__UCLIBC__) && defined(HAS_NOMMU)
23512c01
MGD
4804#if ! (defined(PT_TEXT_ADDR) \
4805 || defined(PT_DATA_ADDR) \
4806 || defined(PT_TEXT_END_ADDR))
52fb6437
NS
4807#if defined(__mcoldfire__)
4808/* These should really be defined in the kernel's ptrace.h header. */
4809#define PT_TEXT_ADDR 49*4
4810#define PT_DATA_ADDR 50*4
4811#define PT_TEXT_END_ADDR 51*4
eb826dc6
MF
4812#elif defined(BFIN)
4813#define PT_TEXT_ADDR 220
4814#define PT_TEXT_END_ADDR 224
4815#define PT_DATA_ADDR 228
58dbd541
YQ
4816#elif defined(__TMS320C6X__)
4817#define PT_TEXT_ADDR (0x10000*4)
4818#define PT_DATA_ADDR (0x10004*4)
4819#define PT_TEXT_END_ADDR (0x10008*4)
52fb6437 4820#endif
23512c01 4821#endif
52fb6437
NS
4822
4823/* Under uClinux, programs are loaded at non-zero offsets, which we need
4824 to tell gdb about. */
4825
4826static int
4827linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
4828{
4829#if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
4830 unsigned long text, text_end, data;
bd99dc85 4831 int pid = lwpid_of (get_thread_lwp (current_inferior));
52fb6437
NS
4832
4833 errno = 0;
4834
4835 text = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_ADDR, 0);
4836 text_end = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_END_ADDR, 0);
4837 data = ptrace (PTRACE_PEEKUSER, pid, (long)PT_DATA_ADDR, 0);
4838
4839 if (errno == 0)
4840 {
4841 /* Both text and data offsets produced at compile-time (and so
1b3f6016
PA
4842 used by gdb) are relative to the beginning of the program,
4843 with the data segment immediately following the text segment.
4844 However, the actual runtime layout in memory may put the data
4845 somewhere else, so when we send gdb a data base-address, we
4846 use the real data base address and subtract the compile-time
4847 data base-address from it (which is just the length of the
4848 text segment). BSS immediately follows data in both
4849 cases. */
52fb6437
NS
4850 *text_p = text;
4851 *data_p = data - (text_end - text);
1b3f6016 4852
52fb6437
NS
4853 return 1;
4854 }
4855#endif
4856 return 0;
4857}
4858#endif
4859
07e059b5
VP
4860static int
4861linux_qxfer_osdata (const char *annex,
1b3f6016
PA
4862 unsigned char *readbuf, unsigned const char *writebuf,
4863 CORE_ADDR offset, int len)
07e059b5 4864{
d26e3629 4865 return linux_common_xfer_osdata (annex, readbuf, offset, len);
07e059b5
VP
4866}
4867
d0722149
DE
4868/* Convert a native/host siginfo object, into/from the siginfo in the
4869 layout of the inferiors' architecture. */
4870
4871static void
a5362b9a 4872siginfo_fixup (siginfo_t *siginfo, void *inf_siginfo, int direction)
d0722149
DE
4873{
4874 int done = 0;
4875
4876 if (the_low_target.siginfo_fixup != NULL)
4877 done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
4878
4879 /* If there was no callback, or the callback didn't do anything,
4880 then just do a straight memcpy. */
4881 if (!done)
4882 {
4883 if (direction == 1)
a5362b9a 4884 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
d0722149 4885 else
a5362b9a 4886 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
d0722149
DE
4887 }
4888}
4889
4aa995e1
PA
4890static int
4891linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
4892 unsigned const char *writebuf, CORE_ADDR offset, int len)
4893{
d0722149 4894 int pid;
a5362b9a
TS
4895 siginfo_t siginfo;
4896 char inf_siginfo[sizeof (siginfo_t)];
4aa995e1
PA
4897
4898 if (current_inferior == NULL)
4899 return -1;
4900
bd99dc85 4901 pid = lwpid_of (get_thread_lwp (current_inferior));
4aa995e1
PA
4902
4903 if (debug_threads)
d0722149 4904 fprintf (stderr, "%s siginfo for lwp %d.\n",
4aa995e1
PA
4905 readbuf != NULL ? "Reading" : "Writing",
4906 pid);
4907
0adea5f7 4908 if (offset >= sizeof (siginfo))
4aa995e1
PA
4909 return -1;
4910
4911 if (ptrace (PTRACE_GETSIGINFO, pid, 0, &siginfo) != 0)
4912 return -1;
4913
d0722149
DE
4914 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
4915 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
4916 inferior with a 64-bit GDBSERVER should look the same as debugging it
4917 with a 32-bit GDBSERVER, we need to convert it. */
4918 siginfo_fixup (&siginfo, inf_siginfo, 0);
4919
4aa995e1
PA
4920 if (offset + len > sizeof (siginfo))
4921 len = sizeof (siginfo) - offset;
4922
4923 if (readbuf != NULL)
d0722149 4924 memcpy (readbuf, inf_siginfo + offset, len);
4aa995e1
PA
4925 else
4926 {
d0722149
DE
4927 memcpy (inf_siginfo + offset, writebuf, len);
4928
4929 /* Convert back to ptrace layout before flushing it out. */
4930 siginfo_fixup (&siginfo, inf_siginfo, 1);
4931
4aa995e1
PA
4932 if (ptrace (PTRACE_SETSIGINFO, pid, 0, &siginfo) != 0)
4933 return -1;
4934 }
4935
4936 return len;
4937}
4938
bd99dc85
PA
4939/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4940 so we notice when children change state; as the handler for the
4941 sigsuspend in my_waitpid. */
4942
4943static void
4944sigchld_handler (int signo)
4945{
4946 int old_errno = errno;
4947
4948 if (debug_threads)
e581f2b4
PA
4949 {
4950 do
4951 {
4952 /* fprintf is not async-signal-safe, so call write
4953 directly. */
4954 if (write (2, "sigchld_handler\n",
4955 sizeof ("sigchld_handler\n") - 1) < 0)
4956 break; /* just ignore */
4957 } while (0);
4958 }
bd99dc85
PA
4959
4960 if (target_is_async_p ())
4961 async_file_mark (); /* trigger a linux_wait */
4962
4963 errno = old_errno;
4964}
4965
4966static int
4967linux_supports_non_stop (void)
4968{
4969 return 1;
4970}
4971
4972static int
4973linux_async (int enable)
4974{
4975 int previous = (linux_event_pipe[0] != -1);
4976
8336d594
PA
4977 if (debug_threads)
4978 fprintf (stderr, "linux_async (%d), previous=%d\n",
4979 enable, previous);
4980
bd99dc85
PA
4981 if (previous != enable)
4982 {
4983 sigset_t mask;
4984 sigemptyset (&mask);
4985 sigaddset (&mask, SIGCHLD);
4986
4987 sigprocmask (SIG_BLOCK, &mask, NULL);
4988
4989 if (enable)
4990 {
4991 if (pipe (linux_event_pipe) == -1)
4992 fatal ("creating event pipe failed.");
4993
4994 fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
4995 fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
4996
4997 /* Register the event loop handler. */
4998 add_file_handler (linux_event_pipe[0],
4999 handle_target_event, NULL);
5000
5001 /* Always trigger a linux_wait. */
5002 async_file_mark ();
5003 }
5004 else
5005 {
5006 delete_file_handler (linux_event_pipe[0]);
5007
5008 close (linux_event_pipe[0]);
5009 close (linux_event_pipe[1]);
5010 linux_event_pipe[0] = -1;
5011 linux_event_pipe[1] = -1;
5012 }
5013
5014 sigprocmask (SIG_UNBLOCK, &mask, NULL);
5015 }
5016
5017 return previous;
5018}
5019
5020static int
5021linux_start_non_stop (int nonstop)
5022{
5023 /* Register or unregister from event-loop accordingly. */
5024 linux_async (nonstop);
5025 return 0;
5026}
5027
cf8fd78b
PA
5028static int
5029linux_supports_multi_process (void)
5030{
5031 return 1;
5032}
5033
03583c20
UW
5034static int
5035linux_supports_disable_randomization (void)
5036{
5037#ifdef HAVE_PERSONALITY
5038 return 1;
5039#else
5040 return 0;
5041#endif
5042}
efcbbd14 5043
d1feda86
YQ
5044static int
5045linux_supports_agent (void)
5046{
5047 return 1;
5048}
5049
efcbbd14
UW
5050/* Enumerate spufs IDs for process PID. */
5051static int
5052spu_enumerate_spu_ids (long pid, unsigned char *buf, CORE_ADDR offset, int len)
5053{
5054 int pos = 0;
5055 int written = 0;
5056 char path[128];
5057 DIR *dir;
5058 struct dirent *entry;
5059
5060 sprintf (path, "/proc/%ld/fd", pid);
5061 dir = opendir (path);
5062 if (!dir)
5063 return -1;
5064
5065 rewinddir (dir);
5066 while ((entry = readdir (dir)) != NULL)
5067 {
5068 struct stat st;
5069 struct statfs stfs;
5070 int fd;
5071
5072 fd = atoi (entry->d_name);
5073 if (!fd)
5074 continue;
5075
5076 sprintf (path, "/proc/%ld/fd/%d", pid, fd);
5077 if (stat (path, &st) != 0)
5078 continue;
5079 if (!S_ISDIR (st.st_mode))
5080 continue;
5081
5082 if (statfs (path, &stfs) != 0)
5083 continue;
5084 if (stfs.f_type != SPUFS_MAGIC)
5085 continue;
5086
5087 if (pos >= offset && pos + 4 <= offset + len)
5088 {
5089 *(unsigned int *)(buf + pos - offset) = fd;
5090 written += 4;
5091 }
5092 pos += 4;
5093 }
5094
5095 closedir (dir);
5096 return written;
5097}
5098
5099/* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
5100 object type, using the /proc file system. */
5101static int
5102linux_qxfer_spu (const char *annex, unsigned char *readbuf,
5103 unsigned const char *writebuf,
5104 CORE_ADDR offset, int len)
5105{
5106 long pid = lwpid_of (get_thread_lwp (current_inferior));
5107 char buf[128];
5108 int fd = 0;
5109 int ret = 0;
5110
5111 if (!writebuf && !readbuf)
5112 return -1;
5113
5114 if (!*annex)
5115 {
5116 if (!readbuf)
5117 return -1;
5118 else
5119 return spu_enumerate_spu_ids (pid, readbuf, offset, len);
5120 }
5121
5122 sprintf (buf, "/proc/%ld/fd/%s", pid, annex);
5123 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
5124 if (fd <= 0)
5125 return -1;
5126
5127 if (offset != 0
5128 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
5129 {
5130 close (fd);
5131 return 0;
5132 }
5133
5134 if (writebuf)
5135 ret = write (fd, writebuf, (size_t) len);
5136 else
5137 ret = read (fd, readbuf, (size_t) len);
5138
5139 close (fd);
5140 return ret;
5141}
5142
723b724b 5143#if defined PT_GETDSBT || defined PTRACE_GETFDPIC
78d85199
YQ
5144struct target_loadseg
5145{
5146 /* Core address to which the segment is mapped. */
5147 Elf32_Addr addr;
5148 /* VMA recorded in the program header. */
5149 Elf32_Addr p_vaddr;
5150 /* Size of this segment in memory. */
5151 Elf32_Word p_memsz;
5152};
5153
723b724b 5154# if defined PT_GETDSBT
78d85199
YQ
5155struct target_loadmap
5156{
5157 /* Protocol version number, must be zero. */
5158 Elf32_Word version;
5159 /* Pointer to the DSBT table, its size, and the DSBT index. */
5160 unsigned *dsbt_table;
5161 unsigned dsbt_size, dsbt_index;
5162 /* Number of segments in this map. */
5163 Elf32_Word nsegs;
5164 /* The actual memory map. */
5165 struct target_loadseg segs[/*nsegs*/];
5166};
723b724b
MF
5167# define LINUX_LOADMAP PT_GETDSBT
5168# define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
5169# define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
5170# else
5171struct target_loadmap
5172{
5173 /* Protocol version number, must be zero. */
5174 Elf32_Half version;
5175 /* Number of segments in this map. */
5176 Elf32_Half nsegs;
5177 /* The actual memory map. */
5178 struct target_loadseg segs[/*nsegs*/];
5179};
5180# define LINUX_LOADMAP PTRACE_GETFDPIC
5181# define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
5182# define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
5183# endif
78d85199 5184
78d85199
YQ
5185static int
5186linux_read_loadmap (const char *annex, CORE_ADDR offset,
5187 unsigned char *myaddr, unsigned int len)
5188{
5189 int pid = lwpid_of (get_thread_lwp (current_inferior));
5190 int addr = -1;
5191 struct target_loadmap *data = NULL;
5192 unsigned int actual_length, copy_length;
5193
5194 if (strcmp (annex, "exec") == 0)
723b724b 5195 addr = (int) LINUX_LOADMAP_EXEC;
78d85199 5196 else if (strcmp (annex, "interp") == 0)
723b724b 5197 addr = (int) LINUX_LOADMAP_INTERP;
78d85199
YQ
5198 else
5199 return -1;
5200
723b724b 5201 if (ptrace (LINUX_LOADMAP, pid, addr, &data) != 0)
78d85199
YQ
5202 return -1;
5203
5204 if (data == NULL)
5205 return -1;
5206
5207 actual_length = sizeof (struct target_loadmap)
5208 + sizeof (struct target_loadseg) * data->nsegs;
5209
5210 if (offset < 0 || offset > actual_length)
5211 return -1;
5212
5213 copy_length = actual_length - offset < len ? actual_length - offset : len;
5214 memcpy (myaddr, (char *) data + offset, copy_length);
5215 return copy_length;
5216}
723b724b
MF
5217#else
5218# define linux_read_loadmap NULL
5219#endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
78d85199 5220
1570b33e
L
5221static void
5222linux_process_qsupported (const char *query)
5223{
5224 if (the_low_target.process_qsupported != NULL)
5225 the_low_target.process_qsupported (query);
5226}
5227
219f2f23
PA
5228static int
5229linux_supports_tracepoints (void)
5230{
5231 if (*the_low_target.supports_tracepoints == NULL)
5232 return 0;
5233
5234 return (*the_low_target.supports_tracepoints) ();
5235}
5236
5237static CORE_ADDR
5238linux_read_pc (struct regcache *regcache)
5239{
5240 if (the_low_target.get_pc == NULL)
5241 return 0;
5242
5243 return (*the_low_target.get_pc) (regcache);
5244}
5245
5246static void
5247linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
5248{
5249 gdb_assert (the_low_target.set_pc != NULL);
5250
5251 (*the_low_target.set_pc) (regcache, pc);
5252}
5253
8336d594
PA
5254static int
5255linux_thread_stopped (struct thread_info *thread)
5256{
5257 return get_thread_lwp (thread)->stopped;
5258}
5259
5260/* This exposes stop-all-threads functionality to other modules. */
5261
5262static void
7984d532 5263linux_pause_all (int freeze)
8336d594 5264{
7984d532
PA
5265 stop_all_lwps (freeze, NULL);
5266}
5267
5268/* This exposes unstop-all-threads functionality to other gdbserver
5269 modules. */
5270
5271static void
5272linux_unpause_all (int unfreeze)
5273{
5274 unstop_all_lwps (unfreeze, NULL);
8336d594
PA
5275}
5276
90d74c30
PA
5277static int
5278linux_prepare_to_access_memory (void)
5279{
5280 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
5281 running LWP. */
5282 if (non_stop)
5283 linux_pause_all (1);
5284 return 0;
5285}
5286
5287static void
0146f85b 5288linux_done_accessing_memory (void)
90d74c30
PA
5289{
5290 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
5291 running LWP. */
5292 if (non_stop)
5293 linux_unpause_all (1);
5294}
5295
fa593d66
PA
5296static int
5297linux_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, CORE_ADDR tpaddr,
5298 CORE_ADDR collector,
5299 CORE_ADDR lockaddr,
5300 ULONGEST orig_size,
5301 CORE_ADDR *jump_entry,
405f8e94
SS
5302 CORE_ADDR *trampoline,
5303 ULONGEST *trampoline_size,
fa593d66
PA
5304 unsigned char *jjump_pad_insn,
5305 ULONGEST *jjump_pad_insn_size,
5306 CORE_ADDR *adjusted_insn_addr,
405f8e94
SS
5307 CORE_ADDR *adjusted_insn_addr_end,
5308 char *err)
fa593d66
PA
5309{
5310 return (*the_low_target.install_fast_tracepoint_jump_pad)
5311 (tpoint, tpaddr, collector, lockaddr, orig_size,
405f8e94
SS
5312 jump_entry, trampoline, trampoline_size,
5313 jjump_pad_insn, jjump_pad_insn_size,
5314 adjusted_insn_addr, adjusted_insn_addr_end,
5315 err);
fa593d66
PA
5316}
5317
6a271cae
PA
5318static struct emit_ops *
5319linux_emit_ops (void)
5320{
5321 if (the_low_target.emit_ops != NULL)
5322 return (*the_low_target.emit_ops) ();
5323 else
5324 return NULL;
5325}
5326
405f8e94
SS
5327static int
5328linux_get_min_fast_tracepoint_insn_len (void)
5329{
5330 return (*the_low_target.get_min_fast_tracepoint_insn_len) ();
5331}
5332
2268b414
JK
5333/* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
5334
5335static int
5336get_phdr_phnum_from_proc_auxv (const int pid, const int is_elf64,
5337 CORE_ADDR *phdr_memaddr, int *num_phdr)
5338{
5339 char filename[PATH_MAX];
5340 int fd;
5341 const int auxv_size = is_elf64
5342 ? sizeof (Elf64_auxv_t) : sizeof (Elf32_auxv_t);
5343 char buf[sizeof (Elf64_auxv_t)]; /* The larger of the two. */
5344
5345 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
5346
5347 fd = open (filename, O_RDONLY);
5348 if (fd < 0)
5349 return 1;
5350
5351 *phdr_memaddr = 0;
5352 *num_phdr = 0;
5353 while (read (fd, buf, auxv_size) == auxv_size
5354 && (*phdr_memaddr == 0 || *num_phdr == 0))
5355 {
5356 if (is_elf64)
5357 {
5358 Elf64_auxv_t *const aux = (Elf64_auxv_t *) buf;
5359
5360 switch (aux->a_type)
5361 {
5362 case AT_PHDR:
5363 *phdr_memaddr = aux->a_un.a_val;
5364 break;
5365 case AT_PHNUM:
5366 *num_phdr = aux->a_un.a_val;
5367 break;
5368 }
5369 }
5370 else
5371 {
5372 Elf32_auxv_t *const aux = (Elf32_auxv_t *) buf;
5373
5374 switch (aux->a_type)
5375 {
5376 case AT_PHDR:
5377 *phdr_memaddr = aux->a_un.a_val;
5378 break;
5379 case AT_PHNUM:
5380 *num_phdr = aux->a_un.a_val;
5381 break;
5382 }
5383 }
5384 }
5385
5386 close (fd);
5387
5388 if (*phdr_memaddr == 0 || *num_phdr == 0)
5389 {
5390 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
5391 "phdr_memaddr = %ld, phdr_num = %d",
5392 (long) *phdr_memaddr, *num_phdr);
5393 return 2;
5394 }
5395
5396 return 0;
5397}
5398
5399/* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
5400
5401static CORE_ADDR
5402get_dynamic (const int pid, const int is_elf64)
5403{
5404 CORE_ADDR phdr_memaddr, relocation;
5405 int num_phdr, i;
5406 unsigned char *phdr_buf;
5407 const int phdr_size = is_elf64 ? sizeof (Elf64_Phdr) : sizeof (Elf32_Phdr);
5408
5409 if (get_phdr_phnum_from_proc_auxv (pid, is_elf64, &phdr_memaddr, &num_phdr))
5410 return 0;
5411
5412 gdb_assert (num_phdr < 100); /* Basic sanity check. */
5413 phdr_buf = alloca (num_phdr * phdr_size);
5414
5415 if (linux_read_memory (phdr_memaddr, phdr_buf, num_phdr * phdr_size))
5416 return 0;
5417
5418 /* Compute relocation: it is expected to be 0 for "regular" executables,
5419 non-zero for PIE ones. */
5420 relocation = -1;
5421 for (i = 0; relocation == -1 && i < num_phdr; i++)
5422 if (is_elf64)
5423 {
5424 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
5425
5426 if (p->p_type == PT_PHDR)
5427 relocation = phdr_memaddr - p->p_vaddr;
5428 }
5429 else
5430 {
5431 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
5432
5433 if (p->p_type == PT_PHDR)
5434 relocation = phdr_memaddr - p->p_vaddr;
5435 }
5436
5437 if (relocation == -1)
5438 {
e237a7e2
JK
5439 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
5440 any real world executables, including PIE executables, have always
5441 PT_PHDR present. PT_PHDR is not present in some shared libraries or
5442 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
5443 or present DT_DEBUG anyway (fpc binaries are statically linked).
5444
5445 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
5446
5447 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
5448
2268b414
JK
5449 return 0;
5450 }
5451
5452 for (i = 0; i < num_phdr; i++)
5453 {
5454 if (is_elf64)
5455 {
5456 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
5457
5458 if (p->p_type == PT_DYNAMIC)
5459 return p->p_vaddr + relocation;
5460 }
5461 else
5462 {
5463 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
5464
5465 if (p->p_type == PT_DYNAMIC)
5466 return p->p_vaddr + relocation;
5467 }
5468 }
5469
5470 return 0;
5471}
5472
5473/* Return &_r_debug in the inferior, or -1 if not present. Return value
367ba2c2
MR
5474 can be 0 if the inferior does not yet have the library list initialized.
5475 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
5476 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
2268b414
JK
5477
5478static CORE_ADDR
5479get_r_debug (const int pid, const int is_elf64)
5480{
5481 CORE_ADDR dynamic_memaddr;
5482 const int dyn_size = is_elf64 ? sizeof (Elf64_Dyn) : sizeof (Elf32_Dyn);
5483 unsigned char buf[sizeof (Elf64_Dyn)]; /* The larger of the two. */
367ba2c2 5484 CORE_ADDR map = -1;
2268b414
JK
5485
5486 dynamic_memaddr = get_dynamic (pid, is_elf64);
5487 if (dynamic_memaddr == 0)
367ba2c2 5488 return map;
2268b414
JK
5489
5490 while (linux_read_memory (dynamic_memaddr, buf, dyn_size) == 0)
5491 {
5492 if (is_elf64)
5493 {
5494 Elf64_Dyn *const dyn = (Elf64_Dyn *) buf;
75f62ce7 5495#ifdef DT_MIPS_RLD_MAP
367ba2c2
MR
5496 union
5497 {
5498 Elf64_Xword map;
5499 unsigned char buf[sizeof (Elf64_Xword)];
5500 }
5501 rld_map;
5502
5503 if (dyn->d_tag == DT_MIPS_RLD_MAP)
5504 {
5505 if (linux_read_memory (dyn->d_un.d_val,
5506 rld_map.buf, sizeof (rld_map.buf)) == 0)
5507 return rld_map.map;
5508 else
5509 break;
5510 }
75f62ce7 5511#endif /* DT_MIPS_RLD_MAP */
2268b414 5512
367ba2c2
MR
5513 if (dyn->d_tag == DT_DEBUG && map == -1)
5514 map = dyn->d_un.d_val;
2268b414
JK
5515
5516 if (dyn->d_tag == DT_NULL)
5517 break;
5518 }
5519 else
5520 {
5521 Elf32_Dyn *const dyn = (Elf32_Dyn *) buf;
75f62ce7 5522#ifdef DT_MIPS_RLD_MAP
367ba2c2
MR
5523 union
5524 {
5525 Elf32_Word map;
5526 unsigned char buf[sizeof (Elf32_Word)];
5527 }
5528 rld_map;
5529
5530 if (dyn->d_tag == DT_MIPS_RLD_MAP)
5531 {
5532 if (linux_read_memory (dyn->d_un.d_val,
5533 rld_map.buf, sizeof (rld_map.buf)) == 0)
5534 return rld_map.map;
5535 else
5536 break;
5537 }
75f62ce7 5538#endif /* DT_MIPS_RLD_MAP */
2268b414 5539
367ba2c2
MR
5540 if (dyn->d_tag == DT_DEBUG && map == -1)
5541 map = dyn->d_un.d_val;
2268b414
JK
5542
5543 if (dyn->d_tag == DT_NULL)
5544 break;
5545 }
5546
5547 dynamic_memaddr += dyn_size;
5548 }
5549
367ba2c2 5550 return map;
2268b414
JK
5551}
5552
5553/* Read one pointer from MEMADDR in the inferior. */
5554
5555static int
5556read_one_ptr (CORE_ADDR memaddr, CORE_ADDR *ptr, int ptr_size)
5557{
485f1ee4
PA
5558 int ret;
5559
5560 /* Go through a union so this works on either big or little endian
5561 hosts, when the inferior's pointer size is smaller than the size
5562 of CORE_ADDR. It is assumed the inferior's endianness is the
5563 same of the superior's. */
5564 union
5565 {
5566 CORE_ADDR core_addr;
5567 unsigned int ui;
5568 unsigned char uc;
5569 } addr;
5570
5571 ret = linux_read_memory (memaddr, &addr.uc, ptr_size);
5572 if (ret == 0)
5573 {
5574 if (ptr_size == sizeof (CORE_ADDR))
5575 *ptr = addr.core_addr;
5576 else if (ptr_size == sizeof (unsigned int))
5577 *ptr = addr.ui;
5578 else
5579 gdb_assert_not_reached ("unhandled pointer size");
5580 }
5581 return ret;
2268b414
JK
5582}
5583
5584struct link_map_offsets
5585 {
5586 /* Offset and size of r_debug.r_version. */
5587 int r_version_offset;
5588
5589 /* Offset and size of r_debug.r_map. */
5590 int r_map_offset;
5591
5592 /* Offset to l_addr field in struct link_map. */
5593 int l_addr_offset;
5594
5595 /* Offset to l_name field in struct link_map. */
5596 int l_name_offset;
5597
5598 /* Offset to l_ld field in struct link_map. */
5599 int l_ld_offset;
5600
5601 /* Offset to l_next field in struct link_map. */
5602 int l_next_offset;
5603
5604 /* Offset to l_prev field in struct link_map. */
5605 int l_prev_offset;
5606 };
5607
fb723180 5608/* Construct qXfer:libraries-svr4:read reply. */
2268b414
JK
5609
5610static int
5611linux_qxfer_libraries_svr4 (const char *annex, unsigned char *readbuf,
5612 unsigned const char *writebuf,
5613 CORE_ADDR offset, int len)
5614{
5615 char *document;
5616 unsigned document_len;
5617 struct process_info_private *const priv = current_process ()->private;
5618 char filename[PATH_MAX];
5619 int pid, is_elf64;
5620
5621 static const struct link_map_offsets lmo_32bit_offsets =
5622 {
5623 0, /* r_version offset. */
5624 4, /* r_debug.r_map offset. */
5625 0, /* l_addr offset in link_map. */
5626 4, /* l_name offset in link_map. */
5627 8, /* l_ld offset in link_map. */
5628 12, /* l_next offset in link_map. */
5629 16 /* l_prev offset in link_map. */
5630 };
5631
5632 static const struct link_map_offsets lmo_64bit_offsets =
5633 {
5634 0, /* r_version offset. */
5635 8, /* r_debug.r_map offset. */
5636 0, /* l_addr offset in link_map. */
5637 8, /* l_name offset in link_map. */
5638 16, /* l_ld offset in link_map. */
5639 24, /* l_next offset in link_map. */
5640 32 /* l_prev offset in link_map. */
5641 };
5642 const struct link_map_offsets *lmo;
214d508e 5643 unsigned int machine;
2268b414
JK
5644
5645 if (writebuf != NULL)
5646 return -2;
5647 if (readbuf == NULL)
5648 return -1;
5649
5650 pid = lwpid_of (get_thread_lwp (current_inferior));
5651 xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
214d508e 5652 is_elf64 = elf_64_file_p (filename, &machine);
2268b414
JK
5653 lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
5654
5655 if (priv->r_debug == 0)
5656 priv->r_debug = get_r_debug (pid, is_elf64);
5657
0c5bf5a9
JK
5658 /* We failed to find DT_DEBUG. Such situation will not change for this
5659 inferior - do not retry it. Report it to GDB as E01, see for the reasons
5660 at the GDB solib-svr4.c side. */
5661 if (priv->r_debug == (CORE_ADDR) -1)
5662 return -1;
5663
5664 if (priv->r_debug == 0)
2268b414
JK
5665 {
5666 document = xstrdup ("<library-list-svr4 version=\"1.0\"/>\n");
5667 }
5668 else
5669 {
5670 int allocated = 1024;
5671 char *p;
5672 const int ptr_size = is_elf64 ? 8 : 4;
5673 CORE_ADDR lm_addr, lm_prev, l_name, l_addr, l_ld, l_next, l_prev;
5674 int r_version, header_done = 0;
5675
5676 document = xmalloc (allocated);
5677 strcpy (document, "<library-list-svr4 version=\"1.0\"");
5678 p = document + strlen (document);
5679
5680 r_version = 0;
5681 if (linux_read_memory (priv->r_debug + lmo->r_version_offset,
5682 (unsigned char *) &r_version,
5683 sizeof (r_version)) != 0
5684 || r_version != 1)
5685 {
5686 warning ("unexpected r_debug version %d", r_version);
5687 goto done;
5688 }
5689
5690 if (read_one_ptr (priv->r_debug + lmo->r_map_offset,
5691 &lm_addr, ptr_size) != 0)
5692 {
5693 warning ("unable to read r_map from 0x%lx",
5694 (long) priv->r_debug + lmo->r_map_offset);
5695 goto done;
5696 }
5697
5698 lm_prev = 0;
5699 while (read_one_ptr (lm_addr + lmo->l_name_offset,
5700 &l_name, ptr_size) == 0
5701 && read_one_ptr (lm_addr + lmo->l_addr_offset,
5702 &l_addr, ptr_size) == 0
5703 && read_one_ptr (lm_addr + lmo->l_ld_offset,
5704 &l_ld, ptr_size) == 0
5705 && read_one_ptr (lm_addr + lmo->l_prev_offset,
5706 &l_prev, ptr_size) == 0
5707 && read_one_ptr (lm_addr + lmo->l_next_offset,
5708 &l_next, ptr_size) == 0)
5709 {
5710 unsigned char libname[PATH_MAX];
5711
5712 if (lm_prev != l_prev)
5713 {
5714 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
5715 (long) lm_prev, (long) l_prev);
5716 break;
5717 }
5718
5719 /* Not checking for error because reading may stop before
5720 we've got PATH_MAX worth of characters. */
5721 libname[0] = '\0';
5722 linux_read_memory (l_name, libname, sizeof (libname) - 1);
5723 libname[sizeof (libname) - 1] = '\0';
5724 if (libname[0] != '\0')
5725 {
5726 /* 6x the size for xml_escape_text below. */
5727 size_t len = 6 * strlen ((char *) libname);
5728 char *name;
5729
5730 if (!header_done)
5731 {
5732 /* Terminate `<library-list-svr4'. */
5733 *p++ = '>';
5734 header_done = 1;
5735 }
5736
5737 while (allocated < p - document + len + 200)
5738 {
5739 /* Expand to guarantee sufficient storage. */
5740 uintptr_t document_len = p - document;
5741
5742 document = xrealloc (document, 2 * allocated);
5743 allocated *= 2;
5744 p = document + document_len;
5745 }
5746
5747 name = xml_escape_text ((char *) libname);
5748 p += sprintf (p, "<library name=\"%s\" lm=\"0x%lx\" "
5749 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
5750 name, (unsigned long) lm_addr,
5751 (unsigned long) l_addr, (unsigned long) l_ld);
5752 free (name);
5753 }
5754 else if (lm_prev == 0)
5755 {
5756 sprintf (p, " main-lm=\"0x%lx\"", (unsigned long) lm_addr);
5757 p = p + strlen (p);
5758 }
5759
5760 if (l_next == 0)
5761 break;
5762
5763 lm_prev = lm_addr;
5764 lm_addr = l_next;
5765 }
5766 done:
0afae3cf
PA
5767 if (!header_done)
5768 {
5769 /* Empty list; terminate `<library-list-svr4'. */
5770 strcpy (p, "/>");
5771 }
5772 else
5773 strcpy (p, "</library-list-svr4>");
2268b414
JK
5774 }
5775
5776 document_len = strlen (document);
5777 if (offset < document_len)
5778 document_len -= offset;
5779 else
5780 document_len = 0;
5781 if (len > document_len)
5782 len = document_len;
5783
5784 memcpy (readbuf, document + offset, len);
5785 xfree (document);
5786
5787 return len;
5788}
5789
ce3a066d
DJ
5790static struct target_ops linux_target_ops = {
5791 linux_create_inferior,
5792 linux_attach,
5793 linux_kill,
6ad8ae5c 5794 linux_detach,
8336d594 5795 linux_mourn,
444d6139 5796 linux_join,
ce3a066d
DJ
5797 linux_thread_alive,
5798 linux_resume,
5799 linux_wait,
5800 linux_fetch_registers,
5801 linux_store_registers,
90d74c30 5802 linux_prepare_to_access_memory,
0146f85b 5803 linux_done_accessing_memory,
ce3a066d
DJ
5804 linux_read_memory,
5805 linux_write_memory,
2f2893d9 5806 linux_look_up_symbols,
ef57601b 5807 linux_request_interrupt,
aa691b87 5808 linux_read_auxv,
d993e290
PA
5809 linux_insert_point,
5810 linux_remove_point,
e013ee27
OF
5811 linux_stopped_by_watchpoint,
5812 linux_stopped_data_address,
42c81e2a 5813#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437 5814 linux_read_offsets,
dae5f5cf
DJ
5815#else
5816 NULL,
5817#endif
5818#ifdef USE_THREAD_DB
5819 thread_db_get_tls_address,
5820#else
5821 NULL,
52fb6437 5822#endif
efcbbd14 5823 linux_qxfer_spu,
59a016f0 5824 hostio_last_error_from_errno,
07e059b5 5825 linux_qxfer_osdata,
4aa995e1 5826 linux_xfer_siginfo,
bd99dc85
PA
5827 linux_supports_non_stop,
5828 linux_async,
5829 linux_start_non_stop,
cdbfd419
PP
5830 linux_supports_multi_process,
5831#ifdef USE_THREAD_DB
dc146f7c 5832 thread_db_handle_monitor_command,
cdbfd419 5833#else
dc146f7c 5834 NULL,
cdbfd419 5835#endif
d26e3629 5836 linux_common_core_of_thread,
78d85199 5837 linux_read_loadmap,
219f2f23
PA
5838 linux_process_qsupported,
5839 linux_supports_tracepoints,
5840 linux_read_pc,
8336d594
PA
5841 linux_write_pc,
5842 linux_thread_stopped,
7984d532 5843 NULL,
711e434b 5844 linux_pause_all,
7984d532 5845 linux_unpause_all,
fa593d66
PA
5846 linux_cancel_breakpoints,
5847 linux_stabilize_threads,
6a271cae 5848 linux_install_fast_tracepoint_jump_pad,
03583c20
UW
5849 linux_emit_ops,
5850 linux_supports_disable_randomization,
405f8e94 5851 linux_get_min_fast_tracepoint_insn_len,
2268b414 5852 linux_qxfer_libraries_svr4,
d1feda86 5853 linux_supports_agent,
ce3a066d
DJ
5854};
5855
0d62e5e8
DJ
5856static void
5857linux_init_signals ()
5858{
5859 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
5860 to find what the cancel signal actually is. */
1a981360 5861#ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
254787d4 5862 signal (__SIGRTMIN+1, SIG_IGN);
60c3d7b0 5863#endif
0d62e5e8
DJ
5864}
5865
da6d8c04
DJ
5866void
5867initialize_low (void)
5868{
bd99dc85
PA
5869 struct sigaction sigchld_action;
5870 memset (&sigchld_action, 0, sizeof (sigchld_action));
ce3a066d 5871 set_target_ops (&linux_target_ops);
611cb4a5
DJ
5872 set_breakpoint_data (the_low_target.breakpoint,
5873 the_low_target.breakpoint_len);
0d62e5e8 5874 linux_init_signals ();
24a09b5f 5875 linux_test_for_tracefork ();
52fa2412
UW
5876#ifdef HAVE_LINUX_REGSETS
5877 for (num_regsets = 0; target_regsets[num_regsets].size >= 0; num_regsets++)
5878 ;
bca929d3 5879 disabled_regsets = xmalloc (num_regsets);
52fa2412 5880#endif
bd99dc85
PA
5881
5882 sigchld_action.sa_handler = sigchld_handler;
5883 sigemptyset (&sigchld_action.sa_mask);
5884 sigchld_action.sa_flags = SA_RESTART;
5885 sigaction (SIGCHLD, &sigchld_action, NULL);
da6d8c04 5886}