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 /* Return which PID to pass to ptrace in order to observe/control the
 298    tracee identified by PTID.  */
 299
 300 pid_t
 301 get_ptrace_pid (ptid_t ptid)
 302 {
 303   pid_t pid;
 304
 305   /* If we have an LWPID to work with, use it.  Otherwise, we're
 306      dealing with a non-threaded program/target.  */
 307   pid = ptid_get_lwp (ptid);
 308   if (pid == 0)
 309     pid = ptid_get_pid (ptid);
 310   return pid;
 311 }
 312
 313 /* Resume execution of thread PTID, or all threads if PTID is -1.  If
 314    STEP is nonzero, single-step it.  If SIGNAL is nonzero, give it
 315    that signal.  */
 316
 317 static void
 318 inf_ptrace_resume (struct target_ops *ops,
 319                    ptid_t ptid, int step, enum gdb_signal signal)
 320 {
 321   pid_t pid;
 322   int request;
 323
 324   if (ptid_equal (minus_one_ptid, ptid))
 325     /* Resume all threads.  Traditionally ptrace() only supports
 326        single-threaded processes, so simply resume the inferior.  */
 327     pid = ptid_get_pid (inferior_ptid);
 328   else
 329     pid = get_ptrace_pid (ptid);
 330
 331   if (catch_syscall_enabled () > 0)
 332     request = PT_SYSCALL;
 333   else
 334     request = PT_CONTINUE;
 335
 336   if (step)
 337     {
 338       /* If this system does not support PT_STEP, a higher level
 339          function will have called single_step() to transmute the step
 340          request into a continue request (by setting breakpoints on
 341          all possible successor instructions), so we don't have to
 342          worry about that here.  */
 343       request = PT_STEP;
 344     }
 345
 346   /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
 347      where it was.  If GDB wanted it to start some other way, we have
 348      already written a new program counter value to the child.  */
 349   errno = 0;
 350   ptrace (request, pid, (PTRACE_TYPE_ARG3)1, gdb_signal_to_host (signal));
 351   if (errno != 0)
 352     perror_with_name (("ptrace"));
 353 }
 354
 355 /* Wait for the child specified by PTID to do something.  Return the
 356    process ID of the child, or MINUS_ONE_PTID in case of error; store
 357    the status in *OURSTATUS.  */
 358
 359 static ptid_t
 360 inf_ptrace_wait (struct target_ops *ops,
 361                  ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 362 {
 363   pid_t pid;
 364   int status, save_errno;
 365
 366   do
 367     {
 368       set_sigint_trap ();
 369
 370       do
 371         {
 372           pid = waitpid (ptid_get_pid (ptid), &status, 0);
 373           save_errno = errno;
 374         }
 375       while (pid == -1 && errno == EINTR);
 376
 377       clear_sigint_trap ();
 378
 379       if (pid == -1)
 380         {
 381           fprintf_unfiltered (gdb_stderr,
 382                               _("Child process unexpectedly missing: %s.\n"),
 383                               safe_strerror (save_errno));
 384
 385           /* Claim it exited with unknown signal.  */
 386           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 387           ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
 388           return inferior_ptid;
 389         }
 390
 391       /* Ignore terminated detached child processes.  */
 392       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
 393         pid = -1;
 394     }
 395   while (pid == -1);
 396
 397 #ifdef PT_GET_PROCESS_STATE
 398   if (WIFSTOPPED (status))
 399     {
 400       ptrace_state_t pe;
 401       pid_t fpid;
 402
 403       if (ptrace (PT_GET_PROCESS_STATE, pid,
 404                   (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 405         perror_with_name (("ptrace"));
 406
 407       switch (pe.pe_report_event)
 408         {
 409         case PTRACE_FORK:
 410           ourstatus->kind = TARGET_WAITKIND_FORKED;
 411           ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
 412
 413           /* Make sure the other end of the fork is stopped too.  */
 414           fpid = waitpid (pe.pe_other_pid, &status, 0);
 415           if (fpid == -1)
 416             perror_with_name (("waitpid"));
 417
 418           if (ptrace (PT_GET_PROCESS_STATE, fpid,
 419                       (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 420             perror_with_name (("ptrace"));
 421
 422           gdb_assert (pe.pe_report_event == PTRACE_FORK);
 423           gdb_assert (pe.pe_other_pid == pid);
 424           if (fpid == ptid_get_pid (inferior_ptid))
 425             {
 426               ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
 427               return pid_to_ptid (fpid);
 428             }
 429
 430           return pid_to_ptid (pid);
 431         }
 432     }
 433 #endif
 434
 435   store_waitstatus (ourstatus, status);
 436   return pid_to_ptid (pid);
 437 }
 438
 439 /* Transfer data via ptrace into process PID's memory from WRITEBUF, or
 440    from process PID's memory into READBUF.  Start at target address ADDR
 441    and transfer up to LEN bytes.  Exactly one of READBUF and WRITEBUF must
 442    be non-null.  Return the number of transferred bytes.  */
 443
 444 static ULONGEST
 445 inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf,
 446                       const gdb_byte *writebuf,
 447                       ULONGEST addr, ULONGEST len)
 448 {
 449   ULONGEST n;
 450   unsigned int chunk;
 451
 452   /* We transfer aligned words.  Thus align ADDR down to a word
 453      boundary and determine how many bytes to skip at the
 454      beginning.  */
 455   ULONGEST skip = addr & (sizeof (PTRACE_TYPE_RET) - 1);
 456   addr -= skip;
 457
 458   for (n = 0;
 459        n < len;
 460        n += chunk, addr += sizeof (PTRACE_TYPE_RET), skip = 0)
 461     {
 462       /* Restrict to a chunk that fits in the current word.  */
 463       chunk = std::min (sizeof (PTRACE_TYPE_RET) - skip, len - n);
 464
 465       /* Use a union for type punning.  */
 466       union
 467       {
 468         PTRACE_TYPE_RET word;
 469         gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 470       } buf;
 471
 472       /* Read the word, also when doing a partial word write.  */
 473       if (readbuf != NULL || chunk < sizeof (PTRACE_TYPE_RET))
 474         {
 475           errno = 0;
 476           buf.word = ptrace (PT_READ_I, pid,
 477                              (PTRACE_TYPE_ARG3)(uintptr_t) addr, 0);
 478           if (errno != 0)
 479             break;
 480           if (readbuf != NULL)
 481             memcpy (readbuf + n, buf.byte + skip, chunk);
 482         }
 483       if (writebuf != NULL)
 484         {
 485           memcpy (buf.byte + skip, writebuf + n, chunk);
 486           errno = 0;
 487           ptrace (PT_WRITE_D, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
 488                   buf.word);
 489           if (errno != 0)
 490             {
 491               /* Using the appropriate one (I or D) is necessary for
 492                  Gould NP1, at least.  */
 493               errno = 0;
 494               ptrace (PT_WRITE_I, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
 495                       buf.word);
 496               if (errno != 0)
 497                 break;
 498             }
 499         }
 500     }
 501
 502   return n;
 503 }
 504
 505 /* Implement the to_xfer_partial target_ops method.  */
 506
 507 static enum target_xfer_status
 508 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
 509                          const char *annex, gdb_byte *readbuf,
 510                          const gdb_byte *writebuf,
 511                          ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 512 {
 513   pid_t pid = get_ptrace_pid (inferior_ptid);
 514
 515   switch (object)
 516     {
 517     case TARGET_OBJECT_MEMORY:
 518 #ifdef PT_IO
 519       /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
 520          request that promises to be much more efficient in reading
 521          and writing data in the traced process's address space.  */
 522       {
 523         struct ptrace_io_desc piod;
 524
 525         /* NOTE: We assume that there are no distinct address spaces
 526            for instruction and data.  However, on OpenBSD 3.9 and
 527            later, PIOD_WRITE_D doesn't allow changing memory that's
 528            mapped read-only.  Since most code segments will be
 529            read-only, using PIOD_WRITE_D will prevent us from
 530            inserting breakpoints, so we use PIOD_WRITE_I instead.  */
 531         piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
 532         piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
 533         piod.piod_offs = (void *) (long) offset;
 534         piod.piod_len = len;
 535
 536         errno = 0;
 537         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 538           {
 539             /* Return the actual number of bytes read or written.  */
 540             *xfered_len = piod.piod_len;
 541             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 542           }
 543         /* If the PT_IO request is somehow not supported, fallback on
 544            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 545            to indicate failure.  */
 546         if (errno != EINVAL)
 547           return TARGET_XFER_EOF;
 548       }
 549 #endif
 550       *xfered_len = inf_ptrace_peek_poke (pid, readbuf, writebuf,
 551                                           offset, len);
 552       return *xfered_len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
 553
 554     case TARGET_OBJECT_UNWIND_TABLE:
 555       return TARGET_XFER_E_IO;
 556
 557     case TARGET_OBJECT_AUXV:
 558 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 559       /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
 560          request that allows us to read the auxilliary vector.  Other
 561          BSD's may follow if they feel the need to support PIE.  */
 562       {
 563         struct ptrace_io_desc piod;
 564
 565         if (writebuf)
 566           return TARGET_XFER_E_IO;
 567         piod.piod_op = PIOD_READ_AUXV;
 568         piod.piod_addr = readbuf;
 569         piod.piod_offs = (void *) (long) offset;
 570         piod.piod_len = len;
 571
 572         errno = 0;
 573         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 574           {
 575             /* Return the actual number of bytes read or written.  */
 576             *xfered_len = piod.piod_len;
 577             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 578           }
 579       }
 580 #endif
 581       return TARGET_XFER_E_IO;
 582
 583     case TARGET_OBJECT_WCOOKIE:
 584       return TARGET_XFER_E_IO;
 585
 586     default:
 587       return TARGET_XFER_E_IO;
 588     }
 589 }
 590
 591 /* Return non-zero if the thread specified by PTID is alive.  */
 592
 593 static int
 594 inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
 595 {
 596   /* ??? Is kill the right way to do this?  */
 597   return (kill (ptid_get_pid (ptid), 0) != -1);
 598 }
 599
 600 /* Print status information about what we're accessing.  */
 601
 602 static void
 603 inf_ptrace_files_info (struct target_ops *ignore)
 604 {
 605   struct inferior *inf = current_inferior ();
 606
 607   printf_filtered (_("\tUsing the running image of %s %s.\n"),
 608                    inf->attach_flag ? "attached" : "child",
 609                    target_pid_to_str (inferior_ptid));
 610 }
 611
 612 static const char *
 613 inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
 614 {
 615   return normal_pid_to_str (ptid);
 616 }
 617
 618 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 619
 620 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 621    Return 0 if *READPTR is already at the end of the buffer.
 622    Return -1 if there is insufficient buffer for a whole entry.
 623    Return 1 if an entry was read into *TYPEP and *VALP.  */
 624
 625 static int
 626 inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
 627                        gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 628 {
 629   struct type *int_type = builtin_type (target_gdbarch ())->builtin_int;
 630   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 631   const int sizeof_auxv_type = TYPE_LENGTH (int_type);
 632   const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
 633   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 634   gdb_byte *ptr = *readptr;
 635
 636   if (endptr == ptr)
 637     return 0;
 638
 639   if (endptr - ptr < 2 * sizeof_auxv_val)
 640     return -1;
 641
 642   *typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order);
 643   ptr += sizeof_auxv_val;       /* Alignment.  */
 644   *valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order);
 645   ptr += sizeof_auxv_val;
 646
 647   *readptr = ptr;
 648   return 1;
 649 }
 650
 651 #endif
 652
 653 /* Create a prototype ptrace target.  The client can override it with
 654    local methods.  */
 655
 656 struct target_ops *
 657 inf_ptrace_target (void)
 658 {
 659   struct target_ops *t = inf_child_target ();
 660
 661   t->to_attach = inf_ptrace_attach;
 662   t->to_detach = inf_ptrace_detach;
 663   t->to_resume = inf_ptrace_resume;
 664   t->to_wait = inf_ptrace_wait;
 665   t->to_files_info = inf_ptrace_files_info;
 666   t->to_kill = inf_ptrace_kill;
 667   t->to_create_inferior = inf_ptrace_create_inferior;
 668 #ifdef PT_GET_PROCESS_STATE
 669   t->to_follow_fork = inf_ptrace_follow_fork;
 670   t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint;
 671   t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint;
 672   t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
 673   t->to_post_attach = inf_ptrace_post_attach;
 674 #endif
 675   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
 676   t->to_thread_alive = inf_ptrace_thread_alive;
 677   t->to_pid_to_str = inf_ptrace_pid_to_str;
 678   t->to_xfer_partial = inf_ptrace_xfer_partial;
 679 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 680   t->to_auxv_parse = inf_ptrace_auxv_parse;
 681 #endif
 682
 683   return t;
 684 }
 685 \f
 686
 687 /* Pointer to a function that returns the offset within the user area
 688    where a particular register is stored.  */
 689 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);
 690
 691 /* Fetch register REGNUM from the inferior.  */
 692
 693 static void
 694 inf_ptrace_fetch_register (struct regcache *regcache, int regnum)
 695 {
 696   struct gdbarch *gdbarch = regcache->arch ();
 697   CORE_ADDR addr;
 698   size_t size;
 699   PTRACE_TYPE_RET *buf;
 700   pid_t pid;
 701   int i;
 702
 703   /* This isn't really an address, but ptrace thinks of it as one.  */
 704   addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
 705   if (addr == (CORE_ADDR)-1
 706       || gdbarch_cannot_fetch_register (gdbarch, regnum))
 707     {
 708       regcache_raw_supply (regcache, regnum, NULL);
 709       return;
 710     }
 711
 712   pid = get_ptrace_pid (regcache_get_ptid (regcache));
 713
 714   size = register_size (gdbarch, regnum);
 715   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 716   buf = (PTRACE_TYPE_RET *) alloca (size);
 717
 718   /* Read the register contents from the inferior a chunk at a time.  */
 719   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 720     {
 721       errno = 0;
 722       buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);
 723       if (errno != 0)
 724         error (_("Couldn't read register %s (#%d): %s."),
 725                gdbarch_register_name (gdbarch, regnum),
 726                regnum, safe_strerror (errno));
 727
 728       addr += sizeof (PTRACE_TYPE_RET);
 729     }
 730   regcache_raw_supply (regcache, regnum, buf);
 731 }
 732
 733 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 734    for all registers.  */
 735
 736 static void
 737 inf_ptrace_fetch_registers (struct target_ops *ops,
 738                             struct regcache *regcache, int regnum)
 739 {
 740   if (regnum == -1)
 741     for (regnum = 0;
 742          regnum < gdbarch_num_regs (regcache->arch ());
 743          regnum++)
 744       inf_ptrace_fetch_register (regcache, regnum);
 745   else
 746     inf_ptrace_fetch_register (regcache, regnum);
 747 }
 748
 749 /* Store register REGNUM into the inferior.  */
 750
 751 static void
 752 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
 753 {
 754   struct gdbarch *gdbarch = regcache->arch ();
 755   CORE_ADDR addr;
 756   size_t size;
 757   PTRACE_TYPE_RET *buf;
 758   pid_t pid;
 759   int i;
 760
 761   /* This isn't really an address, but ptrace thinks of it as one.  */
 762   addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
 763   if (addr == (CORE_ADDR)-1
 764       || gdbarch_cannot_store_register (gdbarch, regnum))
 765     return;
 766
 767   pid = get_ptrace_pid (regcache_get_ptid (regcache));
 768
 769   size = register_size (gdbarch, regnum);
 770   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 771   buf = (PTRACE_TYPE_RET *) alloca (size);
 772
 773   /* Write the register contents into the inferior a chunk at a time.  */
 774   regcache_raw_collect (regcache, regnum, buf);
 775   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 776     {
 777       errno = 0;
 778       ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
 779       if (errno != 0)
 780         error (_("Couldn't write register %s (#%d): %s."),
 781                gdbarch_register_name (gdbarch, regnum),
 782                regnum, safe_strerror (errno));
 783
 784       addr += sizeof (PTRACE_TYPE_RET);
 785     }
 786 }
 787
 788 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 789    this for all registers.  */
 790
 791 static void
 792 inf_ptrace_store_registers (struct target_ops *ops,
 793                             struct regcache *regcache, int regnum)
 794 {
 795   if (regnum == -1)
 796     for (regnum = 0;
 797          regnum < gdbarch_num_regs (regcache->arch ());
 798          regnum++)
 799       inf_ptrace_store_register (regcache, regnum);
 800   else
 801     inf_ptrace_store_register (regcache, regnum);
 802 }
 803
 804 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be
 805    a function returning the offset within the user area where a
 806    particular register is stored.  */
 807
 808 struct target_ops *
 809 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
 810                                         (struct gdbarch *, int, int))
 811 {
 812   struct target_ops *t = inf_ptrace_target();
 813
 814   gdb_assert (register_u_offset);
 815   inf_ptrace_register_u_offset = register_u_offset;
 816   t->to_fetch_registers = inf_ptrace_fetch_registers;
 817   t->to_store_registers = inf_ptrace_store_registers;
 818
 819   return t;
 820 }