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