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