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