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