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