gdb/inf-ptrace.c

   1 /* Low level Unix child interface to ptrace, for GDB when running under Unix.
   2
   3    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1998, 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "observer.h"
  25 #include "gdb_ptrace.h"
  26 #include "inflow.h"
  27 #include "inferior.h"
  28 #include "regcache.h"
  29 #include "command.h"
  30 #include "gdbcore.h"
  31 #include "inf-child.h"
  32 #include "gdbcmd.h"
  33 #include "gdb_string.h"
  34
  35 #include <sys/wait.h>
  36 #include <signal.h>
  37
  38 /* HACK: Save the ptrace ops returned by ptrace_target.  */
  39 static struct target_ops *ptrace_ops_hack;
  40
  41 static void
  42 inf_ptrace_kill_inferior (void)
  43 {
  44   int status;
  45   int pid = PIDGET (inferior_ptid);
  46
  47   if (pid == 0)
  48     return;
  49
  50   /* This once used to call "kill" to kill the inferior just in case
  51      the inferior was still running.  As others have noted in the past
  52      (kingdon) there shouldn't be any way to get here if the inferior
  53      is still running -- else there's a major problem elsewere in gdb
  54      and it needs to be fixed.
  55
  56      The kill call causes problems under hpux10, so it's been removed;
  57      if this causes problems we'll deal with them as they arise.  */
  58   ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3) 0, 0);
  59   wait (&status);
  60   target_mourn_inferior ();
  61 }
  62
  63 /* Resume execution of the inferior process.  If STEP is nonzero,
  64    single-step it.  If SIGNAL is nonzero, give it that signal.  */
  65
  66 static void
  67 inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal)
  68 {
  69   int request = PT_CONTINUE;
  70   int pid = PIDGET (ptid);
  71
  72   if (pid == -1)
  73     /* Resume all threads.  */
  74     /* I think this only gets used in the non-threaded case, where
  75        "resume all threads" and "resume inferior_ptid" are the
  76        same.  */
  77     pid = PIDGET (inferior_ptid);
  78
  79   if (step)
  80     {
  81       /* If this system does not support PT_STEP, a higher level
  82          function will have called single_step() to transmute the step
  83          request into a continue request (by setting breakpoints on
  84          all possible successor instructions), so we don't have to
  85          worry about that here.  */
  86       request = PT_STEP;
  87     }
  88
  89   /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
  90      where it was.  If GDB wanted it to start some other way, we have
  91      already written a new PC value to the child.  */
  92   errno = 0;
  93   ptrace (request, pid, (PTRACE_TYPE_ARG3) 1, target_signal_to_host (signal));
  94   if (errno != 0)
  95     perror_with_name ("ptrace");
  96 }
  97
  98 /* Set an upper limit on alloca.  */
  99 #define GDB_MAX_ALLOCA 0x1000
 100
 101 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
 102    in the NEW_SUN_PTRACE case.  It ought to be straightforward.  But
 103    it appears that writing did not write the data that I specified.  I
 104    cannot understand where it got the data that it actually did
 105    write.  */
 106
 107 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR to
 108    debugger memory starting at MYADDR.  Copy to inferior if WRITE is
 109    nonzero.  TARGET is ignored.
 110
 111    Returns the length copied, which is either the LEN argument or
 112    zero.  This xfer function does not do partial moves, since
 113    ptrace_ops_hack doesn't allow memory operations to cross below us in the
 114    target stack anyway.  */
 115
 116 int
 117 inf_ptrace_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 118                         struct mem_attrib *attrib, struct target_ops *target)
 119 {
 120   int i;
 121   /* Round starting address down to longword boundary.  */
 122   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 123   /* Round ending address up; get number of longwords that makes.  */
 124   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 125                / sizeof (PTRACE_TYPE_RET));
 126   int alloc = count * sizeof (PTRACE_TYPE_RET);
 127   PTRACE_TYPE_RET *buffer;
 128   struct cleanup *old_chain = NULL;
 129
 130 #ifdef PT_IO
 131   /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request
 132      that promises to be much more efficient in reading and writing
 133      data in the traced process's address space.  */
 134
 135   {
 136     struct ptrace_io_desc piod;
 137
 138     /* NOTE: We assume that there are no distinct address spaces for
 139        instruction and data.  */
 140     piod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D;
 141     piod.piod_offs = (void *) memaddr;
 142     piod.piod_addr = myaddr;
 143     piod.piod_len = len;
 144
 145     if (ptrace (PT_IO, PIDGET (inferior_ptid), (caddr_t) &piod, 0) == -1)
 146       {
 147         /* If the PT_IO request is somehow not supported, fallback on
 148            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 149            to indicate failure.  */
 150         if (errno != EINVAL)
 151           return 0;
 152       }
 153     else
 154       {
 155         /* Return the actual number of bytes read or written.  */
 156         return piod.piod_len;
 157       }
 158   }
 159 #endif
 160
 161   /* Allocate buffer of that many longwords.  */
 162   if (len < GDB_MAX_ALLOCA)
 163     {
 164       buffer = (PTRACE_TYPE_RET *) alloca (alloc);
 165     }
 166   else
 167     {
 168       buffer = (PTRACE_TYPE_RET *) xmalloc (alloc);
 169       old_chain = make_cleanup (xfree, buffer);
 170     }
 171
 172   if (write)
 173     {
 174       /* Fill start and end extra bytes of buffer with existing memory
 175          data.  */
 176       if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 177         {
 178           /* Need part of initial word -- fetch it.  */
 179           buffer[0] = ptrace (PT_READ_I, PIDGET (inferior_ptid),
 180                               (PTRACE_TYPE_ARG3) addr, 0);
 181         }
 182
 183       if (count > 1)            /* FIXME, avoid if even boundary.  */
 184         {
 185           buffer[count - 1] =
 186             ptrace (PT_READ_I, PIDGET (inferior_ptid),
 187                     ((PTRACE_TYPE_ARG3)
 188                      (addr + (count - 1) * sizeof (PTRACE_TYPE_RET))), 0);
 189         }
 190
 191       /* Copy data to be written over corresponding part of buffer.  */
 192       memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 193               myaddr, len);
 194
 195       /* Write the entire buffer.  */
 196       for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 197         {
 198           errno = 0;
 199           ptrace (PT_WRITE_D, PIDGET (inferior_ptid),
 200                   (PTRACE_TYPE_ARG3) addr, buffer[i]);
 201           if (errno)
 202             {
 203               /* Using the appropriate one (I or D) is necessary for
 204                  Gould NP1, at least.  */
 205               errno = 0;
 206               ptrace (PT_WRITE_I, PIDGET (inferior_ptid),
 207                       (PTRACE_TYPE_ARG3) addr, buffer[i]);
 208             }
 209           if (errno)
 210             return 0;
 211         }
 212     }
 213   else
 214     {
 215       /* Read all the longwords.  */
 216       for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 217         {
 218           errno = 0;
 219           buffer[i] = ptrace (PT_READ_I, PIDGET (inferior_ptid),
 220                               (PTRACE_TYPE_ARG3) addr, 0);
 221           if (errno)
 222             return 0;
 223           QUIT;
 224         }
 225
 226       /* Copy appropriate bytes out of the buffer.  */
 227       memcpy (myaddr,
 228               (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 229               len);
 230     }
 231
 232   if (old_chain != NULL)
 233     do_cleanups (old_chain);
 234   return len;
 235 }
 236
 237 /* Wait for child to do something.  Return pid of child, or -1 in case
 238    of error; store status through argument pointer OURSTATUS.  */
 239
 240 static ptid_t
 241 inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 242 {
 243   int save_errno;
 244   int status;
 245   char *execd_pathname = NULL;
 246   int exit_status;
 247   int related_pid;
 248   int syscall_id;
 249   enum target_waitkind kind;
 250   int pid;
 251
 252   do
 253     {
 254       set_sigint_trap ();       /* Causes SIGINT to be passed on to the
 255                                    attached process. */
 256       set_sigio_trap ();
 257
 258       pid = wait (&status);
 259
 260       save_errno = errno;
 261
 262       clear_sigio_trap ();
 263
 264       clear_sigint_trap ();
 265
 266       if (pid == -1)
 267         {
 268           if (save_errno == EINTR)
 269             continue;
 270
 271           fprintf_unfiltered (gdb_stderr,
 272                               "Child process unexpectedly missing: %s.\n",
 273                               safe_strerror (save_errno));
 274
 275           /* Claim it exited with unknown signal.  */
 276           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 277           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 278           return pid_to_ptid (-1);
 279         }
 280
 281       /* Did it exit?
 282        */
 283       if (target_has_exited (pid, status, &exit_status))
 284         {
 285           /* ??rehrauer: For now, ignore this. */
 286           continue;
 287         }
 288
 289       if (!target_thread_alive (pid_to_ptid (pid)))
 290         {
 291           ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 292           return pid_to_ptid (pid);
 293         }
 294     }
 295   while (pid != PIDGET (inferior_ptid));        /* Some other child died or stopped */
 296
 297   store_waitstatus (ourstatus, status);
 298   return pid_to_ptid (pid);
 299 }
 300
 301 /* Check to see if the given thread is alive.
 302
 303    FIXME: Is kill() ever the right way to do this?  I doubt it, but
 304    for now we're going to try and be compatable with the old thread
 305    code.  */
 306
 307 static int
 308 inf_ptrace_thread_alive (ptid_t ptid)
 309 {
 310   pid_t pid = PIDGET (ptid);
 311
 312   return (kill (pid, 0) != -1);
 313 }
 314
 315 /* Attach to process PID, then initialize for debugging it.  */
 316
 317 static void
 318 inf_ptrace_attach (char *args, int from_tty)
 319 {
 320   char *exec_file;
 321   int pid;
 322   char *dummy;
 323
 324   if (!args)
 325     error_no_arg ("process-id to attach");
 326
 327   dummy = args;
 328   pid = strtol (args, &dummy, 0);
 329   /* Some targets don't set errno on errors, grrr! */
 330   if (pid == 0 && args == dummy)
 331     error ("Illegal process-id: %s\n", args);
 332
 333   if (pid == getpid ())         /* Trying to masturbate? */
 334     error ("I refuse to debug myself!");
 335
 336   if (from_tty)
 337     {
 338       exec_file = (char *) get_exec_file (0);
 339
 340       if (exec_file)
 341         printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
 342                            target_pid_to_str (pid_to_ptid (pid)));
 343       else
 344         printf_unfiltered ("Attaching to %s\n",
 345                            target_pid_to_str (pid_to_ptid (pid)));
 346
 347       gdb_flush (gdb_stdout);
 348     }
 349
 350 #ifdef PT_ATTACH
 351   errno = 0;
 352   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3) 0, 0);
 353   if (errno != 0)
 354     perror_with_name ("ptrace");
 355   attach_flag = 1;
 356 #else
 357   error ("This system does not support attaching to a process");
 358 #endif
 359
 360   inferior_ptid = pid_to_ptid (pid);
 361   push_target (ptrace_ops_hack);
 362 }
 363
 364 static void
 365 inf_ptrace_post_attach (int pid)
 366 {
 367   /* This version of Unix doesn't require a meaningful "post attach"
 368      operation by a debugger.  */
 369 }
 370
 371 /* Take a program previously attached to and detaches it.  The program
 372    resumes execution and will no longer stop on signals, etc.  We'd
 373    better not have left any breakpoints in the program or it'll die
 374    when it hits one.  For this to work, it may be necessary for the
 375    process to have been previously attached.  It *might* work if the
 376    program was started via the normal ptrace (PTRACE_TRACEME).  */
 377
 378 static void
 379 inf_ptrace_detach (char *args, int from_tty)
 380 {
 381   int sig = 0;
 382   int pid = PIDGET (inferior_ptid);
 383
 384   if (from_tty)
 385     {
 386       char *exec_file = get_exec_file (0);
 387       if (exec_file == 0)
 388         exec_file = "";
 389       printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
 390                          target_pid_to_str (pid_to_ptid (pid)));
 391       gdb_flush (gdb_stdout);
 392     }
 393   if (args)
 394     sig = atoi (args);
 395
 396 #ifdef PT_DETACH
 397   errno = 0;
 398   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3) 1, sig);
 399   if (errno != 0)
 400     perror_with_name ("ptrace");
 401   attach_flag = 0;
 402 #else
 403   error ("This system does not support detaching from a process");
 404 #endif
 405
 406   inferior_ptid = null_ptid;
 407   unpush_target (ptrace_ops_hack);
 408 }
 409
 410 /* Get ready to modify the registers array.  On machines which store
 411    individual registers, this doesn't need to do anything.  On
 412    machines which store all the registers in one fell swoop, this
 413    makes sure that registers contains all the registers from the
 414    program being debugged.  */
 415
 416 static void
 417 inf_ptrace_prepare_to_store (void)
 418 {
 419 }
 420
 421 /* Print status information about what we're accessing.  */
 422
 423 static void
 424 inf_ptrace_files_info (struct target_ops *ignore)
 425 {
 426   printf_unfiltered ("\tUsing the running image of %s %s.\n",
 427                      attach_flag ? "attached" : "child",
 428                      target_pid_to_str (inferior_ptid));
 429 }
 430
 431 static void
 432 inf_ptrace_open (char *arg, int from_tty)
 433 {
 434   error ("Use the \"run\" command to start a Unix child process.");
 435 }
 436
 437 /* Stub function which causes the inferior that runs it, to be ptrace-able
 438    by its parent process.  */
 439
 440 static void
 441 inf_ptrace_me (void)
 442 {
 443   /* "Trace me, Dr. Memory!" */
 444   ptrace (0, 0, (PTRACE_TYPE_ARG3) 0, 0);
 445 }
 446
 447 /* Stub function which causes the GDB that runs it, to start ptrace-ing
 448    the child process.  */
 449
 450 static void
 451 inf_ptrace_him (int pid)
 452 {
 453   push_target (ptrace_ops_hack);
 454
 455   /* On some targets, there must be some explicit synchronization
 456      between the parent and child processes after the debugger
 457      forks, and before the child execs the debuggee program.  This
 458      call basically gives permission for the child to exec.
 459    */
 460
 461   target_acknowledge_created_inferior (pid);
 462
 463   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h,
 464    * and will be 1 or 2 depending on whether we're starting
 465    * without or with a shell.
 466    */
 467   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 468
 469   /* On some targets, there must be some explicit actions taken after
 470      the inferior has been started up.
 471    */
 472   target_post_startup_inferior (pid_to_ptid (pid));
 473 }
 474
 475 /* Start an inferior Unix child process and sets inferior_ptid to its
 476    pid.  EXEC_FILE is the file to run.  ALLARGS is a string containing
 477    the arguments to the program.  ENV is the environment vector to
 478    pass.  Errors reported with error().  */
 479
 480 static void
 481 inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env,
 482                             int from_tty)
 483 {
 484   fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him,
 485                  NULL, NULL);
 486   /* We are at the first instruction we care about.  */
 487   observer_notify_inferior_created (&current_target, from_tty);
 488   /* Pedal to the metal... */
 489   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
 490 }
 491
 492 static void
 493 inf_ptrace_post_startup_inferior (ptid_t ptid)
 494 {
 495   /* This version of Unix doesn't require a meaningful "post startup inferior"
 496      operation by a debugger.
 497    */
 498 }
 499
 500 static void
 501 inf_ptrace_acknowledge_created_inferior (int pid)
 502 {
 503   /* This version of Unix doesn't require a meaningful "acknowledge created inferior"
 504      operation by a debugger.
 505    */
 506 }
 507
 508 static int
 509 inf_ptrace_insert_fork_catchpoint (int pid)
 510 {
 511   /* This version of Unix doesn't support notification of fork events.  */
 512   return 0;
 513 }
 514
 515 static int
 516 inf_ptrace_remove_fork_catchpoint (int pid)
 517 {
 518   /* This version of Unix doesn't support notification of fork events.  */
 519   return 0;
 520 }
 521
 522 static int
 523 inf_ptrace_insert_vfork_catchpoint (int pid)
 524 {
 525   /* This version of Unix doesn't support notification of vfork events.  */
 526   return 0;
 527 }
 528
 529 static int
 530 inf_ptrace_remove_vfork_catchpoint (int pid)
 531 {
 532   /* This version of Unix doesn't support notification of vfork events.  */
 533   return 0;
 534 }
 535
 536 static int
 537 inf_ptrace_follow_fork (int follow_child)
 538 {
 539   /* This version of Unix doesn't support following fork or vfork events.  */
 540   return 0;
 541 }
 542
 543 static int
 544 inf_ptrace_insert_exec_catchpoint (int pid)
 545 {
 546   /* This version of Unix doesn't support notification of exec events.  */
 547   return 0;
 548 }
 549
 550 static int
 551 inf_ptrace_remove_exec_catchpoint (int pid)
 552 {
 553   /* This version of Unix doesn't support notification of exec events.  */
 554   return 0;
 555 }
 556
 557 static int
 558 inf_ptrace_reported_exec_events_per_exec_call (void)
 559 {
 560   /* This version of Unix doesn't support notification of exec events.
 561    */
 562   return 1;
 563 }
 564
 565 static int
 566 inf_ptrace_has_exited (int pid, int wait_status, int *exit_status)
 567 {
 568   if (WIFEXITED (wait_status))
 569     {
 570       *exit_status = WEXITSTATUS (wait_status);
 571       return 1;
 572     }
 573
 574   if (WIFSIGNALED (wait_status))
 575     {
 576       *exit_status = 0;         /* ?? Don't know what else to say here. */
 577       return 1;
 578     }
 579
 580   /* ?? Do we really need to consult the event state, too?  Assume the
 581      wait_state alone suffices.
 582    */
 583   return 0;
 584 }
 585
 586 static void
 587 inf_ptrace_mourn_inferior (void)
 588 {
 589   unpush_target (ptrace_ops_hack);
 590   generic_mourn_inferior ();
 591 }
 592
 593 static int
 594 inf_ptrace_can_run (void)
 595 {
 596   return 1;
 597 }
 598
 599 /* Send a SIGINT to the process group.  This acts just like the user
 600    typed a ^C on the controlling terminal.
 601
 602    XXX - This may not be correct for all systems.  Some may want to
 603    use killpg() instead of kill (-pgrp). */
 604
 605 static void
 606 inf_ptrace_stop (void)
 607 {
 608   kill (-inferior_process_group, SIGINT);
 609 }
 610
 611 /* Perform a partial transfer to/from the specified object.  For
 612    memory transfers, fall back to the old memory xfer functions.  */
 613
 614 static LONGEST
 615 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
 616                          const char *annex, void *readbuf,
 617                          const void *writebuf, ULONGEST offset, LONGEST len)
 618 {
 619   switch (object)
 620     {
 621     case TARGET_OBJECT_MEMORY:
 622       if (readbuf)
 623         return inf_ptrace_xfer_memory (offset, readbuf, len, 0 /*write */ ,
 624                                        NULL, ops);
 625       if (writebuf)
 626         return inf_ptrace_xfer_memory (offset, readbuf, len, 1 /*write */ ,
 627                                        NULL, ops);
 628       return -1;
 629
 630     case TARGET_OBJECT_UNWIND_TABLE:
 631       return -1;
 632
 633     case TARGET_OBJECT_AUXV:
 634       return -1;
 635
 636     case TARGET_OBJECT_WCOOKIE:
 637       return -1;
 638
 639     default:
 640       return -1;
 641     }
 642 }
 643
 644 static char *
 645 inf_ptrace_pid_to_str (ptid_t ptid)
 646 {
 647   return normal_pid_to_str (ptid);
 648 }
 649
 650 struct target_ops *
 651 inf_ptrace_target (void)
 652 {
 653   struct target_ops *t = inf_child_target ();
 654   t->to_open = inf_ptrace_open;
 655   t->to_attach = inf_ptrace_attach;
 656   t->to_post_attach = inf_ptrace_post_attach;
 657   t->to_detach = inf_ptrace_detach;
 658   t->to_resume = inf_ptrace_resume;
 659   t->to_wait = inf_ptrace_wait;
 660   t->to_prepare_to_store = inf_ptrace_prepare_to_store;
 661   t->to_xfer_memory = inf_ptrace_xfer_memory;
 662   t->to_xfer_partial = inf_ptrace_xfer_partial;
 663   t->to_files_info = inf_ptrace_files_info;
 664   t->to_kill = inf_ptrace_kill_inferior;
 665   t->to_create_inferior = inf_ptrace_create_inferior;
 666   t->to_post_startup_inferior = inf_ptrace_post_startup_inferior;
 667   t->to_acknowledge_created_inferior =
 668     inf_ptrace_acknowledge_created_inferior;
 669   t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint;
 670   t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint;
 671   t->to_insert_vfork_catchpoint = inf_ptrace_insert_vfork_catchpoint;
 672   t->to_remove_vfork_catchpoint = inf_ptrace_remove_vfork_catchpoint;
 673   t->to_follow_fork = inf_ptrace_follow_fork;
 674   t->to_insert_exec_catchpoint = inf_ptrace_insert_exec_catchpoint;
 675   t->to_remove_exec_catchpoint = inf_ptrace_remove_exec_catchpoint;
 676   t->to_reported_exec_events_per_exec_call =
 677     inf_ptrace_reported_exec_events_per_exec_call;
 678   t->to_has_exited = inf_ptrace_has_exited;
 679   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
 680   t->to_can_run = inf_ptrace_can_run;
 681   t->to_thread_alive = inf_ptrace_thread_alive;
 682   t->to_pid_to_str = inf_ptrace_pid_to_str;
 683   t->to_stop = inf_ptrace_stop;
 684   t->to_stratum = process_stratum;
 685   t->to_has_all_memory = 1;
 686   t->to_has_memory = 1;
 687   t->to_has_stack = 1;
 688   t->to_has_registers = 1;
 689   t->to_has_execution = 1;
 690   t->to_magic = OPS_MAGIC;
 691   ptrace_ops_hack = t;
 692   return t;
 693 }