gdb/inf-ptrace.c

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