gdb/inf-ptrace.c

   1 /* Low-level child interface to ptrace.
   2
   3    Copyright (C) 1988-2014 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 <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   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 141
 142   /* On some targets, there must be some explicit actions taken after
 143      the inferior has been started up.  */
 144   target_post_startup_inferior (pid_to_ptid (pid));
 145 }
 146
 147 #ifdef PT_GET_PROCESS_STATE
 148
 149 static void
 150 inf_ptrace_post_startup_inferior (ptid_t pid)
 151 {
 152   ptrace_event_t pe;
 153
 154   /* Set the initial event mask.  */
 155   memset (&pe, 0, sizeof pe);
 156   pe.pe_set_event |= PTRACE_FORK;
 157   if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
 158               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 159     perror_with_name (("ptrace"));
 160 }
 161
 162 #endif
 163
 164 /* Clean up a rotting corpse of an inferior after it died.  */
 165
 166 static void
 167 inf_ptrace_mourn_inferior (struct target_ops *ops)
 168 {
 169   int status;
 170
 171   /* Wait just one more time to collect the inferior's exit status.
 172      Do not check whether this succeeds though, since we may be
 173      dealing with a process that we attached to.  Such a process will
 174      only report its exit status to its original parent.  */
 175   waitpid (ptid_get_pid (inferior_ptid), &status, 0);
 176
 177   generic_mourn_inferior ();
 178
 179   if (!have_inferiors ())
 180     unpush_target (ops);
 181 }
 182
 183 /* Attach to the process specified by ARGS.  If FROM_TTY is non-zero,
 184    be chatty about it.  */
 185
 186 static void
 187 inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)
 188 {
 189   char *exec_file;
 190   pid_t pid;
 191   struct inferior *inf;
 192
 193   /* Do not change either targets above or the same target if already present.
 194      The reason is the target stack is shared across multiple inferiors.  */
 195   int ops_already_pushed = target_is_pushed (ops);
 196   struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
 197
 198   pid = parse_pid_to_attach (args);
 199
 200   if (pid == getpid ())         /* Trying to masturbate?  */
 201     error (_("I refuse to debug myself!"));
 202
 203   if (! ops_already_pushed)
 204     {
 205       /* target_pid_to_str already uses the target.  Also clear possible core
 206          file with its process_stratum.  */
 207       push_target (ops);
 208       make_cleanup_unpush_target (ops);
 209     }
 210
 211   if (from_tty)
 212     {
 213       exec_file = get_exec_file (0);
 214
 215       if (exec_file)
 216         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
 217                            target_pid_to_str (pid_to_ptid (pid)));
 218       else
 219         printf_unfiltered (_("Attaching to %s\n"),
 220                            target_pid_to_str (pid_to_ptid (pid)));
 221
 222       gdb_flush (gdb_stdout);
 223     }
 224
 225 #ifdef PT_ATTACH
 226   errno = 0;
 227   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
 228   if (errno != 0)
 229     perror_with_name (("ptrace"));
 230 #else
 231   error (_("This system does not support attaching to a process"));
 232 #endif
 233
 234   inf = current_inferior ();
 235   inferior_appeared (inf, pid);
 236   inf->attach_flag = 1;
 237   inferior_ptid = pid_to_ptid (pid);
 238
 239   /* Always add a main thread.  If some target extends the ptrace
 240      target, it should decorate the ptid later with more info.  */
 241   add_thread_silent (inferior_ptid);
 242
 243   discard_cleanups (back_to);
 244 }
 245
 246 #ifdef PT_GET_PROCESS_STATE
 247
 248 static void
 249 inf_ptrace_post_attach (int pid)
 250 {
 251   ptrace_event_t pe;
 252
 253   /* Set the initial event mask.  */
 254   memset (&pe, 0, sizeof pe);
 255   pe.pe_set_event |= PTRACE_FORK;
 256   if (ptrace (PT_SET_EVENT_MASK, pid,
 257               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 258     perror_with_name (("ptrace"));
 259 }
 260
 261 #endif
 262
 263 /* Detach from the inferior, optionally passing it the signal
 264    specified by ARGS.  If FROM_TTY is non-zero, be chatty about it.  */
 265
 266 static void
 267 inf_ptrace_detach (struct target_ops *ops, const char *args, int from_tty)
 268 {
 269   pid_t pid = ptid_get_pid (inferior_ptid);
 270   int sig = 0;
 271
 272   if (from_tty)
 273     {
 274       char *exec_file = get_exec_file (0);
 275       if (exec_file == 0)
 276         exec_file = "";
 277       printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
 278                          target_pid_to_str (pid_to_ptid (pid)));
 279       gdb_flush (gdb_stdout);
 280     }
 281   if (args)
 282     sig = atoi (args);
 283
 284 #ifdef PT_DETACH
 285   /* We'd better not have left any breakpoints in the program or it'll
 286      die when it hits one.  Also note that this may only work if we
 287      previously attached to the inferior.  It *might* work if we
 288      started the process ourselves.  */
 289   errno = 0;
 290   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
 291   if (errno != 0)
 292     perror_with_name (("ptrace"));
 293 #else
 294   error (_("This system does not support detaching from a process"));
 295 #endif
 296
 297   inferior_ptid = null_ptid;
 298   detach_inferior (pid);
 299
 300   if (!have_inferiors ())
 301     unpush_target (ops);
 302 }
 303
 304 /* Kill the inferior.  */
 305
 306 static void
 307 inf_ptrace_kill (struct target_ops *ops)
 308 {
 309   pid_t pid = ptid_get_pid (inferior_ptid);
 310   int status;
 311
 312   if (pid == 0)
 313     return;
 314
 315   ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
 316   waitpid (pid, &status, 0);
 317
 318   target_mourn_inferior ();
 319 }
 320
 321 /* Stop the inferior.  */
 322
 323 static void
 324 inf_ptrace_stop (ptid_t ptid)
 325 {
 326   /* Send a SIGINT to the process group.  This acts just like the user
 327      typed a ^C on the controlling terminal.  Note that using a
 328      negative process number in kill() is a System V-ism.  The proper
 329      BSD interface is killpg().  However, all modern BSDs support the
 330      System V interface too.  */
 331   kill (-inferior_process_group (), SIGINT);
 332 }
 333
 334 /* Resume execution of thread PTID, or all threads if PTID is -1.  If
 335    STEP is nonzero, single-step it.  If SIGNAL is nonzero, give it
 336    that signal.  */
 337
 338 static void
 339 inf_ptrace_resume (struct target_ops *ops,
 340                    ptid_t ptid, int step, enum gdb_signal signal)
 341 {
 342   pid_t pid = ptid_get_pid (ptid);
 343   int request;
 344
 345   if (pid == -1)
 346     /* Resume all threads.  Traditionally ptrace() only supports
 347        single-threaded processes, so simply resume the inferior.  */
 348     pid = ptid_get_pid (inferior_ptid);
 349
 350   if (catch_syscall_enabled () > 0)
 351     request = PT_SYSCALL;
 352   else
 353     request = PT_CONTINUE;
 354
 355   if (step)
 356     {
 357       /* If this system does not support PT_STEP, a higher level
 358          function will have called single_step() to transmute the step
 359          request into a continue request (by setting breakpoints on
 360          all possible successor instructions), so we don't have to
 361          worry about that here.  */
 362       request = PT_STEP;
 363     }
 364
 365   /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
 366      where it was.  If GDB wanted it to start some other way, we have
 367      already written a new program counter value to the child.  */
 368   errno = 0;
 369   ptrace (request, pid, (PTRACE_TYPE_ARG3)1, gdb_signal_to_host (signal));
 370   if (errno != 0)
 371     perror_with_name (("ptrace"));
 372 }
 373
 374 /* Wait for the child specified by PTID to do something.  Return the
 375    process ID of the child, or MINUS_ONE_PTID in case of error; store
 376    the status in *OURSTATUS.  */
 377
 378 static ptid_t
 379 inf_ptrace_wait (struct target_ops *ops,
 380                  ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 381 {
 382   pid_t pid;
 383   int status, save_errno;
 384
 385   do
 386     {
 387       set_sigint_trap ();
 388
 389       do
 390         {
 391           pid = waitpid (ptid_get_pid (ptid), &status, 0);
 392           save_errno = errno;
 393         }
 394       while (pid == -1 && errno == EINTR);
 395
 396       clear_sigint_trap ();
 397
 398       if (pid == -1)
 399         {
 400           fprintf_unfiltered (gdb_stderr,
 401                               _("Child process unexpectedly missing: %s.\n"),
 402                               safe_strerror (save_errno));
 403
 404           /* Claim it exited with unknown signal.  */
 405           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 406           ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
 407           return inferior_ptid;
 408         }
 409
 410       /* Ignore terminated detached child processes.  */
 411       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
 412         pid = -1;
 413     }
 414   while (pid == -1);
 415
 416 #ifdef PT_GET_PROCESS_STATE
 417   if (WIFSTOPPED (status))
 418     {
 419       ptrace_state_t pe;
 420       pid_t fpid;
 421
 422       if (ptrace (PT_GET_PROCESS_STATE, pid,
 423                   (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 424         perror_with_name (("ptrace"));
 425
 426       switch (pe.pe_report_event)
 427         {
 428         case PTRACE_FORK:
 429           ourstatus->kind = TARGET_WAITKIND_FORKED;
 430           ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
 431
 432           /* Make sure the other end of the fork is stopped too.  */
 433           fpid = waitpid (pe.pe_other_pid, &status, 0);
 434           if (fpid == -1)
 435             perror_with_name (("waitpid"));
 436
 437           if (ptrace (PT_GET_PROCESS_STATE, fpid,
 438                       (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 439             perror_with_name (("ptrace"));
 440
 441           gdb_assert (pe.pe_report_event == PTRACE_FORK);
 442           gdb_assert (pe.pe_other_pid == pid);
 443           if (fpid == ptid_get_pid (inferior_ptid))
 444             {
 445               ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
 446               return pid_to_ptid (fpid);
 447             }
 448
 449           return pid_to_ptid (pid);
 450         }
 451     }
 452 #endif
 453
 454   store_waitstatus (ourstatus, status);
 455   return pid_to_ptid (pid);
 456 }
 457
 458 /* Implement the to_xfer_partial target_ops method.  */
 459
 460 static enum target_xfer_status
 461 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
 462                          const char *annex, gdb_byte *readbuf,
 463                          const gdb_byte *writebuf,
 464                          ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 465 {
 466   pid_t pid = ptid_get_pid (inferior_ptid);
 467
 468   switch (object)
 469     {
 470     case TARGET_OBJECT_MEMORY:
 471 #ifdef PT_IO
 472       /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
 473          request that promises to be much more efficient in reading
 474          and writing data in the traced process's address space.  */
 475       {
 476         struct ptrace_io_desc piod;
 477
 478         /* NOTE: We assume that there are no distinct address spaces
 479            for instruction and data.  However, on OpenBSD 3.9 and
 480            later, PIOD_WRITE_D doesn't allow changing memory that's
 481            mapped read-only.  Since most code segments will be
 482            read-only, using PIOD_WRITE_D will prevent us from
 483            inserting breakpoints, so we use PIOD_WRITE_I instead.  */
 484         piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
 485         piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
 486         piod.piod_offs = (void *) (long) offset;
 487         piod.piod_len = len;
 488
 489         errno = 0;
 490         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 491           {
 492             /* Return the actual number of bytes read or written.  */
 493             *xfered_len = piod.piod_len;
 494             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 495           }
 496         /* If the PT_IO request is somehow not supported, fallback on
 497            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 498            to indicate failure.  */
 499         if (errno != EINVAL)
 500           return TARGET_XFER_EOF;
 501       }
 502 #endif
 503       {
 504         union
 505         {
 506           PTRACE_TYPE_RET word;
 507           gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 508         } buffer;
 509         ULONGEST rounded_offset;
 510         ULONGEST partial_len;
 511
 512         /* Round the start offset down to the next long word
 513            boundary.  */
 514         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 515
 516         /* Since ptrace will transfer a single word starting at that
 517            rounded_offset the partial_len needs to be adjusted down to
 518            that (remember this function only does a single transfer).
 519            Should the required length be even less, adjust it down
 520            again.  */
 521         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
 522         if (partial_len > len)
 523           partial_len = len;
 524
 525         if (writebuf)
 526           {
 527             /* If OFFSET:PARTIAL_LEN is smaller than
 528                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
 529                be needed.  Read in the entire word.  */
 530             if (rounded_offset < offset
 531                 || (offset + partial_len
 532                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
 533               /* Need part of initial word -- fetch it.  */
 534               buffer.word = ptrace (PT_READ_I, pid,
 535                                     (PTRACE_TYPE_ARG3)(uintptr_t)
 536                                     rounded_offset, 0);
 537
 538             /* Copy data to be written over corresponding part of
 539                buffer.  */
 540             memcpy (buffer.byte + (offset - rounded_offset),
 541                     writebuf, partial_len);
 542
 543             errno = 0;
 544             ptrace (PT_WRITE_D, pid,
 545                     (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
 546                     buffer.word);
 547             if (errno)
 548               {
 549                 /* Using the appropriate one (I or D) is necessary for
 550                    Gould NP1, at least.  */
 551                 errno = 0;
 552                 ptrace (PT_WRITE_I, pid,
 553                         (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
 554                         buffer.word);
 555                 if (errno)
 556                   return TARGET_XFER_EOF;
 557               }
 558           }
 559
 560         if (readbuf)
 561           {
 562             errno = 0;
 563             buffer.word = ptrace (PT_READ_I, pid,
 564                                   (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
 565                                   0);
 566             if (errno)
 567               return TARGET_XFER_EOF;
 568             /* Copy appropriate bytes out of the buffer.  */
 569             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
 570                     partial_len);
 571           }
 572
 573         *xfered_len = partial_len;
 574         return TARGET_XFER_OK;
 575       }
 576
 577     case TARGET_OBJECT_UNWIND_TABLE:
 578       return TARGET_XFER_E_IO;
 579
 580     case TARGET_OBJECT_AUXV:
 581 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 582       /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
 583          request that allows us to read the auxilliary vector.  Other
 584          BSD's may follow if they feel the need to support PIE.  */
 585       {
 586         struct ptrace_io_desc piod;
 587
 588         if (writebuf)
 589           return TARGET_XFER_E_IO;
 590         piod.piod_op = PIOD_READ_AUXV;
 591         piod.piod_addr = readbuf;
 592         piod.piod_offs = (void *) (long) offset;
 593         piod.piod_len = len;
 594
 595         errno = 0;
 596         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 597           {
 598             /* Return the actual number of bytes read or written.  */
 599             *xfered_len = piod.piod_len;
 600             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 601           }
 602       }
 603 #endif
 604       return TARGET_XFER_E_IO;
 605
 606     case TARGET_OBJECT_WCOOKIE:
 607       return TARGET_XFER_E_IO;
 608
 609     default:
 610       return TARGET_XFER_E_IO;
 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 }