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 /* Implement the to_xfer_partial target_ops method.  */
 450
 451 static enum target_xfer_status
 452 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
 453                          const char *annex, gdb_byte *readbuf,
 454                          const gdb_byte *writebuf,
 455                          ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 456 {
 457   pid_t pid = ptid_get_pid (inferior_ptid);
 458
 459   switch (object)
 460     {
 461     case TARGET_OBJECT_MEMORY:
 462 #ifdef PT_IO
 463       /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
 464          request that promises to be much more efficient in reading
 465          and writing data in the traced process's address space.  */
 466       {
 467         struct ptrace_io_desc piod;
 468
 469         /* NOTE: We assume that there are no distinct address spaces
 470            for instruction and data.  However, on OpenBSD 3.9 and
 471            later, PIOD_WRITE_D doesn't allow changing memory that's
 472            mapped read-only.  Since most code segments will be
 473            read-only, using PIOD_WRITE_D will prevent us from
 474            inserting breakpoints, so we use PIOD_WRITE_I instead.  */
 475         piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
 476         piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
 477         piod.piod_offs = (void *) (long) offset;
 478         piod.piod_len = len;
 479
 480         errno = 0;
 481         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 482           {
 483             /* Return the actual number of bytes read or written.  */
 484             *xfered_len = piod.piod_len;
 485             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 486           }
 487         /* If the PT_IO request is somehow not supported, fallback on
 488            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 489            to indicate failure.  */
 490         if (errno != EINVAL)
 491           return TARGET_XFER_EOF;
 492       }
 493 #endif
 494       {
 495         union
 496         {
 497           PTRACE_TYPE_RET word;
 498           gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 499         } buffer;
 500         ULONGEST rounded_offset;
 501         ULONGEST partial_len;
 502
 503         /* Round the start offset down to the next long word
 504            boundary.  */
 505         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 506
 507         /* Since ptrace will transfer a single word starting at that
 508            rounded_offset the partial_len needs to be adjusted down to
 509            that (remember this function only does a single transfer).
 510            Should the required length be even less, adjust it down
 511            again.  */
 512         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
 513         if (partial_len > len)
 514           partial_len = len;
 515
 516         if (writebuf)
 517           {
 518             /* If OFFSET:PARTIAL_LEN is smaller than
 519                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
 520                be needed.  Read in the entire word.  */
 521             if (rounded_offset < offset
 522                 || (offset + partial_len
 523                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
 524               /* Need part of initial word -- fetch it.  */
 525               buffer.word = ptrace (PT_READ_I, pid,
 526                                     (PTRACE_TYPE_ARG3)(uintptr_t)
 527                                     rounded_offset, 0);
 528
 529             /* Copy data to be written over corresponding part of
 530                buffer.  */
 531             memcpy (buffer.byte + (offset - rounded_offset),
 532                     writebuf, partial_len);
 533
 534             errno = 0;
 535             ptrace (PT_WRITE_D, pid,
 536                     (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
 537                     buffer.word);
 538             if (errno)
 539               {
 540                 /* Using the appropriate one (I or D) is necessary for
 541                    Gould NP1, at least.  */
 542                 errno = 0;
 543                 ptrace (PT_WRITE_I, pid,
 544                         (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
 545                         buffer.word);
 546                 if (errno)
 547                   return TARGET_XFER_EOF;
 548               }
 549           }
 550
 551         if (readbuf)
 552           {
 553             errno = 0;
 554             buffer.word = ptrace (PT_READ_I, pid,
 555                                   (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
 556                                   0);
 557             if (errno)
 558               return TARGET_XFER_EOF;
 559             /* Copy appropriate bytes out of the buffer.  */
 560             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
 561                     partial_len);
 562           }
 563
 564         *xfered_len = partial_len;
 565         return TARGET_XFER_OK;
 566       }
 567
 568     case TARGET_OBJECT_UNWIND_TABLE:
 569       return TARGET_XFER_E_IO;
 570
 571     case TARGET_OBJECT_AUXV:
 572 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 573       /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
 574          request that allows us to read the auxilliary vector.  Other
 575          BSD's may follow if they feel the need to support PIE.  */
 576       {
 577         struct ptrace_io_desc piod;
 578
 579         if (writebuf)
 580           return TARGET_XFER_E_IO;
 581         piod.piod_op = PIOD_READ_AUXV;
 582         piod.piod_addr = readbuf;
 583         piod.piod_offs = (void *) (long) offset;
 584         piod.piod_len = len;
 585
 586         errno = 0;
 587         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 588           {
 589             /* Return the actual number of bytes read or written.  */
 590             *xfered_len = piod.piod_len;
 591             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 592           }
 593       }
 594 #endif
 595       return TARGET_XFER_E_IO;
 596
 597     case TARGET_OBJECT_WCOOKIE:
 598       return TARGET_XFER_E_IO;
 599
 600     default:
 601       return TARGET_XFER_E_IO;
 602     }
 603 }
 604
 605 /* Return non-zero if the thread specified by PTID is alive.  */
 606
 607 static int
 608 inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
 609 {
 610   /* ??? Is kill the right way to do this?  */
 611   return (kill (ptid_get_pid (ptid), 0) != -1);
 612 }
 613
 614 /* Print status information about what we're accessing.  */
 615
 616 static void
 617 inf_ptrace_files_info (struct target_ops *ignore)
 618 {
 619   struct inferior *inf = current_inferior ();
 620
 621   printf_filtered (_("\tUsing the running image of %s %s.\n"),
 622                    inf->attach_flag ? "attached" : "child",
 623                    target_pid_to_str (inferior_ptid));
 624 }
 625
 626 static char *
 627 inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
 628 {
 629   return normal_pid_to_str (ptid);
 630 }
 631
 632 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 633
 634 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 635    Return 0 if *READPTR is already at the end of the buffer.
 636    Return -1 if there is insufficient buffer for a whole entry.
 637    Return 1 if an entry was read into *TYPEP and *VALP.  */
 638
 639 static int
 640 inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
 641                        gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 642 {
 643   struct type *int_type = builtin_type (target_gdbarch ())->builtin_int;
 644   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 645   const int sizeof_auxv_type = TYPE_LENGTH (int_type);
 646   const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
 647   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 648   gdb_byte *ptr = *readptr;
 649
 650   if (endptr == ptr)
 651     return 0;
 652
 653   if (endptr - ptr < 2 * sizeof_auxv_val)
 654     return -1;
 655
 656   *typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order);
 657   ptr += sizeof_auxv_val;       /* Alignment.  */
 658   *valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order);
 659   ptr += sizeof_auxv_val;
 660
 661   *readptr = ptr;
 662   return 1;
 663 }
 664
 665 #endif
 666
 667 /* Create a prototype ptrace target.  The client can override it with
 668    local methods.  */
 669
 670 struct target_ops *
 671 inf_ptrace_target (void)
 672 {
 673   struct target_ops *t = inf_child_target ();
 674
 675   t->to_attach = inf_ptrace_attach;
 676   t->to_detach = inf_ptrace_detach;
 677   t->to_resume = inf_ptrace_resume;
 678   t->to_wait = inf_ptrace_wait;
 679   t->to_files_info = inf_ptrace_files_info;
 680   t->to_kill = inf_ptrace_kill;
 681   t->to_create_inferior = inf_ptrace_create_inferior;
 682 #ifdef PT_GET_PROCESS_STATE
 683   t->to_follow_fork = inf_ptrace_follow_fork;
 684   t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint;
 685   t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint;
 686   t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
 687   t->to_post_attach = inf_ptrace_post_attach;
 688 #endif
 689   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
 690   t->to_thread_alive = inf_ptrace_thread_alive;
 691   t->to_pid_to_str = inf_ptrace_pid_to_str;
 692   t->to_interrupt = inf_ptrace_interrupt;
 693   t->to_xfer_partial = inf_ptrace_xfer_partial;
 694 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 695   t->to_auxv_parse = inf_ptrace_auxv_parse;
 696 #endif
 697
 698   return t;
 699 }
 700 \f
 701
 702 /* Pointer to a function that returns the offset within the user area
 703    where a particular register is stored.  */
 704 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
 705
 706 /* Fetch register REGNUM from the inferior.  */
 707
 708 static void
 709 inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
 710 {
 711   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 712   CORE_ADDR addr;
 713   size_t size;
 714   PTRACE_TYPE_RET *buf;
 715   int pid, 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   /* Cater for systems like GNU/Linux, that implement threads as
 727      separate processes.  */
 728   pid = ptid_get_lwp (inferior_ptid);
 729   if (pid == 0)
 730     pid = ptid_get_pid (inferior_ptid);
 731
 732   size = register_size (gdbarch, regnum);
 733   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 734   buf = (PTRACE_TYPE_RET *) alloca (size);
 735
 736   /* Read the register contents from the inferior a chunk at a time.  */
 737   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 738     {
 739       errno = 0;
 740       buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
 741       if (errno != 0)
 742         error (_("Couldn't read register %s (#%d): %s."),
 743                gdbarch_register_name (gdbarch, regnum),
 744                regnum, safe_strerror (errno));
 745
 746       addr += sizeof (PTRACE_TYPE_RET);
 747     }
 748   regcache_raw_supply (regcache, regnum, buf);
 749 }
 750
 751 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 752    for all registers.  */
 753
 754 static void
 755 inf_ptrace_fetch_registers (struct target_ops *ops,
 756                             struct regcache *regcache, int regnum)
 757 {
 758   if (regnum == -1)
 759     for (regnum = 0;
 760          regnum < gdbarch_num_regs (get_regcache_arch (regcache));
 761          regnum++)
 762       inf_ptrace_fetch_register (regcache, regnum);
 763   else
 764     inf_ptrace_fetch_register (regcache, regnum);
 765 }
 766
 767 /* Store register REGNUM into the inferior.  */
 768
 769 static void
 770 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
 771 {
 772   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 773   CORE_ADDR addr;
 774   size_t size;
 775   PTRACE_TYPE_RET *buf;
 776   int pid, i;
 777
 778   /* This isn't really an address, but ptrace thinks of it as one.  */
 779   addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
 780   if (addr == (CORE_ADDR)-1
 781       || gdbarch_cannot_store_register (gdbarch, regnum))
 782     return;
 783
 784   /* Cater for systems like GNU/Linux, that implement threads as
 785      separate processes.  */
 786   pid = ptid_get_lwp (inferior_ptid);
 787   if (pid == 0)
 788     pid = ptid_get_pid (inferior_ptid);
 789
 790   size = register_size (gdbarch, regnum);
 791   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 792   buf = (PTRACE_TYPE_RET *) alloca (size);
 793
 794   /* Write the register contents into the inferior a chunk at a time.  */
 795   regcache_raw_collect (regcache, regnum, buf);
 796   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 797     {
 798       errno = 0;
 799       ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
 800       if (errno != 0)
 801         error (_("Couldn't write register %s (#%d): %s."),
 802                gdbarch_register_name (gdbarch, regnum),
 803                regnum, safe_strerror (errno));
 804
 805       addr += sizeof (PTRACE_TYPE_RET);
 806     }
 807 }
 808
 809 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 810    this for all registers.  */
 811
 812 static void
 813 inf_ptrace_store_registers (struct target_ops *ops,
 814                             struct regcache *regcache, int regnum)
 815 {
 816   if (regnum == -1)
 817     for (regnum = 0;
 818          regnum < gdbarch_num_regs (get_regcache_arch (regcache));
 819          regnum++)
 820       inf_ptrace_store_register (regcache, regnum);
 821   else
 822     inf_ptrace_store_register (regcache, regnum);
 823 }
 824
 825 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be
 826    a function returning the offset within the user area where a
 827    particular register is stored.  */
 828
 829 struct target_ops *
 830 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
 831                                         (struct gdbarch *, int, int))
 832 {
 833   struct target_ops *t = inf_ptrace_target();
 834
 835   gdb_assert (register_u_offset);
 836   inf_ptrace_register_u_offset = register_u_offset;
 837   t->to_fetch_registers = inf_ptrace_fetch_registers;
 838   t->to_store_registers = inf_ptrace_store_registers;
 839
 840   return t;
 841 }