* event-loop.c: Include unistd.h if it exists.
[deliverable/binutils-gdb.git] / gdb / gdbserver / linux-low.c
1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "server.h"
21 #include "linux-low.h"
22 #include "ansidecl.h" /* For ATTRIBUTE_PACKED, must be bug in external.h. */
23 #include "elf/common.h"
24 #include "elf/external.h"
25
26 #include <sys/wait.h>
27 #include <stdio.h>
28 #include <sys/param.h>
29 #include <sys/ptrace.h>
30 #include <signal.h>
31 #include <sys/ioctl.h>
32 #include <fcntl.h>
33 #include <string.h>
34 #include <stdlib.h>
35 #include <unistd.h>
36 #include <errno.h>
37 #include <sys/syscall.h>
38 #include <sched.h>
39 #include <ctype.h>
40 #include <pwd.h>
41 #include <sys/types.h>
42 #include <dirent.h>
43 #include <sys/stat.h>
44 #include <sys/vfs.h>
45
46 #ifndef SPUFS_MAGIC
47 #define SPUFS_MAGIC 0x23c9b64e
48 #endif
49
50 #ifndef PTRACE_GETSIGINFO
51 # define PTRACE_GETSIGINFO 0x4202
52 # define PTRACE_SETSIGINFO 0x4203
53 #endif
54
55 #ifndef O_LARGEFILE
56 #define O_LARGEFILE 0
57 #endif
58
59 /* If the system headers did not provide the constants, hard-code the normal
60 values. */
61 #ifndef PTRACE_EVENT_FORK
62
63 #define PTRACE_SETOPTIONS 0x4200
64 #define PTRACE_GETEVENTMSG 0x4201
65
66 /* options set using PTRACE_SETOPTIONS */
67 #define PTRACE_O_TRACESYSGOOD 0x00000001
68 #define PTRACE_O_TRACEFORK 0x00000002
69 #define PTRACE_O_TRACEVFORK 0x00000004
70 #define PTRACE_O_TRACECLONE 0x00000008
71 #define PTRACE_O_TRACEEXEC 0x00000010
72 #define PTRACE_O_TRACEVFORKDONE 0x00000020
73 #define PTRACE_O_TRACEEXIT 0x00000040
74
75 /* Wait extended result codes for the above trace options. */
76 #define PTRACE_EVENT_FORK 1
77 #define PTRACE_EVENT_VFORK 2
78 #define PTRACE_EVENT_CLONE 3
79 #define PTRACE_EVENT_EXEC 4
80 #define PTRACE_EVENT_VFORK_DONE 5
81 #define PTRACE_EVENT_EXIT 6
82
83 #endif /* PTRACE_EVENT_FORK */
84
85 /* We can't always assume that this flag is available, but all systems
86 with the ptrace event handlers also have __WALL, so it's safe to use
87 in some contexts. */
88 #ifndef __WALL
89 #define __WALL 0x40000000 /* Wait for any child. */
90 #endif
91
92 #ifdef __UCLIBC__
93 #if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
94 #define HAS_NOMMU
95 #endif
96 #endif
97
98 /* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
99 representation of the thread ID.
100
101 ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
102 the same as the LWP ID.
103
104 ``all_processes'' is keyed by the "overall process ID", which
105 GNU/Linux calls tgid, "thread group ID". */
106
107 struct inferior_list all_lwps;
108
109 /* A list of all unknown processes which receive stop signals. Some other
110 process will presumably claim each of these as forked children
111 momentarily. */
112
113 struct inferior_list stopped_pids;
114
115 /* FIXME this is a bit of a hack, and could be removed. */
116 int stopping_threads;
117
118 /* FIXME make into a target method? */
119 int using_threads = 1;
120
121 /* This flag is true iff we've just created or attached to our first
122 inferior but it has not stopped yet. As soon as it does, we need
123 to call the low target's arch_setup callback. Doing this only on
124 the first inferior avoids reinializing the architecture on every
125 inferior, and avoids messing with the register caches of the
126 already running inferiors. NOTE: this assumes all inferiors under
127 control of gdbserver have the same architecture. */
128 static int new_inferior;
129
130 static void linux_resume_one_lwp (struct lwp_info *lwp,
131 int step, int signal, siginfo_t *info);
132 static void linux_resume (struct thread_resume *resume_info, size_t n);
133 static void stop_all_lwps (void);
134 static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
135 static int check_removed_breakpoint (struct lwp_info *event_child);
136 static void *add_lwp (ptid_t ptid);
137 static int my_waitpid (int pid, int *status, int flags);
138 static int linux_stopped_by_watchpoint (void);
139 static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
140
141 struct pending_signals
142 {
143 int signal;
144 siginfo_t info;
145 struct pending_signals *prev;
146 };
147
148 #define PTRACE_ARG3_TYPE long
149 #define PTRACE_XFER_TYPE long
150
151 #ifdef HAVE_LINUX_REGSETS
152 static char *disabled_regsets;
153 static int num_regsets;
154 #endif
155
156 /* The read/write ends of the pipe registered as waitable file in the
157 event loop. */
158 static int linux_event_pipe[2] = { -1, -1 };
159
160 /* True if we're currently in async mode. */
161 #define target_is_async_p() (linux_event_pipe[0] != -1)
162
163 static void send_sigstop (struct inferior_list_entry *entry);
164 static void wait_for_sigstop (struct inferior_list_entry *entry);
165
166 /* Accepts an integer PID; Returns a string representing a file that
167 can be opened to get info for the child process.
168 Space for the result is malloc'd, caller must free. */
169
170 char *
171 linux_child_pid_to_exec_file (int pid)
172 {
173 char *name1, *name2;
174
175 name1 = xmalloc (MAXPATHLEN);
176 name2 = xmalloc (MAXPATHLEN);
177 memset (name2, 0, MAXPATHLEN);
178
179 sprintf (name1, "/proc/%d/exe", pid);
180 if (readlink (name1, name2, MAXPATHLEN) > 0)
181 {
182 free (name1);
183 return name2;
184 }
185 else
186 {
187 free (name2);
188 return name1;
189 }
190 }
191
192 /* Return non-zero if HEADER is a 64-bit ELF file. */
193
194 static int
195 elf_64_header_p (const Elf64_External_Ehdr *header)
196 {
197 return (header->e_ident[EI_MAG0] == ELFMAG0
198 && header->e_ident[EI_MAG1] == ELFMAG1
199 && header->e_ident[EI_MAG2] == ELFMAG2
200 && header->e_ident[EI_MAG3] == ELFMAG3
201 && header->e_ident[EI_CLASS] == ELFCLASS64);
202 }
203
204 /* Return non-zero if FILE is a 64-bit ELF file,
205 zero if the file is not a 64-bit ELF file,
206 and -1 if the file is not accessible or doesn't exist. */
207
208 int
209 elf_64_file_p (const char *file)
210 {
211 Elf64_External_Ehdr header;
212 int fd;
213
214 fd = open (file, O_RDONLY);
215 if (fd < 0)
216 return -1;
217
218 if (read (fd, &header, sizeof (header)) != sizeof (header))
219 {
220 close (fd);
221 return 0;
222 }
223 close (fd);
224
225 return elf_64_header_p (&header);
226 }
227
228 static void
229 delete_lwp (struct lwp_info *lwp)
230 {
231 remove_thread (get_lwp_thread (lwp));
232 remove_inferior (&all_lwps, &lwp->head);
233 free (lwp->arch_private);
234 free (lwp);
235 }
236
237 /* Add a process to the common process list, and set its private
238 data. */
239
240 static struct process_info *
241 linux_add_process (int pid, int attached)
242 {
243 struct process_info *proc;
244
245 /* Is this the first process? If so, then set the arch. */
246 if (all_processes.head == NULL)
247 new_inferior = 1;
248
249 proc = add_process (pid, attached);
250 proc->private = xcalloc (1, sizeof (*proc->private));
251
252 if (the_low_target.new_process != NULL)
253 proc->private->arch_private = the_low_target.new_process ();
254
255 return proc;
256 }
257
258 /* Remove a process from the common process list,
259 also freeing all private data. */
260
261 static void
262 linux_remove_process (struct process_info *process, int detaching)
263 {
264 struct process_info_private *priv = process->private;
265
266 #ifdef USE_THREAD_DB
267 thread_db_free (process, detaching);
268 #endif
269
270 free (priv->arch_private);
271 free (priv);
272 remove_process (process);
273 }
274
275 /* Wrapper function for waitpid which handles EINTR, and emulates
276 __WALL for systems where that is not available. */
277
278 static int
279 my_waitpid (int pid, int *status, int flags)
280 {
281 int ret, out_errno;
282
283 if (debug_threads)
284 fprintf (stderr, "my_waitpid (%d, 0x%x)\n", pid, flags);
285
286 if (flags & __WALL)
287 {
288 sigset_t block_mask, org_mask, wake_mask;
289 int wnohang;
290
291 wnohang = (flags & WNOHANG) != 0;
292 flags &= ~(__WALL | __WCLONE);
293 flags |= WNOHANG;
294
295 /* Block all signals while here. This avoids knowing about
296 LinuxThread's signals. */
297 sigfillset (&block_mask);
298 sigprocmask (SIG_BLOCK, &block_mask, &org_mask);
299
300 /* ... except during the sigsuspend below. */
301 sigemptyset (&wake_mask);
302
303 while (1)
304 {
305 /* Since all signals are blocked, there's no need to check
306 for EINTR here. */
307 ret = waitpid (pid, status, flags);
308 out_errno = errno;
309
310 if (ret == -1 && out_errno != ECHILD)
311 break;
312 else if (ret > 0)
313 break;
314
315 if (flags & __WCLONE)
316 {
317 /* We've tried both flavors now. If WNOHANG is set,
318 there's nothing else to do, just bail out. */
319 if (wnohang)
320 break;
321
322 if (debug_threads)
323 fprintf (stderr, "blocking\n");
324
325 /* Block waiting for signals. */
326 sigsuspend (&wake_mask);
327 }
328
329 flags ^= __WCLONE;
330 }
331
332 sigprocmask (SIG_SETMASK, &org_mask, NULL);
333 }
334 else
335 {
336 do
337 ret = waitpid (pid, status, flags);
338 while (ret == -1 && errno == EINTR);
339 out_errno = errno;
340 }
341
342 if (debug_threads)
343 fprintf (stderr, "my_waitpid (%d, 0x%x): status(%x), %d\n",
344 pid, flags, status ? *status : -1, ret);
345
346 errno = out_errno;
347 return ret;
348 }
349
350 /* Handle a GNU/Linux extended wait response. If we see a clone
351 event, we need to add the new LWP to our list (and not report the
352 trap to higher layers). */
353
354 static void
355 handle_extended_wait (struct lwp_info *event_child, int wstat)
356 {
357 int event = wstat >> 16;
358 struct lwp_info *new_lwp;
359
360 if (event == PTRACE_EVENT_CLONE)
361 {
362 ptid_t ptid;
363 unsigned long new_pid;
364 int ret, status = W_STOPCODE (SIGSTOP);
365
366 ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), 0, &new_pid);
367
368 /* If we haven't already seen the new PID stop, wait for it now. */
369 if (! pull_pid_from_list (&stopped_pids, new_pid))
370 {
371 /* The new child has a pending SIGSTOP. We can't affect it until it
372 hits the SIGSTOP, but we're already attached. */
373
374 ret = my_waitpid (new_pid, &status, __WALL);
375
376 if (ret == -1)
377 perror_with_name ("waiting for new child");
378 else if (ret != new_pid)
379 warning ("wait returned unexpected PID %d", ret);
380 else if (!WIFSTOPPED (status))
381 warning ("wait returned unexpected status 0x%x", status);
382 }
383
384 ptrace (PTRACE_SETOPTIONS, new_pid, 0, PTRACE_O_TRACECLONE);
385
386 ptid = ptid_build (pid_of (event_child), new_pid, 0);
387 new_lwp = (struct lwp_info *) add_lwp (ptid);
388 add_thread (ptid, new_lwp);
389
390 /* Either we're going to immediately resume the new thread
391 or leave it stopped. linux_resume_one_lwp is a nop if it
392 thinks the thread is currently running, so set this first
393 before calling linux_resume_one_lwp. */
394 new_lwp->stopped = 1;
395
396 /* Normally we will get the pending SIGSTOP. But in some cases
397 we might get another signal delivered to the group first.
398 If we do get another signal, be sure not to lose it. */
399 if (WSTOPSIG (status) == SIGSTOP)
400 {
401 if (! stopping_threads)
402 linux_resume_one_lwp (new_lwp, 0, 0, NULL);
403 }
404 else
405 {
406 new_lwp->stop_expected = 1;
407 if (stopping_threads)
408 {
409 new_lwp->status_pending_p = 1;
410 new_lwp->status_pending = status;
411 }
412 else
413 /* Pass the signal on. This is what GDB does - except
414 shouldn't we really report it instead? */
415 linux_resume_one_lwp (new_lwp, 0, WSTOPSIG (status), NULL);
416 }
417
418 /* Always resume the current thread. If we are stopping
419 threads, it will have a pending SIGSTOP; we may as well
420 collect it now. */
421 linux_resume_one_lwp (event_child, event_child->stepping, 0, NULL);
422 }
423 }
424
425 /* This function should only be called if the process got a SIGTRAP.
426 The SIGTRAP could mean several things.
427
428 On i386, where decr_pc_after_break is non-zero:
429 If we were single-stepping this process using PTRACE_SINGLESTEP,
430 we will get only the one SIGTRAP (even if the instruction we
431 stepped over was a breakpoint). The value of $eip will be the
432 next instruction.
433 If we continue the process using PTRACE_CONT, we will get a
434 SIGTRAP when we hit a breakpoint. The value of $eip will be
435 the instruction after the breakpoint (i.e. needs to be
436 decremented). If we report the SIGTRAP to GDB, we must also
437 report the undecremented PC. If we cancel the SIGTRAP, we
438 must resume at the decremented PC.
439
440 (Presumably, not yet tested) On a non-decr_pc_after_break machine
441 with hardware or kernel single-step:
442 If we single-step over a breakpoint instruction, our PC will
443 point at the following instruction. If we continue and hit a
444 breakpoint instruction, our PC will point at the breakpoint
445 instruction. */
446
447 static CORE_ADDR
448 get_stop_pc (void)
449 {
450 CORE_ADDR stop_pc = (*the_low_target.get_pc) ();
451
452 if (! get_thread_lwp (current_inferior)->stepping)
453 stop_pc -= the_low_target.decr_pc_after_break;
454
455 if (debug_threads)
456 fprintf (stderr, "stop pc is 0x%lx\n", (long) stop_pc);
457
458 return stop_pc;
459 }
460
461 static void *
462 add_lwp (ptid_t ptid)
463 {
464 struct lwp_info *lwp;
465
466 lwp = (struct lwp_info *) xmalloc (sizeof (*lwp));
467 memset (lwp, 0, sizeof (*lwp));
468
469 lwp->head.id = ptid;
470
471 if (the_low_target.new_thread != NULL)
472 lwp->arch_private = the_low_target.new_thread ();
473
474 add_inferior_to_list (&all_lwps, &lwp->head);
475
476 return lwp;
477 }
478
479 /* Start an inferior process and returns its pid.
480 ALLARGS is a vector of program-name and args. */
481
482 static int
483 linux_create_inferior (char *program, char **allargs)
484 {
485 struct lwp_info *new_lwp;
486 int pid;
487 ptid_t ptid;
488
489 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
490 pid = vfork ();
491 #else
492 pid = fork ();
493 #endif
494 if (pid < 0)
495 perror_with_name ("fork");
496
497 if (pid == 0)
498 {
499 ptrace (PTRACE_TRACEME, 0, 0, 0);
500
501 signal (__SIGRTMIN + 1, SIG_DFL);
502
503 setpgid (0, 0);
504
505 execv (program, allargs);
506 if (errno == ENOENT)
507 execvp (program, allargs);
508
509 fprintf (stderr, "Cannot exec %s: %s.\n", program,
510 strerror (errno));
511 fflush (stderr);
512 _exit (0177);
513 }
514
515 linux_add_process (pid, 0);
516
517 ptid = ptid_build (pid, pid, 0);
518 new_lwp = add_lwp (ptid);
519 add_thread (ptid, new_lwp);
520 new_lwp->must_set_ptrace_flags = 1;
521
522 return pid;
523 }
524
525 /* Attach to an inferior process. */
526
527 static void
528 linux_attach_lwp_1 (unsigned long lwpid, int initial)
529 {
530 ptid_t ptid;
531 struct lwp_info *new_lwp;
532
533 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) != 0)
534 {
535 if (!initial)
536 {
537 /* If we fail to attach to an LWP, just warn. */
538 fprintf (stderr, "Cannot attach to lwp %ld: %s (%d)\n", lwpid,
539 strerror (errno), errno);
540 fflush (stderr);
541 return;
542 }
543 else
544 /* If we fail to attach to a process, report an error. */
545 error ("Cannot attach to lwp %ld: %s (%d)\n", lwpid,
546 strerror (errno), errno);
547 }
548
549 if (initial)
550 /* NOTE/FIXME: This lwp might have not been the tgid. */
551 ptid = ptid_build (lwpid, lwpid, 0);
552 else
553 {
554 /* Note that extracting the pid from the current inferior is
555 safe, since we're always called in the context of the same
556 process as this new thread. */
557 int pid = pid_of (get_thread_lwp (current_inferior));
558 ptid = ptid_build (pid, lwpid, 0);
559 }
560
561 new_lwp = (struct lwp_info *) add_lwp (ptid);
562 add_thread (ptid, new_lwp);
563
564 /* We need to wait for SIGSTOP before being able to make the next
565 ptrace call on this LWP. */
566 new_lwp->must_set_ptrace_flags = 1;
567
568 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
569 brings it to a halt.
570
571 There are several cases to consider here:
572
573 1) gdbserver has already attached to the process and is being notified
574 of a new thread that is being created.
575 In this case we should ignore that SIGSTOP and resume the process.
576 This is handled below by setting stop_expected = 1.
577
578 2) This is the first thread (the process thread), and we're attaching
579 to it via attach_inferior.
580 In this case we want the process thread to stop.
581 This is handled by having linux_attach clear stop_expected after
582 we return.
583 ??? If the process already has several threads we leave the other
584 threads running.
585
586 3) GDB is connecting to gdbserver and is requesting an enumeration of all
587 existing threads.
588 In this case we want the thread to stop.
589 FIXME: This case is currently not properly handled.
590 We should wait for the SIGSTOP but don't. Things work apparently
591 because enough time passes between when we ptrace (ATTACH) and when
592 gdb makes the next ptrace call on the thread.
593
594 On the other hand, if we are currently trying to stop all threads, we
595 should treat the new thread as if we had sent it a SIGSTOP. This works
596 because we are guaranteed that the add_lwp call above added us to the
597 end of the list, and so the new thread has not yet reached
598 wait_for_sigstop (but will). */
599 if (! stopping_threads)
600 new_lwp->stop_expected = 1;
601 }
602
603 void
604 linux_attach_lwp (unsigned long lwpid)
605 {
606 linux_attach_lwp_1 (lwpid, 0);
607 }
608
609 int
610 linux_attach (unsigned long pid)
611 {
612 struct lwp_info *lwp;
613
614 linux_attach_lwp_1 (pid, 1);
615
616 linux_add_process (pid, 1);
617
618 if (!non_stop)
619 {
620 /* Don't ignore the initial SIGSTOP if we just attached to this
621 process. It will be collected by wait shortly. */
622 lwp = (struct lwp_info *) find_inferior_id (&all_lwps,
623 ptid_build (pid, pid, 0));
624 lwp->stop_expected = 0;
625 }
626
627 return 0;
628 }
629
630 struct counter
631 {
632 int pid;
633 int count;
634 };
635
636 static int
637 second_thread_of_pid_p (struct inferior_list_entry *entry, void *args)
638 {
639 struct counter *counter = args;
640
641 if (ptid_get_pid (entry->id) == counter->pid)
642 {
643 if (++counter->count > 1)
644 return 1;
645 }
646
647 return 0;
648 }
649
650 static int
651 last_thread_of_process_p (struct thread_info *thread)
652 {
653 ptid_t ptid = ((struct inferior_list_entry *)thread)->id;
654 int pid = ptid_get_pid (ptid);
655 struct counter counter = { pid , 0 };
656
657 return (find_inferior (&all_threads,
658 second_thread_of_pid_p, &counter) == NULL);
659 }
660
661 /* Kill the inferior lwp. */
662
663 static int
664 linux_kill_one_lwp (struct inferior_list_entry *entry, void *args)
665 {
666 struct thread_info *thread = (struct thread_info *) entry;
667 struct lwp_info *lwp = get_thread_lwp (thread);
668 int wstat;
669 int pid = * (int *) args;
670
671 if (ptid_get_pid (entry->id) != pid)
672 return 0;
673
674 /* We avoid killing the first thread here, because of a Linux kernel (at
675 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
676 the children get a chance to be reaped, it will remain a zombie
677 forever. */
678
679 if (lwpid_of (lwp) == pid)
680 {
681 if (debug_threads)
682 fprintf (stderr, "lkop: is last of process %s\n",
683 target_pid_to_str (entry->id));
684 return 0;
685 }
686
687 /* If we're killing a running inferior, make sure it is stopped
688 first, as PTRACE_KILL will not work otherwise. */
689 if (!lwp->stopped)
690 send_sigstop (&lwp->head);
691
692 do
693 {
694 ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
695
696 /* Make sure it died. The loop is most likely unnecessary. */
697 pid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
698 } while (pid > 0 && WIFSTOPPED (wstat));
699
700 return 0;
701 }
702
703 static int
704 linux_kill (int pid)
705 {
706 struct process_info *process;
707 struct lwp_info *lwp;
708 struct thread_info *thread;
709 int wstat;
710 int lwpid;
711
712 process = find_process_pid (pid);
713 if (process == NULL)
714 return -1;
715
716 find_inferior (&all_threads, linux_kill_one_lwp, &pid);
717
718 /* See the comment in linux_kill_one_lwp. We did not kill the first
719 thread in the list, so do so now. */
720 lwp = find_lwp_pid (pid_to_ptid (pid));
721 thread = get_lwp_thread (lwp);
722
723 if (debug_threads)
724 fprintf (stderr, "lk_1: killing lwp %ld, for pid: %d\n",
725 lwpid_of (lwp), pid);
726
727 /* If we're killing a running inferior, make sure it is stopped
728 first, as PTRACE_KILL will not work otherwise. */
729 if (!lwp->stopped)
730 send_sigstop (&lwp->head);
731
732 do
733 {
734 ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
735
736 /* Make sure it died. The loop is most likely unnecessary. */
737 lwpid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
738 } while (lwpid > 0 && WIFSTOPPED (wstat));
739
740 delete_lwp (lwp);
741 linux_remove_process (process, 0);
742 return 0;
743 }
744
745 static int
746 linux_detach_one_lwp (struct inferior_list_entry *entry, void *args)
747 {
748 struct thread_info *thread = (struct thread_info *) entry;
749 struct lwp_info *lwp = get_thread_lwp (thread);
750 int pid = * (int *) args;
751
752 if (ptid_get_pid (entry->id) != pid)
753 return 0;
754
755 /* If we're detaching from a running inferior, make sure it is
756 stopped first, as PTRACE_DETACH will not work otherwise. */
757 if (!lwp->stopped)
758 {
759 int lwpid = lwpid_of (lwp);
760
761 stopping_threads = 1;
762 send_sigstop (&lwp->head);
763
764 /* If this detects a new thread through a clone event, the new
765 thread is appended to the end of the lwp list, so we'll
766 eventually detach from it. */
767 wait_for_sigstop (&lwp->head);
768 stopping_threads = 0;
769
770 /* If LWP exits while we're trying to stop it, there's nothing
771 left to do. */
772 lwp = find_lwp_pid (pid_to_ptid (lwpid));
773 if (lwp == NULL)
774 return 0;
775 }
776
777 /* Make sure the process isn't stopped at a breakpoint that's
778 no longer there. */
779 check_removed_breakpoint (lwp);
780
781 /* If this process is stopped but is expecting a SIGSTOP, then make
782 sure we take care of that now. This isn't absolutely guaranteed
783 to collect the SIGSTOP, but is fairly likely to. */
784 if (lwp->stop_expected)
785 {
786 int wstat;
787 /* Clear stop_expected, so that the SIGSTOP will be reported. */
788 lwp->stop_expected = 0;
789 if (lwp->stopped)
790 linux_resume_one_lwp (lwp, 0, 0, NULL);
791 linux_wait_for_event (lwp->head.id, &wstat, __WALL);
792 }
793
794 /* Flush any pending changes to the process's registers. */
795 regcache_invalidate_one ((struct inferior_list_entry *)
796 get_lwp_thread (lwp));
797
798 /* Finally, let it resume. */
799 ptrace (PTRACE_DETACH, lwpid_of (lwp), 0, 0);
800
801 delete_lwp (lwp);
802 return 0;
803 }
804
805 static int
806 any_thread_of (struct inferior_list_entry *entry, void *args)
807 {
808 int *pid_p = args;
809
810 if (ptid_get_pid (entry->id) == *pid_p)
811 return 1;
812
813 return 0;
814 }
815
816 static int
817 linux_detach (int pid)
818 {
819 struct process_info *process;
820
821 process = find_process_pid (pid);
822 if (process == NULL)
823 return -1;
824
825 current_inferior =
826 (struct thread_info *) find_inferior (&all_threads, any_thread_of, &pid);
827
828 delete_all_breakpoints ();
829 find_inferior (&all_threads, linux_detach_one_lwp, &pid);
830 linux_remove_process (process, 1);
831 return 0;
832 }
833
834 static void
835 linux_join (int pid)
836 {
837 int status, ret;
838 struct process_info *process;
839
840 process = find_process_pid (pid);
841 if (process == NULL)
842 return;
843
844 do {
845 ret = my_waitpid (pid, &status, 0);
846 if (WIFEXITED (status) || WIFSIGNALED (status))
847 break;
848 } while (ret != -1 || errno != ECHILD);
849 }
850
851 /* Return nonzero if the given thread is still alive. */
852 static int
853 linux_thread_alive (ptid_t ptid)
854 {
855 struct lwp_info *lwp = find_lwp_pid (ptid);
856
857 /* We assume we always know if a thread exits. If a whole process
858 exited but we still haven't been able to report it to GDB, we'll
859 hold on to the last lwp of the dead process. */
860 if (lwp != NULL)
861 return !lwp->dead;
862 else
863 return 0;
864 }
865
866 /* Return nonzero if this process stopped at a breakpoint which
867 no longer appears to be inserted. Also adjust the PC
868 appropriately to resume where the breakpoint used to be. */
869 static int
870 check_removed_breakpoint (struct lwp_info *event_child)
871 {
872 CORE_ADDR stop_pc;
873 struct thread_info *saved_inferior;
874
875 if (event_child->pending_is_breakpoint == 0)
876 return 0;
877
878 if (debug_threads)
879 fprintf (stderr, "Checking for breakpoint in lwp %ld.\n",
880 lwpid_of (event_child));
881
882 saved_inferior = current_inferior;
883 current_inferior = get_lwp_thread (event_child);
884
885 stop_pc = get_stop_pc ();
886
887 /* If the PC has changed since we stopped, then we shouldn't do
888 anything. This happens if, for instance, GDB handled the
889 decr_pc_after_break subtraction itself. */
890 if (stop_pc != event_child->pending_stop_pc)
891 {
892 if (debug_threads)
893 fprintf (stderr, "Ignoring, PC was changed. Old PC was 0x%08llx\n",
894 event_child->pending_stop_pc);
895
896 event_child->pending_is_breakpoint = 0;
897 current_inferior = saved_inferior;
898 return 0;
899 }
900
901 /* If the breakpoint is still there, we will report hitting it. */
902 if ((*the_low_target.breakpoint_at) (stop_pc))
903 {
904 if (debug_threads)
905 fprintf (stderr, "Ignoring, breakpoint is still present.\n");
906 current_inferior = saved_inferior;
907 return 0;
908 }
909
910 if (debug_threads)
911 fprintf (stderr, "Removed breakpoint.\n");
912
913 /* For decr_pc_after_break targets, here is where we perform the
914 decrement. We go immediately from this function to resuming,
915 and can not safely call get_stop_pc () again. */
916 if (the_low_target.set_pc != NULL)
917 {
918 if (debug_threads)
919 fprintf (stderr, "Set pc to 0x%lx\n", (long) stop_pc);
920 (*the_low_target.set_pc) (stop_pc);
921 }
922
923 /* We consumed the pending SIGTRAP. */
924 event_child->pending_is_breakpoint = 0;
925 event_child->status_pending_p = 0;
926 event_child->status_pending = 0;
927
928 current_inferior = saved_inferior;
929 return 1;
930 }
931
932 /* Return 1 if this lwp has an interesting status pending. This
933 function may silently resume an inferior lwp. */
934 static int
935 status_pending_p (struct inferior_list_entry *entry, void *arg)
936 {
937 struct lwp_info *lwp = (struct lwp_info *) entry;
938 ptid_t ptid = * (ptid_t *) arg;
939
940 /* Check if we're only interested in events from a specific process
941 or its lwps. */
942 if (!ptid_equal (minus_one_ptid, ptid)
943 && ptid_get_pid (ptid) != ptid_get_pid (lwp->head.id))
944 return 0;
945
946 if (lwp->status_pending_p && !lwp->suspended)
947 if (check_removed_breakpoint (lwp))
948 {
949 /* This thread was stopped at a breakpoint, and the breakpoint
950 is now gone. We were told to continue (or step...) all threads,
951 so GDB isn't trying to single-step past this breakpoint.
952 So instead of reporting the old SIGTRAP, pretend we got to
953 the breakpoint just after it was removed instead of just
954 before; resume the process. */
955 linux_resume_one_lwp (lwp, 0, 0, NULL);
956 return 0;
957 }
958
959 return (lwp->status_pending_p && !lwp->suspended);
960 }
961
962 static int
963 same_lwp (struct inferior_list_entry *entry, void *data)
964 {
965 ptid_t ptid = *(ptid_t *) data;
966 int lwp;
967
968 if (ptid_get_lwp (ptid) != 0)
969 lwp = ptid_get_lwp (ptid);
970 else
971 lwp = ptid_get_pid (ptid);
972
973 if (ptid_get_lwp (entry->id) == lwp)
974 return 1;
975
976 return 0;
977 }
978
979 struct lwp_info *
980 find_lwp_pid (ptid_t ptid)
981 {
982 return (struct lwp_info*) find_inferior (&all_lwps, same_lwp, &ptid);
983 }
984
985 static struct lwp_info *
986 linux_wait_for_lwp (ptid_t ptid, int *wstatp, int options)
987 {
988 int ret;
989 int to_wait_for = -1;
990 struct lwp_info *child = NULL;
991
992 if (debug_threads)
993 fprintf (stderr, "linux_wait_for_lwp: %s\n", target_pid_to_str (ptid));
994
995 if (ptid_equal (ptid, minus_one_ptid))
996 to_wait_for = -1; /* any child */
997 else
998 to_wait_for = ptid_get_lwp (ptid); /* this lwp only */
999
1000 options |= __WALL;
1001
1002 retry:
1003
1004 ret = my_waitpid (to_wait_for, wstatp, options);
1005 if (ret == 0 || (ret == -1 && errno == ECHILD && (options & WNOHANG)))
1006 return NULL;
1007 else if (ret == -1)
1008 perror_with_name ("waitpid");
1009
1010 if (debug_threads
1011 && (!WIFSTOPPED (*wstatp)
1012 || (WSTOPSIG (*wstatp) != 32
1013 && WSTOPSIG (*wstatp) != 33)))
1014 fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
1015
1016 child = find_lwp_pid (pid_to_ptid (ret));
1017
1018 /* If we didn't find a process, one of two things presumably happened:
1019 - A process we started and then detached from has exited. Ignore it.
1020 - A process we are controlling has forked and the new child's stop
1021 was reported to us by the kernel. Save its PID. */
1022 if (child == NULL && WIFSTOPPED (*wstatp))
1023 {
1024 add_pid_to_list (&stopped_pids, ret);
1025 goto retry;
1026 }
1027 else if (child == NULL)
1028 goto retry;
1029
1030 child->stopped = 1;
1031 child->pending_is_breakpoint = 0;
1032
1033 child->last_status = *wstatp;
1034
1035 /* Architecture-specific setup after inferior is running.
1036 This needs to happen after we have attached to the inferior
1037 and it is stopped for the first time, but before we access
1038 any inferior registers. */
1039 if (new_inferior)
1040 {
1041 the_low_target.arch_setup ();
1042 #ifdef HAVE_LINUX_REGSETS
1043 memset (disabled_regsets, 0, num_regsets);
1044 #endif
1045 new_inferior = 0;
1046 }
1047
1048 if (debug_threads
1049 && WIFSTOPPED (*wstatp)
1050 && the_low_target.get_pc != NULL)
1051 {
1052 struct thread_info *saved_inferior = current_inferior;
1053 CORE_ADDR pc;
1054
1055 current_inferior = (struct thread_info *)
1056 find_inferior_id (&all_threads, child->head.id);
1057 pc = (*the_low_target.get_pc) ();
1058 fprintf (stderr, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc);
1059 current_inferior = saved_inferior;
1060 }
1061
1062 return child;
1063 }
1064
1065 /* Wait for an event from child PID. If PID is -1, wait for any
1066 child. Store the stop status through the status pointer WSTAT.
1067 OPTIONS is passed to the waitpid call. Return 0 if no child stop
1068 event was found and OPTIONS contains WNOHANG. Return the PID of
1069 the stopped child otherwise. */
1070
1071 static int
1072 linux_wait_for_event_1 (ptid_t ptid, int *wstat, int options)
1073 {
1074 CORE_ADDR stop_pc;
1075 struct lwp_info *event_child = NULL;
1076 int bp_status;
1077 struct lwp_info *requested_child = NULL;
1078
1079 /* Check for a lwp with a pending status. */
1080 /* It is possible that the user changed the pending task's registers since
1081 it stopped. We correctly handle the change of PC if we hit a breakpoint
1082 (in check_removed_breakpoint); signals should be reported anyway. */
1083
1084 if (ptid_equal (ptid, minus_one_ptid)
1085 || ptid_equal (pid_to_ptid (ptid_get_pid (ptid)), ptid))
1086 {
1087 event_child = (struct lwp_info *)
1088 find_inferior (&all_lwps, status_pending_p, &ptid);
1089 if (debug_threads && event_child)
1090 fprintf (stderr, "Got a pending child %ld\n", lwpid_of (event_child));
1091 }
1092 else
1093 {
1094 requested_child = find_lwp_pid (ptid);
1095 if (requested_child->status_pending_p
1096 && !check_removed_breakpoint (requested_child))
1097 event_child = requested_child;
1098 }
1099
1100 if (event_child != NULL)
1101 {
1102 if (debug_threads)
1103 fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
1104 lwpid_of (event_child), event_child->status_pending);
1105 *wstat = event_child->status_pending;
1106 event_child->status_pending_p = 0;
1107 event_child->status_pending = 0;
1108 current_inferior = get_lwp_thread (event_child);
1109 return lwpid_of (event_child);
1110 }
1111
1112 /* We only enter this loop if no process has a pending wait status. Thus
1113 any action taken in response to a wait status inside this loop is
1114 responding as soon as we detect the status, not after any pending
1115 events. */
1116 while (1)
1117 {
1118 event_child = linux_wait_for_lwp (ptid, wstat, options);
1119
1120 if ((options & WNOHANG) && event_child == NULL)
1121 return 0;
1122
1123 if (event_child == NULL)
1124 error ("event from unknown child");
1125
1126 current_inferior = get_lwp_thread (event_child);
1127
1128 /* Check for thread exit. */
1129 if (! WIFSTOPPED (*wstat))
1130 {
1131 if (debug_threads)
1132 fprintf (stderr, "LWP %ld exiting\n", lwpid_of (event_child));
1133
1134 /* If the last thread is exiting, just return. */
1135 if (last_thread_of_process_p (current_inferior))
1136 {
1137 if (debug_threads)
1138 fprintf (stderr, "LWP %ld is last lwp of process\n",
1139 lwpid_of (event_child));
1140 return lwpid_of (event_child);
1141 }
1142
1143 delete_lwp (event_child);
1144
1145 if (!non_stop)
1146 {
1147 current_inferior = (struct thread_info *) all_threads.head;
1148 if (debug_threads)
1149 fprintf (stderr, "Current inferior is now %ld\n",
1150 lwpid_of (get_thread_lwp (current_inferior)));
1151 }
1152 else
1153 {
1154 current_inferior = NULL;
1155 if (debug_threads)
1156 fprintf (stderr, "Current inferior is now <NULL>\n");
1157 }
1158
1159 /* If we were waiting for this particular child to do something...
1160 well, it did something. */
1161 if (requested_child != NULL)
1162 return lwpid_of (event_child);
1163
1164 /* Wait for a more interesting event. */
1165 continue;
1166 }
1167
1168 if (event_child->must_set_ptrace_flags)
1169 {
1170 ptrace (PTRACE_SETOPTIONS, lwpid_of (event_child),
1171 0, PTRACE_O_TRACECLONE);
1172 event_child->must_set_ptrace_flags = 0;
1173 }
1174
1175 if (WIFSTOPPED (*wstat)
1176 && WSTOPSIG (*wstat) == SIGSTOP
1177 && event_child->stop_expected)
1178 {
1179 if (debug_threads)
1180 fprintf (stderr, "Expected stop.\n");
1181 event_child->stop_expected = 0;
1182 linux_resume_one_lwp (event_child, event_child->stepping, 0, NULL);
1183 continue;
1184 }
1185
1186 if (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) == SIGTRAP
1187 && *wstat >> 16 != 0)
1188 {
1189 handle_extended_wait (event_child, *wstat);
1190 continue;
1191 }
1192
1193 /* If GDB is not interested in this signal, don't stop other
1194 threads, and don't report it to GDB. Just resume the
1195 inferior right away. We do this for threading-related
1196 signals as well as any that GDB specifically requested we
1197 ignore. But never ignore SIGSTOP if we sent it ourselves,
1198 and do not ignore signals when stepping - they may require
1199 special handling to skip the signal handler. */
1200 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
1201 thread library? */
1202 if (WIFSTOPPED (*wstat)
1203 && !event_child->stepping
1204 && (
1205 #ifdef USE_THREAD_DB
1206 (current_process ()->private->thread_db != NULL
1207 && (WSTOPSIG (*wstat) == __SIGRTMIN
1208 || WSTOPSIG (*wstat) == __SIGRTMIN + 1))
1209 ||
1210 #endif
1211 (pass_signals[target_signal_from_host (WSTOPSIG (*wstat))]
1212 && (WSTOPSIG (*wstat) != SIGSTOP || !stopping_threads))))
1213 {
1214 siginfo_t info, *info_p;
1215
1216 if (debug_threads)
1217 fprintf (stderr, "Ignored signal %d for LWP %ld.\n",
1218 WSTOPSIG (*wstat), lwpid_of (event_child));
1219
1220 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child), 0, &info) == 0)
1221 info_p = &info;
1222 else
1223 info_p = NULL;
1224 linux_resume_one_lwp (event_child,
1225 event_child->stepping,
1226 WSTOPSIG (*wstat), info_p);
1227 continue;
1228 }
1229
1230 /* If this event was not handled above, and is not a SIGTRAP, report
1231 it. */
1232 if (!WIFSTOPPED (*wstat) || WSTOPSIG (*wstat) != SIGTRAP)
1233 return lwpid_of (event_child);
1234
1235 /* If this target does not support breakpoints, we simply report the
1236 SIGTRAP; it's of no concern to us. */
1237 if (the_low_target.get_pc == NULL)
1238 return lwpid_of (event_child);
1239
1240 stop_pc = get_stop_pc ();
1241
1242 /* bp_reinsert will only be set if we were single-stepping.
1243 Notice that we will resume the process after hitting
1244 a gdbserver breakpoint; single-stepping to/over one
1245 is not supported (yet). */
1246 if (event_child->bp_reinsert != 0)
1247 {
1248 if (debug_threads)
1249 fprintf (stderr, "Reinserted breakpoint.\n");
1250 reinsert_breakpoint (event_child->bp_reinsert);
1251 event_child->bp_reinsert = 0;
1252
1253 /* Clear the single-stepping flag and SIGTRAP as we resume. */
1254 linux_resume_one_lwp (event_child, 0, 0, NULL);
1255 continue;
1256 }
1257
1258 bp_status = check_breakpoints (stop_pc);
1259
1260 if (bp_status != 0)
1261 {
1262 if (debug_threads)
1263 fprintf (stderr, "Hit a gdbserver breakpoint.\n");
1264
1265 /* We hit one of our own breakpoints. We mark it as a pending
1266 breakpoint, so that check_removed_breakpoint () will do the PC
1267 adjustment for us at the appropriate time. */
1268 event_child->pending_is_breakpoint = 1;
1269 event_child->pending_stop_pc = stop_pc;
1270
1271 /* We may need to put the breakpoint back. We continue in the event
1272 loop instead of simply replacing the breakpoint right away,
1273 in order to not lose signals sent to the thread that hit the
1274 breakpoint. Unfortunately this increases the window where another
1275 thread could sneak past the removed breakpoint. For the current
1276 use of server-side breakpoints (thread creation) this is
1277 acceptable; but it needs to be considered before this breakpoint
1278 mechanism can be used in more general ways. For some breakpoints
1279 it may be necessary to stop all other threads, but that should
1280 be avoided where possible.
1281
1282 If breakpoint_reinsert_addr is NULL, that means that we can
1283 use PTRACE_SINGLESTEP on this platform. Uninsert the breakpoint,
1284 mark it for reinsertion, and single-step.
1285
1286 Otherwise, call the target function to figure out where we need
1287 our temporary breakpoint, create it, and continue executing this
1288 process. */
1289
1290 /* NOTE: we're lifting breakpoints in non-stop mode. This
1291 is currently only used for thread event breakpoints, so
1292 it isn't that bad as long as we have PTRACE_EVENT_CLONE
1293 events. */
1294 if (bp_status == 2)
1295 /* No need to reinsert. */
1296 linux_resume_one_lwp (event_child, 0, 0, NULL);
1297 else if (the_low_target.breakpoint_reinsert_addr == NULL)
1298 {
1299 event_child->bp_reinsert = stop_pc;
1300 uninsert_breakpoint (stop_pc);
1301 linux_resume_one_lwp (event_child, 1, 0, NULL);
1302 }
1303 else
1304 {
1305 reinsert_breakpoint_by_bp
1306 (stop_pc, (*the_low_target.breakpoint_reinsert_addr) ());
1307 linux_resume_one_lwp (event_child, 0, 0, NULL);
1308 }
1309
1310 continue;
1311 }
1312
1313 if (debug_threads)
1314 fprintf (stderr, "Hit a non-gdbserver breakpoint.\n");
1315
1316 /* If we were single-stepping, we definitely want to report the
1317 SIGTRAP. Although the single-step operation has completed,
1318 do not clear clear the stepping flag yet; we need to check it
1319 in wait_for_sigstop. */
1320 if (event_child->stepping)
1321 return lwpid_of (event_child);
1322
1323 /* A SIGTRAP that we can't explain. It may have been a breakpoint.
1324 Check if it is a breakpoint, and if so mark the process information
1325 accordingly. This will handle both the necessary fiddling with the
1326 PC on decr_pc_after_break targets and suppressing extra threads
1327 hitting a breakpoint if two hit it at once and then GDB removes it
1328 after the first is reported. Arguably it would be better to report
1329 multiple threads hitting breakpoints simultaneously, but the current
1330 remote protocol does not allow this. */
1331 if ((*the_low_target.breakpoint_at) (stop_pc))
1332 {
1333 event_child->pending_is_breakpoint = 1;
1334 event_child->pending_stop_pc = stop_pc;
1335 }
1336
1337 return lwpid_of (event_child);
1338 }
1339
1340 /* NOTREACHED */
1341 return 0;
1342 }
1343
1344 static int
1345 linux_wait_for_event (ptid_t ptid, int *wstat, int options)
1346 {
1347 ptid_t wait_ptid;
1348
1349 if (ptid_is_pid (ptid))
1350 {
1351 /* A request to wait for a specific tgid. This is not possible
1352 with waitpid, so instead, we wait for any child, and leave
1353 children we're not interested in right now with a pending
1354 status to report later. */
1355 wait_ptid = minus_one_ptid;
1356 }
1357 else
1358 wait_ptid = ptid;
1359
1360 while (1)
1361 {
1362 int event_pid;
1363
1364 event_pid = linux_wait_for_event_1 (wait_ptid, wstat, options);
1365
1366 if (event_pid > 0
1367 && ptid_is_pid (ptid) && ptid_get_pid (ptid) != event_pid)
1368 {
1369 struct lwp_info *event_child = find_lwp_pid (pid_to_ptid (event_pid));
1370
1371 if (! WIFSTOPPED (*wstat))
1372 mark_lwp_dead (event_child, *wstat);
1373 else
1374 {
1375 event_child->status_pending_p = 1;
1376 event_child->status_pending = *wstat;
1377 }
1378 }
1379 else
1380 return event_pid;
1381 }
1382 }
1383
1384 /* Wait for process, returns status. */
1385
1386 static ptid_t
1387 linux_wait_1 (ptid_t ptid,
1388 struct target_waitstatus *ourstatus, int target_options)
1389 {
1390 int w;
1391 struct thread_info *thread = NULL;
1392 struct lwp_info *lwp = NULL;
1393 int options;
1394 int pid;
1395
1396 /* Translate generic target options into linux options. */
1397 options = __WALL;
1398 if (target_options & TARGET_WNOHANG)
1399 options |= WNOHANG;
1400
1401 retry:
1402 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1403
1404 /* If we were only supposed to resume one thread, only wait for
1405 that thread - if it's still alive. If it died, however - which
1406 can happen if we're coming from the thread death case below -
1407 then we need to make sure we restart the other threads. We could
1408 pick a thread at random or restart all; restarting all is less
1409 arbitrary. */
1410 if (!non_stop
1411 && !ptid_equal (cont_thread, null_ptid)
1412 && !ptid_equal (cont_thread, minus_one_ptid))
1413 {
1414 thread = (struct thread_info *) find_inferior_id (&all_threads,
1415 cont_thread);
1416
1417 /* No stepping, no signal - unless one is pending already, of course. */
1418 if (thread == NULL)
1419 {
1420 struct thread_resume resume_info;
1421 resume_info.thread = minus_one_ptid;
1422 resume_info.kind = resume_continue;
1423 resume_info.sig = 0;
1424 linux_resume (&resume_info, 1);
1425 }
1426 else
1427 ptid = cont_thread;
1428 }
1429
1430 pid = linux_wait_for_event (ptid, &w, options);
1431 if (pid == 0) /* only if TARGET_WNOHANG */
1432 return null_ptid;
1433
1434 lwp = get_thread_lwp (current_inferior);
1435
1436 /* If we are waiting for a particular child, and it exited,
1437 linux_wait_for_event will return its exit status. Similarly if
1438 the last child exited. If this is not the last child, however,
1439 do not report it as exited until there is a 'thread exited' response
1440 available in the remote protocol. Instead, just wait for another event.
1441 This should be safe, because if the thread crashed we will already
1442 have reported the termination signal to GDB; that should stop any
1443 in-progress stepping operations, etc.
1444
1445 Report the exit status of the last thread to exit. This matches
1446 LinuxThreads' behavior. */
1447
1448 if (last_thread_of_process_p (current_inferior))
1449 {
1450 if (WIFEXITED (w) || WIFSIGNALED (w))
1451 {
1452 int pid = pid_of (lwp);
1453 struct process_info *process = find_process_pid (pid);
1454
1455 delete_lwp (lwp);
1456 linux_remove_process (process, 0);
1457
1458 current_inferior = NULL;
1459
1460 if (WIFEXITED (w))
1461 {
1462 ourstatus->kind = TARGET_WAITKIND_EXITED;
1463 ourstatus->value.integer = WEXITSTATUS (w);
1464
1465 if (debug_threads)
1466 fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
1467 }
1468 else
1469 {
1470 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1471 ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));
1472
1473 if (debug_threads)
1474 fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
1475
1476 }
1477
1478 return pid_to_ptid (pid);
1479 }
1480 }
1481 else
1482 {
1483 if (!WIFSTOPPED (w))
1484 goto retry;
1485 }
1486
1487 /* In all-stop, stop all threads. Be careful to only do this if
1488 we're about to report an event to GDB. */
1489 if (!non_stop)
1490 stop_all_lwps ();
1491
1492 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1493
1494 if (lwp->suspended && WSTOPSIG (w) == SIGSTOP)
1495 {
1496 /* A thread that has been requested to stop by GDB with vCont;t,
1497 and it stopped cleanly, so report as SIG0. The use of
1498 SIGSTOP is an implementation detail. */
1499 ourstatus->value.sig = TARGET_SIGNAL_0;
1500 }
1501 else if (lwp->suspended && WSTOPSIG (w) != SIGSTOP)
1502 {
1503 /* A thread that has been requested to stop by GDB with vCont;t,
1504 but, it stopped for other reasons. Set stop_expected so the
1505 pending SIGSTOP is ignored and the LWP is resumed. */
1506 lwp->stop_expected = 1;
1507 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
1508 }
1509 else
1510 {
1511 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
1512 }
1513
1514 if (debug_threads)
1515 fprintf (stderr, "linux_wait ret = %s, %d, %d\n",
1516 target_pid_to_str (lwp->head.id),
1517 ourstatus->kind,
1518 ourstatus->value.sig);
1519
1520 return lwp->head.id;
1521 }
1522
1523 /* Get rid of any pending event in the pipe. */
1524 static void
1525 async_file_flush (void)
1526 {
1527 int ret;
1528 char buf;
1529
1530 do
1531 ret = read (linux_event_pipe[0], &buf, 1);
1532 while (ret >= 0 || (ret == -1 && errno == EINTR));
1533 }
1534
1535 /* Put something in the pipe, so the event loop wakes up. */
1536 static void
1537 async_file_mark (void)
1538 {
1539 int ret;
1540
1541 async_file_flush ();
1542
1543 do
1544 ret = write (linux_event_pipe[1], "+", 1);
1545 while (ret == 0 || (ret == -1 && errno == EINTR));
1546
1547 /* Ignore EAGAIN. If the pipe is full, the event loop will already
1548 be awakened anyway. */
1549 }
1550
1551 static ptid_t
1552 linux_wait (ptid_t ptid,
1553 struct target_waitstatus *ourstatus, int target_options)
1554 {
1555 ptid_t event_ptid;
1556
1557 if (debug_threads)
1558 fprintf (stderr, "linux_wait: [%s]\n", target_pid_to_str (ptid));
1559
1560 /* Flush the async file first. */
1561 if (target_is_async_p ())
1562 async_file_flush ();
1563
1564 event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
1565
1566 /* If at least one stop was reported, there may be more. A single
1567 SIGCHLD can signal more than one child stop. */
1568 if (target_is_async_p ()
1569 && (target_options & TARGET_WNOHANG) != 0
1570 && !ptid_equal (event_ptid, null_ptid))
1571 async_file_mark ();
1572
1573 return event_ptid;
1574 }
1575
1576 /* Send a signal to an LWP. For LinuxThreads, kill is enough; however, if
1577 thread groups are in use, we need to use tkill. */
1578
1579 static int
1580 kill_lwp (unsigned long lwpid, int signo)
1581 {
1582 static int tkill_failed;
1583
1584 errno = 0;
1585
1586 #ifdef SYS_tkill
1587 if (!tkill_failed)
1588 {
1589 int ret = syscall (SYS_tkill, lwpid, signo);
1590 if (errno != ENOSYS)
1591 return ret;
1592 errno = 0;
1593 tkill_failed = 1;
1594 }
1595 #endif
1596
1597 return kill (lwpid, signo);
1598 }
1599
1600 static void
1601 send_sigstop (struct inferior_list_entry *entry)
1602 {
1603 struct lwp_info *lwp = (struct lwp_info *) entry;
1604 int pid;
1605
1606 if (lwp->stopped)
1607 return;
1608
1609 pid = lwpid_of (lwp);
1610
1611 /* If we already have a pending stop signal for this process, don't
1612 send another. */
1613 if (lwp->stop_expected)
1614 {
1615 if (debug_threads)
1616 fprintf (stderr, "Have pending sigstop for lwp %d\n", pid);
1617
1618 /* We clear the stop_expected flag so that wait_for_sigstop
1619 will receive the SIGSTOP event (instead of silently resuming and
1620 waiting again). It'll be reset below. */
1621 lwp->stop_expected = 0;
1622 return;
1623 }
1624
1625 if (debug_threads)
1626 fprintf (stderr, "Sending sigstop to lwp %d\n", pid);
1627
1628 kill_lwp (pid, SIGSTOP);
1629 }
1630
1631 static void
1632 mark_lwp_dead (struct lwp_info *lwp, int wstat)
1633 {
1634 /* It's dead, really. */
1635 lwp->dead = 1;
1636
1637 /* Store the exit status for later. */
1638 lwp->status_pending_p = 1;
1639 lwp->status_pending = wstat;
1640
1641 /* So that check_removed_breakpoint doesn't try to figure out if
1642 this is stopped at a breakpoint. */
1643 lwp->pending_is_breakpoint = 0;
1644
1645 /* Prevent trying to stop it. */
1646 lwp->stopped = 1;
1647
1648 /* No further stops are expected from a dead lwp. */
1649 lwp->stop_expected = 0;
1650 }
1651
1652 static void
1653 wait_for_sigstop (struct inferior_list_entry *entry)
1654 {
1655 struct lwp_info *lwp = (struct lwp_info *) entry;
1656 struct thread_info *saved_inferior;
1657 int wstat;
1658 ptid_t saved_tid;
1659 ptid_t ptid;
1660
1661 if (lwp->stopped)
1662 return;
1663
1664 saved_inferior = current_inferior;
1665 if (saved_inferior != NULL)
1666 saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
1667 else
1668 saved_tid = null_ptid; /* avoid bogus unused warning */
1669
1670 ptid = lwp->head.id;
1671
1672 linux_wait_for_event (ptid, &wstat, __WALL);
1673
1674 /* If we stopped with a non-SIGSTOP signal, save it for later
1675 and record the pending SIGSTOP. If the process exited, just
1676 return. */
1677 if (WIFSTOPPED (wstat)
1678 && WSTOPSIG (wstat) != SIGSTOP)
1679 {
1680 if (debug_threads)
1681 fprintf (stderr, "LWP %ld stopped with non-sigstop status %06x\n",
1682 lwpid_of (lwp), wstat);
1683
1684 /* Do not leave a pending single-step finish to be reported to
1685 the client. The client will give us a new action for this
1686 thread, possibly a continue request --- otherwise, the client
1687 would consider this pending SIGTRAP reported later a spurious
1688 signal. */
1689 if (WSTOPSIG (wstat) == SIGTRAP
1690 && lwp->stepping
1691 && !linux_stopped_by_watchpoint ())
1692 {
1693 if (debug_threads)
1694 fprintf (stderr, " single-step SIGTRAP ignored\n");
1695 }
1696 else
1697 {
1698 lwp->status_pending_p = 1;
1699 lwp->status_pending = wstat;
1700 }
1701 lwp->stop_expected = 1;
1702 }
1703 else if (!WIFSTOPPED (wstat))
1704 {
1705 if (debug_threads)
1706 fprintf (stderr, "Process %ld exited while stopping LWPs\n",
1707 lwpid_of (lwp));
1708
1709 /* Leave this status pending for the next time we're able to
1710 report it. In the mean time, we'll report this lwp as dead
1711 to GDB, so GDB doesn't try to read registers and memory from
1712 it. */
1713 mark_lwp_dead (lwp, wstat);
1714 }
1715
1716 if (saved_inferior == NULL || linux_thread_alive (saved_tid))
1717 current_inferior = saved_inferior;
1718 else
1719 {
1720 if (debug_threads)
1721 fprintf (stderr, "Previously current thread died.\n");
1722
1723 if (non_stop)
1724 {
1725 /* We can't change the current inferior behind GDB's back,
1726 otherwise, a subsequent command may apply to the wrong
1727 process. */
1728 current_inferior = NULL;
1729 }
1730 else
1731 {
1732 /* Set a valid thread as current. */
1733 set_desired_inferior (0);
1734 }
1735 }
1736 }
1737
1738 static void
1739 stop_all_lwps (void)
1740 {
1741 stopping_threads = 1;
1742 for_each_inferior (&all_lwps, send_sigstop);
1743 for_each_inferior (&all_lwps, wait_for_sigstop);
1744 stopping_threads = 0;
1745 }
1746
1747 /* Resume execution of the inferior process.
1748 If STEP is nonzero, single-step it.
1749 If SIGNAL is nonzero, give it that signal. */
1750
1751 static void
1752 linux_resume_one_lwp (struct lwp_info *lwp,
1753 int step, int signal, siginfo_t *info)
1754 {
1755 struct thread_info *saved_inferior;
1756
1757 if (lwp->stopped == 0)
1758 return;
1759
1760 /* If we have pending signals or status, and a new signal, enqueue the
1761 signal. Also enqueue the signal if we are waiting to reinsert a
1762 breakpoint; it will be picked up again below. */
1763 if (signal != 0
1764 && (lwp->status_pending_p || lwp->pending_signals != NULL
1765 || lwp->bp_reinsert != 0))
1766 {
1767 struct pending_signals *p_sig;
1768 p_sig = xmalloc (sizeof (*p_sig));
1769 p_sig->prev = lwp->pending_signals;
1770 p_sig->signal = signal;
1771 if (info == NULL)
1772 memset (&p_sig->info, 0, sizeof (siginfo_t));
1773 else
1774 memcpy (&p_sig->info, info, sizeof (siginfo_t));
1775 lwp->pending_signals = p_sig;
1776 }
1777
1778 if (lwp->status_pending_p && !check_removed_breakpoint (lwp))
1779 return;
1780
1781 saved_inferior = current_inferior;
1782 current_inferior = get_lwp_thread (lwp);
1783
1784 if (debug_threads)
1785 fprintf (stderr, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
1786 lwpid_of (lwp), step ? "step" : "continue", signal,
1787 lwp->stop_expected ? "expected" : "not expected");
1788
1789 /* This bit needs some thinking about. If we get a signal that
1790 we must report while a single-step reinsert is still pending,
1791 we often end up resuming the thread. It might be better to
1792 (ew) allow a stack of pending events; then we could be sure that
1793 the reinsert happened right away and not lose any signals.
1794
1795 Making this stack would also shrink the window in which breakpoints are
1796 uninserted (see comment in linux_wait_for_lwp) but not enough for
1797 complete correctness, so it won't solve that problem. It may be
1798 worthwhile just to solve this one, however. */
1799 if (lwp->bp_reinsert != 0)
1800 {
1801 if (debug_threads)
1802 fprintf (stderr, " pending reinsert at %08lx", (long)lwp->bp_reinsert);
1803 if (step == 0)
1804 fprintf (stderr, "BAD - reinserting but not stepping.\n");
1805 step = 1;
1806
1807 /* Postpone any pending signal. It was enqueued above. */
1808 signal = 0;
1809 }
1810
1811 check_removed_breakpoint (lwp);
1812
1813 if (debug_threads && the_low_target.get_pc != NULL)
1814 {
1815 CORE_ADDR pc = (*the_low_target.get_pc) ();
1816 fprintf (stderr, " resuming from pc 0x%lx\n", (long) pc);
1817 }
1818
1819 /* If we have pending signals, consume one unless we are trying to reinsert
1820 a breakpoint. */
1821 if (lwp->pending_signals != NULL && lwp->bp_reinsert == 0)
1822 {
1823 struct pending_signals **p_sig;
1824
1825 p_sig = &lwp->pending_signals;
1826 while ((*p_sig)->prev != NULL)
1827 p_sig = &(*p_sig)->prev;
1828
1829 signal = (*p_sig)->signal;
1830 if ((*p_sig)->info.si_signo != 0)
1831 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
1832
1833 free (*p_sig);
1834 *p_sig = NULL;
1835 }
1836
1837 if (the_low_target.prepare_to_resume != NULL)
1838 the_low_target.prepare_to_resume (lwp);
1839
1840 regcache_invalidate_one ((struct inferior_list_entry *)
1841 get_lwp_thread (lwp));
1842 errno = 0;
1843 lwp->stopped = 0;
1844 lwp->stepping = step;
1845 ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp), 0, signal);
1846
1847 current_inferior = saved_inferior;
1848 if (errno)
1849 {
1850 /* ESRCH from ptrace either means that the thread was already
1851 running (an error) or that it is gone (a race condition). If
1852 it's gone, we will get a notification the next time we wait,
1853 so we can ignore the error. We could differentiate these
1854 two, but it's tricky without waiting; the thread still exists
1855 as a zombie, so sending it signal 0 would succeed. So just
1856 ignore ESRCH. */
1857 if (errno == ESRCH)
1858 return;
1859
1860 perror_with_name ("ptrace");
1861 }
1862 }
1863
1864 struct thread_resume_array
1865 {
1866 struct thread_resume *resume;
1867 size_t n;
1868 };
1869
1870 /* This function is called once per thread. We look up the thread
1871 in RESUME_PTR, and mark the thread with a pointer to the appropriate
1872 resume request.
1873
1874 This algorithm is O(threads * resume elements), but resume elements
1875 is small (and will remain small at least until GDB supports thread
1876 suspension). */
1877 static int
1878 linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
1879 {
1880 struct lwp_info *lwp;
1881 struct thread_info *thread;
1882 int ndx;
1883 struct thread_resume_array *r;
1884
1885 thread = (struct thread_info *) entry;
1886 lwp = get_thread_lwp (thread);
1887 r = arg;
1888
1889 for (ndx = 0; ndx < r->n; ndx++)
1890 {
1891 ptid_t ptid = r->resume[ndx].thread;
1892 if (ptid_equal (ptid, minus_one_ptid)
1893 || ptid_equal (ptid, entry->id)
1894 || (ptid_is_pid (ptid)
1895 && (ptid_get_pid (ptid) == pid_of (lwp)))
1896 || (ptid_get_lwp (ptid) == -1
1897 && (ptid_get_pid (ptid) == pid_of (lwp))))
1898 {
1899 lwp->resume = &r->resume[ndx];
1900 return 0;
1901 }
1902 }
1903
1904 /* No resume action for this thread. */
1905 lwp->resume = NULL;
1906
1907 return 0;
1908 }
1909
1910
1911 /* Set *FLAG_P if this lwp has an interesting status pending. */
1912 static int
1913 resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
1914 {
1915 struct lwp_info *lwp = (struct lwp_info *) entry;
1916
1917 /* LWPs which will not be resumed are not interesting, because
1918 we might not wait for them next time through linux_wait. */
1919 if (lwp->resume == NULL)
1920 return 0;
1921
1922 /* If this thread has a removed breakpoint, we won't have any
1923 events to report later, so check now. check_removed_breakpoint
1924 may clear status_pending_p. We avoid calling check_removed_breakpoint
1925 for any thread that we are not otherwise going to resume - this
1926 lets us preserve stopped status when two threads hit a breakpoint.
1927 GDB removes the breakpoint to single-step a particular thread
1928 past it, then re-inserts it and resumes all threads. We want
1929 to report the second thread without resuming it in the interim. */
1930 if (lwp->status_pending_p)
1931 check_removed_breakpoint (lwp);
1932
1933 if (lwp->status_pending_p)
1934 * (int *) flag_p = 1;
1935
1936 return 0;
1937 }
1938
1939 /* This function is called once per thread. We check the thread's resume
1940 request, which will tell us whether to resume, step, or leave the thread
1941 stopped; and what signal, if any, it should be sent.
1942
1943 For threads which we aren't explicitly told otherwise, we preserve
1944 the stepping flag; this is used for stepping over gdbserver-placed
1945 breakpoints.
1946
1947 If pending_flags was set in any thread, we queue any needed
1948 signals, since we won't actually resume. We already have a pending
1949 event to report, so we don't need to preserve any step requests;
1950 they should be re-issued if necessary. */
1951
1952 static int
1953 linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
1954 {
1955 struct lwp_info *lwp;
1956 struct thread_info *thread;
1957 int step;
1958 int pending_flag = * (int *) arg;
1959
1960 thread = (struct thread_info *) entry;
1961 lwp = get_thread_lwp (thread);
1962
1963 if (lwp->resume == NULL)
1964 return 0;
1965
1966 if (lwp->resume->kind == resume_stop)
1967 {
1968 if (debug_threads)
1969 fprintf (stderr, "suspending LWP %ld\n", lwpid_of (lwp));
1970
1971 if (!lwp->stopped)
1972 {
1973 if (debug_threads)
1974 fprintf (stderr, "running -> suspending LWP %ld\n", lwpid_of (lwp));
1975
1976 lwp->suspended = 1;
1977 send_sigstop (&lwp->head);
1978 }
1979 else
1980 {
1981 if (debug_threads)
1982 {
1983 if (lwp->suspended)
1984 fprintf (stderr, "already stopped/suspended LWP %ld\n",
1985 lwpid_of (lwp));
1986 else
1987 fprintf (stderr, "already stopped/not suspended LWP %ld\n",
1988 lwpid_of (lwp));
1989 }
1990
1991 /* Make sure we leave the LWP suspended, so we don't try to
1992 resume it without GDB telling us to. FIXME: The LWP may
1993 have been stopped in an internal event that was not meant
1994 to be notified back to GDB (e.g., gdbserver breakpoint),
1995 so we should be reporting a stop event in that case
1996 too. */
1997 lwp->suspended = 1;
1998 }
1999
2000 /* For stop requests, we're done. */
2001 lwp->resume = NULL;
2002 return 0;
2003 }
2004 else
2005 lwp->suspended = 0;
2006
2007 /* If this thread which is about to be resumed has a pending status,
2008 then don't resume any threads - we can just report the pending
2009 status. Make sure to queue any signals that would otherwise be
2010 sent. In all-stop mode, we do this decision based on if *any*
2011 thread has a pending status. */
2012 if (non_stop)
2013 resume_status_pending_p (&lwp->head, &pending_flag);
2014
2015 if (!pending_flag)
2016 {
2017 if (debug_threads)
2018 fprintf (stderr, "resuming LWP %ld\n", lwpid_of (lwp));
2019
2020 if (ptid_equal (lwp->resume->thread, minus_one_ptid)
2021 && lwp->stepping
2022 && lwp->pending_is_breakpoint)
2023 step = 1;
2024 else
2025 step = (lwp->resume->kind == resume_step);
2026
2027 linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL);
2028 }
2029 else
2030 {
2031 if (debug_threads)
2032 fprintf (stderr, "leaving LWP %ld stopped\n", lwpid_of (lwp));
2033
2034 /* If we have a new signal, enqueue the signal. */
2035 if (lwp->resume->sig != 0)
2036 {
2037 struct pending_signals *p_sig;
2038 p_sig = xmalloc (sizeof (*p_sig));
2039 p_sig->prev = lwp->pending_signals;
2040 p_sig->signal = lwp->resume->sig;
2041 memset (&p_sig->info, 0, sizeof (siginfo_t));
2042
2043 /* If this is the same signal we were previously stopped by,
2044 make sure to queue its siginfo. We can ignore the return
2045 value of ptrace; if it fails, we'll skip
2046 PTRACE_SETSIGINFO. */
2047 if (WIFSTOPPED (lwp->last_status)
2048 && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
2049 ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
2050
2051 lwp->pending_signals = p_sig;
2052 }
2053 }
2054
2055 lwp->resume = NULL;
2056 return 0;
2057 }
2058
2059 static void
2060 linux_resume (struct thread_resume *resume_info, size_t n)
2061 {
2062 int pending_flag;
2063 struct thread_resume_array array = { resume_info, n };
2064
2065 find_inferior (&all_threads, linux_set_resume_request, &array);
2066
2067 /* If there is a thread which would otherwise be resumed, which
2068 has a pending status, then don't resume any threads - we can just
2069 report the pending status. Make sure to queue any signals
2070 that would otherwise be sent. In non-stop mode, we'll apply this
2071 logic to each thread individually. */
2072 pending_flag = 0;
2073 if (!non_stop)
2074 find_inferior (&all_lwps, resume_status_pending_p, &pending_flag);
2075
2076 if (debug_threads)
2077 {
2078 if (pending_flag)
2079 fprintf (stderr, "Not resuming, pending status\n");
2080 else
2081 fprintf (stderr, "Resuming, no pending status\n");
2082 }
2083
2084 find_inferior (&all_threads, linux_resume_one_thread, &pending_flag);
2085 }
2086
2087 #ifdef HAVE_LINUX_USRREGS
2088
2089 int
2090 register_addr (int regnum)
2091 {
2092 int addr;
2093
2094 if (regnum < 0 || regnum >= the_low_target.num_regs)
2095 error ("Invalid register number %d.", regnum);
2096
2097 addr = the_low_target.regmap[regnum];
2098
2099 return addr;
2100 }
2101
2102 /* Fetch one register. */
2103 static void
2104 fetch_register (int regno)
2105 {
2106 CORE_ADDR regaddr;
2107 int i, size;
2108 char *buf;
2109 int pid;
2110
2111 if (regno >= the_low_target.num_regs)
2112 return;
2113 if ((*the_low_target.cannot_fetch_register) (regno))
2114 return;
2115
2116 regaddr = register_addr (regno);
2117 if (regaddr == -1)
2118 return;
2119
2120 pid = lwpid_of (get_thread_lwp (current_inferior));
2121 size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
2122 & - sizeof (PTRACE_XFER_TYPE));
2123 buf = alloca (size);
2124 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
2125 {
2126 errno = 0;
2127 *(PTRACE_XFER_TYPE *) (buf + i) =
2128 ptrace (PTRACE_PEEKUSER, pid, (PTRACE_ARG3_TYPE) regaddr, 0);
2129 regaddr += sizeof (PTRACE_XFER_TYPE);
2130 if (errno != 0)
2131 {
2132 /* Warning, not error, in case we are attached; sometimes the
2133 kernel doesn't let us at the registers. */
2134 char *err = strerror (errno);
2135 char *msg = alloca (strlen (err) + 128);
2136 sprintf (msg, "reading register %d: %s", regno, err);
2137 error (msg);
2138 goto error_exit;
2139 }
2140 }
2141
2142 if (the_low_target.supply_ptrace_register)
2143 the_low_target.supply_ptrace_register (regno, buf);
2144 else
2145 supply_register (regno, buf);
2146
2147 error_exit:;
2148 }
2149
2150 /* Fetch all registers, or just one, from the child process. */
2151 static void
2152 usr_fetch_inferior_registers (int regno)
2153 {
2154 if (regno == -1)
2155 for (regno = 0; regno < the_low_target.num_regs; regno++)
2156 fetch_register (regno);
2157 else
2158 fetch_register (regno);
2159 }
2160
2161 /* Store our register values back into the inferior.
2162 If REGNO is -1, do this for all registers.
2163 Otherwise, REGNO specifies which register (so we can save time). */
2164 static void
2165 usr_store_inferior_registers (int regno)
2166 {
2167 CORE_ADDR regaddr;
2168 int i, size;
2169 char *buf;
2170 int pid;
2171
2172 if (regno >= 0)
2173 {
2174 if (regno >= the_low_target.num_regs)
2175 return;
2176
2177 if ((*the_low_target.cannot_store_register) (regno) == 1)
2178 return;
2179
2180 regaddr = register_addr (regno);
2181 if (regaddr == -1)
2182 return;
2183 errno = 0;
2184 size = (register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
2185 & - sizeof (PTRACE_XFER_TYPE);
2186 buf = alloca (size);
2187 memset (buf, 0, size);
2188
2189 if (the_low_target.collect_ptrace_register)
2190 the_low_target.collect_ptrace_register (regno, buf);
2191 else
2192 collect_register (regno, buf);
2193
2194 pid = lwpid_of (get_thread_lwp (current_inferior));
2195 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
2196 {
2197 errno = 0;
2198 ptrace (PTRACE_POKEUSER, pid, (PTRACE_ARG3_TYPE) regaddr,
2199 *(PTRACE_XFER_TYPE *) (buf + i));
2200 if (errno != 0)
2201 {
2202 /* At this point, ESRCH should mean the process is
2203 already gone, in which case we simply ignore attempts
2204 to change its registers. See also the related
2205 comment in linux_resume_one_lwp. */
2206 if (errno == ESRCH)
2207 return;
2208
2209 if ((*the_low_target.cannot_store_register) (regno) == 0)
2210 {
2211 char *err = strerror (errno);
2212 char *msg = alloca (strlen (err) + 128);
2213 sprintf (msg, "writing register %d: %s",
2214 regno, err);
2215 error (msg);
2216 return;
2217 }
2218 }
2219 regaddr += sizeof (PTRACE_XFER_TYPE);
2220 }
2221 }
2222 else
2223 for (regno = 0; regno < the_low_target.num_regs; regno++)
2224 usr_store_inferior_registers (regno);
2225 }
2226 #endif /* HAVE_LINUX_USRREGS */
2227
2228
2229
2230 #ifdef HAVE_LINUX_REGSETS
2231
2232 static int
2233 regsets_fetch_inferior_registers ()
2234 {
2235 struct regset_info *regset;
2236 int saw_general_regs = 0;
2237 int pid;
2238
2239 regset = target_regsets;
2240
2241 pid = lwpid_of (get_thread_lwp (current_inferior));
2242 while (regset->size >= 0)
2243 {
2244 void *buf;
2245 int res;
2246
2247 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
2248 {
2249 regset ++;
2250 continue;
2251 }
2252
2253 buf = xmalloc (regset->size);
2254 #ifndef __sparc__
2255 res = ptrace (regset->get_request, pid, 0, buf);
2256 #else
2257 res = ptrace (regset->get_request, pid, buf, 0);
2258 #endif
2259 if (res < 0)
2260 {
2261 if (errno == EIO)
2262 {
2263 /* If we get EIO on a regset, do not try it again for
2264 this process. */
2265 disabled_regsets[regset - target_regsets] = 1;
2266 free (buf);
2267 continue;
2268 }
2269 else
2270 {
2271 char s[256];
2272 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
2273 pid);
2274 perror (s);
2275 }
2276 }
2277 else if (regset->type == GENERAL_REGS)
2278 saw_general_regs = 1;
2279 regset->store_function (buf);
2280 regset ++;
2281 free (buf);
2282 }
2283 if (saw_general_regs)
2284 return 0;
2285 else
2286 return 1;
2287 }
2288
2289 static int
2290 regsets_store_inferior_registers ()
2291 {
2292 struct regset_info *regset;
2293 int saw_general_regs = 0;
2294 int pid;
2295
2296 regset = target_regsets;
2297
2298 pid = lwpid_of (get_thread_lwp (current_inferior));
2299 while (regset->size >= 0)
2300 {
2301 void *buf;
2302 int res;
2303
2304 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
2305 {
2306 regset ++;
2307 continue;
2308 }
2309
2310 buf = xmalloc (regset->size);
2311
2312 /* First fill the buffer with the current register set contents,
2313 in case there are any items in the kernel's regset that are
2314 not in gdbserver's regcache. */
2315 #ifndef __sparc__
2316 res = ptrace (regset->get_request, pid, 0, buf);
2317 #else
2318 res = ptrace (regset->get_request, pid, buf, 0);
2319 #endif
2320
2321 if (res == 0)
2322 {
2323 /* Then overlay our cached registers on that. */
2324 regset->fill_function (buf);
2325
2326 /* Only now do we write the register set. */
2327 #ifndef __sparc__
2328 res = ptrace (regset->set_request, pid, 0, buf);
2329 #else
2330 res = ptrace (regset->set_request, pid, buf, 0);
2331 #endif
2332 }
2333
2334 if (res < 0)
2335 {
2336 if (errno == EIO)
2337 {
2338 /* If we get EIO on a regset, do not try it again for
2339 this process. */
2340 disabled_regsets[regset - target_regsets] = 1;
2341 free (buf);
2342 continue;
2343 }
2344 else if (errno == ESRCH)
2345 {
2346 /* At this point, ESRCH should mean the process is
2347 already gone, in which case we simply ignore attempts
2348 to change its registers. See also the related
2349 comment in linux_resume_one_lwp. */
2350 free (buf);
2351 return 0;
2352 }
2353 else
2354 {
2355 perror ("Warning: ptrace(regsets_store_inferior_registers)");
2356 }
2357 }
2358 else if (regset->type == GENERAL_REGS)
2359 saw_general_regs = 1;
2360 regset ++;
2361 free (buf);
2362 }
2363 if (saw_general_regs)
2364 return 0;
2365 else
2366 return 1;
2367 return 0;
2368 }
2369
2370 #endif /* HAVE_LINUX_REGSETS */
2371
2372
2373 void
2374 linux_fetch_registers (int regno)
2375 {
2376 #ifdef HAVE_LINUX_REGSETS
2377 if (regsets_fetch_inferior_registers () == 0)
2378 return;
2379 #endif
2380 #ifdef HAVE_LINUX_USRREGS
2381 usr_fetch_inferior_registers (regno);
2382 #endif
2383 }
2384
2385 void
2386 linux_store_registers (int regno)
2387 {
2388 #ifdef HAVE_LINUX_REGSETS
2389 if (regsets_store_inferior_registers () == 0)
2390 return;
2391 #endif
2392 #ifdef HAVE_LINUX_USRREGS
2393 usr_store_inferior_registers (regno);
2394 #endif
2395 }
2396
2397
2398 /* Copy LEN bytes from inferior's memory starting at MEMADDR
2399 to debugger memory starting at MYADDR. */
2400
2401 static int
2402 linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
2403 {
2404 register int i;
2405 /* Round starting address down to longword boundary. */
2406 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
2407 /* Round ending address up; get number of longwords that makes. */
2408 register int count
2409 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
2410 / sizeof (PTRACE_XFER_TYPE);
2411 /* Allocate buffer of that many longwords. */
2412 register PTRACE_XFER_TYPE *buffer
2413 = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
2414 int fd;
2415 char filename[64];
2416 int pid = lwpid_of (get_thread_lwp (current_inferior));
2417
2418 /* Try using /proc. Don't bother for one word. */
2419 if (len >= 3 * sizeof (long))
2420 {
2421 /* We could keep this file open and cache it - possibly one per
2422 thread. That requires some juggling, but is even faster. */
2423 sprintf (filename, "/proc/%d/mem", pid);
2424 fd = open (filename, O_RDONLY | O_LARGEFILE);
2425 if (fd == -1)
2426 goto no_proc;
2427
2428 /* If pread64 is available, use it. It's faster if the kernel
2429 supports it (only one syscall), and it's 64-bit safe even on
2430 32-bit platforms (for instance, SPARC debugging a SPARC64
2431 application). */
2432 #ifdef HAVE_PREAD64
2433 if (pread64 (fd, myaddr, len, memaddr) != len)
2434 #else
2435 if (lseek (fd, memaddr, SEEK_SET) == -1 || read (fd, myaddr, len) != len)
2436 #endif
2437 {
2438 close (fd);
2439 goto no_proc;
2440 }
2441
2442 close (fd);
2443 return 0;
2444 }
2445
2446 no_proc:
2447 /* Read all the longwords */
2448 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
2449 {
2450 errno = 0;
2451 buffer[i] = ptrace (PTRACE_PEEKTEXT, pid, (PTRACE_ARG3_TYPE) addr, 0);
2452 if (errno)
2453 return errno;
2454 }
2455
2456 /* Copy appropriate bytes out of the buffer. */
2457 memcpy (myaddr,
2458 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
2459 len);
2460
2461 return 0;
2462 }
2463
2464 /* Copy LEN bytes of data from debugger memory at MYADDR
2465 to inferior's memory at MEMADDR.
2466 On failure (cannot write the inferior)
2467 returns the value of errno. */
2468
2469 static int
2470 linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
2471 {
2472 register int i;
2473 /* Round starting address down to longword boundary. */
2474 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
2475 /* Round ending address up; get number of longwords that makes. */
2476 register int count
2477 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) / sizeof (PTRACE_XFER_TYPE);
2478 /* Allocate buffer of that many longwords. */
2479 register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
2480 int pid = lwpid_of (get_thread_lwp (current_inferior));
2481
2482 if (debug_threads)
2483 {
2484 /* Dump up to four bytes. */
2485 unsigned int val = * (unsigned int *) myaddr;
2486 if (len == 1)
2487 val = val & 0xff;
2488 else if (len == 2)
2489 val = val & 0xffff;
2490 else if (len == 3)
2491 val = val & 0xffffff;
2492 fprintf (stderr, "Writing %0*x to 0x%08lx\n", 2 * ((len < 4) ? len : 4),
2493 val, (long)memaddr);
2494 }
2495
2496 /* Fill start and end extra bytes of buffer with existing memory data. */
2497
2498 buffer[0] = ptrace (PTRACE_PEEKTEXT, pid, (PTRACE_ARG3_TYPE) addr, 0);
2499
2500 if (count > 1)
2501 {
2502 buffer[count - 1]
2503 = ptrace (PTRACE_PEEKTEXT, pid,
2504 (PTRACE_ARG3_TYPE) (addr + (count - 1)
2505 * sizeof (PTRACE_XFER_TYPE)),
2506 0);
2507 }
2508
2509 /* Copy data to be written over corresponding part of buffer */
2510
2511 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), myaddr, len);
2512
2513 /* Write the entire buffer. */
2514
2515 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
2516 {
2517 errno = 0;
2518 ptrace (PTRACE_POKETEXT, pid, (PTRACE_ARG3_TYPE) addr, buffer[i]);
2519 if (errno)
2520 return errno;
2521 }
2522
2523 return 0;
2524 }
2525
2526 static int linux_supports_tracefork_flag;
2527
2528 /* Helper functions for linux_test_for_tracefork, called via clone (). */
2529
2530 static int
2531 linux_tracefork_grandchild (void *arg)
2532 {
2533 _exit (0);
2534 }
2535
2536 #define STACK_SIZE 4096
2537
2538 static int
2539 linux_tracefork_child (void *arg)
2540 {
2541 ptrace (PTRACE_TRACEME, 0, 0, 0);
2542 kill (getpid (), SIGSTOP);
2543 #ifdef __ia64__
2544 __clone2 (linux_tracefork_grandchild, arg, STACK_SIZE,
2545 CLONE_VM | SIGCHLD, NULL);
2546 #else
2547 clone (linux_tracefork_grandchild, arg + STACK_SIZE,
2548 CLONE_VM | SIGCHLD, NULL);
2549 #endif
2550 _exit (0);
2551 }
2552
2553 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
2554 sure that we can enable the option, and that it had the desired
2555 effect. */
2556
2557 static void
2558 linux_test_for_tracefork (void)
2559 {
2560 int child_pid, ret, status;
2561 long second_pid;
2562 char *stack = xmalloc (STACK_SIZE * 4);
2563
2564 linux_supports_tracefork_flag = 0;
2565
2566 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
2567 #ifdef __ia64__
2568 child_pid = __clone2 (linux_tracefork_child, stack, STACK_SIZE,
2569 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
2570 #else
2571 child_pid = clone (linux_tracefork_child, stack + STACK_SIZE,
2572 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
2573 #endif
2574 if (child_pid == -1)
2575 perror_with_name ("clone");
2576
2577 ret = my_waitpid (child_pid, &status, 0);
2578 if (ret == -1)
2579 perror_with_name ("waitpid");
2580 else if (ret != child_pid)
2581 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
2582 if (! WIFSTOPPED (status))
2583 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
2584
2585 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
2586 if (ret != 0)
2587 {
2588 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
2589 if (ret != 0)
2590 {
2591 warning ("linux_test_for_tracefork: failed to kill child");
2592 return;
2593 }
2594
2595 ret = my_waitpid (child_pid, &status, 0);
2596 if (ret != child_pid)
2597 warning ("linux_test_for_tracefork: failed to wait for killed child");
2598 else if (!WIFSIGNALED (status))
2599 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
2600 "killed child", status);
2601
2602 return;
2603 }
2604
2605 ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
2606 if (ret != 0)
2607 warning ("linux_test_for_tracefork: failed to resume child");
2608
2609 ret = my_waitpid (child_pid, &status, 0);
2610
2611 if (ret == child_pid && WIFSTOPPED (status)
2612 && status >> 16 == PTRACE_EVENT_FORK)
2613 {
2614 second_pid = 0;
2615 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
2616 if (ret == 0 && second_pid != 0)
2617 {
2618 int second_status;
2619
2620 linux_supports_tracefork_flag = 1;
2621 my_waitpid (second_pid, &second_status, 0);
2622 ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
2623 if (ret != 0)
2624 warning ("linux_test_for_tracefork: failed to kill second child");
2625 my_waitpid (second_pid, &status, 0);
2626 }
2627 }
2628 else
2629 warning ("linux_test_for_tracefork: unexpected result from waitpid "
2630 "(%d, status 0x%x)", ret, status);
2631
2632 do
2633 {
2634 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
2635 if (ret != 0)
2636 warning ("linux_test_for_tracefork: failed to kill child");
2637 my_waitpid (child_pid, &status, 0);
2638 }
2639 while (WIFSTOPPED (status));
2640
2641 free (stack);
2642 }
2643
2644
2645 static void
2646 linux_look_up_symbols (void)
2647 {
2648 #ifdef USE_THREAD_DB
2649 struct process_info *proc = current_process ();
2650
2651 if (proc->private->thread_db != NULL)
2652 return;
2653
2654 thread_db_init (!linux_supports_tracefork_flag);
2655 #endif
2656 }
2657
2658 static void
2659 linux_request_interrupt (void)
2660 {
2661 extern unsigned long signal_pid;
2662
2663 if (!ptid_equal (cont_thread, null_ptid)
2664 && !ptid_equal (cont_thread, minus_one_ptid))
2665 {
2666 struct lwp_info *lwp;
2667 int lwpid;
2668
2669 lwp = get_thread_lwp (current_inferior);
2670 lwpid = lwpid_of (lwp);
2671 kill_lwp (lwpid, SIGINT);
2672 }
2673 else
2674 kill_lwp (signal_pid, SIGINT);
2675 }
2676
2677 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
2678 to debugger memory starting at MYADDR. */
2679
2680 static int
2681 linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len)
2682 {
2683 char filename[PATH_MAX];
2684 int fd, n;
2685 int pid = lwpid_of (get_thread_lwp (current_inferior));
2686
2687 snprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
2688
2689 fd = open (filename, O_RDONLY);
2690 if (fd < 0)
2691 return -1;
2692
2693 if (offset != (CORE_ADDR) 0
2694 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
2695 n = -1;
2696 else
2697 n = read (fd, myaddr, len);
2698
2699 close (fd);
2700
2701 return n;
2702 }
2703
2704 /* These breakpoint and watchpoint related wrapper functions simply
2705 pass on the function call if the target has registered a
2706 corresponding function. */
2707
2708 static int
2709 linux_insert_point (char type, CORE_ADDR addr, int len)
2710 {
2711 if (the_low_target.insert_point != NULL)
2712 return the_low_target.insert_point (type, addr, len);
2713 else
2714 /* Unsupported (see target.h). */
2715 return 1;
2716 }
2717
2718 static int
2719 linux_remove_point (char type, CORE_ADDR addr, int len)
2720 {
2721 if (the_low_target.remove_point != NULL)
2722 return the_low_target.remove_point (type, addr, len);
2723 else
2724 /* Unsupported (see target.h). */
2725 return 1;
2726 }
2727
2728 static int
2729 linux_stopped_by_watchpoint (void)
2730 {
2731 if (the_low_target.stopped_by_watchpoint != NULL)
2732 return the_low_target.stopped_by_watchpoint ();
2733 else
2734 return 0;
2735 }
2736
2737 static CORE_ADDR
2738 linux_stopped_data_address (void)
2739 {
2740 if (the_low_target.stopped_data_address != NULL)
2741 return the_low_target.stopped_data_address ();
2742 else
2743 return 0;
2744 }
2745
2746 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
2747 #if defined(__mcoldfire__)
2748 /* These should really be defined in the kernel's ptrace.h header. */
2749 #define PT_TEXT_ADDR 49*4
2750 #define PT_DATA_ADDR 50*4
2751 #define PT_TEXT_END_ADDR 51*4
2752 #endif
2753
2754 /* Under uClinux, programs are loaded at non-zero offsets, which we need
2755 to tell gdb about. */
2756
2757 static int
2758 linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
2759 {
2760 #if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
2761 unsigned long text, text_end, data;
2762 int pid = lwpid_of (get_thread_lwp (current_inferior));
2763
2764 errno = 0;
2765
2766 text = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_ADDR, 0);
2767 text_end = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_END_ADDR, 0);
2768 data = ptrace (PTRACE_PEEKUSER, pid, (long)PT_DATA_ADDR, 0);
2769
2770 if (errno == 0)
2771 {
2772 /* Both text and data offsets produced at compile-time (and so
2773 used by gdb) are relative to the beginning of the program,
2774 with the data segment immediately following the text segment.
2775 However, the actual runtime layout in memory may put the data
2776 somewhere else, so when we send gdb a data base-address, we
2777 use the real data base address and subtract the compile-time
2778 data base-address from it (which is just the length of the
2779 text segment). BSS immediately follows data in both
2780 cases. */
2781 *text_p = text;
2782 *data_p = data - (text_end - text);
2783
2784 return 1;
2785 }
2786 #endif
2787 return 0;
2788 }
2789 #endif
2790
2791 static int
2792 linux_qxfer_osdata (const char *annex,
2793 unsigned char *readbuf, unsigned const char *writebuf,
2794 CORE_ADDR offset, int len)
2795 {
2796 /* We make the process list snapshot when the object starts to be
2797 read. */
2798 static const char *buf;
2799 static long len_avail = -1;
2800 static struct buffer buffer;
2801
2802 DIR *dirp;
2803
2804 if (strcmp (annex, "processes") != 0)
2805 return 0;
2806
2807 if (!readbuf || writebuf)
2808 return 0;
2809
2810 if (offset == 0)
2811 {
2812 if (len_avail != -1 && len_avail != 0)
2813 buffer_free (&buffer);
2814 len_avail = 0;
2815 buf = NULL;
2816 buffer_init (&buffer);
2817 buffer_grow_str (&buffer, "<osdata type=\"processes\">");
2818
2819 dirp = opendir ("/proc");
2820 if (dirp)
2821 {
2822 struct dirent *dp;
2823 while ((dp = readdir (dirp)) != NULL)
2824 {
2825 struct stat statbuf;
2826 char procentry[sizeof ("/proc/4294967295")];
2827
2828 if (!isdigit (dp->d_name[0])
2829 || strlen (dp->d_name) > sizeof ("4294967295") - 1)
2830 continue;
2831
2832 sprintf (procentry, "/proc/%s", dp->d_name);
2833 if (stat (procentry, &statbuf) == 0
2834 && S_ISDIR (statbuf.st_mode))
2835 {
2836 char pathname[128];
2837 FILE *f;
2838 char cmd[MAXPATHLEN + 1];
2839 struct passwd *entry;
2840
2841 sprintf (pathname, "/proc/%s/cmdline", dp->d_name);
2842 entry = getpwuid (statbuf.st_uid);
2843
2844 if ((f = fopen (pathname, "r")) != NULL)
2845 {
2846 size_t len = fread (cmd, 1, sizeof (cmd) - 1, f);
2847 if (len > 0)
2848 {
2849 int i;
2850 for (i = 0; i < len; i++)
2851 if (cmd[i] == '\0')
2852 cmd[i] = ' ';
2853 cmd[len] = '\0';
2854
2855 buffer_xml_printf (
2856 &buffer,
2857 "<item>"
2858 "<column name=\"pid\">%s</column>"
2859 "<column name=\"user\">%s</column>"
2860 "<column name=\"command\">%s</column>"
2861 "</item>",
2862 dp->d_name,
2863 entry ? entry->pw_name : "?",
2864 cmd);
2865 }
2866 fclose (f);
2867 }
2868 }
2869 }
2870
2871 closedir (dirp);
2872 }
2873 buffer_grow_str0 (&buffer, "</osdata>\n");
2874 buf = buffer_finish (&buffer);
2875 len_avail = strlen (buf);
2876 }
2877
2878 if (offset >= len_avail)
2879 {
2880 /* Done. Get rid of the data. */
2881 buffer_free (&buffer);
2882 buf = NULL;
2883 len_avail = 0;
2884 return 0;
2885 }
2886
2887 if (len > len_avail - offset)
2888 len = len_avail - offset;
2889 memcpy (readbuf, buf + offset, len);
2890
2891 return len;
2892 }
2893
2894 /* Convert a native/host siginfo object, into/from the siginfo in the
2895 layout of the inferiors' architecture. */
2896
2897 static void
2898 siginfo_fixup (struct siginfo *siginfo, void *inf_siginfo, int direction)
2899 {
2900 int done = 0;
2901
2902 if (the_low_target.siginfo_fixup != NULL)
2903 done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
2904
2905 /* If there was no callback, or the callback didn't do anything,
2906 then just do a straight memcpy. */
2907 if (!done)
2908 {
2909 if (direction == 1)
2910 memcpy (siginfo, inf_siginfo, sizeof (struct siginfo));
2911 else
2912 memcpy (inf_siginfo, siginfo, sizeof (struct siginfo));
2913 }
2914 }
2915
2916 static int
2917 linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
2918 unsigned const char *writebuf, CORE_ADDR offset, int len)
2919 {
2920 int pid;
2921 struct siginfo siginfo;
2922 char inf_siginfo[sizeof (struct siginfo)];
2923
2924 if (current_inferior == NULL)
2925 return -1;
2926
2927 pid = lwpid_of (get_thread_lwp (current_inferior));
2928
2929 if (debug_threads)
2930 fprintf (stderr, "%s siginfo for lwp %d.\n",
2931 readbuf != NULL ? "Reading" : "Writing",
2932 pid);
2933
2934 if (offset > sizeof (siginfo))
2935 return -1;
2936
2937 if (ptrace (PTRACE_GETSIGINFO, pid, 0, &siginfo) != 0)
2938 return -1;
2939
2940 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
2941 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
2942 inferior with a 64-bit GDBSERVER should look the same as debugging it
2943 with a 32-bit GDBSERVER, we need to convert it. */
2944 siginfo_fixup (&siginfo, inf_siginfo, 0);
2945
2946 if (offset + len > sizeof (siginfo))
2947 len = sizeof (siginfo) - offset;
2948
2949 if (readbuf != NULL)
2950 memcpy (readbuf, inf_siginfo + offset, len);
2951 else
2952 {
2953 memcpy (inf_siginfo + offset, writebuf, len);
2954
2955 /* Convert back to ptrace layout before flushing it out. */
2956 siginfo_fixup (&siginfo, inf_siginfo, 1);
2957
2958 if (ptrace (PTRACE_SETSIGINFO, pid, 0, &siginfo) != 0)
2959 return -1;
2960 }
2961
2962 return len;
2963 }
2964
2965 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
2966 so we notice when children change state; as the handler for the
2967 sigsuspend in my_waitpid. */
2968
2969 static void
2970 sigchld_handler (int signo)
2971 {
2972 int old_errno = errno;
2973
2974 if (debug_threads)
2975 /* fprintf is not async-signal-safe, so call write directly. */
2976 write (2, "sigchld_handler\n", sizeof ("sigchld_handler\n") - 1);
2977
2978 if (target_is_async_p ())
2979 async_file_mark (); /* trigger a linux_wait */
2980
2981 errno = old_errno;
2982 }
2983
2984 static int
2985 linux_supports_non_stop (void)
2986 {
2987 return 1;
2988 }
2989
2990 static int
2991 linux_async (int enable)
2992 {
2993 int previous = (linux_event_pipe[0] != -1);
2994
2995 if (previous != enable)
2996 {
2997 sigset_t mask;
2998 sigemptyset (&mask);
2999 sigaddset (&mask, SIGCHLD);
3000
3001 sigprocmask (SIG_BLOCK, &mask, NULL);
3002
3003 if (enable)
3004 {
3005 if (pipe (linux_event_pipe) == -1)
3006 fatal ("creating event pipe failed.");
3007
3008 fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
3009 fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
3010
3011 /* Register the event loop handler. */
3012 add_file_handler (linux_event_pipe[0],
3013 handle_target_event, NULL);
3014
3015 /* Always trigger a linux_wait. */
3016 async_file_mark ();
3017 }
3018 else
3019 {
3020 delete_file_handler (linux_event_pipe[0]);
3021
3022 close (linux_event_pipe[0]);
3023 close (linux_event_pipe[1]);
3024 linux_event_pipe[0] = -1;
3025 linux_event_pipe[1] = -1;
3026 }
3027
3028 sigprocmask (SIG_UNBLOCK, &mask, NULL);
3029 }
3030
3031 return previous;
3032 }
3033
3034 static int
3035 linux_start_non_stop (int nonstop)
3036 {
3037 /* Register or unregister from event-loop accordingly. */
3038 linux_async (nonstop);
3039 return 0;
3040 }
3041
3042 static int
3043 linux_supports_multi_process (void)
3044 {
3045 return 1;
3046 }
3047
3048
3049 /* Enumerate spufs IDs for process PID. */
3050 static int
3051 spu_enumerate_spu_ids (long pid, unsigned char *buf, CORE_ADDR offset, int len)
3052 {
3053 int pos = 0;
3054 int written = 0;
3055 char path[128];
3056 DIR *dir;
3057 struct dirent *entry;
3058
3059 sprintf (path, "/proc/%ld/fd", pid);
3060 dir = opendir (path);
3061 if (!dir)
3062 return -1;
3063
3064 rewinddir (dir);
3065 while ((entry = readdir (dir)) != NULL)
3066 {
3067 struct stat st;
3068 struct statfs stfs;
3069 int fd;
3070
3071 fd = atoi (entry->d_name);
3072 if (!fd)
3073 continue;
3074
3075 sprintf (path, "/proc/%ld/fd/%d", pid, fd);
3076 if (stat (path, &st) != 0)
3077 continue;
3078 if (!S_ISDIR (st.st_mode))
3079 continue;
3080
3081 if (statfs (path, &stfs) != 0)
3082 continue;
3083 if (stfs.f_type != SPUFS_MAGIC)
3084 continue;
3085
3086 if (pos >= offset && pos + 4 <= offset + len)
3087 {
3088 *(unsigned int *)(buf + pos - offset) = fd;
3089 written += 4;
3090 }
3091 pos += 4;
3092 }
3093
3094 closedir (dir);
3095 return written;
3096 }
3097
3098 /* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
3099 object type, using the /proc file system. */
3100 static int
3101 linux_qxfer_spu (const char *annex, unsigned char *readbuf,
3102 unsigned const char *writebuf,
3103 CORE_ADDR offset, int len)
3104 {
3105 long pid = lwpid_of (get_thread_lwp (current_inferior));
3106 char buf[128];
3107 int fd = 0;
3108 int ret = 0;
3109
3110 if (!writebuf && !readbuf)
3111 return -1;
3112
3113 if (!*annex)
3114 {
3115 if (!readbuf)
3116 return -1;
3117 else
3118 return spu_enumerate_spu_ids (pid, readbuf, offset, len);
3119 }
3120
3121 sprintf (buf, "/proc/%ld/fd/%s", pid, annex);
3122 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
3123 if (fd <= 0)
3124 return -1;
3125
3126 if (offset != 0
3127 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
3128 {
3129 close (fd);
3130 return 0;
3131 }
3132
3133 if (writebuf)
3134 ret = write (fd, writebuf, (size_t) len);
3135 else
3136 ret = read (fd, readbuf, (size_t) len);
3137
3138 close (fd);
3139 return ret;
3140 }
3141
3142 static struct target_ops linux_target_ops = {
3143 linux_create_inferior,
3144 linux_attach,
3145 linux_kill,
3146 linux_detach,
3147 linux_join,
3148 linux_thread_alive,
3149 linux_resume,
3150 linux_wait,
3151 linux_fetch_registers,
3152 linux_store_registers,
3153 linux_read_memory,
3154 linux_write_memory,
3155 linux_look_up_symbols,
3156 linux_request_interrupt,
3157 linux_read_auxv,
3158 linux_insert_point,
3159 linux_remove_point,
3160 linux_stopped_by_watchpoint,
3161 linux_stopped_data_address,
3162 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
3163 linux_read_offsets,
3164 #else
3165 NULL,
3166 #endif
3167 #ifdef USE_THREAD_DB
3168 thread_db_get_tls_address,
3169 #else
3170 NULL,
3171 #endif
3172 linux_qxfer_spu,
3173 hostio_last_error_from_errno,
3174 linux_qxfer_osdata,
3175 linux_xfer_siginfo,
3176 linux_supports_non_stop,
3177 linux_async,
3178 linux_start_non_stop,
3179 linux_supports_multi_process,
3180 #ifdef USE_THREAD_DB
3181 thread_db_handle_monitor_command
3182 #else
3183 NULL
3184 #endif
3185 };
3186
3187 static void
3188 linux_init_signals ()
3189 {
3190 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
3191 to find what the cancel signal actually is. */
3192 signal (__SIGRTMIN+1, SIG_IGN);
3193 }
3194
3195 void
3196 initialize_low (void)
3197 {
3198 struct sigaction sigchld_action;
3199 memset (&sigchld_action, 0, sizeof (sigchld_action));
3200 set_target_ops (&linux_target_ops);
3201 set_breakpoint_data (the_low_target.breakpoint,
3202 the_low_target.breakpoint_len);
3203 linux_init_signals ();
3204 linux_test_for_tracefork ();
3205 #ifdef HAVE_LINUX_REGSETS
3206 for (num_regsets = 0; target_regsets[num_regsets].size >= 0; num_regsets++)
3207 ;
3208 disabled_regsets = xmalloc (num_regsets);
3209 #endif
3210
3211 sigchld_action.sa_handler = sigchld_handler;
3212 sigemptyset (&sigchld_action.sa_mask);
3213 sigchld_action.sa_flags = SA_RESTART;
3214 sigaction (SIGCHLD, &sigchld_action, NULL);
3215 }
This page took 0.097325 seconds and 4 git commands to generate.