gdb/inf-ptrace.c

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