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