contrib/gdb-7/gdb/inf-ptrace.c

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