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