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