gdb/inf-ptrace.c

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