gdb/inf-ptrace.c

   1 /* Low-level child interface to ptrace.
   2
   3    Copyright (C) 1988-2018 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 #include "nat/fork-inferior.h"
  35 #include "utils.h"
  36
  37 \f
  38
  39 #ifdef PT_GET_PROCESS_STATE
  40
  41 /* Target hook for follow_fork.  On entry and at return inferior_ptid is
  42    the ptid of the followed inferior.  */
  43
  44 static int
  45 inf_ptrace_follow_fork (struct target_ops *ops, int follow_child,
  46                         int detach_fork)
  47 {
  48   if (!follow_child)
  49     {
  50       struct thread_info *tp = inferior_thread ();
  51       pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid);
  52
  53       /* Breakpoints have already been detached from the child by
  54          infrun.c.  */
  55
  56       if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
  57         perror_with_name (("ptrace"));
  58     }
  59
  60   return 0;
  61 }
  62
  63 static int
  64 inf_ptrace_insert_fork_catchpoint (struct target_ops *self, int pid)
  65 {
  66   return 0;
  67 }
  68
  69 static int
  70 inf_ptrace_remove_fork_catchpoint (struct target_ops *self, int pid)
  71 {
  72   return 0;
  73 }
  74
  75 #endif /* PT_GET_PROCESS_STATE */
  76 \f
  77
  78 /* Prepare to be traced.  */
  79
  80 static void
  81 inf_ptrace_me (void)
  82 {
  83   /* "Trace me, Dr. Memory!"  */
  84   if (ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3) 0, 0) < 0)
  85     trace_start_error_with_name ("ptrace");
  86 }
  87
  88 /* Start a new inferior Unix child process.  EXEC_FILE is the file to
  89    run, ALLARGS is a string containing the arguments to the program.
  90    ENV is the environment vector to pass.  If FROM_TTY is non-zero, be
  91    chatty about it.  */
  92
  93 static void
  94 inf_ptrace_create_inferior (struct target_ops *ops,
  95                             const char *exec_file, const std::string &allargs,
  96                             char **env, int from_tty)
  97 {
  98   pid_t pid;
  99   ptid_t ptid;
 100
 101   /* Do not change either targets above or the same target if already present.
 102      The reason is the target stack is shared across multiple inferiors.  */
 103   int ops_already_pushed = target_is_pushed (ops);
 104   struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
 105
 106   if (! ops_already_pushed)
 107     {
 108       /* Clear possible core file with its process_stratum.  */
 109       push_target (ops);
 110       make_cleanup_unpush_target (ops);
 111     }
 112
 113   pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
 114                        NULL, NULL, NULL);
 115
 116   ptid = pid_to_ptid (pid);
 117   /* We have something that executes now.  We'll be running through
 118      the shell at this point (if startup-with-shell is true), but the
 119      pid shouldn't change.  */
 120   add_thread_silent (ptid);
 121
 122   discard_cleanups (back_to);
 123
 124   gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
 125
 126   /* On some targets, there must be some explicit actions taken after
 127      the inferior has been started up.  */
 128   target_post_startup_inferior (ptid);
 129 }
 130
 131 #ifdef PT_GET_PROCESS_STATE
 132
 133 static void
 134 inf_ptrace_post_startup_inferior (struct target_ops *self, ptid_t pid)
 135 {
 136   ptrace_event_t pe;
 137
 138   /* Set the initial event mask.  */
 139   memset (&pe, 0, sizeof pe);
 140   pe.pe_set_event |= PTRACE_FORK;
 141   if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
 142               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 143     perror_with_name (("ptrace"));
 144 }
 145
 146 #endif
 147
 148 /* Clean up a rotting corpse of an inferior after it died.  */
 149
 150 static void
 151 inf_ptrace_mourn_inferior (struct target_ops *ops)
 152 {
 153   int status;
 154
 155   /* Wait just one more time to collect the inferior's exit status.
 156      Do not check whether this succeeds though, since we may be
 157      dealing with a process that we attached to.  Such a process will
 158      only report its exit status to its original parent.  */
 159   waitpid (ptid_get_pid (inferior_ptid), &status, 0);
 160
 161   inf_child_mourn_inferior (ops);
 162 }
 163
 164 /* Attach to the process specified by ARGS.  If FROM_TTY is non-zero,
 165    be chatty about it.  */
 166
 167 static void
 168 inf_ptrace_attach (struct target_ops *ops, const char *args, int from_tty)
 169 {
 170   char *exec_file;
 171   pid_t pid;
 172   struct inferior *inf;
 173
 174   /* Do not change either targets above or the same target if already present.
 175      The reason is the target stack is shared across multiple inferiors.  */
 176   int ops_already_pushed = target_is_pushed (ops);
 177   struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
 178
 179   pid = parse_pid_to_attach (args);
 180
 181   if (pid == getpid ())         /* Trying to masturbate?  */
 182     error (_("I refuse to debug myself!"));
 183
 184   if (! ops_already_pushed)
 185     {
 186       /* target_pid_to_str already uses the target.  Also clear possible core
 187          file with its process_stratum.  */
 188       push_target (ops);
 189       make_cleanup_unpush_target (ops);
 190     }
 191
 192   if (from_tty)
 193     {
 194       exec_file = get_exec_file (0);
 195
 196       if (exec_file)
 197         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
 198                            target_pid_to_str (pid_to_ptid (pid)));
 199       else
 200         printf_unfiltered (_("Attaching to %s\n"),
 201                            target_pid_to_str (pid_to_ptid (pid)));
 202
 203       gdb_flush (gdb_stdout);
 204     }
 205
 206 #ifdef PT_ATTACH
 207   errno = 0;
 208   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
 209   if (errno != 0)
 210     perror_with_name (("ptrace"));
 211 #else
 212   error (_("This system does not support attaching to a process"));
 213 #endif
 214
 215   inf = current_inferior ();
 216   inferior_appeared (inf, pid);
 217   inf->attach_flag = 1;
 218   inferior_ptid = pid_to_ptid (pid);
 219
 220   /* Always add a main thread.  If some target extends the ptrace
 221      target, it should decorate the ptid later with more info.  */
 222   add_thread_silent (inferior_ptid);
 223
 224   discard_cleanups (back_to);
 225 }
 226
 227 #ifdef PT_GET_PROCESS_STATE
 228
 229 static void
 230 inf_ptrace_post_attach (struct target_ops *self, int pid)
 231 {
 232   ptrace_event_t pe;
 233
 234   /* Set the initial event mask.  */
 235   memset (&pe, 0, sizeof pe);
 236   pe.pe_set_event |= PTRACE_FORK;
 237   if (ptrace (PT_SET_EVENT_MASK, pid,
 238               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 239     perror_with_name (("ptrace"));
 240 }
 241
 242 #endif
 243
 244 /* Detach from the inferior.  If FROM_TTY is non-zero, be chatty about it.  */
 245
 246 static void
 247 inf_ptrace_detach (struct target_ops *ops, inferior *inf, int from_tty)
 248 {
 249   pid_t pid = ptid_get_pid (inferior_ptid);
 250
 251   target_announce_detach (from_tty);
 252
 253 #ifdef PT_DETACH
 254   /* We'd better not have left any breakpoints in the program or it'll
 255      die when it hits one.  Also note that this may only work if we
 256      previously attached to the inferior.  It *might* work if we
 257      started the process ourselves.  */
 258   errno = 0;
 259   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0);
 260   if (errno != 0)
 261     perror_with_name (("ptrace"));
 262 #else
 263   error (_("This system does not support detaching from a process"));
 264 #endif
 265
 266   inf_ptrace_detach_success (ops, inf);
 267 }
 268
 269 /* See inf-ptrace.h.  */
 270
 271 void
 272 inf_ptrace_detach_success (struct target_ops *ops, inferior *inf)
 273 {
 274   inferior_ptid = null_ptid;
 275   detach_inferior (inf);
 276
 277   inf_child_maybe_unpush_target (ops);
 278 }
 279
 280 /* Kill the inferior.  */
 281
 282 static void
 283 inf_ptrace_kill (struct target_ops *ops)
 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 (inferior_ptid);
 295 }
 296
 297 /* Interrupt the inferior.  */
 298
 299 static void
 300 inf_ptrace_interrupt (struct target_ops *self, ptid_t ptid)
 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 /* Return which PID to pass to ptrace in order to observe/control the
 311    tracee identified by PTID.  */
 312
 313 pid_t
 314 get_ptrace_pid (ptid_t ptid)
 315 {
 316   pid_t pid;
 317
 318   /* If we have an LWPID to work with, use it.  Otherwise, we're
 319      dealing with a non-threaded program/target.  */
 320   pid = ptid_get_lwp (ptid);
 321   if (pid == 0)
 322     pid = ptid_get_pid (ptid);
 323   return pid;
 324 }
 325
 326 /* Resume execution of thread PTID, or all threads if PTID is -1.  If
 327    STEP is nonzero, single-step it.  If SIGNAL is nonzero, give it
 328    that signal.  */
 329
 330 static void
 331 inf_ptrace_resume (struct target_ops *ops,
 332                    ptid_t ptid, int step, enum gdb_signal signal)
 333 {
 334   pid_t pid;
 335   int request;
 336
 337   if (ptid_equal (minus_one_ptid, ptid))
 338     /* Resume all threads.  Traditionally ptrace() only supports
 339        single-threaded processes, so simply resume the inferior.  */
 340     pid = ptid_get_pid (inferior_ptid);
 341   else
 342     pid = get_ptrace_pid (ptid);
 343
 344   if (catch_syscall_enabled () > 0)
 345     request = PT_SYSCALL;
 346   else
 347     request = PT_CONTINUE;
 348
 349   if (step)
 350     {
 351       /* If this system does not support PT_STEP, a higher level
 352          function will have called single_step() to transmute the step
 353          request into a continue request (by setting breakpoints on
 354          all possible successor instructions), so we don't have to
 355          worry about that here.  */
 356       request = PT_STEP;
 357     }
 358
 359   /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
 360      where it was.  If GDB wanted it to start some other way, we have
 361      already written a new program counter value to the child.  */
 362   errno = 0;
 363   ptrace (request, pid, (PTRACE_TYPE_ARG3)1, gdb_signal_to_host (signal));
 364   if (errno != 0)
 365     perror_with_name (("ptrace"));
 366 }
 367
 368 /* Wait for the child specified by PTID to do something.  Return the
 369    process ID of the child, or MINUS_ONE_PTID in case of error; store
 370    the status in *OURSTATUS.  */
 371
 372 static ptid_t
 373 inf_ptrace_wait (struct target_ops *ops,
 374                  ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 375 {
 376   pid_t pid;
 377   int status, save_errno;
 378
 379   do
 380     {
 381       set_sigint_trap ();
 382
 383       do
 384         {
 385           pid = waitpid (ptid_get_pid (ptid), &status, 0);
 386           save_errno = errno;
 387         }
 388       while (pid == -1 && errno == EINTR);
 389
 390       clear_sigint_trap ();
 391
 392       if (pid == -1)
 393         {
 394           fprintf_unfiltered (gdb_stderr,
 395                               _("Child process unexpectedly missing: %s.\n"),
 396                               safe_strerror (save_errno));
 397
 398           /* Claim it exited with unknown signal.  */
 399           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 400           ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
 401           return inferior_ptid;
 402         }
 403
 404       /* Ignore terminated detached child processes.  */
 405       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
 406         pid = -1;
 407     }
 408   while (pid == -1);
 409
 410 #ifdef PT_GET_PROCESS_STATE
 411   if (WIFSTOPPED (status))
 412     {
 413       ptrace_state_t pe;
 414       pid_t fpid;
 415
 416       if (ptrace (PT_GET_PROCESS_STATE, pid,
 417                   (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 418         perror_with_name (("ptrace"));
 419
 420       switch (pe.pe_report_event)
 421         {
 422         case PTRACE_FORK:
 423           ourstatus->kind = TARGET_WAITKIND_FORKED;
 424           ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
 425
 426           /* Make sure the other end of the fork is stopped too.  */
 427           fpid = waitpid (pe.pe_other_pid, &status, 0);
 428           if (fpid == -1)
 429             perror_with_name (("waitpid"));
 430
 431           if (ptrace (PT_GET_PROCESS_STATE, fpid,
 432                       (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 433             perror_with_name (("ptrace"));
 434
 435           gdb_assert (pe.pe_report_event == PTRACE_FORK);
 436           gdb_assert (pe.pe_other_pid == pid);
 437           if (fpid == ptid_get_pid (inferior_ptid))
 438             {
 439               ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
 440               return pid_to_ptid (fpid);
 441             }
 442
 443           return pid_to_ptid (pid);
 444         }
 445     }
 446 #endif
 447
 448   store_waitstatus (ourstatus, status);
 449   return pid_to_ptid (pid);
 450 }
 451
 452 /* Transfer data via ptrace into process PID's memory from WRITEBUF, or
 453    from process PID's memory into READBUF.  Start at target address ADDR
 454    and transfer up to LEN bytes.  Exactly one of READBUF and WRITEBUF must
 455    be non-null.  Return the number of transferred bytes.  */
 456
 457 static ULONGEST
 458 inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf,
 459                       const gdb_byte *writebuf,
 460                       ULONGEST addr, ULONGEST len)
 461 {
 462   ULONGEST n;
 463   unsigned int chunk;
 464
 465   /* We transfer aligned words.  Thus align ADDR down to a word
 466      boundary and determine how many bytes to skip at the
 467      beginning.  */
 468   ULONGEST skip = addr & (sizeof (PTRACE_TYPE_RET) - 1);
 469   addr -= skip;
 470
 471   for (n = 0;
 472        n < len;
 473        n += chunk, addr += sizeof (PTRACE_TYPE_RET), skip = 0)
 474     {
 475       /* Restrict to a chunk that fits in the current word.  */
 476       chunk = std::min (sizeof (PTRACE_TYPE_RET) - skip, len - n);
 477
 478       /* Use a union for type punning.  */
 479       union
 480       {
 481         PTRACE_TYPE_RET word;
 482         gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 483       } buf;
 484
 485       /* Read the word, also when doing a partial word write.  */
 486       if (readbuf != NULL || chunk < sizeof (PTRACE_TYPE_RET))
 487         {
 488           errno = 0;
 489           buf.word = ptrace (PT_READ_I, pid,
 490                              (PTRACE_TYPE_ARG3)(uintptr_t) addr, 0);
 491           if (errno != 0)
 492             break;
 493           if (readbuf != NULL)
 494             memcpy (readbuf + n, buf.byte + skip, chunk);
 495         }
 496       if (writebuf != NULL)
 497         {
 498           memcpy (buf.byte + skip, writebuf + n, chunk);
 499           errno = 0;
 500           ptrace (PT_WRITE_D, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
 501                   buf.word);
 502           if (errno != 0)
 503             {
 504               /* Using the appropriate one (I or D) is necessary for
 505                  Gould NP1, at least.  */
 506               errno = 0;
 507               ptrace (PT_WRITE_I, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
 508                       buf.word);
 509               if (errno != 0)
 510                 break;
 511             }
 512         }
 513     }
 514
 515   return n;
 516 }
 517
 518 /* Implement the to_xfer_partial target_ops method.  */
 519
 520 static enum target_xfer_status
 521 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
 522                          const char *annex, gdb_byte *readbuf,
 523                          const gdb_byte *writebuf,
 524                          ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 525 {
 526   pid_t pid = get_ptrace_pid (inferior_ptid);
 527
 528   switch (object)
 529     {
 530     case TARGET_OBJECT_MEMORY:
 531 #ifdef PT_IO
 532       /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
 533          request that promises to be much more efficient in reading
 534          and writing data in the traced process's address space.  */
 535       {
 536         struct ptrace_io_desc piod;
 537
 538         /* NOTE: We assume that there are no distinct address spaces
 539            for instruction and data.  However, on OpenBSD 3.9 and
 540            later, PIOD_WRITE_D doesn't allow changing memory that's
 541            mapped read-only.  Since most code segments will be
 542            read-only, using PIOD_WRITE_D will prevent us from
 543            inserting breakpoints, so we use PIOD_WRITE_I instead.  */
 544         piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
 545         piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
 546         piod.piod_offs = (void *) (long) offset;
 547         piod.piod_len = len;
 548
 549         errno = 0;
 550         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 551           {
 552             /* Return the actual number of bytes read or written.  */
 553             *xfered_len = piod.piod_len;
 554             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 555           }
 556         /* If the PT_IO request is somehow not supported, fallback on
 557            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 558            to indicate failure.  */
 559         if (errno != EINVAL)
 560           return TARGET_XFER_EOF;
 561       }
 562 #endif
 563       *xfered_len = inf_ptrace_peek_poke (pid, readbuf, writebuf,
 564                                           offset, len);
 565       return *xfered_len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
 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 const 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 = regcache->arch ();
 711   CORE_ADDR addr;
 712   size_t size;
 713   PTRACE_TYPE_RET *buf;
 714   pid_t pid;
 715   int i;
 716
 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))
 721     {
 722       regcache_raw_supply (regcache, regnum, NULL);
 723       return;
 724     }
 725
 726   pid = get_ptrace_pid (regcache_get_ptid (regcache));
 727
 728   size = register_size (gdbarch, regnum);
 729   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 730   buf = (PTRACE_TYPE_RET *) alloca (size);
 731
 732   /* Read the register contents from the inferior a chunk at a time.  */
 733   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 734     {
 735       errno = 0;
 736       buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
 737       if (errno != 0)
 738         error (_("Couldn't read register %s (#%d): %s."),
 739                gdbarch_register_name (gdbarch, regnum),
 740                regnum, safe_strerror (errno));
 741
 742       addr += sizeof (PTRACE_TYPE_RET);
 743     }
 744   regcache_raw_supply (regcache, regnum, buf);
 745 }
 746
 747 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 748    for all registers.  */
 749
 750 static void
 751 inf_ptrace_fetch_registers (struct target_ops *ops,
 752                             struct regcache *regcache, int regnum)
 753 {
 754   if (regnum == -1)
 755     for (regnum = 0;
 756          regnum < gdbarch_num_regs (regcache->arch ());
 757          regnum++)
 758       inf_ptrace_fetch_register (regcache, regnum);
 759   else
 760     inf_ptrace_fetch_register (regcache, regnum);
 761 }
 762
 763 /* Store register REGNUM into the inferior.  */
 764
 765 static void
 766 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
 767 {
 768   struct gdbarch *gdbarch = regcache->arch ();
 769   CORE_ADDR addr;
 770   size_t size;
 771   PTRACE_TYPE_RET *buf;
 772   pid_t pid;
 773   int i;
 774
 775   /* This isn't really an address, but ptrace thinks of it as one.  */
 776   addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
 777   if (addr == (CORE_ADDR)-1
 778       || gdbarch_cannot_store_register (gdbarch, regnum))
 779     return;
 780
 781   pid = get_ptrace_pid (regcache_get_ptid (regcache));
 782
 783   size = register_size (gdbarch, regnum);
 784   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 785   buf = (PTRACE_TYPE_RET *) alloca (size);
 786
 787   /* Write the register contents into the inferior a chunk at a time.  */
 788   regcache_raw_collect (regcache, regnum, buf);
 789   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 790     {
 791       errno = 0;
 792       ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
 793       if (errno != 0)
 794         error (_("Couldn't write register %s (#%d): %s."),
 795                gdbarch_register_name (gdbarch, regnum),
 796                regnum, safe_strerror (errno));
 797
 798       addr += sizeof (PTRACE_TYPE_RET);
 799     }
 800 }
 801
 802 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 803    this for all registers.  */
 804
 805 static void
 806 inf_ptrace_store_registers (struct target_ops *ops,
 807                             struct regcache *regcache, int regnum)
 808 {
 809   if (regnum == -1)
 810     for (regnum = 0;
 811          regnum < gdbarch_num_regs (regcache->arch ());
 812          regnum++)
 813       inf_ptrace_store_register (regcache, regnum);
 814   else
 815     inf_ptrace_store_register (regcache, regnum);
 816 }
 817
 818 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be
 819    a function returning the offset within the user area where a
 820    particular register is stored.  */
 821
 822 struct target_ops *
 823 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
 824                                         (struct gdbarch *, int, int))
 825 {
 826   struct target_ops *t = inf_ptrace_target();
 827
 828   gdb_assert (register_u_offset);
 829   inf_ptrace_register_u_offset = register_u_offset;
 830   t->to_fetch_registers = inf_ptrace_fetch_registers;
 831   t->to_store_registers = inf_ptrace_store_registers;
 832
 833   return t;
 834 }