Deleted Added
sdiff udiff text old ( 157572 ) new ( 157574 )
full compact
fbsd-low.c (157572) fbsd-low.c (157574)
1/* Low level interface to ptrace, for the remote server for GDB.
2 Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 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

--- 5 unchanged lines hidden (view full) ---

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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
1/* Low level interface to ptrace, for the remote server for GDB.
2 Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 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

--- 5 unchanged lines hidden (view full) ---

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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22#include <sys/cdefs.h>
23__FBSDID("$FreeBSD: head/gnu/usr.bin/gdb/gdbserver/fbsd-low.c 157574 2006-04-06 22:24:01Z jmg $");
24
22#include "server.h"
25#include "server.h"
23#include "linux-low.h"
26#include "fbsd-low.h"
24
25#include <sys/wait.h>
27
28#include <sys/wait.h>
26#include <stdio.h>
27#include <sys/param.h>
29#include <sys/param.h>
28#include <sys/dir.h>
29#include <sys/ptrace.h>
30#include <sys/user.h>
30#include <sys/ptrace.h>
31#include <sys/user.h>
31#include <signal.h>
32#include <sys/ioctl.h>
32#include <sys/ioctl.h>
33#include <dirent.h>
34#include <errno.h>
33#include <fcntl.h>
35#include <fcntl.h>
34#include <string.h>
36#include <signal.h>
37#include <stdio.h>
35#include <stdlib.h>
38#include <stdlib.h>
39#include <string.h>
36#include <unistd.h>
40#include <unistd.h>
37#include <errno.h>
38
39/* ``all_threads'' is keyed by the LWP ID - it should be the thread ID instead,
40 however. This requires changing the ID in place when we go from !using_threads
41 to using_threads, immediately.
42
43 ``all_processes'' is keyed by the process ID - which on Linux is (presently)
44 the same as the LWP ID. */
45
46struct inferior_list all_processes;
47
48/* FIXME this is a bit of a hack, and could be removed. */
49int stopping_threads;
50
51/* FIXME make into a target method? */
52int using_threads;
53
41
42/* ``all_threads'' is keyed by the LWP ID - it should be the thread ID instead,
43 however. This requires changing the ID in place when we go from !using_threads
44 to using_threads, immediately.
45
46 ``all_processes'' is keyed by the process ID - which on Linux is (presently)
47 the same as the LWP ID. */
48
49struct inferior_list all_processes;
50
51/* FIXME this is a bit of a hack, and could be removed. */
52int stopping_threads;
53
54/* FIXME make into a target method? */
55int using_threads;
56
54static void linux_resume_one_process (struct inferior_list_entry *entry,
57static void fbsd_resume_one_process (struct inferior_list_entry *entry,
55 int step, int signal);
58 int step, int signal);
56static void linux_resume (struct thread_resume *resume_info);
59static void fbsd_resume (struct thread_resume *resume_info);
57static void stop_all_processes (void);
60static void stop_all_processes (void);
58static int linux_wait_for_event (struct thread_info *child);
61static int fbsd_wait_for_event (struct thread_info *child);
59
60struct pending_signals
61{
62 int signal;
63 struct pending_signals *prev;
64};
65
62
63struct pending_signals
64{
65 int signal;
66 struct pending_signals *prev;
67};
68
66#define PTRACE_ARG3_TYPE long
67#define PTRACE_XFER_TYPE long
69#define PTRACE_ARG3_TYPE caddr_t
70#define PTRACE_XFER_TYPE int
68
71
69#ifdef HAVE_LINUX_REGSETS
70static int use_regsets_p = 1;
71#endif
72
73int debug_threads = 0;
74
75#define pid_of(proc) ((proc)->head.id)
76
77/* FIXME: Delete eventually. */
78#define inferior_pid (pid_of (get_thread_process (current_inferior)))
79
80/* This function should only be called if the process got a SIGTRAP.
81 The SIGTRAP could mean several things.
82
83 On i386, where decr_pc_after_break is non-zero:
72int debug_threads = 0;
73
74#define pid_of(proc) ((proc)->head.id)
75
76/* FIXME: Delete eventually. */
77#define inferior_pid (pid_of (get_thread_process (current_inferior)))
78
79/* This function should only be called if the process got a SIGTRAP.
80 The SIGTRAP could mean several things.
81
82 On i386, where decr_pc_after_break is non-zero:
84 If we were single-stepping this process using PTRACE_SINGLESTEP,
83 If we were single-stepping this process using PT_STEP,
85 we will get only the one SIGTRAP (even if the instruction we
86 stepped over was a breakpoint). The value of $eip will be the
87 next instruction.
88 If we continue the process using PTRACE_CONT, we will get a
89 SIGTRAP when we hit a breakpoint. The value of $eip will be
90 the instruction after the breakpoint (i.e. needs to be
91 decremented). If we report the SIGTRAP to GDB, we must also
92 report the undecremented PC. If we cancel the SIGTRAP, we

--- 35 unchanged lines hidden (view full) ---

128
129 return process;
130}
131
132/* Start an inferior process and returns its pid.
133 ALLARGS is a vector of program-name and args. */
134
135static int
84 we will get only the one SIGTRAP (even if the instruction we
85 stepped over was a breakpoint). The value of $eip will be the
86 next instruction.
87 If we continue the process using PTRACE_CONT, we will get a
88 SIGTRAP when we hit a breakpoint. The value of $eip will be
89 the instruction after the breakpoint (i.e. needs to be
90 decremented). If we report the SIGTRAP to GDB, we must also
91 report the undecremented PC. If we cancel the SIGTRAP, we

--- 35 unchanged lines hidden (view full) ---

127
128 return process;
129}
130
131/* Start an inferior process and returns its pid.
132 ALLARGS is a vector of program-name and args. */
133
134static int
136linux_create_inferior (char *program, char **allargs)
135fbsd_create_inferior (char *program, char **allargs)
137{
138 void *new_process;
139 int pid;
140
136{
137 void *new_process;
138 int pid;
139
141 pid = fork ();
140 pid = vfork ();
142 if (pid < 0)
141 if (pid < 0)
143 perror_with_name ("fork");
142 perror_with_name ("vfork");
144
145 if (pid == 0)
146 {
143
144 if (pid == 0)
145 {
147 ptrace (PTRACE_TRACEME, 0, 0, 0);
146 ptrace (PT_TRACE_ME, 0, 0, 0);
148
147
149 signal (__SIGRTMIN + 1, SIG_DFL);
150
151 setpgid (0, 0);
152
153 execv (program, allargs);
154
155 fprintf (stderr, "Cannot exec %s: %s.\n", program,
156 strerror (errno));
157 fflush (stderr);
158 _exit (0177);
159 }
160
161 new_process = add_process (pid);
162 add_thread (pid, new_process);
163
164 return pid;
165}
166
167/* Attach to an inferior process. */
168
169void
148 setpgid (0, 0);
149
150 execv (program, allargs);
151
152 fprintf (stderr, "Cannot exec %s: %s.\n", program,
153 strerror (errno));
154 fflush (stderr);
155 _exit (0177);
156 }
157
158 new_process = add_process (pid);
159 add_thread (pid, new_process);
160
161 return pid;
162}
163
164/* Attach to an inferior process. */
165
166void
170linux_attach_lwp (int pid, int tid)
167fbsd_attach_lwp (int pid, int tid)
171{
172 struct process_info *new_process;
173
168{
169 struct process_info *new_process;
170
174 if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
171 if (ptrace (PT_ATTACH, pid, 0, 0) != 0)
175 {
176 fprintf (stderr, "Cannot attach to process %d: %s (%d)\n", pid,
177 strerror (errno), errno);
178 fflush (stderr);
179
180 /* If we fail to attach to an LWP, just return. */
181 if (!using_threads)
182 _exit (0177);
183 return;
184 }
185
186 new_process = (struct process_info *) add_process (pid);
187 add_thread (tid, new_process);
188
189 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
190 brings it to a halt. We should ignore that SIGSTOP and resume the process
191 (unless this is the first process, in which case the flag will be cleared
172 {
173 fprintf (stderr, "Cannot attach to process %d: %s (%d)\n", pid,
174 strerror (errno), errno);
175 fflush (stderr);
176
177 /* If we fail to attach to an LWP, just return. */
178 if (!using_threads)
179 _exit (0177);
180 return;
181 }
182
183 new_process = (struct process_info *) add_process (pid);
184 add_thread (tid, new_process);
185
186 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
187 brings it to a halt. We should ignore that SIGSTOP and resume the process
188 (unless this is the first process, in which case the flag will be cleared
192 in linux_attach).
189 in fbsd_attach).
193
194 On the other hand, if we are currently trying to stop all threads, we
195 should treat the new thread as if we had sent it a SIGSTOP. This works
196 because we are guaranteed that add_process added us to the end of the
197 list, and so the new thread has not yet reached wait_for_sigstop (but
198 will). */
199 if (! stopping_threads)
200 new_process->stop_expected = 1;
201}
202
203int
190
191 On the other hand, if we are currently trying to stop all threads, we
192 should treat the new thread as if we had sent it a SIGSTOP. This works
193 because we are guaranteed that add_process added us to the end of the
194 list, and so the new thread has not yet reached wait_for_sigstop (but
195 will). */
196 if (! stopping_threads)
197 new_process->stop_expected = 1;
198}
199
200int
204linux_attach (int pid)
201fbsd_attach (int pid)
205{
206 struct process_info *process;
207
202{
203 struct process_info *process;
204
208 linux_attach_lwp (pid, pid);
205 fbsd_attach_lwp (pid, pid);
209
210 /* Don't ignore the initial SIGSTOP if we just attached to this process. */
211 process = (struct process_info *) find_inferior_id (&all_processes, pid);
212 process->stop_expected = 0;
213
214 return 0;
215}
216
217/* Kill the inferior process. Make us have no inferior. */
218
219static void
206
207 /* Don't ignore the initial SIGSTOP if we just attached to this process. */
208 process = (struct process_info *) find_inferior_id (&all_processes, pid);
209 process->stop_expected = 0;
210
211 return 0;
212}
213
214/* Kill the inferior process. Make us have no inferior. */
215
216static void
220linux_kill_one_process (struct inferior_list_entry *entry)
217fbsd_kill_one_process (struct inferior_list_entry *entry)
221{
222 struct thread_info *thread = (struct thread_info *) entry;
223 struct process_info *process = get_thread_process (thread);
224 int wstat;
225
226 do
227 {
218{
219 struct thread_info *thread = (struct thread_info *) entry;
220 struct process_info *process = get_thread_process (thread);
221 int wstat;
222
223 do
224 {
228 ptrace (PTRACE_KILL, pid_of (process), 0, 0);
225 ptrace (PT_KILL, pid_of (process), 0, 0);
229
230 /* Make sure it died. The loop is most likely unnecessary. */
226
227 /* Make sure it died. The loop is most likely unnecessary. */
231 wstat = linux_wait_for_event (thread);
228 wstat = fbsd_wait_for_event (thread);
232 } while (WIFSTOPPED (wstat));
233}
234
235static void
229 } while (WIFSTOPPED (wstat));
230}
231
232static void
236linux_kill (void)
233fbsd_kill (void)
237{
234{
238 for_each_inferior (&all_threads, linux_kill_one_process);
235 for_each_inferior (&all_threads, fbsd_kill_one_process);
239}
240
241static void
236}
237
238static void
242linux_detach_one_process (struct inferior_list_entry *entry)
239fbsd_detach_one_process (struct inferior_list_entry *entry)
243{
244 struct thread_info *thread = (struct thread_info *) entry;
245 struct process_info *process = get_thread_process (thread);
246
240{
241 struct thread_info *thread = (struct thread_info *) entry;
242 struct process_info *process = get_thread_process (thread);
243
247 ptrace (PTRACE_DETACH, pid_of (process), 0, 0);
244 ptrace (PT_DETACH, pid_of (process), 0, 0);
248}
249
250static void
245}
246
247static void
251linux_detach (void)
248fbsd_detach (void)
252{
249{
253 for_each_inferior (&all_threads, linux_detach_one_process);
250 for_each_inferior (&all_threads, fbsd_detach_one_process);
254}
255
256/* Return nonzero if the given thread is still alive. */
257static int
251}
252
253/* Return nonzero if the given thread is still alive. */
254static int
258linux_thread_alive (int tid)
255fbsd_thread_alive (int tid)
259{
260 if (find_inferior_id (&all_threads, tid) != NULL)
261 return 1;
262 else
263 return 0;
264}
265
266/* Return nonzero if this process stopped at a breakpoint which

--- 67 unchanged lines hidden (view full) ---

334 if (check_removed_breakpoint (process))
335 {
336 /* This thread was stopped at a breakpoint, and the breakpoint
337 is now gone. We were told to continue (or step...) all threads,
338 so GDB isn't trying to single-step past this breakpoint.
339 So instead of reporting the old SIGTRAP, pretend we got to
340 the breakpoint just after it was removed instead of just
341 before; resume the process. */
256{
257 if (find_inferior_id (&all_threads, tid) != NULL)
258 return 1;
259 else
260 return 0;
261}
262
263/* Return nonzero if this process stopped at a breakpoint which

--- 67 unchanged lines hidden (view full) ---

331 if (check_removed_breakpoint (process))
332 {
333 /* This thread was stopped at a breakpoint, and the breakpoint
334 is now gone. We were told to continue (or step...) all threads,
335 so GDB isn't trying to single-step past this breakpoint.
336 So instead of reporting the old SIGTRAP, pretend we got to
337 the breakpoint just after it was removed instead of just
338 before; resume the process. */
342 linux_resume_one_process (&process->head, 0, 0);
339 fbsd_resume_one_process (&process->head, 0, 0);
343 return 0;
344 }
345
346 return process->status_pending_p;
347}
348
349static void
340 return 0;
341 }
342
343 return process->status_pending_p;
344}
345
346static void
350linux_wait_for_process (struct process_info **childp, int *wstatp)
347fbsd_wait_for_process (struct process_info **childp, int *wstatp)
351{
352 int ret;
353 int to_wait_for = -1;
354
355 if (*childp != NULL)
356 to_wait_for = (*childp)->lwpid;
357
358 while (1)
359 {
360 ret = waitpid (to_wait_for, wstatp, WNOHANG);
361
362 if (ret == -1)
363 {
364 if (errno != ECHILD)
365 perror_with_name ("waitpid");
366 }
367 else if (ret > 0)
368 break;
369
348{
349 int ret;
350 int to_wait_for = -1;
351
352 if (*childp != NULL)
353 to_wait_for = (*childp)->lwpid;
354
355 while (1)
356 {
357 ret = waitpid (to_wait_for, wstatp, WNOHANG);
358
359 if (ret == -1)
360 {
361 if (errno != ECHILD)
362 perror_with_name ("waitpid");
363 }
364 else if (ret > 0)
365 break;
366
370 ret = waitpid (to_wait_for, wstatp, WNOHANG | __WCLONE);
371
372 if (ret == -1)
373 {
374 if (errno != ECHILD)
375 perror_with_name ("waitpid (WCLONE)");
376 }
377 else if (ret > 0)
378 break;
379
380 usleep (1000);
381 }
382
383 if (debug_threads
384 && (!WIFSTOPPED (*wstatp)
385 || (WSTOPSIG (*wstatp) != 32
386 && WSTOPSIG (*wstatp) != 33)))
387 fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);

--- 11 unchanged lines hidden (view full) ---

399 find_inferior_id (&all_threads, (*childp)->tid);
400 /* For testing only; i386_stop_pc prints out a diagnostic. */
401 if (the_low_target.get_pc != NULL)
402 get_stop_pc ();
403 }
404}
405
406static int
367 usleep (1000);
368 }
369
370 if (debug_threads
371 && (!WIFSTOPPED (*wstatp)
372 || (WSTOPSIG (*wstatp) != 32
373 && WSTOPSIG (*wstatp) != 33)))
374 fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);

--- 11 unchanged lines hidden (view full) ---

386 find_inferior_id (&all_threads, (*childp)->tid);
387 /* For testing only; i386_stop_pc prints out a diagnostic. */
388 if (the_low_target.get_pc != NULL)
389 get_stop_pc ();
390 }
391}
392
393static int
407linux_wait_for_event (struct thread_info *child)
394fbsd_wait_for_event (struct thread_info *child)
408{
409 CORE_ADDR stop_pc;
410 struct process_info *event_child;
411 int wstat;
412
413 /* Check for a process with a pending status. */
414 /* It is possible that the user changed the pending task's registers since
415 it stopped. We correctly handle the change of PC if we hit a breakpoint

--- 34 unchanged lines hidden (view full) ---

450 events. */
451 while (1)
452 {
453 if (child == NULL)
454 event_child = NULL;
455 else
456 event_child = get_thread_process (child);
457
395{
396 CORE_ADDR stop_pc;
397 struct process_info *event_child;
398 int wstat;
399
400 /* Check for a process with a pending status. */
401 /* It is possible that the user changed the pending task's registers since
402 it stopped. We correctly handle the change of PC if we hit a breakpoint

--- 34 unchanged lines hidden (view full) ---

437 events. */
438 while (1)
439 {
440 if (child == NULL)
441 event_child = NULL;
442 else
443 event_child = get_thread_process (child);
444
458 linux_wait_for_process (&event_child, &wstat);
445 fbsd_wait_for_process (&event_child, &wstat);
459
460 if (event_child == NULL)
461 error ("event from unknown child");
462
463 current_inferior = (struct thread_info *)
464 find_inferior_id (&all_threads, event_child->tid);
465
466 if (using_threads)

--- 27 unchanged lines hidden (view full) ---

494
495 if (WIFSTOPPED (wstat)
496 && WSTOPSIG (wstat) == SIGSTOP
497 && event_child->stop_expected)
498 {
499 if (debug_threads)
500 fprintf (stderr, "Expected stop.\n");
501 event_child->stop_expected = 0;
446
447 if (event_child == NULL)
448 error ("event from unknown child");
449
450 current_inferior = (struct thread_info *)
451 find_inferior_id (&all_threads, event_child->tid);
452
453 if (using_threads)

--- 27 unchanged lines hidden (view full) ---

481
482 if (WIFSTOPPED (wstat)
483 && WSTOPSIG (wstat) == SIGSTOP
484 && event_child->stop_expected)
485 {
486 if (debug_threads)
487 fprintf (stderr, "Expected stop.\n");
488 event_child->stop_expected = 0;
502 linux_resume_one_process (&event_child->head,
489 fbsd_resume_one_process (&event_child->head,
503 event_child->stepping, 0);
504 continue;
505 }
506
507 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
508 thread library? */
490 event_child->stepping, 0);
491 continue;
492 }
493
494 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
495 thread library? */
509 if (WIFSTOPPED (wstat)
510 && (WSTOPSIG (wstat) == __SIGRTMIN
511 || WSTOPSIG (wstat) == __SIGRTMIN + 1))
496 if (WIFSTOPPED (wstat))
512 {
513 if (debug_threads)
514 fprintf (stderr, "Ignored signal %d for %d (LWP %d).\n",
515 WSTOPSIG (wstat), event_child->tid,
516 event_child->head.id);
497 {
498 if (debug_threads)
499 fprintf (stderr, "Ignored signal %d for %d (LWP %d).\n",
500 WSTOPSIG (wstat), event_child->tid,
501 event_child->head.id);
517 linux_resume_one_process (&event_child->head,
502 fbsd_resume_one_process (&event_child->head,
518 event_child->stepping,
519 WSTOPSIG (wstat));
520 continue;
521 }
522 }
523
524 /* If this event was not handled above, and is not a SIGTRAP, report
525 it. */

--- 14 unchanged lines hidden (view full) ---

540 if (event_child->bp_reinsert != 0)
541 {
542 if (debug_threads)
543 fprintf (stderr, "Reinserted breakpoint.\n");
544 reinsert_breakpoint (event_child->bp_reinsert);
545 event_child->bp_reinsert = 0;
546
547 /* Clear the single-stepping flag and SIGTRAP as we resume. */
503 event_child->stepping,
504 WSTOPSIG (wstat));
505 continue;
506 }
507 }
508
509 /* If this event was not handled above, and is not a SIGTRAP, report
510 it. */

--- 14 unchanged lines hidden (view full) ---

525 if (event_child->bp_reinsert != 0)
526 {
527 if (debug_threads)
528 fprintf (stderr, "Reinserted breakpoint.\n");
529 reinsert_breakpoint (event_child->bp_reinsert);
530 event_child->bp_reinsert = 0;
531
532 /* Clear the single-stepping flag and SIGTRAP as we resume. */
548 linux_resume_one_process (&event_child->head, 0, 0);
533 fbsd_resume_one_process (&event_child->head, 0, 0);
549 continue;
550 }
551
552 if (debug_threads)
553 fprintf (stderr, "Hit a (non-reinsert) breakpoint.\n");
554
555 if (check_breakpoints (stop_pc) != 0)
556 {

--- 10 unchanged lines hidden (view full) ---

567 thread could sneak past the removed breakpoint. For the current
568 use of server-side breakpoints (thread creation) this is
569 acceptable; but it needs to be considered before this breakpoint
570 mechanism can be used in more general ways. For some breakpoints
571 it may be necessary to stop all other threads, but that should
572 be avoided where possible.
573
574 If breakpoint_reinsert_addr is NULL, that means that we can
534 continue;
535 }
536
537 if (debug_threads)
538 fprintf (stderr, "Hit a (non-reinsert) breakpoint.\n");
539
540 if (check_breakpoints (stop_pc) != 0)
541 {

--- 10 unchanged lines hidden (view full) ---

552 thread could sneak past the removed breakpoint. For the current
553 use of server-side breakpoints (thread creation) this is
554 acceptable; but it needs to be considered before this breakpoint
555 mechanism can be used in more general ways. For some breakpoints
556 it may be necessary to stop all other threads, but that should
557 be avoided where possible.
558
559 If breakpoint_reinsert_addr is NULL, that means that we can
575 use PTRACE_SINGLESTEP on this platform. Uninsert the breakpoint,
560 use PT_STEP on this platform. Uninsert the breakpoint,
576 mark it for reinsertion, and single-step.
577
578 Otherwise, call the target function to figure out where we need
579 our temporary breakpoint, create it, and continue executing this
580 process. */
581 if (the_low_target.breakpoint_reinsert_addr == NULL)
582 {
583 event_child->bp_reinsert = stop_pc;
584 uninsert_breakpoint (stop_pc);
561 mark it for reinsertion, and single-step.
562
563 Otherwise, call the target function to figure out where we need
564 our temporary breakpoint, create it, and continue executing this
565 process. */
566 if (the_low_target.breakpoint_reinsert_addr == NULL)
567 {
568 event_child->bp_reinsert = stop_pc;
569 uninsert_breakpoint (stop_pc);
585 linux_resume_one_process (&event_child->head, 1, 0);
570 fbsd_resume_one_process (&event_child->head, 1, 0);
586 }
587 else
588 {
589 reinsert_breakpoint_by_bp
590 (stop_pc, (*the_low_target.breakpoint_reinsert_addr) ());
571 }
572 else
573 {
574 reinsert_breakpoint_by_bp
575 (stop_pc, (*the_low_target.breakpoint_reinsert_addr) ());
591 linux_resume_one_process (&event_child->head, 0, 0);
576 fbsd_resume_one_process (&event_child->head, 0, 0);
592 }
593
594 continue;
595 }
596
597 /* If we were single-stepping, we definitely want to report the
598 SIGTRAP. The single-step operation has completed, so also
599 clear the stepping flag; in general this does not matter,

--- 28 unchanged lines hidden (view full) ---

628
629 /* NOTREACHED */
630 return 0;
631}
632
633/* Wait for process, returns status. */
634
635static unsigned char
577 }
578
579 continue;
580 }
581
582 /* If we were single-stepping, we definitely want to report the
583 SIGTRAP. The single-step operation has completed, so also
584 clear the stepping flag; in general this does not matter,

--- 28 unchanged lines hidden (view full) ---

613
614 /* NOTREACHED */
615 return 0;
616}
617
618/* Wait for process, returns status. */
619
620static unsigned char
636linux_wait (char *status)
621fbsd_wait (char *status)
637{
638 int w;
639 struct thread_info *child = NULL;
640
641retry:
642 /* If we were only supposed to resume one thread, only wait for
643 that thread - if it's still alive. If it died, however - which
644 can happen if we're coming from the thread death case below -

--- 6 unchanged lines hidden (view full) ---

651 cont_thread);
652
653 /* No stepping, no signal - unless one is pending already, of course. */
654 if (child == NULL)
655 {
656 struct thread_resume resume_info;
657 resume_info.thread = -1;
658 resume_info.step = resume_info.sig = resume_info.leave_stopped = 0;
622{
623 int w;
624 struct thread_info *child = NULL;
625
626retry:
627 /* If we were only supposed to resume one thread, only wait for
628 that thread - if it's still alive. If it died, however - which
629 can happen if we're coming from the thread death case below -

--- 6 unchanged lines hidden (view full) ---

636 cont_thread);
637
638 /* No stepping, no signal - unless one is pending already, of course. */
639 if (child == NULL)
640 {
641 struct thread_resume resume_info;
642 resume_info.thread = -1;
643 resume_info.step = resume_info.sig = resume_info.leave_stopped = 0;
659 linux_resume (&resume_info);
644 fbsd_resume (&resume_info);
660 }
661 }
662
663 enable_async_io ();
664 unblock_async_io ();
645 }
646 }
647
648 enable_async_io ();
649 unblock_async_io ();
665 w = linux_wait_for_event (child);
650 w = fbsd_wait_for_event (child);
666 stop_all_processes ();
667 disable_async_io ();
668
669 /* If we are waiting for a particular child, and it exited,
651 stop_all_processes ();
652 disable_async_io ();
653
654 /* If we are waiting for a particular child, and it exited,
670 linux_wait_for_event will return its exit status. Similarly if
655 fbsd_wait_for_event will return its exit status. Similarly if
671 the last child exited. If this is not the last child, however,
672 do not report it as exited until there is a 'thread exited' response
673 available in the remote protocol. Instead, just wait for another event.
674 This should be safe, because if the thread crashed we will already
675 have reported the termination signal to GDB; that should stop any
676 in-progress stepping operations, etc.
677
678 Report the exit status of the last thread to exit. This matches

--- 62 unchanged lines hidden (view full) ---

741
742 if (process->stopped)
743 return;
744
745 saved_inferior = current_inferior;
746 saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
747 thread = (struct thread_info *) find_inferior_id (&all_threads,
748 process->tid);
656 the last child exited. If this is not the last child, however,
657 do not report it as exited until there is a 'thread exited' response
658 available in the remote protocol. Instead, just wait for another event.
659 This should be safe, because if the thread crashed we will already
660 have reported the termination signal to GDB; that should stop any
661 in-progress stepping operations, etc.
662
663 Report the exit status of the last thread to exit. This matches

--- 62 unchanged lines hidden (view full) ---

726
727 if (process->stopped)
728 return;
729
730 saved_inferior = current_inferior;
731 saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
732 thread = (struct thread_info *) find_inferior_id (&all_threads,
733 process->tid);
749 wstat = linux_wait_for_event (thread);
734 wstat = fbsd_wait_for_event (thread);
750
751 /* If we stopped with a non-SIGSTOP signal, save it for later
752 and record the pending SIGSTOP. If the process exited, just
753 return. */
754 if (WIFSTOPPED (wstat)
755 && WSTOPSIG (wstat) != SIGSTOP)
756 {
757 if (debug_threads)
758 fprintf (stderr, "Stopped with non-sigstop signal\n");
759 process->status_pending_p = 1;
760 process->status_pending = wstat;
761 process->stop_expected = 1;
762 }
763
735
736 /* If we stopped with a non-SIGSTOP signal, save it for later
737 and record the pending SIGSTOP. If the process exited, just
738 return. */
739 if (WIFSTOPPED (wstat)
740 && WSTOPSIG (wstat) != SIGSTOP)
741 {
742 if (debug_threads)
743 fprintf (stderr, "Stopped with non-sigstop signal\n");
744 process->status_pending_p = 1;
745 process->status_pending = wstat;
746 process->stop_expected = 1;
747 }
748
764 if (linux_thread_alive (saved_tid))
749 if (fbsd_thread_alive (saved_tid))
765 current_inferior = saved_inferior;
766 else
767 {
768 if (debug_threads)
769 fprintf (stderr, "Previously current thread died.\n");
770
771 /* Set a valid thread as current. */
772 set_desired_inferior (0);

--- 9 unchanged lines hidden (view full) ---

782 stopping_threads = 0;
783}
784
785/* Resume execution of the inferior process.
786 If STEP is nonzero, single-step it.
787 If SIGNAL is nonzero, give it that signal. */
788
789static void
750 current_inferior = saved_inferior;
751 else
752 {
753 if (debug_threads)
754 fprintf (stderr, "Previously current thread died.\n");
755
756 /* Set a valid thread as current. */
757 set_desired_inferior (0);

--- 9 unchanged lines hidden (view full) ---

767 stopping_threads = 0;
768}
769
770/* Resume execution of the inferior process.
771 If STEP is nonzero, single-step it.
772 If SIGNAL is nonzero, give it that signal. */
773
774static void
790linux_resume_one_process (struct inferior_list_entry *entry,
775fbsd_resume_one_process (struct inferior_list_entry *entry,
791 int step, int signal)
792{
793 struct process_info *process = (struct process_info *) entry;
794 struct thread_info *saved_inferior;
795
796 if (process->stopped == 0)
797 return;
798

--- 24 unchanged lines hidden (view full) ---

823
824 /* This bit needs some thinking about. If we get a signal that
825 we must report while a single-step reinsert is still pending,
826 we often end up resuming the thread. It might be better to
827 (ew) allow a stack of pending events; then we could be sure that
828 the reinsert happened right away and not lose any signals.
829
830 Making this stack would also shrink the window in which breakpoints are
776 int step, int signal)
777{
778 struct process_info *process = (struct process_info *) entry;
779 struct thread_info *saved_inferior;
780
781 if (process->stopped == 0)
782 return;
783

--- 24 unchanged lines hidden (view full) ---

808
809 /* This bit needs some thinking about. If we get a signal that
810 we must report while a single-step reinsert is still pending,
811 we often end up resuming the thread. It might be better to
812 (ew) allow a stack of pending events; then we could be sure that
813 the reinsert happened right away and not lose any signals.
814
815 Making this stack would also shrink the window in which breakpoints are
831 uninserted (see comment in linux_wait_for_process) but not enough for
816 uninserted (see comment in fbsd_wait_for_process) but not enough for
832 complete correctness, so it won't solve that problem. It may be
833 worthwhile just to solve this one, however. */
834 if (process->bp_reinsert != 0)
835 {
836 if (debug_threads)
837 fprintf (stderr, " pending reinsert at %08lx", (long)process->bp_reinsert);
838 if (step == 0)
839 fprintf (stderr, "BAD - reinserting but not stepping.\n");

--- 26 unchanged lines hidden (view full) ---

866 *p_sig = NULL;
867 }
868
869 regcache_invalidate_one ((struct inferior_list_entry *)
870 get_process_thread (process));
871 errno = 0;
872 process->stopped = 0;
873 process->stepping = step;
817 complete correctness, so it won't solve that problem. It may be
818 worthwhile just to solve this one, however. */
819 if (process->bp_reinsert != 0)
820 {
821 if (debug_threads)
822 fprintf (stderr, " pending reinsert at %08lx", (long)process->bp_reinsert);
823 if (step == 0)
824 fprintf (stderr, "BAD - reinserting but not stepping.\n");

--- 26 unchanged lines hidden (view full) ---

851 *p_sig = NULL;
852 }
853
854 regcache_invalidate_one ((struct inferior_list_entry *)
855 get_process_thread (process));
856 errno = 0;
857 process->stopped = 0;
858 process->stepping = step;
874 ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, process->lwpid, 0, signal);
859 ptrace (step ? PT_STEP : PT_CONTINUE, process->lwpid, (PTRACE_ARG3_TYPE) 1, signal);
875
876 current_inferior = saved_inferior;
877 if (errno)
878 perror_with_name ("ptrace");
879}
880
881static struct thread_resume *resume_ptr;
882
883/* This function is called once per thread. We look up the thread
884 in RESUME_PTR, and mark the thread with a pointer to the appropriate
885 resume request.
886
887 This algorithm is O(threads * resume elements), but resume elements
888 is small (and will remain small at least until GDB supports thread
889 suspension). */
890static void
860
861 current_inferior = saved_inferior;
862 if (errno)
863 perror_with_name ("ptrace");
864}
865
866static struct thread_resume *resume_ptr;
867
868/* This function is called once per thread. We look up the thread
869 in RESUME_PTR, and mark the thread with a pointer to the appropriate
870 resume request.
871
872 This algorithm is O(threads * resume elements), but resume elements
873 is small (and will remain small at least until GDB supports thread
874 suspension). */
875static void
891linux_set_resume_request (struct inferior_list_entry *entry)
876fbsd_set_resume_request (struct inferior_list_entry *entry)
892{
893 struct process_info *process;
894 struct thread_info *thread;
895 int ndx;
896
897 thread = (struct thread_info *) entry;
898 process = get_thread_process (thread);
899

--- 6 unchanged lines hidden (view full) ---

906
907/* This function is called once per thread. We check the thread's resume
908 request, which will tell us whether to resume, step, or leave the thread
909 stopped; and what signal, if any, it should be sent. For threads which
910 we aren't explicitly told otherwise, we preserve the stepping flag; this
911 is used for stepping over gdbserver-placed breakpoints. */
912
913static void
877{
878 struct process_info *process;
879 struct thread_info *thread;
880 int ndx;
881
882 thread = (struct thread_info *) entry;
883 process = get_thread_process (thread);
884

--- 6 unchanged lines hidden (view full) ---

891
892/* This function is called once per thread. We check the thread's resume
893 request, which will tell us whether to resume, step, or leave the thread
894 stopped; and what signal, if any, it should be sent. For threads which
895 we aren't explicitly told otherwise, we preserve the stepping flag; this
896 is used for stepping over gdbserver-placed breakpoints. */
897
898static void
914linux_continue_one_thread (struct inferior_list_entry *entry)
899fbsd_continue_one_thread (struct inferior_list_entry *entry)
915{
916 struct process_info *process;
917 struct thread_info *thread;
918 int step;
919
920 thread = (struct thread_info *) entry;
921 process = get_thread_process (thread);
922
923 if (process->resume->leave_stopped)
924 return;
925
926 if (process->resume->thread == -1)
927 step = process->stepping || process->resume->step;
928 else
929 step = process->resume->step;
930
900{
901 struct process_info *process;
902 struct thread_info *thread;
903 int step;
904
905 thread = (struct thread_info *) entry;
906 process = get_thread_process (thread);
907
908 if (process->resume->leave_stopped)
909 return;
910
911 if (process->resume->thread == -1)
912 step = process->stepping || process->resume->step;
913 else
914 step = process->resume->step;
915
931 linux_resume_one_process (&process->head, step, process->resume->sig);
916 fbsd_resume_one_process (&process->head, step, process->resume->sig);
932
933 process->resume = NULL;
934}
935
936/* This function is called once per thread. We check the thread's resume
937 request, which will tell us whether to resume, step, or leave the thread
938 stopped; and what signal, if any, it should be sent. We queue any needed
939 signals, since we won't actually resume. We already have a pending event
940 to report, so we don't need to preserve any step requests; they should
941 be re-issued if necessary. */
942
943static void
917
918 process->resume = NULL;
919}
920
921/* This function is called once per thread. We check the thread's resume
922 request, which will tell us whether to resume, step, or leave the thread
923 stopped; and what signal, if any, it should be sent. We queue any needed
924 signals, since we won't actually resume. We already have a pending event
925 to report, so we don't need to preserve any step requests; they should
926 be re-issued if necessary. */
927
928static void
944linux_queue_one_thread (struct inferior_list_entry *entry)
929fbsd_queue_one_thread (struct inferior_list_entry *entry)
945{
946 struct process_info *process;
947 struct thread_info *thread;
948
949 thread = (struct thread_info *) entry;
950 process = get_thread_process (thread);
951
952 if (process->resume->leave_stopped)

--- 14 unchanged lines hidden (view full) ---

967
968/* Set DUMMY if this process has an interesting status pending. */
969static int
970resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
971{
972 struct process_info *process = (struct process_info *) entry;
973
974 /* Processes which will not be resumed are not interesting, because
930{
931 struct process_info *process;
932 struct thread_info *thread;
933
934 thread = (struct thread_info *) entry;
935 process = get_thread_process (thread);
936
937 if (process->resume->leave_stopped)

--- 14 unchanged lines hidden (view full) ---

952
953/* Set DUMMY if this process has an interesting status pending. */
954static int
955resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
956{
957 struct process_info *process = (struct process_info *) entry;
958
959 /* Processes which will not be resumed are not interesting, because
975 we might not wait for them next time through linux_wait. */
960 we might not wait for them next time through fbsd_wait. */
976 if (process->resume->leave_stopped)
977 return 0;
978
979 /* If this thread has a removed breakpoint, we won't have any
980 events to report later, so check now. check_removed_breakpoint
981 may clear status_pending_p. We avoid calling check_removed_breakpoint
982 for any thread that we are not otherwise going to resume - this
983 lets us preserve stopped status when two threads hit a breakpoint.

--- 5 unchanged lines hidden (view full) ---

989
990 if (process->status_pending_p)
991 * (int *) flag_p = 1;
992
993 return 0;
994}
995
996static void
961 if (process->resume->leave_stopped)
962 return 0;
963
964 /* If this thread has a removed breakpoint, we won't have any
965 events to report later, so check now. check_removed_breakpoint
966 may clear status_pending_p. We avoid calling check_removed_breakpoint
967 for any thread that we are not otherwise going to resume - this
968 lets us preserve stopped status when two threads hit a breakpoint.

--- 5 unchanged lines hidden (view full) ---

974
975 if (process->status_pending_p)
976 * (int *) flag_p = 1;
977
978 return 0;
979}
980
981static void
997linux_resume (struct thread_resume *resume_info)
982fbsd_resume (struct thread_resume *resume_info)
998{
999 int pending_flag;
1000
1001 /* Yes, the use of a global here is rather ugly. */
1002 resume_ptr = resume_info;
1003
983{
984 int pending_flag;
985
986 /* Yes, the use of a global here is rather ugly. */
987 resume_ptr = resume_info;
988
1004 for_each_inferior (&all_threads, linux_set_resume_request);
989 for_each_inferior (&all_threads, fbsd_set_resume_request);
1005
1006 /* If there is a thread which would otherwise be resumed, which
1007 has a pending status, then don't resume any threads - we can just
1008 report the pending status. Make sure to queue any signals
1009 that would otherwise be sent. */
1010 pending_flag = 0;
1011 find_inferior (&all_processes, resume_status_pending_p, &pending_flag);
1012
1013 if (debug_threads)
1014 {
1015 if (pending_flag)
1016 fprintf (stderr, "Not resuming, pending status\n");
1017 else
1018 fprintf (stderr, "Resuming, no pending status\n");
1019 }
1020
1021 if (pending_flag)
990
991 /* If there is a thread which would otherwise be resumed, which
992 has a pending status, then don't resume any threads - we can just
993 report the pending status. Make sure to queue any signals
994 that would otherwise be sent. */
995 pending_flag = 0;
996 find_inferior (&all_processes, resume_status_pending_p, &pending_flag);
997
998 if (debug_threads)
999 {
1000 if (pending_flag)
1001 fprintf (stderr, "Not resuming, pending status\n");
1002 else
1003 fprintf (stderr, "Resuming, no pending status\n");
1004 }
1005
1006 if (pending_flag)
1022 for_each_inferior (&all_threads, linux_queue_one_thread);
1007 for_each_inferior (&all_threads, fbsd_queue_one_thread);
1023 else
1024 {
1025 block_async_io ();
1026 enable_async_io ();
1008 else
1009 {
1010 block_async_io ();
1011 enable_async_io ();
1027 for_each_inferior (&all_threads, linux_continue_one_thread);
1012 for_each_inferior (&all_threads, fbsd_continue_one_thread);
1028 }
1029}
1030
1013 }
1014}
1015
1031#ifdef HAVE_LINUX_USRREGS
1032
1016
1033int
1034register_addr (int regnum)
1035{
1036 int addr;
1037
1038 if (regnum < 0 || regnum >= the_low_target.num_regs)
1039 error ("Invalid register number %d.", regnum);
1040
1041 addr = the_low_target.regmap[regnum];
1042
1043 return addr;
1044}
1045
1046/* Fetch one register. */
1047static void
1048fetch_register (int regno)
1049{
1050 CORE_ADDR regaddr;
1051 register int i;
1052 char *buf;
1053
1054 if (regno >= the_low_target.num_regs)
1055 return;
1056 if ((*the_low_target.cannot_fetch_register) (regno))
1057 return;
1058
1059 regaddr = register_addr (regno);
1060 if (regaddr == -1)
1061 return;
1062 buf = alloca (register_size (regno));
1063 for (i = 0; i < register_size (regno); i += sizeof (PTRACE_XFER_TYPE))
1064 {
1065 errno = 0;
1066 *(PTRACE_XFER_TYPE *) (buf + i) =
1067 ptrace (PTRACE_PEEKUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, 0);
1068 regaddr += sizeof (PTRACE_XFER_TYPE);
1069 if (errno != 0)
1070 {
1071 /* Warning, not error, in case we are attached; sometimes the
1072 kernel doesn't let us at the registers. */
1073 char *err = strerror (errno);
1074 char *msg = alloca (strlen (err) + 128);
1075 sprintf (msg, "reading register %d: %s", regno, err);
1076 error (msg);
1077 goto error_exit;
1078 }
1079 }
1080 supply_register (regno, buf);
1081
1082error_exit:;
1083}
1084
1085/* Fetch all registers, or just one, from the child process. */
1086static void
1087usr_fetch_inferior_registers (int regno)
1088{
1089 if (regno == -1 || regno == 0)
1090 for (regno = 0; regno < the_low_target.num_regs; regno++)
1091 fetch_register (regno);
1092 else
1093 fetch_register (regno);
1094}
1095
1096/* Store our register values back into the inferior.
1097 If REGNO is -1, do this for all registers.
1098 Otherwise, REGNO specifies which register (so we can save time). */
1099static void
1100usr_store_inferior_registers (int regno)
1101{
1102 CORE_ADDR regaddr;
1103 int i;
1104 char *buf;
1105
1106 if (regno >= 0)
1107 {
1108 if (regno >= the_low_target.num_regs)
1109 return;
1110
1111 if ((*the_low_target.cannot_store_register) (regno) == 1)
1112 return;
1113
1114 regaddr = register_addr (regno);
1115 if (regaddr == -1)
1116 return;
1117 errno = 0;
1118 buf = alloca (register_size (regno));
1119 collect_register (regno, buf);
1120 for (i = 0; i < register_size (regno); i += sizeof (PTRACE_XFER_TYPE))
1121 {
1122 errno = 0;
1123 ptrace (PTRACE_POKEUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
1124 *(PTRACE_XFER_TYPE *) (buf + i));
1125 if (errno != 0)
1126 {
1127 if ((*the_low_target.cannot_store_register) (regno) == 0)
1128 {
1129 char *err = strerror (errno);
1130 char *msg = alloca (strlen (err) + 128);
1131 sprintf (msg, "writing register %d: %s",
1132 regno, err);
1133 error (msg);
1134 return;
1135 }
1136 }
1137 regaddr += sizeof (PTRACE_XFER_TYPE);
1138 }
1139 }
1140 else
1141 for (regno = 0; regno < the_low_target.num_regs; regno++)
1142 usr_store_inferior_registers (regno);
1143}
1144#endif /* HAVE_LINUX_USRREGS */
1145
1146
1147
1148#ifdef HAVE_LINUX_REGSETS
1149
1150static int
1151regsets_fetch_inferior_registers ()
1152{
1153 struct regset_info *regset;
1154
1155 regset = target_regsets;
1156
1157 while (regset->size >= 0)
1158 {
1159 void *buf;
1160 int res;
1161
1162 if (regset->size == 0)
1163 {
1164 regset ++;
1165 continue;
1166 }
1167
1168 buf = malloc (regset->size);
1017static int
1018regsets_fetch_inferior_registers ()
1019{
1020 struct regset_info *regset;
1021
1022 regset = target_regsets;
1023
1024 while (regset->size >= 0)
1025 {
1026 void *buf;
1027 int res;
1028
1029 if (regset->size == 0)
1030 {
1031 regset ++;
1032 continue;
1033 }
1034
1035 buf = malloc (regset->size);
1169 res = ptrace (regset->get_request, inferior_pid, 0, buf);
1036 res = ptrace (regset->get_request, inferior_pid, (PTRACE_ARG3_TYPE) buf, 0);
1170 if (res < 0)
1171 {
1037 if (res < 0)
1038 {
1172 if (errno == EIO)
1173 {
1174 /* If we get EIO on the first regset, do not try regsets again.
1175 If we get EIO on a later regset, disable that regset. */
1176 if (regset == target_regsets)
1177 {
1178 use_regsets_p = 0;
1179 return -1;
1180 }
1181 else
1182 {
1183 regset->size = 0;
1184 continue;
1185 }
1186 }
1187 else
1188 {
1189 char s[256];
1190 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
1191 inferior_pid);
1192 perror (s);
1193 }
1039 char s[256];
1040 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
1041 inferior_pid);
1042 perror (s);
1194 }
1195 regset->store_function (buf);
1196 regset ++;
1197 }
1198 return 0;
1199}
1200
1201static int

--- 11 unchanged lines hidden (view full) ---

1213 if (regset->size == 0)
1214 {
1215 regset ++;
1216 continue;
1217 }
1218
1219 buf = malloc (regset->size);
1220 regset->fill_function (buf);
1043 }
1044 regset->store_function (buf);
1045 regset ++;
1046 }
1047 return 0;
1048}
1049
1050static int

--- 11 unchanged lines hidden (view full) ---

1062 if (regset->size == 0)
1063 {
1064 regset ++;
1065 continue;
1066 }
1067
1068 buf = malloc (regset->size);
1069 regset->fill_function (buf);
1221 res = ptrace (regset->set_request, inferior_pid, 0, buf);
1070 res = ptrace (regset->set_request, inferior_pid, (PTRACE_ARG3_TYPE) buf, 0);
1222 if (res < 0)
1223 {
1071 if (res < 0)
1072 {
1224 if (errno == EIO)
1225 {
1226 /* If we get EIO on the first regset, do not try regsets again.
1227 If we get EIO on a later regset, disable that regset. */
1228 if (regset == target_regsets)
1229 {
1230 use_regsets_p = 0;
1231 return -1;
1232 }
1233 else
1234 {
1235 regset->size = 0;
1236 continue;
1237 }
1238 }
1239 else
1240 {
1241 perror ("Warning: ptrace(regsets_store_inferior_registers)");
1242 }
1073 perror ("Warning: ptrace(regsets_store_inferior_registers)");
1243 }
1244 regset ++;
1245 free (buf);
1246 }
1247 return 0;
1248}
1249
1074 }
1075 regset ++;
1076 free (buf);
1077 }
1078 return 0;
1079}
1080
1250#endif /* HAVE_LINUX_REGSETS */
1251
1252
1253void
1081void
1254linux_fetch_registers (int regno)
1082fbsd_fetch_registers (int regno)
1255{
1083{
1256#ifdef HAVE_LINUX_REGSETS
1257 if (use_regsets_p)
1258 {
1259 if (regsets_fetch_inferior_registers () == 0)
1260 return;
1261 }
1262#endif
1263#ifdef HAVE_LINUX_USRREGS
1264 usr_fetch_inferior_registers (regno);
1265#endif
1084 regsets_fetch_inferior_registers ();
1266}
1267
1268void
1085}
1086
1087void
1269linux_store_registers (int regno)
1088fbsd_store_registers (int regno)
1270{
1089{
1271#ifdef HAVE_LINUX_REGSETS
1272 if (use_regsets_p)
1273 {
1274 if (regsets_store_inferior_registers () == 0)
1275 return;
1276 }
1277#endif
1278#ifdef HAVE_LINUX_USRREGS
1279 usr_store_inferior_registers (regno);
1280#endif
1090 regsets_store_inferior_registers ();
1281}
1282
1283
1284/* Copy LEN bytes from inferior's memory starting at MEMADDR
1285 to debugger memory starting at MYADDR. */
1286
1287static int
1091}
1092
1093
1094/* Copy LEN bytes from inferior's memory starting at MEMADDR
1095 to debugger memory starting at MYADDR. */
1096
1097static int
1288linux_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
1098fbsd_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
1289{
1290 register int i;
1291 /* Round starting address down to longword boundary. */
1292 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
1293 /* Round ending address up; get number of longwords that makes. */
1294 register int count
1295 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
1296 / sizeof (PTRACE_XFER_TYPE);
1297 /* Allocate buffer of that many longwords. */
1298 register PTRACE_XFER_TYPE *buffer
1299 = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
1300
1301 /* Read all the longwords */
1302 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
1303 {
1304 errno = 0;
1099{
1100 register int i;
1101 /* Round starting address down to longword boundary. */
1102 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
1103 /* Round ending address up; get number of longwords that makes. */
1104 register int count
1105 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
1106 / sizeof (PTRACE_XFER_TYPE);
1107 /* Allocate buffer of that many longwords. */
1108 register PTRACE_XFER_TYPE *buffer
1109 = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
1110
1111 /* Read all the longwords */
1112 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
1113 {
1114 errno = 0;
1305 buffer[i] = ptrace (PTRACE_PEEKTEXT, inferior_pid, (PTRACE_ARG3_TYPE) addr, 0);
1115 buffer[i] = ptrace (PT_READ_D, inferior_pid, (PTRACE_ARG3_TYPE) (intptr_t)addr, 0);
1306 if (errno)
1307 return errno;
1308 }
1309
1310 /* Copy appropriate bytes out of the buffer. */
1311 memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), len);
1312
1313 return 0;
1314}
1315
1316/* Copy LEN bytes of data from debugger memory at MYADDR
1317 to inferior's memory at MEMADDR.
1318 On failure (cannot write the inferior)
1319 returns the value of errno. */
1320
1321static int
1116 if (errno)
1117 return errno;
1118 }
1119
1120 /* Copy appropriate bytes out of the buffer. */
1121 memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), len);
1122
1123 return 0;
1124}
1125
1126/* Copy LEN bytes of data from debugger memory at MYADDR
1127 to inferior's memory at MEMADDR.
1128 On failure (cannot write the inferior)
1129 returns the value of errno. */
1130
1131static int
1322linux_write_memory (CORE_ADDR memaddr, const char *myaddr, int len)
1132fbsd_write_memory (CORE_ADDR memaddr, const char *myaddr, int len)
1323{
1324 register int i;
1325 /* Round starting address down to longword boundary. */
1326 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
1327 /* Round ending address up; get number of longwords that makes. */
1328 register int count
1329 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) / sizeof (PTRACE_XFER_TYPE);
1330 /* Allocate buffer of that many longwords. */
1331 register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
1332 extern int errno;
1333
1334 if (debug_threads)
1335 {
1336 fprintf (stderr, "Writing %02x to %08lx\n", (unsigned)myaddr[0], (long)memaddr);
1337 }
1338
1339 /* Fill start and end extra bytes of buffer with existing memory data. */
1340
1133{
1134 register int i;
1135 /* Round starting address down to longword boundary. */
1136 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
1137 /* Round ending address up; get number of longwords that makes. */
1138 register int count
1139 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) / sizeof (PTRACE_XFER_TYPE);
1140 /* Allocate buffer of that many longwords. */
1141 register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
1142 extern int errno;
1143
1144 if (debug_threads)
1145 {
1146 fprintf (stderr, "Writing %02x to %08lx\n", (unsigned)myaddr[0], (long)memaddr);
1147 }
1148
1149 /* Fill start and end extra bytes of buffer with existing memory data. */
1150
1341 buffer[0] = ptrace (PTRACE_PEEKTEXT, inferior_pid,
1342 (PTRACE_ARG3_TYPE) addr, 0);
1151 buffer[0] = ptrace (PT_READ_D, inferior_pid,
1152 (PTRACE_ARG3_TYPE) (intptr_t)addr, 0);
1343
1344 if (count > 1)
1345 {
1346 buffer[count - 1]
1153
1154 if (count > 1)
1155 {
1156 buffer[count - 1]
1347 = ptrace (PTRACE_PEEKTEXT, inferior_pid,
1348 (PTRACE_ARG3_TYPE) (addr + (count - 1)
1157 = ptrace (PT_READ_D, inferior_pid,
1158 (PTRACE_ARG3_TYPE) (intptr_t) (addr + (count - 1)
1349 * sizeof (PTRACE_XFER_TYPE)),
1350 0);
1351 }
1352
1353 /* Copy data to be written over corresponding part of buffer */
1354
1355 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), myaddr, len);
1356
1357 /* Write the entire buffer. */
1358
1359 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
1360 {
1361 errno = 0;
1159 * sizeof (PTRACE_XFER_TYPE)),
1160 0);
1161 }
1162
1163 /* Copy data to be written over corresponding part of buffer */
1164
1165 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), myaddr, len);
1166
1167 /* Write the entire buffer. */
1168
1169 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
1170 {
1171 errno = 0;
1362 ptrace (PTRACE_POKETEXT, inferior_pid, (PTRACE_ARG3_TYPE) addr, buffer[i]);
1172 ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) (intptr_t)addr, buffer[i]);
1363 if (errno)
1364 return errno;
1365 }
1366
1367 return 0;
1368}
1369
1370static void
1173 if (errno)
1174 return errno;
1175 }
1176
1177 return 0;
1178}
1179
1180static void
1371linux_look_up_symbols (void)
1181fbsd_look_up_symbols (void)
1372{
1373#ifdef USE_THREAD_DB
1374 if (using_threads)
1375 return;
1376
1377 using_threads = thread_db_init ();
1378#endif
1379}
1380
1381static void
1182{
1183#ifdef USE_THREAD_DB
1184 if (using_threads)
1185 return;
1186
1187 using_threads = thread_db_init ();
1188#endif
1189}
1190
1191static void
1382linux_send_signal (int signum)
1192fbsd_send_signal (int signum)
1383{
1384 extern int signal_pid;
1385
1386 if (cont_thread > 0)
1387 {
1388 struct process_info *process;
1389
1390 process = get_thread_process (current_inferior);
1391 kill (process->lwpid, signum);
1392 }
1393 else
1394 kill (signal_pid, signum);
1395}
1396
1397/* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
1398 to debugger memory starting at MYADDR. */
1399
1400static int
1193{
1194 extern int signal_pid;
1195
1196 if (cont_thread > 0)
1197 {
1198 struct process_info *process;
1199
1200 process = get_thread_process (current_inferior);
1201 kill (process->lwpid, signum);
1202 }
1203 else
1204 kill (signal_pid, signum);
1205}
1206
1207/* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
1208 to debugger memory starting at MYADDR. */
1209
1210static int
1401linux_read_auxv (CORE_ADDR offset, char *myaddr, unsigned int len)
1211fbsd_read_auxv (CORE_ADDR offset, char *myaddr, unsigned int len)
1402{
1403 char filename[PATH_MAX];
1404 int fd, n;
1405
1406 snprintf (filename, sizeof filename, "/proc/%d/auxv", inferior_pid);
1407
1408 fd = open (filename, O_RDONLY);
1409 if (fd < 0)

--- 6 unchanged lines hidden (view full) ---

1416 n = read (fd, myaddr, len);
1417
1418 close (fd);
1419
1420 return n;
1421}
1422
1423
1212{
1213 char filename[PATH_MAX];
1214 int fd, n;
1215
1216 snprintf (filename, sizeof filename, "/proc/%d/auxv", inferior_pid);
1217
1218 fd = open (filename, O_RDONLY);
1219 if (fd < 0)

--- 6 unchanged lines hidden (view full) ---

1226 n = read (fd, myaddr, len);
1227
1228 close (fd);
1229
1230 return n;
1231}
1232
1233
1424static struct target_ops linux_target_ops = {
1425 linux_create_inferior,
1426 linux_attach,
1427 linux_kill,
1428 linux_detach,
1429 linux_thread_alive,
1430 linux_resume,
1431 linux_wait,
1432 linux_fetch_registers,
1433 linux_store_registers,
1434 linux_read_memory,
1435 linux_write_memory,
1436 linux_look_up_symbols,
1437 linux_send_signal,
1438 linux_read_auxv,
1234static struct target_ops fbsd_target_ops = {
1235 fbsd_create_inferior,
1236 fbsd_attach,
1237 fbsd_kill,
1238 fbsd_detach,
1239 fbsd_thread_alive,
1240 fbsd_resume,
1241 fbsd_wait,
1242 fbsd_fetch_registers,
1243 fbsd_store_registers,
1244 fbsd_read_memory,
1245 fbsd_write_memory,
1246 fbsd_look_up_symbols,
1247 fbsd_send_signal,
1248 fbsd_read_auxv,
1439};
1440
1441static void
1249};
1250
1251static void
1442linux_init_signals ()
1252fbsd_init_signals ()
1443{
1253{
1444 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
1445 to find what the cancel signal actually is. */
1446 signal (__SIGRTMIN+1, SIG_IGN);
1447}
1448
1449void
1450initialize_low (void)
1451{
1452 using_threads = 0;
1254}
1255
1256void
1257initialize_low (void)
1258{
1259 using_threads = 0;
1453 set_target_ops (&linux_target_ops);
1260 set_target_ops (&fbsd_target_ops);
1454 set_breakpoint_data (the_low_target.breakpoint,
1455 the_low_target.breakpoint_len);
1456 init_registers ();
1261 set_breakpoint_data (the_low_target.breakpoint,
1262 the_low_target.breakpoint_len);
1263 init_registers ();
1457 linux_init_signals ();
1264 fbsd_init_signals ();
1458}
1265}