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
 115       /* Breakpoints have already been detached from the child by
 116          infrun.c.  */
 117
 118       if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
 119         perror_with_name (("ptrace"));
 120       detach_inferior (pid);
 121     }
 122
 123   return 0;
 124 }
 125
 126 #endif /* PT_GET_PROCESS_STATE */
 127 \f
 128
 129 /* Prepare to be traced.  */
 130
 131 static void
 132 inf_ptrace_me (void)
 133 {
 134   /* "Trace me, Dr. Memory!"  */
 135   ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
 136 }
 137
 138 /* Start a new inferior Unix child process.  EXEC_FILE is the file to
 139    run, ALLARGS is a string containing the arguments to the program.
 140    ENV is the environment vector to pass.  If FROM_TTY is non-zero, be
 141    chatty about it.  */
 142
 143 static void
 144 inf_ptrace_create_inferior (struct target_ops *ops,
 145                             char *exec_file, char *allargs, char **env,
 146                             int from_tty)
 147 {
 148   int pid;
 149
 150   pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
 151                        NULL, NULL);
 152
 153   push_target (ops);
 154
 155   /* On some targets, there must be some explicit synchronization
 156      between the parent and child processes after the debugger
 157      forks, and before the child execs the debuggee program.  This
 158      call basically gives permission for the child to exec.  */
 159
 160   target_acknowledge_created_inferior (pid);
 161
 162   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will
 163      be 1 or 2 depending on whether we're starting without or with a
 164      shell.  */
 165   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 166
 167   /* On some targets, there must be some explicit actions taken after
 168      the inferior has been started up.  */
 169   target_post_startup_inferior (pid_to_ptid (pid));
 170 }
 171
 172 #ifdef PT_GET_PROCESS_STATE
 173
 174 static void
 175 inf_ptrace_post_startup_inferior (ptid_t pid)
 176 {
 177   ptrace_event_t pe;
 178
 179   /* Set the initial event mask.  */
 180   memset (&pe, 0, sizeof pe);
 181   pe.pe_set_event |= PTRACE_FORK;
 182   if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid),
 183               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 184     perror_with_name (("ptrace"));
 185 }
 186
 187 #endif
 188
 189 /* Clean up a rotting corpse of an inferior after it died.  */
 190
 191 static void
 192 inf_ptrace_mourn_inferior (struct target_ops *ops)
 193 {
 194   int status;
 195
 196   /* Wait just one more time to collect the inferior's exit status.
 197      Do not check whether this succeeds though, since we may be
 198      dealing with a process that we attached to.  Such a process will
 199      only report its exit status to its original parent.  */
 200   waitpid (ptid_get_pid (inferior_ptid), &status, 0);
 201
 202   unpush_target (ops);
 203   generic_mourn_inferior ();
 204 }
 205
 206 /* Attach to the process specified by ARGS.  If FROM_TTY is non-zero,
 207    be chatty about it.  */
 208
 209 static void
 210 inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)
 211 {
 212   char *exec_file;
 213   pid_t pid;
 214   char *dummy;
 215   struct inferior *inf;
 216
 217   if (!args)
 218     error_no_arg (_("process-id to attach"));
 219
 220   dummy = args;
 221   pid = strtol (args, &dummy, 0);
 222   /* Some targets don't set errno on errors, grrr!  */
 223   if (pid == 0 && args == dummy)
 224     error (_("Illegal process-id: %s."), args);
 225
 226   if (pid == getpid ())         /* Trying to masturbate?  */
 227     error (_("I refuse to debug myself!"));
 228
 229   if (from_tty)
 230     {
 231       exec_file = get_exec_file (0);
 232
 233       if (exec_file)
 234         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
 235                            target_pid_to_str (pid_to_ptid (pid)));
 236       else
 237         printf_unfiltered (_("Attaching to %s\n"),
 238                            target_pid_to_str (pid_to_ptid (pid)));
 239
 240       gdb_flush (gdb_stdout);
 241     }
 242
 243 #ifdef PT_ATTACH
 244   errno = 0;
 245   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
 246   if (errno != 0)
 247     perror_with_name (("ptrace"));
 248 #else
 249   error (_("This system does not support attaching to a process"));
 250 #endif
 251
 252   inferior_ptid = pid_to_ptid (pid);
 253
 254   inf = add_inferior (pid);
 255   inf->attach_flag = 1;
 256
 257   /* Always add a main thread.  If some target extends the ptrace
 258      target, it should decorate the ptid later with more info.  */
 259   add_thread_silent (inferior_ptid);
 260
 261   push_target(ops);
 262 }
 263
 264 #ifdef PT_GET_PROCESS_STATE
 265
 266 void
 267 inf_ptrace_post_attach (int pid)
 268 {
 269   ptrace_event_t pe;
 270
 271   /* Set the initial event mask.  */
 272   memset (&pe, 0, sizeof pe);
 273   pe.pe_set_event |= PTRACE_FORK;
 274   if (ptrace (PT_SET_EVENT_MASK, pid,
 275               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 276     perror_with_name (("ptrace"));
 277 }
 278
 279 #endif
 280
 281 /* Detach from the inferior, optionally passing it the signal
 282    specified by ARGS.  If FROM_TTY is non-zero, be chatty about it.  */
 283
 284 static void
 285 inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty)
 286 {
 287   pid_t pid = ptid_get_pid (inferior_ptid);
 288   int sig = 0;
 289
 290   if (from_tty)
 291     {
 292       char *exec_file = get_exec_file (0);
 293       if (exec_file == 0)
 294         exec_file = "";
 295       printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
 296                          target_pid_to_str (pid_to_ptid (pid)));
 297       gdb_flush (gdb_stdout);
 298     }
 299   if (args)
 300     sig = atoi (args);
 301
 302 #ifdef PT_DETACH
 303   /* We'd better not have left any breakpoints in the program or it'll
 304      die when it hits one.  Also note that this may only work if we
 305      previously attached to the inferior.  It *might* work if we
 306      started the process ourselves.  */
 307   errno = 0;
 308   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
 309   if (errno != 0)
 310     perror_with_name (("ptrace"));
 311 #else
 312   error (_("This system does not support detaching from a process"));
 313 #endif
 314
 315   inferior_ptid = null_ptid;
 316   detach_inferior (pid);
 317
 318   if (!have_inferiors ())
 319     unpush_target (ops);
 320 }
 321
 322 /* Kill the inferior.  */
 323
 324 static void
 325 inf_ptrace_kill (struct target_ops *ops)
 326 {
 327   pid_t pid = ptid_get_pid (inferior_ptid);
 328   int status;
 329
 330   if (pid == 0)
 331     return;
 332
 333   ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
 334   waitpid (pid, &status, 0);
 335
 336   target_mourn_inferior ();
 337 }
 338
 339 /* Stop the inferior.  */
 340
 341 static void
 342 inf_ptrace_stop (ptid_t ptid)
 343 {
 344   /* Send a SIGINT to the process group.  This acts just like the user
 345      typed a ^C on the controlling terminal.  Note that using a
 346      negative process number in kill() is a System V-ism.  The proper
 347      BSD interface is killpg().  However, all modern BSDs support the
 348      System V interface too.  */
 349   kill (-inferior_process_group, SIGINT);
 350 }
 351
 352 /* Resume execution of thread PTID, or all threads if PTID is -1.  If
 353    STEP is nonzero, single-step it.  If SIGNAL is nonzero, give it
 354    that signal.  */
 355
 356 static void
 357 inf_ptrace_resume (struct target_ops *ops,
 358                    ptid_t ptid, int step, enum target_signal signal)
 359 {
 360   pid_t pid = ptid_get_pid (ptid);
 361   int request = PT_CONTINUE;
 362
 363   if (pid == -1)
 364     /* Resume all threads.  Traditionally ptrace() only supports
 365        single-threaded processes, so simply resume the inferior.  */
 366     pid = ptid_get_pid (inferior_ptid);
 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)
 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 }