1 /* Low-level child interface to ptrace.
3 Copyright (C) 1988-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
27 #include "gdb_ptrace.h"
31 #include "inf-ptrace.h"
32 #include "inf-child.h"
33 #include "gdbthread.h"
37 #ifdef PT_GET_PROCESS_STATE
40 inf_ptrace_follow_fork (struct target_ops
*ops
, int follow_child
,
46 pid
= ptid_get_pid (inferior_ptid
);
48 if (ptrace (PT_GET_PROCESS_STATE
, pid
,
49 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
50 perror_with_name (("ptrace"));
52 gdb_assert (pe
.pe_report_event
== PTRACE_FORK
);
53 fpid
= pe
.pe_other_pid
;
57 struct inferior
*parent_inf
, *child_inf
;
58 struct thread_info
*tp
;
60 parent_inf
= find_inferior_pid (pid
);
63 child_inf
= add_inferior (fpid
);
64 child_inf
->attach_flag
= parent_inf
->attach_flag
;
65 copy_terminal_info (child_inf
, parent_inf
);
66 child_inf
->pspace
= parent_inf
->pspace
;
67 child_inf
->aspace
= parent_inf
->aspace
;
69 /* Before detaching from the parent, remove all breakpoints from
71 remove_breakpoints ();
73 if (ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
74 perror_with_name (("ptrace"));
76 /* Switch inferior_ptid out of the parent's way. */
77 inferior_ptid
= pid_to_ptid (fpid
);
79 /* Delete the parent. */
80 detach_inferior (pid
);
82 add_thread_silent (inferior_ptid
);
86 /* Breakpoints have already been detached from the child by
89 if (ptrace (PT_DETACH
, fpid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
90 perror_with_name (("ptrace"));
96 #endif /* PT_GET_PROCESS_STATE */
99 /* Prepare to be traced. */
104 /* "Trace me, Dr. Memory!" */
105 ptrace (PT_TRACE_ME
, 0, (PTRACE_TYPE_ARG3
)0, 0);
108 /* Start a new inferior Unix child process. EXEC_FILE is the file to
109 run, ALLARGS is a string containing the arguments to the program.
110 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
114 inf_ptrace_create_inferior (struct target_ops
*ops
,
115 char *exec_file
, char *allargs
, char **env
,
120 /* Do not change either targets above or the same target if already present.
121 The reason is the target stack is shared across multiple inferiors. */
122 int ops_already_pushed
= target_is_pushed (ops
);
123 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
125 if (! ops_already_pushed
)
127 /* Clear possible core file with its process_stratum. */
129 make_cleanup_unpush_target (ops
);
132 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ptrace_me
, NULL
,
135 discard_cleanups (back_to
);
137 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
139 /* On some targets, there must be some explicit actions taken after
140 the inferior has been started up. */
141 target_post_startup_inferior (pid_to_ptid (pid
));
144 #ifdef PT_GET_PROCESS_STATE
147 inf_ptrace_post_startup_inferior (struct target_ops
*self
, ptid_t pid
)
151 /* Set the initial event mask. */
152 memset (&pe
, 0, sizeof pe
);
153 pe
.pe_set_event
|= PTRACE_FORK
;
154 if (ptrace (PT_SET_EVENT_MASK
, ptid_get_pid (pid
),
155 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
156 perror_with_name (("ptrace"));
161 /* Clean up a rotting corpse of an inferior after it died. */
164 inf_ptrace_mourn_inferior (struct target_ops
*ops
)
168 /* Wait just one more time to collect the inferior's exit status.
169 Do not check whether this succeeds though, since we may be
170 dealing with a process that we attached to. Such a process will
171 only report its exit status to its original parent. */
172 waitpid (ptid_get_pid (inferior_ptid
), &status
, 0);
174 inf_child_mourn_inferior (ops
);
177 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
178 be chatty about it. */
181 inf_ptrace_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
185 struct inferior
*inf
;
187 /* Do not change either targets above or the same target if already present.
188 The reason is the target stack is shared across multiple inferiors. */
189 int ops_already_pushed
= target_is_pushed (ops
);
190 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
192 pid
= parse_pid_to_attach (args
);
194 if (pid
== getpid ()) /* Trying to masturbate? */
195 error (_("I refuse to debug myself!"));
197 if (! ops_already_pushed
)
199 /* target_pid_to_str already uses the target. Also clear possible core
200 file with its process_stratum. */
202 make_cleanup_unpush_target (ops
);
207 exec_file
= get_exec_file (0);
210 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
211 target_pid_to_str (pid_to_ptid (pid
)));
213 printf_unfiltered (_("Attaching to %s\n"),
214 target_pid_to_str (pid_to_ptid (pid
)));
216 gdb_flush (gdb_stdout
);
221 ptrace (PT_ATTACH
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
223 perror_with_name (("ptrace"));
225 error (_("This system does not support attaching to a process"));
228 inf
= current_inferior ();
229 inferior_appeared (inf
, pid
);
230 inf
->attach_flag
= 1;
231 inferior_ptid
= pid_to_ptid (pid
);
233 /* Always add a main thread. If some target extends the ptrace
234 target, it should decorate the ptid later with more info. */
235 add_thread_silent (inferior_ptid
);
237 discard_cleanups (back_to
);
240 #ifdef PT_GET_PROCESS_STATE
243 inf_ptrace_post_attach (struct target_ops
*self
, int pid
)
247 /* Set the initial event mask. */
248 memset (&pe
, 0, sizeof pe
);
249 pe
.pe_set_event
|= PTRACE_FORK
;
250 if (ptrace (PT_SET_EVENT_MASK
, pid
,
251 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
252 perror_with_name (("ptrace"));
257 /* Detach from the inferior, optionally passing it the signal
258 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */
261 inf_ptrace_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
263 pid_t pid
= ptid_get_pid (inferior_ptid
);
268 char *exec_file
= get_exec_file (0);
271 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
272 target_pid_to_str (pid_to_ptid (pid
)));
273 gdb_flush (gdb_stdout
);
279 /* We'd better not have left any breakpoints in the program or it'll
280 die when it hits one. Also note that this may only work if we
281 previously attached to the inferior. It *might* work if we
282 started the process ourselves. */
284 ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
)1, sig
);
286 perror_with_name (("ptrace"));
288 error (_("This system does not support detaching from a process"));
291 inferior_ptid
= null_ptid
;
292 detach_inferior (pid
);
294 inf_child_maybe_unpush_target (ops
);
297 /* Kill the inferior. */
300 inf_ptrace_kill (struct target_ops
*ops
)
302 pid_t pid
= ptid_get_pid (inferior_ptid
);
308 ptrace (PT_KILL
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
309 waitpid (pid
, &status
, 0);
311 target_mourn_inferior ();
314 /* Stop the inferior. */
317 inf_ptrace_stop (struct target_ops
*self
, ptid_t ptid
)
319 /* Send a SIGINT to the process group. This acts just like the user
320 typed a ^C on the controlling terminal. Note that using a
321 negative process number in kill() is a System V-ism. The proper
322 BSD interface is killpg(). However, all modern BSDs support the
323 System V interface too. */
324 kill (-inferior_process_group (), SIGINT
);
327 /* Resume execution of thread PTID, or all threads if PTID is -1. If
328 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
332 inf_ptrace_resume (struct target_ops
*ops
,
333 ptid_t ptid
, int step
, enum gdb_signal signal
)
335 pid_t pid
= ptid_get_pid (ptid
);
339 /* Resume all threads. Traditionally ptrace() only supports
340 single-threaded processes, so simply resume the inferior. */
341 pid
= ptid_get_pid (inferior_ptid
);
343 if (catch_syscall_enabled () > 0)
344 request
= PT_SYSCALL
;
346 request
= PT_CONTINUE
;
350 /* If this system does not support PT_STEP, a higher level
351 function will have called single_step() to transmute the step
352 request into a continue request (by setting breakpoints on
353 all possible successor instructions), so we don't have to
354 worry about that here. */
358 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
359 where it was. If GDB wanted it to start some other way, we have
360 already written a new program counter value to the child. */
362 ptrace (request
, pid
, (PTRACE_TYPE_ARG3
)1, gdb_signal_to_host (signal
));
364 perror_with_name (("ptrace"));
367 /* Wait for the child specified by PTID to do something. Return the
368 process ID of the child, or MINUS_ONE_PTID in case of error; store
369 the status in *OURSTATUS. */
372 inf_ptrace_wait (struct target_ops
*ops
,
373 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
376 int status
, save_errno
;
384 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
387 while (pid
== -1 && errno
== EINTR
);
389 clear_sigint_trap ();
393 fprintf_unfiltered (gdb_stderr
,
394 _("Child process unexpectedly missing: %s.\n"),
395 safe_strerror (save_errno
));
397 /* Claim it exited with unknown signal. */
398 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
399 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
400 return inferior_ptid
;
403 /* Ignore terminated detached child processes. */
404 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
409 #ifdef PT_GET_PROCESS_STATE
410 if (WIFSTOPPED (status
))
415 if (ptrace (PT_GET_PROCESS_STATE
, pid
,
416 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
417 perror_with_name (("ptrace"));
419 switch (pe
.pe_report_event
)
422 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
423 ourstatus
->value
.related_pid
= pid_to_ptid (pe
.pe_other_pid
);
425 /* Make sure the other end of the fork is stopped too. */
426 fpid
= waitpid (pe
.pe_other_pid
, &status
, 0);
428 perror_with_name (("waitpid"));
430 if (ptrace (PT_GET_PROCESS_STATE
, fpid
,
431 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
432 perror_with_name (("ptrace"));
434 gdb_assert (pe
.pe_report_event
== PTRACE_FORK
);
435 gdb_assert (pe
.pe_other_pid
== pid
);
436 if (fpid
== ptid_get_pid (inferior_ptid
))
438 ourstatus
->value
.related_pid
= pid_to_ptid (pe
.pe_other_pid
);
439 return pid_to_ptid (fpid
);
442 return pid_to_ptid (pid
);
447 store_waitstatus (ourstatus
, status
);
448 return pid_to_ptid (pid
);
451 /* Implement the to_xfer_partial target_ops method. */
453 static enum target_xfer_status
454 inf_ptrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
455 const char *annex
, gdb_byte
*readbuf
,
456 const gdb_byte
*writebuf
,
457 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
459 pid_t pid
= ptid_get_pid (inferior_ptid
);
463 case TARGET_OBJECT_MEMORY
:
465 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
466 request that promises to be much more efficient in reading
467 and writing data in the traced process's address space. */
469 struct ptrace_io_desc piod
;
471 /* NOTE: We assume that there are no distinct address spaces
472 for instruction and data. However, on OpenBSD 3.9 and
473 later, PIOD_WRITE_D doesn't allow changing memory that's
474 mapped read-only. Since most code segments will be
475 read-only, using PIOD_WRITE_D will prevent us from
476 inserting breakpoints, so we use PIOD_WRITE_I instead. */
477 piod
.piod_op
= writebuf
? PIOD_WRITE_I
: PIOD_READ_D
;
478 piod
.piod_addr
= writebuf
? (void *) writebuf
: readbuf
;
479 piod
.piod_offs
= (void *) (long) offset
;
483 if (ptrace (PT_IO
, pid
, (caddr_t
)&piod
, 0) == 0)
485 /* Return the actual number of bytes read or written. */
486 *xfered_len
= piod
.piod_len
;
487 return (piod
.piod_len
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
489 /* If the PT_IO request is somehow not supported, fallback on
490 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
491 to indicate failure. */
493 return TARGET_XFER_EOF
;
499 PTRACE_TYPE_RET word
;
500 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
502 ULONGEST rounded_offset
;
503 ULONGEST partial_len
;
505 /* Round the start offset down to the next long word
507 rounded_offset
= offset
& -(ULONGEST
) sizeof (PTRACE_TYPE_RET
);
509 /* Since ptrace will transfer a single word starting at that
510 rounded_offset the partial_len needs to be adjusted down to
511 that (remember this function only does a single transfer).
512 Should the required length be even less, adjust it down
514 partial_len
= (rounded_offset
+ sizeof (PTRACE_TYPE_RET
)) - offset
;
515 if (partial_len
> len
)
520 /* If OFFSET:PARTIAL_LEN is smaller than
521 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
522 be needed. Read in the entire word. */
523 if (rounded_offset
< offset
524 || (offset
+ partial_len
525 < rounded_offset
+ sizeof (PTRACE_TYPE_RET
)))
526 /* Need part of initial word -- fetch it. */
527 buffer
.word
= ptrace (PT_READ_I
, pid
,
528 (PTRACE_TYPE_ARG3
)(uintptr_t)
531 /* Copy data to be written over corresponding part of
533 memcpy (buffer
.byte
+ (offset
- rounded_offset
),
534 writebuf
, partial_len
);
537 ptrace (PT_WRITE_D
, pid
,
538 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
542 /* Using the appropriate one (I or D) is necessary for
543 Gould NP1, at least. */
545 ptrace (PT_WRITE_I
, pid
,
546 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
549 return TARGET_XFER_EOF
;
556 buffer
.word
= ptrace (PT_READ_I
, pid
,
557 (PTRACE_TYPE_ARG3
)(uintptr_t)rounded_offset
,
560 return TARGET_XFER_EOF
;
561 /* Copy appropriate bytes out of the buffer. */
562 memcpy (readbuf
, buffer
.byte
+ (offset
- rounded_offset
),
566 *xfered_len
= partial_len
;
567 return TARGET_XFER_OK
;
570 case TARGET_OBJECT_UNWIND_TABLE
:
571 return TARGET_XFER_E_IO
;
573 case TARGET_OBJECT_AUXV
:
574 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
575 /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
576 request that allows us to read the auxilliary vector. Other
577 BSD's may follow if they feel the need to support PIE. */
579 struct ptrace_io_desc piod
;
582 return TARGET_XFER_E_IO
;
583 piod
.piod_op
= PIOD_READ_AUXV
;
584 piod
.piod_addr
= readbuf
;
585 piod
.piod_offs
= (void *) (long) offset
;
589 if (ptrace (PT_IO
, pid
, (caddr_t
)&piod
, 0) == 0)
591 /* Return the actual number of bytes read or written. */
592 *xfered_len
= piod
.piod_len
;
593 return (piod
.piod_len
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
597 return TARGET_XFER_E_IO
;
599 case TARGET_OBJECT_WCOOKIE
:
600 return TARGET_XFER_E_IO
;
603 return TARGET_XFER_E_IO
;
607 /* Return non-zero if the thread specified by PTID is alive. */
610 inf_ptrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
612 /* ??? Is kill the right way to do this? */
613 return (kill (ptid_get_pid (ptid
), 0) != -1);
616 /* Print status information about what we're accessing. */
619 inf_ptrace_files_info (struct target_ops
*ignore
)
621 struct inferior
*inf
= current_inferior ();
623 printf_filtered (_("\tUsing the running image of %s %s.\n"),
624 inf
->attach_flag
? "attached" : "child",
625 target_pid_to_str (inferior_ptid
));
629 inf_ptrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
631 return normal_pid_to_str (ptid
);
634 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
636 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
637 Return 0 if *READPTR is already at the end of the buffer.
638 Return -1 if there is insufficient buffer for a whole entry.
639 Return 1 if an entry was read into *TYPEP and *VALP. */
642 inf_ptrace_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
643 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
645 struct type
*int_type
= builtin_type (target_gdbarch ())->builtin_int
;
646 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
647 const int sizeof_auxv_type
= TYPE_LENGTH (int_type
);
648 const int sizeof_auxv_val
= TYPE_LENGTH (ptr_type
);
649 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
650 gdb_byte
*ptr
= *readptr
;
655 if (endptr
- ptr
< 2 * sizeof_auxv_val
)
658 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_type
, byte_order
);
659 ptr
+= sizeof_auxv_val
; /* Alignment. */
660 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_val
, byte_order
);
661 ptr
+= sizeof_auxv_val
;
669 /* Create a prototype ptrace target. The client can override it with
673 inf_ptrace_target (void)
675 struct target_ops
*t
= inf_child_target ();
677 t
->to_attach
= inf_ptrace_attach
;
678 t
->to_detach
= inf_ptrace_detach
;
679 t
->to_resume
= inf_ptrace_resume
;
680 t
->to_wait
= inf_ptrace_wait
;
681 t
->to_files_info
= inf_ptrace_files_info
;
682 t
->to_kill
= inf_ptrace_kill
;
683 t
->to_create_inferior
= inf_ptrace_create_inferior
;
684 #ifdef PT_GET_PROCESS_STATE
685 t
->to_follow_fork
= inf_ptrace_follow_fork
;
686 t
->to_post_startup_inferior
= inf_ptrace_post_startup_inferior
;
687 t
->to_post_attach
= inf_ptrace_post_attach
;
689 t
->to_mourn_inferior
= inf_ptrace_mourn_inferior
;
690 t
->to_thread_alive
= inf_ptrace_thread_alive
;
691 t
->to_pid_to_str
= inf_ptrace_pid_to_str
;
692 t
->to_stop
= inf_ptrace_stop
;
693 t
->to_xfer_partial
= inf_ptrace_xfer_partial
;
694 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
695 t
->to_auxv_parse
= inf_ptrace_auxv_parse
;
702 /* Pointer to a function that returns the offset within the user area
703 where a particular register is stored. */
704 static CORE_ADDR (*inf_ptrace_register_u_offset
)(struct gdbarch
*, int, int);
706 /* Fetch register REGNUM from the inferior. */
709 inf_ptrace_fetch_register (struct regcache
*regcache
, int regnum
)
711 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
714 PTRACE_TYPE_RET
*buf
;
717 /* This isn't really an address, but ptrace thinks of it as one. */
718 addr
= inf_ptrace_register_u_offset (gdbarch
, regnum
, 0);
719 if (addr
== (CORE_ADDR
)-1
720 || gdbarch_cannot_fetch_register (gdbarch
, regnum
))
722 regcache_raw_supply (regcache
, regnum
, NULL
);
726 /* Cater for systems like GNU/Linux, that implement threads as
727 separate processes. */
728 pid
= ptid_get_lwp (inferior_ptid
);
730 pid
= ptid_get_pid (inferior_ptid
);
732 size
= register_size (gdbarch
, regnum
);
733 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
736 /* Read the register contents from the inferior a chunk at a time. */
737 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
740 buf
[i
] = ptrace (PT_READ_U
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t)addr
, 0);
742 error (_("Couldn't read register %s (#%d): %s."),
743 gdbarch_register_name (gdbarch
, regnum
),
744 regnum
, safe_strerror (errno
));
746 addr
+= sizeof (PTRACE_TYPE_RET
);
748 regcache_raw_supply (regcache
, regnum
, buf
);
751 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
752 for all registers. */
755 inf_ptrace_fetch_registers (struct target_ops
*ops
,
756 struct regcache
*regcache
, int regnum
)
760 regnum
< gdbarch_num_regs (get_regcache_arch (regcache
));
762 inf_ptrace_fetch_register (regcache
, regnum
);
764 inf_ptrace_fetch_register (regcache
, regnum
);
767 /* Store register REGNUM into the inferior. */
770 inf_ptrace_store_register (const struct regcache
*regcache
, int regnum
)
772 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
775 PTRACE_TYPE_RET
*buf
;
778 /* This isn't really an address, but ptrace thinks of it as one. */
779 addr
= inf_ptrace_register_u_offset (gdbarch
, regnum
, 1);
780 if (addr
== (CORE_ADDR
)-1
781 || gdbarch_cannot_store_register (gdbarch
, regnum
))
784 /* Cater for systems like GNU/Linux, that implement threads as
785 separate processes. */
786 pid
= ptid_get_lwp (inferior_ptid
);
788 pid
= ptid_get_pid (inferior_ptid
);
790 size
= register_size (gdbarch
, regnum
);
791 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
794 /* Write the register contents into the inferior a chunk at a time. */
795 regcache_raw_collect (regcache
, regnum
, buf
);
796 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
799 ptrace (PT_WRITE_U
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t)addr
, buf
[i
]);
801 error (_("Couldn't write register %s (#%d): %s."),
802 gdbarch_register_name (gdbarch
, regnum
),
803 regnum
, safe_strerror (errno
));
805 addr
+= sizeof (PTRACE_TYPE_RET
);
809 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
810 this for all registers. */
813 inf_ptrace_store_registers (struct target_ops
*ops
,
814 struct regcache
*regcache
, int regnum
)
818 regnum
< gdbarch_num_regs (get_regcache_arch (regcache
));
820 inf_ptrace_store_register (regcache
, regnum
);
822 inf_ptrace_store_register (regcache
, regnum
);
825 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
826 a function returning the offset within the user area where a
827 particular register is stored. */
830 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset
)
831 (struct gdbarch
*, int, int))
833 struct target_ops
*t
= inf_ptrace_target();
835 gdb_assert (register_u_offset
);
836 inf_ptrace_register_u_offset
= register_u_offset
;
837 t
->to_fetch_registers
= inf_ptrace_fetch_registers
;
838 t
->to_store_registers
= inf_ptrace_store_registers
;