gdb/inftarg.c

   1 /* Target-vector operations for controlling Unix child processes, for GDB.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Cygnus Support.
   5
   6    ## Contains temporary hacks..
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 #include "defs.h"
  26 #include "frame.h"              /* required by inferior.h */
  27 #include "inferior.h"
  28 #include "target.h"
  29 #include "gdbcore.h"
  30 #include "command.h"
  31 #include "gdb_stat.h"
  32 #include <signal.h>
  33 #include <sys/types.h>
  34 #include <fcntl.h>
  35
  36 #include "gdb_wait.h"
  37
  38 extern struct symtab_and_line *child_enable_exception_callback (enum
  39                                                                 exception_event_kind,
  40                                                                 int);
  41
  42 extern struct exception_event_record
  43   *child_get_current_exception_event (void);
  44
  45 extern void _initialize_inftarg (void);
  46
  47 static void child_prepare_to_store (void);
  48
  49 #ifndef CHILD_WAIT
  50 static ptid_t child_wait (ptid_t, struct target_waitstatus *);
  51 #endif /* CHILD_WAIT */
  52
  53 #if !defined(CHILD_POST_WAIT)
  54 void child_post_wait (ptid_t, int);
  55 #endif
  56
  57 static void child_open (char *, int);
  58
  59 static void child_files_info (struct target_ops *);
  60
  61 static void child_detach (char *, int);
  62
  63 static void child_detach_from_process (int, char *, int, int);
  64
  65 static void child_attach (char *, int);
  66
  67 static void child_attach_to_process (char *, int, int);
  68
  69 #if !defined(CHILD_POST_ATTACH)
  70 extern void child_post_attach (int);
  71 #endif
  72
  73 static void child_require_attach (char *, int);
  74
  75 static void child_require_detach (int, char *, int);
  76
  77 static void ptrace_me (void);
  78
  79 static void ptrace_him (int);
  80
  81 static void child_create_inferior (char *, char *, char **);
  82
  83 static void child_mourn_inferior (void);
  84
  85 static int child_can_run (void);
  86
  87 static void child_stop (void);
  88
  89 #ifndef CHILD_THREAD_ALIVE
  90 int child_thread_alive (ptid_t);
  91 #endif
  92
  93 static void init_child_ops (void);
  94
  95 extern char **environ;
  96
  97 struct target_ops child_ops;
  98
  99 int child_suppress_run = 0;     /* Non-zero if inftarg should pretend not to
 100                                    be a runnable target.  Used by targets
 101                                    that can sit atop inftarg, such as HPUX
 102                                    thread support.  */
 103
 104 #ifndef CHILD_WAIT
 105
 106 /*## */
 107 /* Enable HACK for ttrace work.  In
 108  * infttrace.c/require_notification_of_events,
 109  * this is set to 0 so that the loop in child_wait
 110  * won't loop.
 111  */
 112 int not_same_real_pid = 1;
 113 /*## */
 114
 115
 116 /* Wait for child to do something.  Return pid of child, or -1 in case
 117    of error; store status through argument pointer OURSTATUS.  */
 118
 119 static ptid_t
 120 child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 121 {
 122   int save_errno;
 123   int status;
 124   char *execd_pathname = NULL;
 125   int exit_status;
 126   int related_pid;
 127   int syscall_id;
 128   enum target_waitkind kind;
 129   int pid;
 130
 131   do
 132     {
 133       set_sigint_trap ();       /* Causes SIGINT to be passed on to the
 134                                    attached process. */
 135       set_sigio_trap ();
 136
 137       pid = ptrace_wait (inferior_ptid, &status);
 138
 139       save_errno = errno;
 140
 141       clear_sigio_trap ();
 142
 143       clear_sigint_trap ();
 144
 145       if (pid == -1)
 146         {
 147           if (save_errno == EINTR)
 148             continue;
 149
 150           fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing: %s.\n",
 151                               safe_strerror (save_errno));
 152
 153           /* Claim it exited with unknown signal.  */
 154           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 155           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 156           return pid_to_ptid (-1);
 157         }
 158
 159       /* Did it exit?
 160        */
 161       if (target_has_exited (pid, status, &exit_status))
 162         {
 163           /* ??rehrauer: For now, ignore this. */
 164           continue;
 165         }
 166
 167       if (!target_thread_alive (pid_to_ptid (pid)))
 168         {
 169           ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 170           return pid_to_ptid (pid);
 171         }
 172
 173       if (target_has_forked (pid, &related_pid)
 174           && ((pid == PIDGET (inferior_ptid))
 175               || (related_pid == PIDGET (inferior_ptid))))
 176         {
 177           ourstatus->kind = TARGET_WAITKIND_FORKED;
 178           ourstatus->value.related_pid = related_pid;
 179           return pid_to_ptid (pid);
 180         }
 181
 182       if (target_has_vforked (pid, &related_pid)
 183           && ((pid == PIDGET (inferior_ptid))
 184               || (related_pid == PIDGET (inferior_ptid))))
 185         {
 186           ourstatus->kind = TARGET_WAITKIND_VFORKED;
 187           ourstatus->value.related_pid = related_pid;
 188           return pid_to_ptid (pid);
 189         }
 190
 191       if (target_has_execd (pid, &execd_pathname))
 192         {
 193           /* Are we ignoring initial exec events?  (This is likely because
 194              we're in the process of starting up the inferior, and another
 195              (older) mechanism handles those.)  If so, we'll report this
 196              as a regular stop, not an exec.
 197            */
 198           if (inferior_ignoring_startup_exec_events)
 199             {
 200               inferior_ignoring_startup_exec_events--;
 201             }
 202           else
 203             {
 204               ourstatus->kind = TARGET_WAITKIND_EXECD;
 205               ourstatus->value.execd_pathname = execd_pathname;
 206               return pid_to_ptid (pid);
 207             }
 208         }
 209
 210       /* All we must do with these is communicate their occurrence
 211          to wait_for_inferior...
 212        */
 213       if (target_has_syscall_event (pid, &kind, &syscall_id))
 214         {
 215           ourstatus->kind = kind;
 216           ourstatus->value.syscall_id = syscall_id;
 217           return pid_to_ptid (pid);
 218         }
 219
 220       /*##  } while (pid != PIDGET (inferior_ptid)); ## *//* Some other child died or stopped */
 221 /* hack for thread testing */
 222     }
 223   while ((pid != PIDGET (inferior_ptid)) && not_same_real_pid);
 224 /*## */
 225
 226   store_waitstatus (ourstatus, status);
 227   return pid_to_ptid (pid);
 228 }
 229 #endif /* CHILD_WAIT */
 230
 231 #if !defined(CHILD_POST_WAIT)
 232 void
 233 child_post_wait (ptid_t ptid, int wait_status)
 234 {
 235   /* This version of Unix doesn't require a meaningful "post wait"
 236      operation.
 237    */
 238 }
 239 #endif
 240
 241
 242 #ifndef CHILD_THREAD_ALIVE
 243
 244 /* Check to see if the given thread is alive.
 245
 246    FIXME: Is kill() ever the right way to do this?  I doubt it, but
 247    for now we're going to try and be compatable with the old thread
 248    code.  */
 249 int
 250 child_thread_alive (ptid_t ptid)
 251 {
 252   pid_t pid = PIDGET (ptid);
 253
 254   return (kill (pid, 0) != -1);
 255 }
 256
 257 #endif
 258
 259 static void
 260 child_attach_to_process (char *args, int from_tty, int after_fork)
 261 {
 262   if (!args)
 263     error_no_arg ("process-id to attach");
 264
 265 #ifndef ATTACH_DETACH
 266   error ("Can't attach to a process on this machine.");
 267 #else
 268   {
 269     char *exec_file;
 270     int pid;
 271     char *dummy;
 272
 273     dummy = args;
 274     pid = strtol (args, &dummy, 0);
 275     /* Some targets don't set errno on errors, grrr! */
 276     if ((pid == 0) && (args == dummy))
 277       error ("Illegal process-id: %s\n", args);
 278
 279     if (pid == getpid ())       /* Trying to masturbate? */
 280       error ("I refuse to debug myself!");
 281
 282     if (from_tty)
 283       {
 284         exec_file = (char *) get_exec_file (0);
 285
 286         if (after_fork)
 287           printf_unfiltered ("Attaching after fork to %s\n",
 288                              target_pid_to_str (pid_to_ptid (pid)));
 289         else if (exec_file)
 290           printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
 291                              target_pid_to_str (pid_to_ptid (pid)));
 292         else
 293           printf_unfiltered ("Attaching to %s\n",
 294                              target_pid_to_str (pid_to_ptid (pid)));
 295
 296         gdb_flush (gdb_stdout);
 297       }
 298
 299     if (!after_fork)
 300       attach (pid);
 301     else
 302       REQUIRE_ATTACH (pid);
 303
 304     inferior_ptid = pid_to_ptid (pid);
 305     push_target (&child_ops);
 306   }
 307 #endif /* ATTACH_DETACH */
 308 }
 309
 310
 311 /* Attach to process PID, then initialize for debugging it.  */
 312
 313 static void
 314 child_attach (char *args, int from_tty)
 315 {
 316   child_attach_to_process (args, from_tty, 0);
 317 }
 318
 319 #if !defined(CHILD_POST_ATTACH)
 320 void
 321 child_post_attach (int pid)
 322 {
 323   /* This version of Unix doesn't require a meaningful "post attach"
 324      operation by a debugger.  */
 325 }
 326 #endif
 327
 328 static void
 329 child_require_attach (char *args, int from_tty)
 330 {
 331   child_attach_to_process (args, from_tty, 1);
 332 }
 333
 334 static void
 335 child_detach_from_process (int pid, char *args, int from_tty, int after_fork)
 336 {
 337 #ifdef ATTACH_DETACH
 338   {
 339     int siggnal = 0;
 340
 341     if (from_tty)
 342       {
 343         char *exec_file = get_exec_file (0);
 344         if (exec_file == 0)
 345           exec_file = "";
 346         if (after_fork)
 347           printf_unfiltered ("Detaching after fork from %s\n",
 348                              target_pid_to_str (pid_to_ptid (pid)));
 349         else
 350           printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
 351                              target_pid_to_str (pid_to_ptid (pid)));
 352         gdb_flush (gdb_stdout);
 353       }
 354     if (args)
 355       siggnal = atoi (args);
 356
 357     if (!after_fork)
 358       detach (siggnal);
 359     else
 360       REQUIRE_DETACH (pid, siggnal);
 361   }
 362 #else
 363   error ("This version of Unix does not support detaching a process.");
 364 #endif
 365 }
 366
 367 /* Take a program previously attached to and detaches it.
 368    The program resumes execution and will no longer stop
 369    on signals, etc.  We'd better not have left any breakpoints
 370    in the program or it'll die when it hits one.  For this
 371    to work, it may be necessary for the process to have been
 372    previously attached.  It *might* work if the program was
 373    started via the normal ptrace (PTRACE_TRACEME).  */
 374
 375 static void
 376 child_detach (char *args, int from_tty)
 377 {
 378   child_detach_from_process (PIDGET (inferior_ptid), args, from_tty, 0);
 379   inferior_ptid = null_ptid;
 380   unpush_target (&child_ops);
 381 }
 382
 383 static void
 384 child_require_detach (int pid, char *args, int from_tty)
 385 {
 386   child_detach_from_process (pid, args, from_tty, 1);
 387 }
 388
 389
 390 /* Get ready to modify the registers array.  On machines which store
 391    individual registers, this doesn't need to do anything.  On machines
 392    which store all the registers in one fell swoop, this makes sure
 393    that registers contains all the registers from the program being
 394    debugged.  */
 395
 396 static void
 397 child_prepare_to_store (void)
 398 {
 399 #ifdef CHILD_PREPARE_TO_STORE
 400   CHILD_PREPARE_TO_STORE ();
 401 #endif
 402 }
 403
 404 /* Print status information about what we're accessing.  */
 405
 406 static void
 407 child_files_info (struct target_ops *ignore)
 408 {
 409   printf_unfiltered ("\tUsing the running image of %s %s.\n",
 410       attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
 411 }
 412
 413 /* ARGSUSED */
 414 static void
 415 child_open (char *arg, int from_tty)
 416 {
 417   error ("Use the \"run\" command to start a Unix child process.");
 418 }
 419
 420 /* Stub function which causes the inferior that runs it, to be ptrace-able
 421    by its parent process.  */
 422
 423 static void
 424 ptrace_me (void)
 425 {
 426   /* "Trace me, Dr. Memory!" */
 427   call_ptrace (0, 0, (PTRACE_ARG3_TYPE) 0, 0);
 428 }
 429
 430 /* Stub function which causes the GDB that runs it, to start ptrace-ing
 431    the child process.  */
 432
 433 static void
 434 ptrace_him (int pid)
 435 {
 436   push_target (&child_ops);
 437
 438   /* On some targets, there must be some explicit synchronization
 439      between the parent and child processes after the debugger
 440      forks, and before the child execs the debuggee program.  This
 441      call basically gives permission for the child to exec.
 442    */
 443
 444   target_acknowledge_created_inferior (pid);
 445
 446   /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h,
 447    * and will be 1 or 2 depending on whether we're starting
 448    * without or with a shell.
 449    */
 450   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
 451
 452   /* On some targets, there must be some explicit actions taken after
 453      the inferior has been started up.
 454    */
 455   target_post_startup_inferior (pid_to_ptid (pid));
 456 }
 457
 458 /* Start an inferior Unix child process and sets inferior_ptid to its pid.
 459    EXEC_FILE is the file to run.
 460    ALLARGS is a string containing the arguments to the program.
 461    ENV is the environment vector to pass.  Errors reported with error().  */
 462
 463 static void
 464 child_create_inferior (char *exec_file, char *allargs, char **env)
 465 {
 466 #ifdef HPUXHPPA
 467   fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, pre_fork_inferior, NULL);
 468 #else
 469   fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, NULL, NULL);
 470 #endif
 471   /* We are at the first instruction we care about.  */
 472   /* Pedal to the metal... */
 473   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
 474 }
 475
 476 #if !defined(CHILD_POST_STARTUP_INFERIOR)
 477 void
 478 child_post_startup_inferior (ptid_t ptid)
 479 {
 480   /* This version of Unix doesn't require a meaningful "post startup inferior"
 481      operation by a debugger.
 482    */
 483 }
 484 #endif
 485
 486 #if !defined(CHILD_ACKNOWLEDGE_CREATED_INFERIOR)
 487 void
 488 child_acknowledge_created_inferior (int pid)
 489 {
 490   /* This version of Unix doesn't require a meaningful "acknowledge created inferior"
 491      operation by a debugger.
 492    */
 493 }
 494 #endif
 495
 496
 497 void
 498 child_clone_and_follow_inferior (int child_pid, int *followed_child)
 499 {
 500   clone_and_follow_inferior (child_pid, followed_child);
 501
 502   /* Don't resume CHILD_PID; it's stopped where it ought to be, until
 503      the decision gets made elsewhere how to continue it.
 504    */
 505 }
 506
 507
 508 #if !defined(CHILD_POST_FOLLOW_INFERIOR_BY_CLONE)
 509 void
 510 child_post_follow_inferior_by_clone (void)
 511 {
 512   /* This version of Unix doesn't require a meaningful "post follow inferior"
 513      operation by a clone debugger.
 514    */
 515 }
 516 #endif
 517
 518 #if !defined(CHILD_INSERT_FORK_CATCHPOINT)
 519 int
 520 child_insert_fork_catchpoint (int pid)
 521 {
 522   /* This version of Unix doesn't support notification of fork events.  */
 523   return 0;
 524 }
 525 #endif
 526
 527 #if !defined(CHILD_REMOVE_FORK_CATCHPOINT)
 528 int
 529 child_remove_fork_catchpoint (int pid)
 530 {
 531   /* This version of Unix doesn't support notification of fork events.  */
 532   return 0;
 533 }
 534 #endif
 535
 536 #if !defined(CHILD_INSERT_VFORK_CATCHPOINT)
 537 int
 538 child_insert_vfork_catchpoint (int pid)
 539 {
 540   /* This version of Unix doesn't support notification of vfork events.  */
 541   return 0;
 542 }
 543 #endif
 544
 545 #if !defined(CHILD_REMOVE_VFORK_CATCHPOINT)
 546 int
 547 child_remove_vfork_catchpoint (int pid)
 548 {
 549   /* This version of Unix doesn't support notification of vfork events.  */
 550   return 0;
 551 }
 552 #endif
 553
 554 #if !defined(CHILD_HAS_FORKED)
 555 int
 556 child_has_forked (int pid, int *child_pid)
 557 {
 558   /* This version of Unix doesn't support notification of fork events.  */
 559   return 0;
 560 }
 561 #endif
 562
 563
 564 #if !defined(CHILD_HAS_VFORKED)
 565 int
 566 child_has_vforked (int pid, int *child_pid)
 567 {
 568   /* This version of Unix doesn't support notification of vfork events.
 569    */
 570   return 0;
 571 }
 572 #endif
 573
 574
 575 #if !defined(CHILD_CAN_FOLLOW_VFORK_PRIOR_TO_EXEC)
 576 int
 577 child_can_follow_vfork_prior_to_exec (void)
 578 {
 579   /* This version of Unix doesn't support notification of vfork events.
 580      However, if it did, it probably wouldn't allow vforks to be followed
 581      before the following exec.
 582    */
 583   return 0;
 584 }
 585 #endif
 586
 587
 588 #if !defined(CHILD_POST_FOLLOW_VFORK)
 589 void
 590 child_post_follow_vfork (int parent_pid, int followed_parent, int child_pid,
 591                          int followed_child)
 592 {
 593   /* This version of Unix doesn't require a meaningful "post follow vfork"
 594      operation by a clone debugger.
 595    */
 596 }
 597 #endif
 598
 599 #if !defined(CHILD_INSERT_EXEC_CATCHPOINT)
 600 int
 601 child_insert_exec_catchpoint (int pid)
 602 {
 603   /* This version of Unix doesn't support notification of exec events.  */
 604   return 0;
 605 }
 606 #endif
 607
 608 #if !defined(CHILD_REMOVE_EXEC_CATCHPOINT)
 609 int
 610 child_remove_exec_catchpoint (int pid)
 611 {
 612   /* This version of Unix doesn't support notification of exec events.  */
 613   return 0;
 614 }
 615 #endif
 616
 617 #if !defined(CHILD_HAS_EXECD)
 618 int
 619 child_has_execd (int pid, char **execd_pathname)
 620 {
 621   /* This version of Unix doesn't support notification of exec events.
 622    */
 623   return 0;
 624 }
 625 #endif
 626
 627
 628 #if !defined(CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL)
 629 int
 630 child_reported_exec_events_per_exec_call (void)
 631 {
 632   /* This version of Unix doesn't support notification of exec events.
 633    */
 634   return 1;
 635 }
 636 #endif
 637
 638
 639 #if !defined(CHILD_HAS_SYSCALL_EVENT)
 640 int
 641 child_has_syscall_event (int pid, enum target_waitkind *kind, int *syscall_id)
 642 {
 643   /* This version of Unix doesn't support notification of syscall events.
 644    */
 645   return 0;
 646 }
 647 #endif
 648
 649
 650 #if !defined(CHILD_HAS_EXITED)
 651 int
 652 child_has_exited (int pid, int wait_status, int *exit_status)
 653 {
 654   if (WIFEXITED (wait_status))
 655     {
 656       *exit_status = WEXITSTATUS (wait_status);
 657       return 1;
 658     }
 659
 660   if (WIFSIGNALED (wait_status))
 661     {
 662       *exit_status = 0;         /* ?? Don't know what else to say here. */
 663       return 1;
 664     }
 665
 666   /* ?? Do we really need to consult the event state, too?  Assume the
 667      wait_state alone suffices.
 668    */
 669   return 0;
 670 }
 671 #endif
 672
 673
 674 static void
 675 child_mourn_inferior (void)
 676 {
 677   unpush_target (&child_ops);
 678   generic_mourn_inferior ();
 679 }
 680
 681 static int
 682 child_can_run (void)
 683 {
 684   /* This variable is controlled by modules that sit atop inftarg that may layer
 685      their own process structure atop that provided here.  hpux-thread.c does
 686      this because of the Hpux user-mode level thread model.  */
 687
 688   return !child_suppress_run;
 689 }
 690
 691 /* Send a SIGINT to the process group.  This acts just like the user typed a
 692    ^C on the controlling terminal.
 693
 694    XXX - This may not be correct for all systems.  Some may want to use
 695    killpg() instead of kill (-pgrp). */
 696
 697 static void
 698 child_stop (void)
 699 {
 700   extern pid_t inferior_process_group;
 701
 702   kill (-inferior_process_group, SIGINT);
 703 }
 704
 705 #if !defined(CHILD_ENABLE_EXCEPTION_CALLBACK)
 706 struct symtab_and_line *
 707 child_enable_exception_callback (enum exception_event_kind kind, int enable)
 708 {
 709   return (struct symtab_and_line *) NULL;
 710 }
 711 #endif
 712
 713 #if !defined(CHILD_GET_CURRENT_EXCEPTION_EVENT)
 714 struct exception_event_record *
 715 child_get_current_exception_event (void)
 716 {
 717   return (struct exception_event_record *) NULL;
 718 }
 719 #endif
 720
 721
 722 #if !defined(CHILD_PID_TO_EXEC_FILE)
 723 char *
 724 child_pid_to_exec_file (int pid)
 725 {
 726   /* This version of Unix doesn't support translation of a process ID
 727      to the filename of the executable file.
 728    */
 729   return NULL;
 730 }
 731 #endif
 732
 733 char *
 734 child_core_file_to_sym_file (char *core)
 735 {
 736   /* The target stratum for a running executable need not support
 737      this operation.
 738    */
 739   return NULL;
 740 }
 741 \f
 742
 743 #if !defined(CHILD_PID_TO_STR)
 744 char *
 745 child_pid_to_str (ptid_t ptid)
 746 {
 747   return normal_pid_to_str (ptid);
 748 }
 749 #endif
 750
 751 static void
 752 init_child_ops (void)
 753 {
 754   child_ops.to_shortname = "child";
 755   child_ops.to_longname = "Unix child process";
 756   child_ops.to_doc = "Unix child process (started by the \"run\" command).";
 757   child_ops.to_open = child_open;
 758   child_ops.to_attach = child_attach;
 759   child_ops.to_post_attach = child_post_attach;
 760   child_ops.to_require_attach = child_require_attach;
 761   child_ops.to_detach = child_detach;
 762   child_ops.to_require_detach = child_require_detach;
 763   child_ops.to_resume = child_resume;
 764   child_ops.to_wait = child_wait;
 765   child_ops.to_post_wait = child_post_wait;
 766   child_ops.to_fetch_registers = fetch_inferior_registers;
 767   child_ops.to_store_registers = store_inferior_registers;
 768   child_ops.to_prepare_to_store = child_prepare_to_store;
 769   child_ops.to_xfer_memory = child_xfer_memory;
 770   child_ops.to_files_info = child_files_info;
 771   child_ops.to_insert_breakpoint = memory_insert_breakpoint;
 772   child_ops.to_remove_breakpoint = memory_remove_breakpoint;
 773   child_ops.to_terminal_init = terminal_init_inferior;
 774   child_ops.to_terminal_inferior = terminal_inferior;
 775   child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
 776   child_ops.to_terminal_ours = terminal_ours;
 777   child_ops.to_terminal_info = child_terminal_info;
 778   child_ops.to_kill = kill_inferior;
 779   child_ops.to_create_inferior = child_create_inferior;
 780   child_ops.to_post_startup_inferior = child_post_startup_inferior;
 781   child_ops.to_acknowledge_created_inferior = child_acknowledge_created_inferior;
 782   child_ops.to_clone_and_follow_inferior = child_clone_and_follow_inferior;
 783   child_ops.to_post_follow_inferior_by_clone = child_post_follow_inferior_by_clone;
 784   child_ops.to_insert_fork_catchpoint = child_insert_fork_catchpoint;
 785   child_ops.to_remove_fork_catchpoint = child_remove_fork_catchpoint;
 786   child_ops.to_insert_vfork_catchpoint = child_insert_vfork_catchpoint;
 787   child_ops.to_remove_vfork_catchpoint = child_remove_vfork_catchpoint;
 788   child_ops.to_has_forked = child_has_forked;
 789   child_ops.to_has_vforked = child_has_vforked;
 790   child_ops.to_can_follow_vfork_prior_to_exec = child_can_follow_vfork_prior_to_exec;
 791   child_ops.to_post_follow_vfork = child_post_follow_vfork;
 792   child_ops.to_insert_exec_catchpoint = child_insert_exec_catchpoint;
 793   child_ops.to_remove_exec_catchpoint = child_remove_exec_catchpoint;
 794   child_ops.to_has_execd = child_has_execd;
 795   child_ops.to_reported_exec_events_per_exec_call = child_reported_exec_events_per_exec_call;
 796   child_ops.to_has_syscall_event = child_has_syscall_event;
 797   child_ops.to_has_exited = child_has_exited;
 798   child_ops.to_mourn_inferior = child_mourn_inferior;
 799   child_ops.to_can_run = child_can_run;
 800   child_ops.to_thread_alive = child_thread_alive;
 801   child_ops.to_pid_to_str = child_pid_to_str;
 802   child_ops.to_stop = child_stop;
 803   child_ops.to_enable_exception_callback = child_enable_exception_callback;
 804   child_ops.to_get_current_exception_event = child_get_current_exception_event;
 805   child_ops.to_pid_to_exec_file = child_pid_to_exec_file;
 806   child_ops.to_stratum = process_stratum;
 807   child_ops.to_has_all_memory = 1;
 808   child_ops.to_has_memory = 1;
 809   child_ops.to_has_stack = 1;
 810   child_ops.to_has_registers = 1;
 811   child_ops.to_has_execution = 1;
 812   child_ops.to_magic = OPS_MAGIC;
 813 }
 814
 815 void
 816 _initialize_inftarg (void)
 817 {
 818 #ifdef HAVE_OPTIONAL_PROC_FS
 819   char procname[32];
 820   int fd;
 821
 822   /* If we have an optional /proc filesystem (e.g. under OSF/1),
 823      don't add ptrace support if we can access the running GDB via /proc.  */
 824 #ifndef PROC_NAME_FMT
 825 #define PROC_NAME_FMT "/proc/%05d"
 826 #endif
 827   sprintf (procname, PROC_NAME_FMT, getpid ());
 828   if ((fd = open (procname, O_RDONLY)) >= 0)
 829     {
 830       close (fd);
 831       return;
 832     }
 833 #endif
 834
 835   init_child_ops ();
 836   add_target (&child_ops);
 837 }