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