gdb/inftarg.c

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