gdb/inf-ptrace.c

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