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);
 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       return -1;
 586
 587     case TARGET_OBJECT_WCOOKIE:
 588       return -1;
 589
 590     default:
 591       return -1;
 592     }
 593 }
 594
 595 /* Return non-zero if the thread specified by PTID is alive.  */
 596
 597 static int
 598 inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid)
 599 {
 600   /* ??? Is kill the right way to do this?  */
 601   return (kill (ptid_get_pid (ptid), 0) != -1);
 602 }
 603
 604 /* Print status information about what we're accessing.  */
 605
 606 static void
 607 inf_ptrace_files_info (struct target_ops *ignore)
 608 {
 609   struct inferior *inf = current_inferior ();
 610
 611   printf_filtered (_("\tUsing the running image of %s %s.\n"),
 612                    inf->attach_flag ? "attached" : "child",
 613                    target_pid_to_str (inferior_ptid));
 614 }
 615
 616 static char *
 617 inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
 618 {
 619   return normal_pid_to_str (ptid);
 620 }
 621
 622 /* Create a prototype ptrace target.  The client can override it with
 623    local methods.  */
 624
 625 struct target_ops *
 626 inf_ptrace_target (void)
 627 {
 628   struct target_ops *t = inf_child_target ();
 629
 630   t->to_attach = inf_ptrace_attach;
 631   t->to_detach = inf_ptrace_detach;
 632   t->to_resume = inf_ptrace_resume;
 633   t->to_wait = inf_ptrace_wait;
 634   t->to_files_info = inf_ptrace_files_info;
 635   t->to_kill = inf_ptrace_kill;
 636   t->to_create_inferior = inf_ptrace_create_inferior;
 637 #ifdef PT_GET_PROCESS_STATE
 638   t->to_follow_fork = inf_ptrace_follow_fork;
 639   t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
 640   t->to_post_attach = inf_ptrace_post_attach;
 641 #endif
 642   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
 643   t->to_thread_alive = inf_ptrace_thread_alive;
 644   t->to_pid_to_str = inf_ptrace_pid_to_str;
 645   t->to_stop = inf_ptrace_stop;
 646   t->to_xfer_partial = inf_ptrace_xfer_partial;
 647
 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 target_ops *ops,
 706                             struct regcache *regcache, int regnum)
 707 {
 708   if (regnum == -1)
 709     for (regnum = 0;
 710          regnum < gdbarch_num_regs (get_regcache_arch (regcache));
 711          regnum++)
 712       inf_ptrace_fetch_register (regcache, regnum);
 713   else
 714     inf_ptrace_fetch_register (regcache, regnum);
 715 }
 716
 717 /* Store register REGNUM into the inferior.  */
 718
 719 static void
 720 inf_ptrace_store_register (const struct regcache *regcache, int regnum)
 721 {
 722   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 723   CORE_ADDR addr;
 724   size_t size;
 725   PTRACE_TYPE_RET *buf;
 726   int pid, i;
 727
 728   /* This isn't really an address, but ptrace thinks of it as one.  */
 729   addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
 730   if (addr == (CORE_ADDR)-1
 731       || gdbarch_cannot_store_register (gdbarch, regnum))
 732     return;
 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   /* Write the register contents into the inferior a chunk at a time.  */
 745   regcache_raw_collect (regcache, regnum, buf);
 746   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 747     {
 748       errno = 0;
 749       ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);
 750       if (errno != 0)
 751         error (_("Couldn't write register %s (#%d): %s."),
 752                gdbarch_register_name (gdbarch, regnum),
 753                regnum, safe_strerror (errno));
 754
 755       addr += sizeof (PTRACE_TYPE_RET);
 756     }
 757 }
 758
 759 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 760    this for all registers.  */
 761
 762 static void
 763 inf_ptrace_store_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_store_register (regcache, regnum);
 771   else
 772     inf_ptrace_store_register (regcache, regnum);
 773 }
 774
 775 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be
 776    a function returning the offset within the user area where a
 777    particular register is stored.  */
 778
 779 struct target_ops *
 780 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
 781                                         (struct gdbarch *, int, int))
 782 {
 783   struct target_ops *t = inf_ptrace_target();
 784
 785   gdb_assert (register_u_offset);
 786   inf_ptrace_register_u_offset = register_u_offset;
 787   t->to_fetch_registers = inf_ptrace_fetch_registers;
 788   t->to_store_registers = inf_ptrace_store_registers;
 789
 790   return t;
 791 }