gdb/inf-ptrace.c

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