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