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