gdb/inf-ptrace.c

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