Adjust fork/vfork/exec to pass ptids around.
[external/binutils.git] / gdb / inf-ptrace.c
1 /* Low-level child interface to ptrace.
2
3    Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
4    1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008
5    Free Software Foundation, Inc.
6
7    This file is part of GDB.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
22 #include "defs.h"
23 #include "command.h"
24 #include "inferior.h"
25 #include "inflow.h"
26 #include "gdbcore.h"
27 #include "regcache.h"
28
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "gdb_ptrace.h"
32 #include "gdb_wait.h"
33 #include <signal.h>
34
35 #include "inf-child.h"
36
37 /* HACK: Save the ptrace ops returned by inf_ptrace_target.  */
38 static struct target_ops *ptrace_ops_hack;
39 \f
40
41 #ifdef PT_GET_PROCESS_STATE
42
43 static int
44 inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
45 {
46   pid_t pid, fpid;
47   ptrace_state_t pe;
48
49   /* FIXME: kettenis/20050720: This stuff should really be passed as
50      an argument by our caller.  */
51   {
52     ptid_t ptid;
53     struct target_waitstatus status;
54
55     get_last_target_status (&ptid, &status);
56     gdb_assert (status.kind == TARGET_WAITKIND_FORKED);
57
58     pid = ptid_get_pid (ptid);
59   }
60
61   if (ptrace (PT_GET_PROCESS_STATE, pid,
62                (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
63     perror_with_name (("ptrace"));
64
65   gdb_assert (pe.pe_report_event == PTRACE_FORK);
66   fpid = pe.pe_other_pid;
67
68   if (follow_child)
69     {
70       inferior_ptid = pid_to_ptid (fpid);
71       detach_breakpoints (pid);
72
73       /* Reset breakpoints in the child as appropriate.  */
74       follow_inferior_reset_breakpoints ();
75
76       if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
77         perror_with_name (("ptrace"));
78     }
79   else
80     {
81       inferior_ptid = pid_to_ptid (pid);
82       detach_breakpoints (fpid);
83
84       if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
85         perror_with_name (("ptrace"));
86     }
87
88   return 0;
89 }
90
91 #endif /* PT_GET_PROCESS_STATE */
92 \f
93
94 /* Prepare to be traced.  */
95
96 static void
97 inf_ptrace_me (void)
98 {
99   /* "Trace me, Dr. Memory!"  */
100   ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
101 }
102
103 /* Start tracing PID.  */
104
105 static void
106 inf_ptrace_him (int pid)
107 {
108   push_target (ptrace_ops_hack);
109
110   /* On some targets, there must be some explicit synchronization
111      between the parent and child processes after the debugger
112      forks, and before the child execs the debuggee program.  This
113      call basically gives permission for the child to exec.  */
114
115   target_acknowledge_created_inferior (pid);
116
117   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
118      be 1 or 2 depending on whether we're starting without or with a
119      shell.  */
120   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
121
122   /* On some targets, there must be some explicit actions taken after
123      the inferior has been started up.  */
124   target_post_startup_inferior (pid_to_ptid (pid));
125 }
126
127 /* Start a new inferior Unix child process.  EXEC_FILE is the file to
128    run, ALLARGS is a string containing the arguments to the program.
129    ENV is the environment vector to pass.  If FROM_TTY is non-zero, be
130    chatty about it.  */
131
132 static void
133 inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env,
134                             int from_tty)
135 {
136   fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him,
137                  NULL, NULL);
138 }
139
140 #ifdef PT_GET_PROCESS_STATE
141
142 static void
143 inf_ptrace_post_startup_inferior (ptid_t pid)
144 {
145   ptrace_event_t pe;
146
147   /* Set the initial event mask.  */
148   memset (&pe, 0, sizeof pe);
149   pe.pe_set_event |= PTRACE_FORK;
150   if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
151               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
152     perror_with_name (("ptrace"));
153 }
154
155 #endif
156
157 /* Clean up a rotting corpse of an inferior after it died.  */
158
159 static void
160 inf_ptrace_mourn_inferior (void)
161 {
162   int status;
163
164   /* Wait just one more time to collect the inferior's exit status.
165      Do not check whether this succeeds though, since we may be
166      dealing with a process that we attached to.  Such a process will
167      only report its exit status to its original parent.  */
168   waitpid (ptid_get_pid (inferior_ptid), &status, 0);
169
170   unpush_target (ptrace_ops_hack);
171   generic_mourn_inferior ();
172 }
173
174 /* Attach to the process specified by ARGS.  If FROM_TTY is non-zero,
175    be chatty about it.  */
176
177 static void
178 inf_ptrace_attach (char *args, int from_tty)
179 {
180   char *exec_file;
181   pid_t pid;
182   char *dummy;
183
184   if (!args)
185     error_no_arg (_("process-id to attach"));
186
187   dummy = args;
188   pid = strtol (args, &dummy, 0);
189   /* Some targets don't set errno on errors, grrr!  */
190   if (pid == 0 && args == dummy)
191     error (_("Illegal process-id: %s."), args);
192
193   if (pid == getpid ())         /* Trying to masturbate?  */
194     error (_("I refuse to debug myself!"));
195
196   if (from_tty)
197     {
198       exec_file = get_exec_file (0);
199
200       if (exec_file)
201         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
202                            target_pid_to_str (pid_to_ptid (pid)));
203       else
204         printf_unfiltered (_("Attaching to %s\n"),
205                            target_pid_to_str (pid_to_ptid (pid)));
206
207       gdb_flush (gdb_stdout);
208     }
209
210 #ifdef PT_ATTACH
211   errno = 0;
212   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
213   if (errno != 0)
214     perror_with_name (("ptrace"));
215   attach_flag = 1;
216 #else
217   error (_("This system does not support attaching to a process"));
218 #endif
219
220   inferior_ptid = pid_to_ptid (pid);
221   push_target (ptrace_ops_hack);
222 }
223
224 #ifdef PT_GET_PROCESS_STATE
225
226 void
227 inf_ptrace_post_attach (int pid)
228 {
229   ptrace_event_t pe;
230
231   /* Set the initial event mask.  */
232   memset (&pe, 0, sizeof pe);
233   pe.pe_set_event |= PTRACE_FORK;
234   if (ptrace (PT_SET_EVENT_MASK, pid,
235               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
236     perror_with_name (("ptrace"));
237 }
238
239 #endif
240
241 /* Detach from the inferior, optionally passing it the signal
242    specified by ARGS.  If FROM_TTY is non-zero, be chatty about it.  */
243
244 static void
245 inf_ptrace_detach (char *args, int from_tty)
246 {
247   pid_t pid = ptid_get_pid (inferior_ptid);
248   int sig = 0;
249
250   if (from_tty)
251     {
252       char *exec_file = get_exec_file (0);
253       if (exec_file == 0)
254         exec_file = "";
255       printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
256                          target_pid_to_str (pid_to_ptid (pid)));
257       gdb_flush (gdb_stdout);
258     }
259   if (args)
260     sig = atoi (args);
261
262 #ifdef PT_DETACH
263   /* We'd better not have left any breakpoints in the program or it'll
264      die when it hits one.  Also note that this may only work if we
265      previously attached to the inferior.  It *might* work if we
266      started the process ourselves.  */
267   errno = 0;
268   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
269   if (errno != 0)
270     perror_with_name (("ptrace"));
271   attach_flag = 0;
272 #else
273   error (_("This system does not support detaching from a process"));
274 #endif
275
276   inferior_ptid = null_ptid;
277   unpush_target (ptrace_ops_hack);
278 }
279
280 /* Kill the inferior.  */
281
282 static void
283 inf_ptrace_kill (void)
284 {
285   pid_t pid = ptid_get_pid (inferior_ptid);
286   int status;
287
288   if (pid == 0)
289     return;
290
291   ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
292   waitpid (pid, &status, 0);
293
294   target_mourn_inferior ();
295 }
296
297 /* Stop the inferior.  */
298
299 static void
300 inf_ptrace_stop (void)
301 {
302   /* Send a SIGINT to the process group.  This acts just like the user
303      typed a ^C on the controlling terminal.  Note that using a
304      negative process number in kill() is a System V-ism.  The proper
305      BSD interface is killpg().  However, all modern BSDs support the
306      System V interface too.  */
307   kill (-inferior_process_group, SIGINT);
308 }
309
310 /* Resume execution of thread PTID, or all threads if PTID is -1.  If
311    STEP is nonzero, single-step it.  If SIGNAL is nonzero, give it
312    that signal.  */
313
314 static void
315 inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal)
316 {
317   pid_t pid = ptid_get_pid (ptid);
318   int request = PT_CONTINUE;
319
320   if (pid == -1)
321     /* Resume all threads.  Traditionally ptrace() only supports
322        single-threaded processes, so simply resume the inferior.  */
323     pid = ptid_get_pid (inferior_ptid);
324
325   if (step)
326     {
327       /* If this system does not support PT_STEP, a higher level
328          function will have called single_step() to transmute the step
329          request into a continue request (by setting breakpoints on
330          all possible successor instructions), so we don't have to
331          worry about that here.  */
332       request = PT_STEP;
333     }
334
335   /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
336      where it was.  If GDB wanted it to start some other way, we have
337      already written a new program counter value to the child.  */
338   errno = 0;
339   ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal));
340   if (errno != 0)
341     perror_with_name (("ptrace"));
342 }
343
344 /* Wait for the child specified by PTID to do something.  Return the
345    process ID of the child, or MINUS_ONE_PTID in case of error; store
346    the status in *OURSTATUS.  */
347
348 static ptid_t
349 inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
350 {
351   pid_t pid;
352   int status, save_errno;
353
354   do
355     {
356       set_sigint_trap ();
357       set_sigio_trap ();
358
359       do
360         {
361           pid = waitpid (ptid_get_pid (ptid), &status, 0);
362           save_errno = errno;
363         }
364       while (pid == -1 && errno == EINTR);
365
366       clear_sigio_trap ();
367       clear_sigint_trap ();
368
369       if (pid == -1)
370         {
371           fprintf_unfiltered (gdb_stderr,
372                               _("Child process unexpectedly missing: %s.\n"),
373                               safe_strerror (save_errno));
374
375           /* Claim it exited with unknown signal.  */
376           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
377           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
378           return minus_one_ptid;
379         }
380
381       /* Ignore terminated detached child processes.  */
382       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
383         pid = -1;
384     }
385   while (pid == -1);
386
387 #ifdef PT_GET_PROCESS_STATE
388   if (WIFSTOPPED (status))
389     {
390       ptrace_state_t pe;
391       pid_t fpid;
392
393       if (ptrace (PT_GET_PROCESS_STATE, pid,
394                   (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
395         perror_with_name (("ptrace"));
396
397       switch (pe.pe_report_event)
398         {
399         case PTRACE_FORK:
400           ourstatus->kind = TARGET_WAITKIND_FORKED;
401           ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
402
403           /* Make sure the other end of the fork is stopped too.  */
404           fpid = waitpid (pe.pe_other_pid, &status, 0);
405           if (fpid == -1)
406             perror_with_name (("waitpid"));
407
408           if (ptrace (PT_GET_PROCESS_STATE, fpid,
409                       (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
410             perror_with_name (("ptrace"));
411
412           gdb_assert (pe.pe_report_event == PTRACE_FORK);
413           gdb_assert (pe.pe_other_pid == pid);
414           if (fpid == ptid_get_pid (inferior_ptid))
415             {
416               ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
417               return pid_to_ptid (fpid);
418             }
419
420           return pid_to_ptid (pid);
421         }
422     }
423 #endif
424
425   store_waitstatus (ourstatus, status);
426   return pid_to_ptid (pid);
427 }
428
429 /* Attempt a transfer all LEN bytes starting at OFFSET between the
430    inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
431    Return the number of bytes actually transferred.  */
432
433 static LONGEST
434 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
435                          const char *annex, gdb_byte *readbuf,
436                          const gdb_byte *writebuf,
437                          ULONGEST offset, LONGEST len)
438 {
439   pid_t pid = ptid_get_pid (inferior_ptid);
440
441   switch (object)
442     {
443     case TARGET_OBJECT_MEMORY:
444 #ifdef PT_IO
445       /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
446          request that promises to be much more efficient in reading
447          and writing data in the traced process's address space.  */
448       {
449         struct ptrace_io_desc piod;
450
451         /* NOTE: We assume that there are no distinct address spaces
452            for instruction and data.  However, on OpenBSD 3.9 and
453            later, PIOD_WRITE_D doesn't allow changing memory that's
454            mapped read-only.  Since most code segments will be
455            read-only, using PIOD_WRITE_D will prevent us from
456            inserting breakpoints, so we use PIOD_WRITE_I instead.  */
457         piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
458         piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
459         piod.piod_offs = (void *) (long) offset;
460         piod.piod_len = len;
461
462         errno = 0;
463         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
464           /* Return the actual number of bytes read or written.  */
465           return piod.piod_len;
466         /* If the PT_IO request is somehow not supported, fallback on
467            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
468            to indicate failure.  */
469         if (errno != EINVAL)
470           return 0;
471       }
472 #endif
473       {
474         union
475         {
476           PTRACE_TYPE_RET word;
477           gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
478         } buffer;
479         ULONGEST rounded_offset;
480         LONGEST partial_len;
481
482         /* Round the start offset down to the next long word
483            boundary.  */
484         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
485
486         /* Since ptrace will transfer a single word starting at that
487            rounded_offset the partial_len needs to be adjusted down to
488            that (remember this function only does a single transfer).
489            Should the required length be even less, adjust it down
490            again.  */
491         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
492         if (partial_len > len)
493           partial_len = len;
494
495         if (writebuf)
496           {
497             /* If OFFSET:PARTIAL_LEN is smaller than
498                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
499                be needed.  Read in the entire word.  */
500             if (rounded_offset < offset
501                 || (offset + partial_len
502                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
503               /* Need part of initial word -- fetch it.  */
504               buffer.word = ptrace (PT_READ_I, pid,
505                                     (PTRACE_TYPE_ARG3)(uintptr_t)
506                                     rounded_offset, 0);
507
508             /* Copy data to be written over corresponding part of
509                buffer.  */
510             memcpy (buffer.byte + (offset - rounded_offset),
511                     writebuf, partial_len);
512
513             errno = 0;
514             ptrace (PT_WRITE_D, pid,
515                     (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
516                     buffer.word);
517             if (errno)
518               {
519                 /* Using the appropriate one (I or D) is necessary for
520                    Gould NP1, at least.  */
521                 errno = 0;
522                 ptrace (PT_WRITE_I, pid,
523                         (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
524                         buffer.word);
525                 if (errno)
526                   return 0;
527               }
528           }
529
530         if (readbuf)
531           {
532             errno = 0;
533             buffer.word = ptrace (PT_READ_I, pid,
534                                   (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
535                                   0);
536             if (errno)
537               return 0;
538             /* Copy appropriate bytes out of the buffer.  */
539             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
540                     partial_len);
541           }
542
543         return partial_len;
544       }
545
546     case TARGET_OBJECT_UNWIND_TABLE:
547       return -1;
548
549     case TARGET_OBJECT_AUXV:
550       return -1;
551
552     case TARGET_OBJECT_WCOOKIE:
553       return -1;
554
555     default:
556       return -1;
557     }
558 }
559
560 /* Return non-zero if the thread specified by PTID is alive.  */
561
562 static int
563 inf_ptrace_thread_alive (ptid_t ptid)
564 {
565   /* ??? Is kill the right way to do this?  */
566   return (kill (ptid_get_pid (ptid), 0) != -1);
567 }
568
569 /* Print status information about what we're accessing.  */
570
571 static void
572 inf_ptrace_files_info (struct target_ops *ignore)
573 {
574   printf_filtered (_("\tUsing the running image of %s %s.\n"),
575                    attach_flag ? "attached" : "child",
576                    target_pid_to_str (inferior_ptid));
577 }
578
579 /* Create a prototype ptrace target.  The client can override it with
580    local methods.  */
581
582 struct target_ops *
583 inf_ptrace_target (void)
584 {
585   struct target_ops *t = inf_child_target ();
586
587   t->to_attach = inf_ptrace_attach;
588   t->to_detach = inf_ptrace_detach;
589   t->to_resume = inf_ptrace_resume;
590   t->to_wait = inf_ptrace_wait;
591   t->to_files_info = inf_ptrace_files_info;
592   t->to_kill = inf_ptrace_kill;
593   t->to_create_inferior = inf_ptrace_create_inferior;
594 #ifdef PT_GET_PROCESS_STATE
595   t->to_follow_fork = inf_ptrace_follow_fork;
596   t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
597   t->to_post_attach = inf_ptrace_post_attach;
598 #endif
599   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
600   t->to_thread_alive = inf_ptrace_thread_alive;
601   t->to_pid_to_str = normal_pid_to_str;
602   t->to_stop = inf_ptrace_stop;
603   t->to_xfer_partial = inf_ptrace_xfer_partial;
604
605   ptrace_ops_hack = t;
606   return t;
607 }
608 \f
609
610 /* Pointer to a function that returns the offset within the user area
611    where a particular register is stored.  */
612 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
613
614 /* Fetch register REGNUM from the inferior.  */
615
616 static void
617 inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
618 {
619   struct gdbarch *gdbarch = get_regcache_arch (regcache);
620   CORE_ADDR addr;
621   size_t size;
622   PTRACE_TYPE_RET *buf;
623   int pid, i;
624
625   /* This isn't really an address, but ptrace thinks of it as one.  */
626   addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
627   if (addr == (CORE_ADDR)-1
628       || gdbarch_cannot_fetch_register (gdbarch, regnum))
629     {
630       regcache_raw_supply (regcache, regnum, NULL);
631       return;
632     }
633
634   /* Cater for systems like GNU/Linux, that implement threads as
635      separate processes.  */
636   pid = ptid_get_lwp (inferior_ptid);
637   if (pid == 0)
638     pid = ptid_get_pid (inferior_ptid);
639
640   size = register_size (gdbarch, regnum);
641   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
642   buf = alloca (size);
643
644   /* Read the register contents from the inferior a chunk at a time.  */
645   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
646     {
647       errno = 0;
648       buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
649       if (errno != 0)
650         error (_("Couldn't read register %s (#%d): %s."),
651                gdbarch_register_name (gdbarch, regnum),
652                regnum, safe_strerror (errno));
653
654       addr += sizeof (PTRACE_TYPE_RET);
655     }
656   regcache_raw_supply (regcache, regnum, buf);
657 }
658
659 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
660    for all registers.  */
661
662 static void
663 inf_ptrace_fetch_registers (struct regcache *regcache, int regnum)
664 {
665   if (regnum == -1)
666     for (regnum = 0;
667          regnum < gdbarch_num_regs (get_regcache_arch (regcache));
668          regnum++)
669       inf_ptrace_fetch_register (regcache, regnum);
670   else
671     inf_ptrace_fetch_register (regcache, regnum);
672 }
673
674 /* Store register REGNUM into the inferior.  */
675
676 static void
677 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
678 {
679   struct gdbarch *gdbarch = get_regcache_arch (regcache);
680   CORE_ADDR addr;
681   size_t size;
682   PTRACE_TYPE_RET *buf;
683   int pid, i;
684
685   /* This isn't really an address, but ptrace thinks of it as one.  */
686   addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
687   if (addr == (CORE_ADDR)-1 
688       || gdbarch_cannot_store_register (gdbarch, regnum))
689     return;
690
691   /* Cater for systems like GNU/Linux, that implement threads as
692      separate processes.  */
693   pid = ptid_get_lwp (inferior_ptid);
694   if (pid == 0)
695     pid = ptid_get_pid (inferior_ptid);
696
697   size = register_size (gdbarch, regnum);
698   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
699   buf = alloca (size);
700
701   /* Write the register contents into the inferior a chunk at a time.  */
702   regcache_raw_collect (regcache, regnum, buf);
703   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
704     {
705       errno = 0;
706       ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
707       if (errno != 0)
708         error (_("Couldn't write register %s (#%d): %s."),
709                gdbarch_register_name (gdbarch, regnum),
710                regnum, safe_strerror (errno));
711
712       addr += sizeof (PTRACE_TYPE_RET);
713     }
714 }
715
716 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
717    this for all registers.  */
718
719 void
720 inf_ptrace_store_registers (struct regcache *regcache, int regnum)
721 {
722   if (regnum == -1)
723     for (regnum = 0;
724          regnum < gdbarch_num_regs (get_regcache_arch (regcache));
725          regnum++)
726       inf_ptrace_store_register (regcache, regnum);
727   else
728     inf_ptrace_store_register (regcache, regnum);
729 }
730
731 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be
732    a function returning the offset within the user area where a
733    particular register is stored.  */
734
735 struct target_ops *
736 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
737                                         (struct gdbarch *, int, int))
738 {
739   struct target_ops *t = inf_ptrace_target();
740
741   gdb_assert (register_u_offset);
742   inf_ptrace_register_u_offset = register_u_offset;
743   t->to_fetch_registers = inf_ptrace_fetch_registers;
744   t->to_store_registers = inf_ptrace_store_registers;
745
746   return t;
747 }