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